diff --git a/CLAUDE.md b/CLAUDE.md
index b15dae7b..2df867bc 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -20,7 +20,7 @@ docker compose up -d
 docker compose logs -f claude-chat
 ```
 
-No linting and no build step configured. `npm test` chains 61 test files under `test/`: 18 DOM-less render/UI-logic tests (`test/render/*.test.mjs`, run through `node --test`) plus 43 plain-`node` suites in `test/` covering the overload detector, env load order, multi-agent results, terminals, bots, telegram, updates, kanban scheduling, i18n completeness, the config precedence resolver plus its secret masking, usage-limit detection, the filesystem path guard (including the SVG sandbox header and the symlink rule on the `@`-mention search endpoints) plus the tunnel-blocks-terminal rule, WS session re-subscription, the SSH remote CLI-session import, the live engine pane / interactive-prompt watchdog, the cross-project global workspace aggregation, the rule that an SSH credential never leaves the server process, the Windows command-quoting oracle, the auth token lifecycle, the multi-agent dependency scheduler (waves, plan sanitising, and the rule that a failure warning must survive dep-context truncation), the SSH stream parser's three guards, the remote non-interactive shell environment (`remote-env.test.js`, which runs the generated prelude through real `bash -lc`: it must parse, print nothing on stdout, and never end on a false test — the caller chains `&& claude …` behind it), the remote CLI-list framing parser, the bot inbox's SQL seam (`bot-inbox.test.js` pins that `from_bot AS "from"` keeps the exact key `planInboxDelivery` reads — rename one without the other and every letter is silently retired as malformed), the one-time config/.env migration onto CCS_CONFIG_PATH and the mid-task clarification delivery contract on the subscription engine (`interrupt-delivery.test.js` — pins that the tmux injection block sits BEFORE the poll loop's completion `break`, that draining does not imply delivery, that a failed paste is re-queued and warns non-terminally, and that the task runner passes the same callbacks the chat path does), the CLAUDE.md / AGENTS.md discovery rules (`agents-md.test.js`, which also pins that AGENTS.md reaches the subprocess as `--append-system-prompt` and never as `--system-prompt`), and the remote file browser's three guard layers (`remote-files.test.js` runs the generated POSIX script through a real `/bin/sh` against a temp tree that contains symlinks OUT of the project; `remote-files-api.test.js` boots a server against a fake remote via `CCS_REMOTE_EXEC_HOOK` and drives `/api/files` the way the SPA does). On the render side, `tables.test.mjs` also pins the ReDoS bound in renderMd step 3.4, `xss.test.mjs` runs 24 adversarial payloads end-to-end, and `forged-tokens.test.mjs` covers the case where user text contains the renderer's own placeholder control bytes, and `pane-font.test.mjs` pins the clamp DIRECTION of `_fitEnginePaneFont` (a wide engine pane may only shrink; a narrow split pane must be allowed to grow). `script-scope.test.mjs` pins which `<script>` block a helper is declared in — declarations hoist only within their own block, so a helper used by `loadSess()` must not live in the terminal block at the bottom of the file. Note the glob: a file under `test/render/` whose name does not end in `.test.mjs` is NEVER run — `_load.selftest.mjs` sat there unexecuted until it was renamed to `loader.test.mjs`. It runs serially and aborts on the first failing file. `.github/workflows/ci.yml` runs it on every push and PR to `main` (tmux installed, so the four tmux-dependent suites do not self-skip).
+No linting and no build step configured. `npm test` chains 63 test files under `test/`: 18 DOM-less render/UI-logic tests (`test/render/*.test.mjs`, run through `node --test`) plus 45 plain-`node` suites in `test/` covering the overload detector, env load order, multi-agent results, terminals, bots, telegram, updates, kanban scheduling, i18n completeness, the config precedence resolver plus its secret masking, usage-limit detection, the filesystem path guard (including the SVG sandbox header and the symlink rule on the `@`-mention search endpoints) plus the tunnel-blocks-terminal rule, WS session re-subscription, the SSH remote CLI-session import, the live engine pane / interactive-prompt watchdog, the cross-project global workspace aggregation, the rule that an SSH credential never leaves the server process, the Windows command-quoting oracle, the auth token lifecycle, the multi-agent dependency scheduler (waves, plan sanitising, and the rule that a failure warning must survive dep-context truncation), the SSH stream parser's three guards, the remote non-interactive shell environment (`remote-env.test.js`, which runs the generated prelude through real `bash -lc`: it must parse, print nothing on stdout, and never end on a false test — the caller chains `&& claude …` behind it), the remote CLI-list framing parser, the bot inbox's SQL seam (`bot-inbox.test.js` pins that `from_bot AS "from"` keeps the exact key `planInboxDelivery` reads — rename one without the other and every letter is silently retired as malformed), the one-time config/.env migration onto CCS_CONFIG_PATH and the mid-task clarification delivery contract on the subscription engine (`interrupt-delivery.test.js` — pins that the tmux injection block sits BEFORE the poll loop's completion `break`, that draining does not imply delivery, that a failed paste is re-queued and warns non-terminally, and that the task runner passes the same callbacks the chat path does), the CLAUDE.md / AGENTS.md discovery rules (`agents-md.test.js`, which also pins that AGENTS.md reaches the subprocess as `--append-system-prompt` and never as `--system-prompt`), and the remote file browser's three guard layers (`remote-files.test.js` runs the generated POSIX script through a real `/bin/sh` against a temp tree that contains symlinks OUT of the project; `remote-files-api.test.js` boots a server against a fake remote via `CCS_REMOTE_EXEC_HOOK` and drives `/api/files` the way the SPA does), and the new-chat defaults chain (`chat-defaults.test.js` pins the pure resolver — the built-ins are asserted to be exactly what the SPA hardcoded before #58, and the choice lists to be exactly the toolbar's `data-v` sets and `MODEL_MAP`'s aliases; `chat-defaults-api.test.js` boots a real server in a throwaway `APP_DIR` and pins that a project writes back a SPARSE override object — a five-key snapshot passes every other assertion in that file and still breaks the feature). On the render side, `tables.test.mjs` also pins the ReDoS bound in renderMd step 3.4, `xss.test.mjs` runs 24 adversarial payloads end-to-end, and `forged-tokens.test.mjs` covers the case where user text contains the renderer's own placeholder control bytes, and `pane-font.test.mjs` pins the clamp DIRECTION of `_fitEnginePaneFont` (a wide engine pane may only shrink; a narrow split pane must be allowed to grow). `script-scope.test.mjs` pins which `<script>` block a helper is declared in — declarations hoist only within their own block, so a helper used by `loadSess()` must not live in the terminal block at the bottom of the file. Note the glob: a file under `test/render/` whose name does not end in `.test.mjs` is NEVER run — `_load.selftest.mjs` sat there unexecuted until it was renamed to `loader.test.mjs`. It runs serially and aborts on the first failing file. `.github/workflows/ci.yml` runs it on every push and PR to `main` (tmux installed, so the four tmux-dependent suites do not self-skip).
 
 ## Architecture
 
@@ -290,6 +290,58 @@ closes that gap for **local** runs.
   the current UI (the config editor reads `/api/claude-md`); its key name is part of
   the endpoint's allowlist contract, so it was left alone.
 
+### New-chat defaults (issue #58)
+
+Every new chat used to open on literals: `newTab()` assigned `curMode='auto'` /
+`curAgent='single'`, the model carried over from whichever tab was open last, and
+`#maxTurns` shipped `value="50"` in the markup. `chat-defaults.js` replaces that with a
+two-link chain, and it is pure (no `fs`, no `require('./server.js')`) so the precedence
+is testable without booting anything:
+
+    project override  >  global default (config.json)  >  BUILTIN
+
+- **The project link is SPARSE, and that is the feature.** A project stores only the
+  dials it pinned. Store a full five-key snapshot instead and every project silently
+  freezes at whatever the global happened to be the day it was created — the opposite
+  of what was asked for. `test/chat-defaults-api.test.js` asserts the object written to
+  `data/projects.json`, because a snapshot satisfies every other assertion in that file.
+- **`BUILTIN` is the pre-#58 behaviour, not a fresh opinion.** Changing one of the five
+  changes how every install that never opened the settings form behaves.
+- **`effort: 'auto'` is a spelled-out sentinel** for "pass no `--effort` flag", which the
+  SPA's `<select>` and the CLI both spell `''`. It has to be a real word: `loadMergedConfig()`
+  resolves with `||`, so an empty string in a config file is indistinguishable from an
+  unset key. `effortToFlag()` is the single translation point.
+- **`loadMergedConfig()` sanitises each LAYER, then spreads — never the reverse.**
+  Spreading `~/.claude/config.json` and `config.json` raw lets a local `model:""`
+  mask a valid global `model:"opus"`; the merged empty string is then dropped and the
+  answer falls all the way to `BUILTIN`, while the settings catalog — which walks the
+  two files separately under `falsyFallsThrough` — keeps reporting `opus` as effective.
+  Two answers for one key. Per-layer sanitising IS the `||` semantics the flag claims.
+- **`sanitize()` is lenient on read, strict on write.** A typo in a hand-edited
+  `config.json` drops that one key and leaves the other four alone; the same typo arriving
+  at `PUT /api/projects/:id/defaults` is a 400 that names the key — silently dropping a dial
+  the user just clicked reads as a save that worked.
+- **The global half is a settings-catalog entry, not a bespoke form.** Five rows in
+  `config-resolve.js` (`section: 'defaults'`) give the Settings UI its section, its source
+  badges and its per-row Reset for free. `coerceValue()` gained optional `min`/`max` for
+  `chatDefaults.turns` so the form cannot store a value its own `<input>` refuses to show,
+  plus an opt-in `int: true` that parses with `Number` (so `'12px'` is refused rather than
+  read as `12`) and truncates AFTER the range check — the same order `chat-defaults.coerce`
+  uses. Settings and the toolbar must coerce one dial identically; without `int` the older
+  `parseInt` behaviour of every pre-existing number row is untouched.
+- **The `falsyFallsThrough` guard is behavioural for nested keys.** `test/config-resolve.test.js`
+  reads the `||` / `??` operator straight out of `loadMergedConfig()` for FLAT keys; a key
+  whose `path` contains a dot has no such line, so it is checked by running the resolver
+  instead. Do not weaken the flat check to make a nested key pass.
+- **Membership before the unpin sentinel.** `sanitize()` rejects an unknown key whatever
+  its value, so `{notADial: null}` is a typo that 400s instead of an unpin that reports
+  success. `PUT /api/projects/:id/defaults` likewise refuses a non-object body — a 200 on
+  `{defaults: null}` reads exactly like the reset that DELETE actually performs. A wrong
+  `projectId` is 404 on all three endpoints; only *no* id means "just the global row".
+- **Only a chat with no session of its own is seeded.** `applyChatDefaults()` runs from
+  `newTab()`, from `switchProject()` and at boot — always behind `if (!currentSessionId)`.
+  An existing chat carries its own mode/model in SQLite and `loadSess()` must keep winning.
+
 ### Markdown Rendering in SPA
 - During streaming: `renderStreaming()` handles unclosed code fences
 - On `done` event: re-render with full `renderMd()` for proper final formatting
@@ -299,7 +351,7 @@ closes that gap for **local** runs.
 
 ## How to Verify Changes
 
-`npm test` runs 61 test files under `test/` (18 `test/render/*.test.mjs` + 43 `test/*.test.js`). There is no CI yet, and nothing covers the live browser/WebSocket path, so also verify that manually:
+`npm test` runs 63 test files under `test/` (18 `test/render/*.test.mjs` + 45 `test/*.test.js`). There is no CI yet, and nothing covers the live browser/WebSocket path, so also verify that manually:
 
 ```bash
 # 1. Start server
diff --git a/chat-defaults.js b/chat-defaults.js
new file mode 100644
index 00000000..bf254f62
--- /dev/null
+++ b/chat-defaults.js
@@ -0,0 +1,120 @@
+// Global chat defaults + per-project overrides — issue #58.
+//
+// Before this, every new chat opened on values hardcoded in the SPA: newTab()
+// assigned curMode='auto' / curAgent='single' literally, the model carried over
+// from whatever tab was open last, and the turns box shipped value="50" in the
+// markup. A user who always works on Opus / Task retyped that on every chat.
+//
+// The chain is two links, and it is deliberately SPARSE at the project link:
+//
+//     project override  >  global default (config.json)  >  BUILTIN
+//
+// A project stores only the keys it pins. That is what makes "inherited" a real
+// state rather than a snapshot: change the global model and every project that
+// never pinned one follows, which is the whole point of the request. Storing a
+// full five-key object per project would silently freeze each project at the
+// global value that happened to be current when it was created.
+//
+// This module is pure — no fs, no require of server.js — so the precedence and
+// the validation can be unit-tested without booting anything.
+'use strict';
+
+/** The five dials, in the order the toolbar shows them. */
+const KEYS = ['mode', 'agent', 'model', 'effort', 'turns'];
+
+/** Allowed values. These are not free choices — each list is the `data-v` set of
+ *  the matching toolbar group in public/index.html, and `model` is MODEL_MAP in
+ *  claude-cli.js. A value that is not here would render as "no button selected". */
+const CHOICES = {
+  mode:   ['auto', 'planning', 'task'],
+  agent:  ['single', 'multi', 'dispatch', 'conversation'],
+  model:  ['haiku', 'sonnet', 'opus', 'fable'],
+  // 'auto' is the sentinel for "pass no --effort flag at all", which the SPA and
+  // the CLI both spell as the empty string. It is spelled out here because an
+  // empty string in a config file is indistinguishable from an unset key once it
+  // has been through `||` — and loadMergedConfig() uses `||`.
+  effort: ['auto', 'low', 'medium', 'high', 'xhigh', 'max'],
+};
+
+/** Matches the min/max on #maxTurns in the toolbar. */
+const TURNS_MIN = 1;
+const TURNS_MAX = 200;
+
+/** What the UI did before this module existed. Changing any of these changes the
+ *  behaviour of every install that never opened the settings form. */
+const BUILTIN = Object.freeze({
+  mode: 'auto',
+  agent: 'single',
+  model: 'sonnet',
+  effort: 'auto',
+  turns: 50,
+});
+
+/** The SPA and the CLI want '' where the catalog wants 'auto'. One place. */
+function effortToFlag(effort) {
+  return effort === 'auto' || !effort ? '' : String(effort);
+}
+
+/** Validate one key/value pair.
+ *  @returns {{ok:true, value:*}|{ok:false, error:string}} */
+function coerce(key, raw) {
+  if (!KEYS.includes(key)) return { ok: false, error: 'unknown_key' };
+  if (key === 'turns') {
+    // `Number`, not `parseInt`: parseInt('12px') is 12, and a settings row that
+    // silently keeps the numeric prefix of a typo is worse than one that refuses
+    // it. The same rule runs in config-resolve.coerceValue for `int` settings —
+    // the two must agree, or Settings and the toolbar show different turn limits.
+    const n = typeof raw === 'number' ? raw : Number(String(raw).trim());
+    if (!Number.isFinite(n) || String(raw).trim() === '') return { ok: false, error: 'expected_number' };
+    if (n < TURNS_MIN || n > TURNS_MAX) return { ok: false, error: 'out_of_range' };
+    return { ok: true, value: Math.trunc(n) };
+  }
+  const v = String(raw);
+  if (!CHOICES[key].includes(v)) return { ok: false, error: 'invalid_choice' };
+  return { ok: true, value: v };
+}
+
+/** Keep the valid pairs, name the rest.
+ *
+ *  Both halves are used: reading config.json takes `value` and ignores `invalid`
+ *  (a typo in a hand-edited file must not blank the other four dials), while the
+ *  write endpoint refuses the request when `invalid` is non-empty — silently
+ *  dropping a key the user just clicked would read as the save having worked.
+ *
+ *  @returns {{value:Object, invalid:string[]}} */
+function sanitize(raw) {
+  const value = {}, invalid = [];
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return { value, invalid };
+  for (const [k, v] of Object.entries(raw)) {
+    // Membership is checked BEFORE the unpin sentinel: `{notADial: null}` is a
+    // typo to report, not an unpin to accept. Only a KNOWN key may be unpinned.
+    if (!KEYS.includes(k)) { invalid.push(k); continue; }
+    // An explicit null/undefined means "stop pinning this key", not "invalid".
+    if (v === null || v === undefined || v === '') continue;
+    const c = coerce(k, v);
+    if (c.ok) value[k] = c.value; else invalid.push(k);
+  }
+  return { value, invalid };
+}
+
+/** Resolve the effective dials for one project.
+ *  @param globalRaw  config.chatDefaults from loadMergedConfig() (may be absent)
+ *  @param projectRaw project.defaults from data/projects.json (may be absent)
+ *  @returns {{effective:Object, global:Object, overrides:Object, overridden:string[]}}
+ *           `overrides` holds ONLY the keys the project pins — that sparseness is
+ *           what the UI draws its "overridden" badges from. */
+function resolveChatDefaults(globalRaw, projectRaw) {
+  const g = { ...BUILTIN, ...sanitize(globalRaw).value };
+  const overrides = sanitize(projectRaw).value;
+  return {
+    effective: { ...g, ...overrides },
+    global: g,
+    overrides,
+    overridden: KEYS.filter(k => k in overrides),
+  };
+}
+
+module.exports = {
+  KEYS, CHOICES, BUILTIN, TURNS_MIN, TURNS_MAX,
+  coerce, sanitize, resolveChatDefaults, effortToFlag,
+};
diff --git a/config-resolve.js b/config-resolve.js
index 5d623dcb..7e670636 100644
--- a/config-resolve.js
+++ b/config-resolve.js
@@ -41,12 +41,14 @@
 
 'use strict';
 
+const chatDefaults = require('./chat-defaults');
+
 // Sources, most-significant first. Ordering here IS the precedence contract;
 // resolve() walks candidates in the order it builds them, not in this order,
 // but the UI uses these ids for badges and the tests pin both.
 const SOURCES = ['project', 'process-env', 'dotenv', 'config-local', 'config-global', 'default'];
 
-const SECTIONS = ['engine', 'agents', 'workspace', 'mcp', 'server', 'security', 'data', 'ui', 'advanced'];
+const SECTIONS = ['engine', 'defaults', 'agents', 'workspace', 'mcp', 'server', 'security', 'data', 'ui', 'advanced'];
 
 // Keys whose value must never reach the browser. The explicit flag in the
 // catalog is authoritative; this pattern is a second net so that a key added
@@ -83,6 +85,28 @@ const SETTINGS = [
     src: 'server.js:loadMergedConfig' },
   { key: 'ANTHROPIC_BASE_URL', section: 'engine', backing: 'env', type: 'string', def: '', restart: true,
     src: '.env.example / claude-cli.js env passthrough' },
+
+  // -- Defaults a NEW chat opens on (issue #58) ------------------------------
+  // Each one is what the toolbar preselects; a project may pin its own value on
+  // top, and that override lives in data/projects.json, not here. The choices
+  // are not restated -- chat-defaults.js owns them, and a second copy would rot.
+  { key: 'chatDefaults.mode', section: 'defaults', backing: 'config', merge: 'merged', path: 'chatDefaults.mode',
+    type: 'enum', choices: chatDefaults.CHOICES.mode, def: chatDefaults.BUILTIN.mode, falsyFallsThrough: true,
+    src: 'chat-defaults.js:resolveChatDefaults' },
+  { key: 'chatDefaults.agent', section: 'defaults', backing: 'config', merge: 'merged', path: 'chatDefaults.agent',
+    type: 'enum', choices: chatDefaults.CHOICES.agent, def: chatDefaults.BUILTIN.agent, falsyFallsThrough: true,
+    src: 'chat-defaults.js:resolveChatDefaults' },
+  { key: 'chatDefaults.model', section: 'defaults', backing: 'config', merge: 'merged', path: 'chatDefaults.model',
+    type: 'enum', choices: chatDefaults.CHOICES.model, def: chatDefaults.BUILTIN.model, falsyFallsThrough: true,
+    src: 'chat-defaults.js:resolveChatDefaults' },
+  { key: 'chatDefaults.effort', section: 'defaults', backing: 'config', merge: 'merged', path: 'chatDefaults.effort',
+    type: 'enum', choices: chatDefaults.CHOICES.effort, def: chatDefaults.BUILTIN.effort, falsyFallsThrough: true,
+    src: 'chat-defaults.js:resolveChatDefaults' },
+  { key: 'chatDefaults.turns', section: 'defaults', backing: 'config', merge: 'merged', path: 'chatDefaults.turns',
+    type: 'number', int: true, def: chatDefaults.BUILTIN.turns,
+    min: chatDefaults.TURNS_MIN, max: chatDefaults.TURNS_MAX,
+    falsyFallsThrough: true,
+    src: 'chat-defaults.js:resolveChatDefaults' },
   { key: 'ANTHROPIC_API_KEY', section: 'engine', backing: 'env', type: 'string', def: '', secret: true,
     readOnly: true, restart: true, src: '.env.example' },
   { key: 'ANTHROPIC_AUTH_TOKEN', section: 'engine', backing: 'env', type: 'string', def: '', secret: true,
@@ -401,9 +425,20 @@ function coerceValue(def, raw) {
       return { ok: false, error: 'expected_bool' };
     }
     case 'number': {
-      const n = typeof raw === 'number' ? raw : parseInt(String(raw).trim(), 10);
-      if (!Number.isFinite(n)) return { ok: false, error: 'expected_number' };
-      return { ok: true, value: n };
+      // `int` settings parse with Number (so '12px' is refused, not read as 12)
+      // and are truncated AFTER the range check, matching chat-defaults.coerce
+      // exactly. Without `int` the old parseInt behaviour is untouched, so every
+      // setting that shipped before keeps accepting what it accepted before.
+      const n = typeof raw === 'number' ? raw
+        : (def.int ? Number(String(raw).trim()) : parseInt(String(raw).trim(), 10));
+      if (!Number.isFinite(n) || (def.int && String(raw).trim() === '')) {
+        return { ok: false, error: 'expected_number' };
+      }
+      // A bound is only checked when the catalog declares one, so the settings
+      // that never had bounds keep accepting what they accepted before.
+      if (def.min !== undefined && n < def.min) return { ok: false, error: 'out_of_range' };
+      if (def.max !== undefined && n > def.max) return { ok: false, error: 'out_of_range' };
+      return { ok: true, value: def.int ? Math.trunc(n) : n };
     }
     case 'enum': {
       const v = String(raw);
diff --git a/package.json b/package.json
index 7bf252ab..885a5b53 100644
--- a/package.json
+++ b/package.json
@@ -8,7 +8,7 @@
   "scripts": {
     "start": "node server.js",
     "dev": "node --watch server.js",
-    "test": "node --test test/render/*.test.mjs && node test/overload-detector.test.js && node test/usage-limit.test.js && node test/env-load-order.test.js && node test/multi-agent-result.test.js && node test/terminal-session.test.js && node test/terminal-schema.test.js && node test/bots.test.js && node test/bot-inbox.test.js && node test/bots-api.test.js && node test/running-sessions.test.js && node test/session-liveness.test.js && node test/terminal-bridge.integration.test.js && node test/telegram-format.test.js && node test/telegram-behaviour.test.js && node test/ask-user-question.test.js && node test/delegate-terminal.test.js && node test/update-flow.test.js && node test/kanban-schedule.test.js && node test/i18n-completeness.test.js && node test/config-resolve.test.js && node test/setup-gate.test.js && node test/path-guard.test.js && node test/subscribe-nocatchup.test.js && node test/cli-import-remote.test.js && node test/remote-list-parse.test.js && node test/config-migrate.test.js && node test/engine-pane.test.js && node test/global-workspace.test.js && node test/ssh-secret.test.js && node test/agent-dag.test.js && node test/ssh-parser.test.js && node test/remote-env.test.js && node test/remote-files.test.js && node test/remote-files-api.test.js && node test/auth-token.test.js && node test/cmd-model.test.js && node test/origin-guard.test.js && node test/interrupted-recovery.test.js && node test/queue-persistence.test.js && node test/interrupt-idle-config.test.js && node test/agents-md.test.js && node test/interrupt-delivery.test.js && node test/terminal-pane-guard.integration.test.js",
+    "test": "node --test test/render/*.test.mjs && node test/overload-detector.test.js && node test/usage-limit.test.js && node test/env-load-order.test.js && node test/multi-agent-result.test.js && node test/terminal-session.test.js && node test/terminal-schema.test.js && node test/bots.test.js && node test/bot-inbox.test.js && node test/bots-api.test.js && node test/running-sessions.test.js && node test/session-liveness.test.js && node test/terminal-bridge.integration.test.js && node test/telegram-format.test.js && node test/telegram-behaviour.test.js && node test/ask-user-question.test.js && node test/delegate-terminal.test.js && node test/update-flow.test.js && node test/kanban-schedule.test.js && node test/i18n-completeness.test.js && node test/config-resolve.test.js && node test/chat-defaults.test.js && node test/chat-defaults-api.test.js && node test/setup-gate.test.js && node test/path-guard.test.js && node test/subscribe-nocatchup.test.js && node test/cli-import-remote.test.js && node test/remote-list-parse.test.js && node test/config-migrate.test.js && node test/engine-pane.test.js && node test/global-workspace.test.js && node test/ssh-secret.test.js && node test/agent-dag.test.js && node test/ssh-parser.test.js && node test/remote-env.test.js && node test/remote-files.test.js && node test/remote-files-api.test.js && node test/auth-token.test.js && node test/cmd-model.test.js && node test/origin-guard.test.js && node test/interrupted-recovery.test.js && node test/queue-persistence.test.js && node test/interrupt-idle-config.test.js && node test/agents-md.test.js && node test/interrupt-delivery.test.js && node test/terminal-pane-guard.integration.test.js",
     "postinstall": "node scripts/install-hooks.js",
     "release": "node scripts/release.js",
     "electron:dev": "electron .",
diff --git a/public/index.html b/public/index.html
index 14e9ef24..eee305b2 100644
--- a/public/index.html
+++ b/public/index.html
@@ -431,6 +431,11 @@
 .toolbar { display: flex; align-items: center; gap: 7px; padding: 6px 14px; background: var(--s1); border-bottom: 1px solid var(--border); flex-wrap: nowrap; overflow-x: auto; }
 .tb-group { display: flex; align-items: center; gap: 2px; background: var(--s2); border: 1px solid var(--border); border-radius: 8px; padding: 3px; }
 .tb-group .label { font-size: 11px; color: var(--muted); padding: 0 7px; text-transform: uppercase; letter-spacing: .6px; font-weight: 700; }
+/* Issue #58: this dial is pinned by the project, not inherited from the global
+   defaults. Drawn on the group label so it reads next to the dial's name. */
+.tb-group.tbg-override { border-color: var(--accent); }
+.tb-group.tbg-override .label { color: var(--accent2); }
+.tb-group.tbg-override .label::after { content: '\2022'; margin-left: 4px; color: var(--accent); font-size: 14px; line-height: 0; }
 .tb-btn { padding: 4px 11px; border-radius: 6px; border: none; background: transparent; color: var(--muted); cursor: pointer; font-size: 13px; transition: background .12s, border-color .12s, color .12s, box-shadow .12s, transform .12s; white-space: nowrap; font-weight: 500; }
 .tb-btn:hover { color: var(--text); background: rgba(255,255,255,.06); }
 .tb-btn.on { background: var(--accent); color: white; box-shadow: 0 1px 6px rgba(124,106,239,.4); }
@@ -3368,14 +3373,14 @@ <h3 data-i18n="mob.tabs">Sessions</h3>
   </div>
 
   <div class="toolbar">
-    <div class="tb-group">
+    <div class="tb-group" data-tbg="mode">
       <span class="label" data-i18n="tb.mode">Режим</span>
       <button class="tb-btn on" data-v="auto" onclick="setOpt(this,'mode')" data-i18n="mode.auto">Auto</button>
       <button class="tb-btn" data-v="planning" onclick="setOpt(this,'mode')" data-i18n="mode.plan">Plan</button>
       <button class="tb-btn" data-v="task" onclick="setOpt(this,'mode')" data-i18n="mode.task">Task</button>
     </div>
     <div class="tb-sep"></div>
-    <div class="tb-group">
+    <div class="tb-group" data-tbg="agent">
       <span class="label" data-i18n="tb.agent">Агент</span>
       <button class="tb-btn on" data-v="single" onclick="setOpt(this,'agent')" data-i18n="agent.single">Single</button>
       <button class="tb-btn" data-v="multi" onclick="setOpt(this,'agent')" data-i18n="agent.multi">Multi</button>
@@ -3383,7 +3388,7 @@ <h3 data-i18n="mob.tabs">Sessions</h3>
       <button class="tb-btn" data-v="conversation" onclick="setOpt(this,'agent')" data-i18n="agent.conversation" data-i18n-tip="agent.conversation.tip">Room</button>
     </div>
     <div class="tb-sep"></div>
-    <div class="tb-group">
+    <div class="tb-group" data-tbg="model">
       <span class="label" data-i18n="tb.model">Модель</span>
       <button class="tb-btn" data-v="haiku" onclick="setOpt(this,'model')">Haiku</button>
       <button class="tb-btn on" data-v="sonnet" onclick="setOpt(this,'model')">Sonnet</button>
@@ -3400,7 +3405,7 @@ <h3 data-i18n="mob.tabs">Sessions</h3>
       <button class="tb-btn" data-default-star onclick="setDefaultEngine()" data-i18n-title="engine.default.title" title="Зробити поточний рушій типовим для нових чатів" style="padding:0 8px">★</button>
     </div>
     <div class="tb-sep"></div>
-    <div class="tb-group">
+    <div class="tb-group" data-tbg="effort">
       <span class="label" data-i18n="tb.effort">Effort</span>
       <select class="tb-input" id="effortSel" onchange="setEffort(this.value)" style="width:78px" data-i18n-title="effort.title" title="Thinking effort dial (claude --effort): Auto = CLI default, higher levels = deeper reasoning">
         <option value="" data-i18n="effort.auto">Auto</option>
@@ -3412,9 +3417,17 @@ <h3 data-i18n="mob.tabs">Sessions</h3>
       </select>
     </div>
     <div class="tb-sep"></div>
-    <div class="tb-group">
+    <div class="tb-group" data-tbg="turns">
       <span class="label" data-i18n="tb.turns">Кроки</span>
-      <input type="number" class="tb-input" id="maxTurns" value="50" min="1" max="200">
+      <input type="number" class="tb-input" id="maxTurns" value="50" min="1" max="200" onchange="markDefaultOverrides()">
+    </div>
+    <div class="tb-sep"></div>
+    <div class="tb-group">
+      <span class="label" data-i18n="tb.defaults">Типове</span>
+      <button class="tb-btn" id="pinDefaultsBtn" onclick="pinProjectDefaults()"
+        data-i18n-title="defaults.pin.title" title="Save the five dials above as this project's defaults">★</button>
+      <button class="tb-btn" id="resetDefaultsBtn" onclick="resetProjectDefaults()" style="display:none"
+        data-i18n-title="defaults.reset.title" title="Drop this project's overrides and inherit the global defaults">↺</button>
     </div>
   </div>
   </div><!-- /hdr-collapse-zone -->
@@ -4571,6 +4584,7 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     'cfg.search.aria':'Пошук параметрів',
     'cfg.search.none':'Нічого не знайдено за «{q}»',
     'cfg.sec.engine':'🤖 Моделі та рушій',
+    'cfg.sec.defaults':'⭐ Типові значення нового чату',
     'cfg.sec.agents':'👥 Агенти й ліміти запуску',
     'cfg.sec.workspace':'📁 Робоча директорія',
     'cfg.sec.mcp':'🔌 MCP, навички, команди',
@@ -4605,6 +4619,7 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     'cfg.reset.done':'Скинуто до вбудованого значення',
     'cfg.saved_restart':'Збережено — перезапустіть сервер, щоб застосувати',
     'cfg.h.defaultEngine':'Рушій, попередньо вибраний для нових чатів і задач: API (без інтерфейсу) або Subscription (Claude Max).',
+    'cfg.h.chatDefaults.mode':'Режим, на якому відкривається новий чат. Проєкт може перевизначити його кнопкою ★ на панелі.','cfg.h.chatDefaults.agent':'Режим агента для нового чату: single, multi, dispatch або conversation.','cfg.h.chatDefaults.model':'Модель, попередньо вибрана для нового чату.','cfg.h.chatDefaults.effort':'Рівень обдумування для нового чату; auto — без прапорця --effort.','cfg.h.chatDefaults.turns':'Ліміт кроків для нового чату (1–200).',
     'cfg.h.ANTHROPIC_BASE_URL':'Направляє запити Claude CLI через проксі чи шлюз замість прямого звернення до Anthropic.',
     'cfg.h.ANTHROPIC_API_KEY':'Ключ API для рушія API, коли claude CLI не має входу в акаунт.',
     'cfg.h.ANTHROPIC_AUTH_TOKEN':'Токен для проксі, заданого в ANTHROPIC_BASE_URL.',
@@ -4919,6 +4934,7 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     'engine.default.toast':'★ {engine} — типовий рушій для нових чатів','engine.default.err':'⚠ Не вдалося зберегти типовий рушій',
     'tb.effort':'Зусилля','effort.title':'Рівень обдумування (claude --effort): Авто — типове значення CLI, вищі рівні — глибші міркування',
     'effort.auto':'Авто','effort.low':'Низьке','effort.med':'Середнє','effort.high':'Високе','effort.xhigh':'Дуже високе','effort.max':'Максимальне',
+    'tb.defaults':'Типове','defaults.pin.title':'Зберегти поточні Режим / Агент / Модель / Effort / Кроки як типові для цього проєкту','defaults.reset.title':'Прибрати перевизначення проєкту й успадкувати глобальні типові значення','defaults.noproject':'Спершу відкрийте проєкт','defaults.pinned':'Типові значення проєкту збережено','defaults.reset.done':'Проєкт успадковує глобальні типові значення',
     'catchup.btn':'⤵ Дочитати','catchup.title':'Дочитати у чат повідомлення, набрані напряму в терміналі (claude --resume)',
     'catchup.err':'Не вдалося дочитати','catchup.baseline':'✓ Базову позицію встановлено — попрацюйте в терміналі й натисніть ще раз',
     'catchup.done':'✓ Дочитано з терміналу: {n}','catchup.none':'Нічого нового з терміналу','catchup.fail':'⚠ Помилка дочитування',
@@ -4950,6 +4966,7 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     'cfg.search.aria':'Search settings',
     'cfg.search.none':'Nothing matches “{q}”',
     'cfg.sec.engine':'🤖 Models and engine',
+    'cfg.sec.defaults':'⭐ New-chat defaults',
     'cfg.sec.agents':'👥 Agents and run limits',
     'cfg.sec.workspace':'📁 Workspace',
     'cfg.sec.mcp':'🔌 MCP, skills, commands',
@@ -4984,6 +5001,7 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     'cfg.reset.done':'Reset to the built-in default',
     'cfg.saved_restart':'Saved — restart the server to apply',
     'cfg.h.defaultEngine':'Engine preselected for new chats and tasks: API (headless) or Subscription (Claude Max).',
+    'cfg.h.chatDefaults.mode':'Mode a new chat opens on. A project can pin its own with the \u2605 button in the toolbar.','cfg.h.chatDefaults.agent':'Agent mode for a new chat: single, multi, dispatch or conversation.','cfg.h.chatDefaults.model':'Model preselected for a new chat.','cfg.h.chatDefaults.effort':'Thinking effort for a new chat; auto means no --effort flag is passed.','cfg.h.chatDefaults.turns':'Turn limit for a new chat (1\u2013200).',
     'cfg.h.ANTHROPIC_BASE_URL':'Route Claude CLI requests through a proxy or gateway instead of Anthropic directly.',
     'cfg.h.ANTHROPIC_API_KEY':'API key for the API engine when the claude CLI is not signed in.',
     'cfg.h.ANTHROPIC_AUTH_TOKEN':'Token for the proxy set in ANTHROPIC_BASE_URL.',
@@ -5298,6 +5316,7 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     'engine.default.toast':'★ {engine} — default engine for new chats','engine.default.err':'⚠ Could not save the default engine',
     'tb.effort':'Effort','effort.title':'Thinking effort dial (claude --effort): Auto = CLI default, higher levels = deeper reasoning',
     'effort.auto':'Auto','effort.low':'Low','effort.med':'Med','effort.high':'High','effort.xhigh':'X-High','effort.max':'Max',
+    'tb.defaults':'Defaults','defaults.pin.title':'Save the current Mode / Agent / Model / Effort / Turns as this project\u2019s defaults','defaults.reset.title':'Drop this project\u2019s overrides and inherit the global defaults','defaults.noproject':'Open a project first','defaults.pinned':'Project defaults saved','defaults.reset.done':'Project inherits the global defaults',
     'catchup.btn':'⤵ Catch up','catchup.title':'Pull messages typed directly in the terminal into this chat (claude --resume)',
     'catchup.err':'Could not catch up','catchup.baseline':'✓ Baseline set — work in the terminal, then press again',
     'catchup.done':'✓ Caught up from the terminal: {n}','catchup.none':'Nothing new from the terminal','catchup.fail':'⚠ Catch-up failed',
@@ -5329,6 +5348,7 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     'cfg.search.aria':'Поиск параметров',
     'cfg.search.none':'Ничего не найдено по «{q}»',
     'cfg.sec.engine':'🤖 Модели и движок',
+    'cfg.sec.defaults':'⭐ Значения по умолчанию для нового чата',
     'cfg.sec.agents':'👥 Агенты и лимиты запуска',
     'cfg.sec.workspace':'📁 Рабочая директория',
     'cfg.sec.mcp':'🔌 MCP, навыки, команды',
@@ -5363,6 +5383,7 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     'cfg.reset.done':'Сброшено до встроенного значения',
     'cfg.saved_restart':'Сохранено — перезапустите сервер, чтобы применить',
     'cfg.h.defaultEngine':'Движок, предварительно выбранный для новых чатов и задач: API (без интерфейса) или Subscription (Claude Max).',
+    'cfg.h.chatDefaults.mode':'Режим, с которым открывается новый чат. Проект может переопределить его кнопкой ★ на панели.','cfg.h.chatDefaults.agent':'Режим агента для нового чата: single, multi, dispatch или conversation.','cfg.h.chatDefaults.model':'Модель, предварительно выбранная для нового чата.','cfg.h.chatDefaults.effort':'Уровень обдумывания для нового чата; auto — без флага --effort.','cfg.h.chatDefaults.turns':'Лимит шагов для нового чата (1–200).',
     'cfg.h.ANTHROPIC_BASE_URL':'Направляет запросы Claude CLI через прокси или шлюз вместо прямого обращения к Anthropic.',
     'cfg.h.ANTHROPIC_API_KEY':'Ключ API для движка API, когда claude CLI не выполнил вход.',
     'cfg.h.ANTHROPIC_AUTH_TOKEN':'Токен для прокси, заданного в ANTHROPIC_BASE_URL.',
@@ -5677,6 +5698,7 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     'engine.default.toast':'★ {engine} — основной движок для новых чатов','engine.default.err':'⚠ Не удалось сохранить основной движок',
     'tb.effort':'Усилие','effort.title':'Уровень обдумывания (claude --effort): Авто — значение CLI по умолчанию, более высокие уровни — более глубокие рассуждения',
     'effort.auto':'Авто','effort.low':'Низкое','effort.med':'Среднее','effort.high':'Высокое','effort.xhigh':'Очень высокое','effort.max':'Максимальное',
+    'tb.defaults':'По умолчанию','defaults.pin.title':'Сохранить текущие Режим / Агент / Модель / Effort / Шаги как значения по умолчанию для этого проекта','defaults.reset.title':'Убрать переопределения проекта и унаследовать глобальные значения по умолчанию','defaults.noproject':'Сначала откройте проект','defaults.pinned':'Значения по умолчанию для проекта сохранены','defaults.reset.done':'Проект наследует глобальные значения по умолчанию',
     'catchup.btn':'⤵ Дочитать','catchup.title':'Подтянуть в чат сообщения, набранные прямо в терминале (claude --resume)',
     'catchup.err':'Не удалось дочитать','catchup.baseline':'✓ Базовая позиция установлена — поработайте в терминале и нажмите ещё раз',
     'catchup.done':'✓ Дочитано из терминала: {n}','catchup.none':'Ничего нового из терминала','catchup.fail':'⚠ Ошибка дочитывания',
@@ -5708,6 +5730,7 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     'cfg.search.aria':'Rechercher un paramètre',
     'cfg.search.none':'Aucun résultat pour « {q} »',
     'cfg.sec.engine':'🤖 Modèles et moteur',
+    'cfg.sec.defaults':'⭐ Valeurs par défaut d\u2019un nouveau chat',
     'cfg.sec.agents':'👥 Agents et limites d’exécution',
     'cfg.sec.workspace':'📁 Répertoire de travail',
     'cfg.sec.mcp':'🔌 MCP, compétences, commandes',
@@ -5742,6 +5765,7 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     'cfg.reset.done':'Réinitialisé à la valeur par défaut',
     'cfg.saved_restart':'Enregistré — redémarrez le serveur pour appliquer',
     'cfg.h.defaultEngine':'Moteur présélectionné pour les nouveaux chats et tâches : API (sans interface) ou Subscription (Claude Max).',
+    'cfg.h.chatDefaults.mode':'Mode avec lequel un nouveau chat s\u2019ouvre. Un projet peut le surcharger avec le bouton \u2605 de la barre d\u2019outils.','cfg.h.chatDefaults.agent':'Mode agent d\u2019un nouveau chat : single, multi, dispatch ou conversation.','cfg.h.chatDefaults.model':'Modèle présélectionné pour un nouveau chat.','cfg.h.chatDefaults.effort':'Niveau de réflexion d\u2019un nouveau chat ; auto n\u2019envoie aucun indicateur --effort.','cfg.h.chatDefaults.turns':'Limite de tours d\u2019un nouveau chat (1\u2013200).',
     'cfg.h.ANTHROPIC_BASE_URL':'Fait passer les requêtes du CLI Claude par un proxy ou une passerelle au lieu d’Anthropic directement.',
     'cfg.h.ANTHROPIC_API_KEY':'Clé API du moteur API lorsque le CLI claude n’est pas connecté.',
     'cfg.h.ANTHROPIC_AUTH_TOKEN':'Jeton du proxy défini dans ANTHROPIC_BASE_URL.',
@@ -5957,6 +5981,7 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     "engine.default.toast":"★ {engine} — moteur par défaut des nouvelles discussions","engine.default.err":"⚠ Impossible d'enregistrer le moteur par défaut",
     "tb.effort":"Effort","effort.title":"Niveau de réflexion (claude --effort) : Auto = valeur par défaut du CLI, les niveaux supérieurs raisonnent plus en profondeur",
     "effort.auto":"Auto","effort.low":"Faible","effort.med":"Moyen","effort.high":"Élevé","effort.xhigh":"Très élevé","effort.max":"Maximal",
+    "tb.defaults":"Par défaut","defaults.pin.title":"Enregistrer les valeurs Mode / Agent / Modèle / Effort / Tours actuelles comme valeurs par défaut de ce projet","defaults.reset.title":"Supprimer les surcharges de ce projet et hériter des valeurs par défaut globales","defaults.noproject":"Ouvrez d\u2019abord un projet","defaults.pinned":"Valeurs par défaut du projet enregistrées","defaults.reset.done":"Le projet hérite des valeurs par défaut globales",
     "catchup.btn":"⤵ Rattraper","catchup.title":"Reprendre dans la discussion les messages saisis directement dans le terminal (claude --resume)",
     "catchup.err":"Impossible de rattraper","catchup.baseline":"✓ Point de repère enregistré — travaillez dans le terminal, puis cliquez à nouveau",
     "catchup.done":"✓ Rattrapé depuis le terminal : {n}","catchup.none":"Rien de nouveau dans le terminal","catchup.fail":"⚠ Échec du rattrapage",
@@ -5988,6 +6013,7 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     'cfg.search.aria':'חיפוש הגדרות',
     'cfg.search.none':'אין תוצאות עבור «{q}»',
     'cfg.sec.engine':'🤖 מודלים ומנוע',
+    'cfg.sec.defaults':'⭐ ברירות מחדל לצ׳אט חדש',
     'cfg.sec.agents':'👥 סוכנים ומגבלות הרצה',
     'cfg.sec.workspace':'📁 תיקיית עבודה',
     'cfg.sec.mcp':'🔌 MCP, מיומנויות, פקודות',
@@ -6022,6 +6048,7 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     'cfg.reset.done':'אופס לברירת המחדל',
     'cfg.saved_restart':'נשמר — הפעילו מחדש את השרת כדי להחיל',
     'cfg.h.defaultEngine':'המנוע שנבחר מראש עבור צ׳אטים ומשימות חדשים: API (ללא ממשק) או Subscription‏ (Claude Max).',
+    'cfg.h.chatDefaults.mode':'המצב שבו נפתח צ׳אט חדש. פרויקט יכול לקבוע ערך משלו בעזרת הכפתור ★ בסרגל הכלים.','cfg.h.chatDefaults.agent':'מצב הסוכן לצ׳אט חדש: single, multi, dispatch או conversation.','cfg.h.chatDefaults.model':'המודל שנבחר מראש לצ׳אט חדש.','cfg.h.chatDefaults.effort':'רמת החשיבה לצ׳אט חדש; auto פירושו שלא נשלח דגל ‎--effort‎.','cfg.h.chatDefaults.turns':'מגבלת הצעדים לצ׳אט חדש (1–200).',
     'cfg.h.ANTHROPIC_BASE_URL':'מנתב את בקשות ה-CLI של Claude דרך פרוקסי או שער במקום ישירות ל-Anthropic.',
     'cfg.h.ANTHROPIC_API_KEY':'מפתח API עבור מנוע ה-API כאשר ה-CLI של claude אינו מחובר.',
     'cfg.h.ANTHROPIC_AUTH_TOKEN':'אסימון עבור הפרוקסי שהוגדר ב-ANTHROPIC_BASE_URL.',
@@ -6209,6 +6236,7 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     "engine.default.toast":"★ {engine} — מנוע ברירת המחדל לצ׳אטים חדשים","engine.default.err":"⚠ שמירת מנוע ברירת המחדל נכשלה",
     "tb.effort":"מאמץ","effort.title":"רמת החשיבה (claude --effort): אוטומטי = ברירת המחדל של ה-CLI, רמות גבוהות יותר = חשיבה מעמיקה יותר",
     "effort.auto":"אוטומטי","effort.low":"נמוך","effort.med":"בינוני","effort.high":"גבוה","effort.xhigh":"גבוה מאוד","effort.max":"מרבי",
+    "tb.defaults":"ברירת מחדל","defaults.pin.title":"שמירת המצב / הסוכן / המודל / המאמץ / הצעדים הנוכחיים כברירת המחדל של הפרויקט הזה","defaults.reset.title":"הסרת ההגדרות הייעודיות של הפרויקט וירושת ברירות המחדל הגלובליות","defaults.noproject":"יש לפתוח פרויקט תחילה","defaults.pinned":"ברירות המחדל של הפרויקט נשמרו","defaults.reset.done":"הפרויקט יורש את ברירות המחדל הגלובליות",
     "catchup.btn":"⤵ להשלים","catchup.title":"למשוך לצ׳אט הודעות שהוקלדו ישירות בטרמינל (claude --resume)",
     "catchup.err":"ההשלמה נכשלה","catchup.baseline":"✓ נקודת הבסיס נקבעה — עבדו בטרמינל ולחצו שוב",
     "catchup.done":"✓ הושלמו מהטרמינל: {n}","catchup.none":"אין חדש מהטרמינל","catchup.fail":"⚠ שגיאה בהשלמה",
@@ -10606,12 +10634,13 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
   _clearAttachments();
   clearReply();
   clearBotsStrip();
-  // Reset skills and mode settings for new tab — new chat = clean slate
+  // Reset skills for new tab — new chat = clean slate
   activeSkills = new Set();
-  curAgent = 'single';
-  curMode = 'auto';
-  syncBtn('agent', 'single');
-  syncBtn('mode', 'auto');
+  // Issue #58: a new chat opens on the project's defaults (global, with this
+  // project's overrides on top) instead of the literals that used to sit here.
+  // applyChatDefaults() no-ops until the first /api/chat-defaults answer lands,
+  // and _chatDefaults itself is seeded with the same built-ins the server uses.
+  applyChatDefaults();
   // New chat starts from the global default — handled centrally by showW() below
   // New tab is never generating — reset interrupt bar and stop button
   isGen = false; generatingTabId = null; setSendStop(false);
@@ -10769,6 +10798,86 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
 }
 
 // ─── Toolbar ─────────────────────────────────────────────────────────────
+// ─── Global chat defaults + this project's overrides (issue #58) ───────────
+// The global half is edited in Settings (chatDefaults.* rows); the per-project
+// half is the star button in the toolbar. What lands here is the RESOLVED answer
+// for the active project plus the list of dials that project pinned, which is
+// what the group dots are drawn from.
+let _chatDefaults = null;
+
+async function loadChatDefaults(projectId) {
+  const q = projectId ? '?projectId=' + encodeURIComponent(projectId) : '';
+  try {
+    const r = await fetch('/api/chat-defaults' + q);
+    if (r.ok) _chatDefaults = await r.json();
+  } catch { /* offline: keep whatever we already resolved, never blank the dials */ }
+  markDefaultOverrides();
+  return _chatDefaults;
+}
+
+// Seed the toolbar. Called for a NEW chat only — an existing session carries its
+// own mode/model in the DB and loadSess() must keep winning over any default.
+function applyChatDefaults() {
+  const d = _chatDefaults && _chatDefaults.effective;
+  if (!d) return;
+  curMode = d.mode; curAgent = d.agent; curModel = d.model;
+  syncBtn('mode', d.mode); syncBtn('agent', d.agent); syncBtn('model', d.model);
+  setEffort(d.effort === 'auto' ? '' : d.effort);
+  const es = $i('effortSel'); if (es) es.value = curEffort;
+  const mt = $i('maxTurns'); if (mt) mt.value = d.turns;
+  markDefaultOverrides();
+  if (typeof updateMobSubtitle === 'function') updateMobSubtitle();
+}
+
+// A dot on every group the project pinned. Also the only place that decides
+// whether the reset button is worth showing — with nothing pinned it would be a
+// button that cannot do anything.
+function markDefaultOverrides() {
+  const ov = new Set((_chatDefaults && _chatDefaults.overridden) || []);
+  document.querySelectorAll('.tb-group[data-tbg]').forEach(g => {
+    g.classList.toggle('tbg-override', ov.has(g.dataset.tbg));
+  });
+  const pin = $i('pinDefaultsBtn');
+  if (pin) pin.classList.toggle('on', ov.size > 0);
+  const rst = $i('resetDefaultsBtn');
+  if (rst) rst.style.display = ov.size ? '' : 'none';
+}
+
+// Pin the CURRENT five dials to the active project. Sends all five rather than a
+// diff against the global: the user's mental model is "remember what I see", and
+// a value that merely happens to equal the global today must stay pinned when
+// the global changes tomorrow.
+async function pinProjectDefaults() {
+  if (!curProjectId) { toast(t('defaults.noproject')); return; }
+  const body = {
+    mode: curMode, agent: curAgent, model: curModel,
+    effort: curEffort || 'auto',
+    turns: Math.max(1, Math.min(200, parseInt($i('maxTurns')?.value, 10) || 50)),
+  };
+  try {
+    const r = await fetch(`/api/projects/${curProjectId}/defaults`, {
+      method: 'PUT', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body),
+    });
+    const d = await r.json();
+    if (!r.ok) { toast('✗ ' + (d.error || r.status)); return; }
+    _chatDefaults = d;
+    markDefaultOverrides();
+    toast('✓ ' + t('defaults.pinned'));
+  } catch (e) { toast('✗ ' + e.message); }
+}
+
+async function resetProjectDefaults() {
+  if (!curProjectId) return;
+  try {
+    const r = await fetch(`/api/projects/${curProjectId}/defaults`, { method: 'DELETE' });
+    const d = await r.json();
+    if (!r.ok) { toast('✗ ' + (d.error || r.status)); return; }
+    _chatDefaults = d;
+    applyChatDefaults();
+    toast('✓ ' + t('defaults.reset.done'));
+  } catch (e) { toast('✗ ' + e.message); }
+}
+
 function setOpt(btn, group) {
   btn.closest('.tb-group').querySelectorAll('.tb-btn').forEach(b => b.classList.remove('on'));
   btn.classList.add('on');
@@ -11702,6 +11811,9 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     // chat's explicit run_engine wins; a chat without one inherits this default.
     _globalDefaultEngine = local.defaultEngine === 'subscription' ? 'subscription' : 'api';
     resolveEngineForView();
+    // Issue #58: resolve the dials for whatever project the session restored to.
+    // Only a brand-new tab is seeded — a restored chat keeps what it was saved with.
+    loadChatDefaults(curProjectId).then(() => { if (!currentSessionId) applyChatDefaults(); });
     const el = $i('versionBadge');
     if (!el) return;
     const cur = local.version || '?';
@@ -14862,6 +14974,9 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
 
   renderProjects(); saveUIState(); loadHist(); loadFiles(''); updateSessBar();
   loadBots(); // roster is per-project: without this the sidebar keeps the old project's bots
+  // Defaults are per project too. Applied only to a tab that has no session of
+  // its own — an existing chat's stored mode/model must not be overwritten.
+  loadChatDefaults(id).then(() => { if (!currentSessionId) applyChatDefaults(); });
   toast(`✓ ${p.name}`);
 }
 
diff --git a/server.js b/server.js
index 846d2bd3..bd7add24 100644
--- a/server.js
+++ b/server.js
@@ -94,6 +94,7 @@ const agentsMd = require('./agents-md');
 // Read-only remote file browsing (issue #57). Its path guard is POSIX-only on
 // purpose — see the header of the module.
 const remoteFiles = require('./remote-files');
+const chatDefaults = require('./chat-defaults');
 const { isTransientOverload, shouldRetryOverload, detectUsageLimit, taskStatusForStop } = require('./rate-limit-utils');
 const { buildTerminalCommand: buildDelegateCommand, winTerminalArgs } = require('./delegate-terminal');
 const { isAgentSuccess, shouldAutoContinue, agentStopReason } = require('./multi-agent-result');
@@ -3006,6 +3007,18 @@ function loadMergedConfig() {
     slashCommands: [...(l.slashCommands||[])],
     lang:          l.lang || g.lang || 'en',
     defaultEngine: l.defaultEngine || g.defaultEngine || 'api',
+    // Per KEY, not per object: a local config that pins only `model` must not
+    // wipe a global `mode`. Same shape as mcpServers/skills above, and it is what
+    // the settings catalog reports for chatDefaults.* (merge:'merged').
+    //
+    // Each layer is sanitised BEFORE the spread, not after. Spreading raw objects
+    // lets a local `model:""` (or a typo) mask a valid global `model:"opus"`, and
+    // the merged garbage then falls all the way to BUILTIN instead of to the
+    // global — while the settings catalog, which walks the two files separately
+    // under `falsyFallsThrough`, keeps reporting "opus" as effective. Two answers
+    // for one key. Sanitising per layer IS the `||` semantics the flag advertises.
+    chatDefaults:  { ...chatDefaults.sanitize(g.chatDefaults).value,
+                     ...chatDefaults.sanitize(l.chatDefaults).value },
     recentProjectsCount: l.recentProjectsCount ?? g.recentProjectsCount ?? 5,
   });
   return _mergedConfigCache;
@@ -8296,6 +8309,63 @@ app.delete('/api/projects/:id', (req,res) => {
   res.json({ ok:true });
 });
 
+// ─── Chat defaults: global, with a sparse per-project override (issue #58) ────
+// The global half is edited through the ordinary settings form (chatDefaults.* in
+// config-resolve.js). This endpoint answers the question the SPA actually has:
+// "which five values should the toolbar open on for THIS project, and which of
+// them did the project pin?"
+app.get('/api/chat-defaults', (req, res) => {
+  const id = String(req.query.projectId || '');
+  // No id at all = "just the global row" (the global workspace asks for exactly
+  // that). A WRONG id is 404, matching PUT/DELETE below: answering 200 with an
+  // empty `overridden` would render a stale project as one that pinned nothing.
+  const proj = id ? loadProjects().find(p => p.id === id) : null;
+  if (id && !proj) return res.status(404).json({ error: 'not found' });
+  res.json(chatDefaults.resolveChatDefaults(loadMergedConfig().chatDefaults, proj && proj.defaults));
+});
+
+// Pin some of the five for one project. The body carries ONLY the keys being
+// pinned; a key sent as null/'' stops being pinned. The stored object stays
+// sparse on purpose — see the header of chat-defaults.js.
+app.put('/api/projects/:id/defaults', (req, res) => {
+  const projects = loadProjects();
+  const proj = projects.find(p => p.id === req.params.id);
+  if (!proj) return res.status(404).json({ error: 'not found' });
+
+  const body = req.body && typeof req.body === 'object' && req.body.defaults !== undefined
+    ? req.body.defaults : req.body;
+  // `{defaults:null}` and a bare string both used to land here as a 200 no-op,
+  // which reads exactly like a reset that worked. Reset is the DELETE below.
+  if (!body || typeof body !== 'object' || Array.isArray(body)) {
+    return res.status(400).json({ error: 'invalid_body' });
+  }
+  const { value, invalid } = chatDefaults.sanitize(body);
+  // Refused, not trimmed: dropping a key the user just clicked would look
+  // exactly like a save that worked.
+  if (invalid.length) return res.status(400).json({ error: 'invalid_defaults', keys: invalid });
+
+  // Only the keys named in the request are touched; the rest keep their state,
+  // so pinning `model` does not silently unpin `turns`.
+  const next = { ...(chatDefaults.sanitize(proj.defaults).value) };
+  for (const k of chatDefaults.KEYS) {
+    if (!(k in Object(body))) continue;
+    if (k in value) next[k] = value[k]; else delete next[k];
+  }
+  if (Object.keys(next).length) proj.defaults = next; else delete proj.defaults;
+  saveProjects(projects);
+  res.json({ ok: true, ...chatDefaults.resolveChatDefaults(loadMergedConfig().chatDefaults, proj.defaults) });
+});
+
+// "Reset to Defaults" at project level: drop every pin, fall back to global.
+app.delete('/api/projects/:id/defaults', (req, res) => {
+  const projects = loadProjects();
+  const proj = projects.find(p => p.id === req.params.id);
+  if (!proj) return res.status(404).json({ error: 'not found' });
+  delete proj.defaults;
+  saveProjects(projects);
+  res.json({ ok: true, ...chatDefaults.resolveChatDefaults(loadMergedConfig().chatDefaults, null) });
+});
+
 // ─── Remote SSH Hosts CRUD ────────────────────────────────────────────────────
 app.get('/api/remote-hosts', (_,res) => res.json(
   loadRemoteHosts().map(h => ({ ...h, password: h.password ? '***' : '' }))
diff --git a/test/chat-defaults-api.test.js b/test/chat-defaults-api.test.js
new file mode 100644
index 00000000..ef329033
--- /dev/null
+++ b/test/chat-defaults-api.test.js
@@ -0,0 +1,236 @@
+// Global chat defaults + per-project overrides over HTTP — issue #58.
+//
+// test/chat-defaults.test.js pins the resolver in isolation. This one boots a real
+// server in a throwaway APP_DIR and drives the three endpoints the SPA calls, plus
+// the settings-form path that owns the global half. What it is here to catch:
+//
+//   - "the global half is edited through the ordinary settings form" — if the
+//     catalog entries were dropped, PUT /api/config/setting would 400 and the
+//     Settings section would render empty with no other test noticing.
+//   - "a PUT touches only the keys it names" — the bug that would otherwise ship
+//     is pinning Model and silently unpinning Turns.
+//   - "an invalid value is refused, not trimmed" — a trimmed key looks exactly
+//     like a save that worked.
+//   - the stored object stays SPARSE, so an unpinned dial keeps following the
+//     global. A five-key snapshot passes every other assertion here and still
+//     breaks the feature.
+//
+// Run: node test/chat-defaults-api.test.js   (TEST_PORT=<n> to move off the default)
+'use strict';
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawn } = require('child_process');
+
+let pass = 0, fail = 0;
+function check(label, actual, expected) {
+  try { assert.deepStrictEqual(actual, expected); pass++; console.log(`  ok   ${label}`); }
+  catch { fail++; console.error(`  FAIL ${label} — expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`); }
+}
+const sleep = ms => new Promise(r => setTimeout(r, ms));
+
+const PORT = Number(process.env.TEST_PORT || 4537);
+const BASE = `http://127.0.0.1:${PORT}`;
+
+const APP_DIR  = fs.mkdtempSync(path.join(os.tmpdir(), 'ccs-cd58-app-'));
+const HOME_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'ccs-cd58-home-'));
+process.on('exit', () => { for (const d of [APP_DIR, HOME_DIR]) { try { fs.rmSync(d, { recursive: true, force: true }); } catch {} } });
+fs.mkdirSync(path.join(APP_DIR, 'data'), { recursive: true });
+const WORKDIR = path.join(APP_DIR, 'workspace');
+const PROJ_A = path.join(WORKDIR, 'alpha');
+const PROJ_B = path.join(WORKDIR, 'beta');
+fs.mkdirSync(PROJ_A, { recursive: true });
+fs.mkdirSync(PROJ_B, { recursive: true });
+
+// Both config layers are seeded, so the very first answer has to come from the
+// merge chain rather than from the built-ins. `agent` is the interesting pair:
+// the GLOBAL file pins a real value and the LOCAL one carries an empty string.
+// Spread the two raw and the '' masks 'multi', then sanitising drops it to the
+// built-in 'single' — a value neither file ever named. Sanitising per layer is
+// what makes the empty local fall through to the global instead.
+fs.mkdirSync(path.join(HOME_DIR, '.claude'), { recursive: true });
+fs.writeFileSync(path.join(HOME_DIR, '.claude', 'config.json'),
+  JSON.stringify({ chatDefaults: { agent: 'multi' } }, null, 2));
+fs.writeFileSync(path.join(APP_DIR, 'config.json'),
+  JSON.stringify({ mcpServers: {}, skills: {}, chatDefaults: { mode: 'task', agent: '' } }, null, 2));
+
+let srvLog = '';
+const child = spawn(process.execPath, [path.join(__dirname, '..', 'server.js')], {
+  env: { ...process.env, PORT: String(PORT), CCS_DESKTOP: '1', APP_DIR, WORKDIR, HOME: HOME_DIR },
+  stdio: ['ignore', 'pipe', 'pipe'],
+});
+let exited = false;
+child.on('exit', () => { exited = true; });
+child.stdout.on('data', d => { srvLog += d; });
+child.stderr.on('data', d => { srvLog += d; });
+
+let cleanedUp = false;
+function cleanup() { if (cleanedUp) return; cleanedUp = true; if (!exited) { try { child.kill('SIGTERM'); } catch {} } }
+process.on('exit', cleanup);
+for (const sig of ['SIGINT', 'SIGTERM', 'SIGHUP']) process.on(sig, () => { cleanup(); process.exit(1); });
+function die(msg) { console.error(msg); if (srvLog) console.error(srvLog.slice(-2000)); cleanup(); process.exit(1); }
+
+async function api(method, url, body) {
+  const res = await fetch(BASE + url, {
+    method,
+    headers: body !== undefined ? { 'content-type': 'application/json' } : undefined,
+    body: body !== undefined ? JSON.stringify(body) : undefined,
+  });
+  const text = await res.text();
+  let json = null; try { json = JSON.parse(text); } catch {}
+  return { status: res.status, json, text };
+}
+const defaultsOf = async id => (await api('GET', '/api/chat-defaults' + (id ? '?projectId=' + encodeURIComponent(id) : ''))).json;
+const storedDefaults = id => {
+  const raw = JSON.parse(fs.readFileSync(path.join(APP_DIR, 'data', 'projects.json'), 'utf8'));
+  const list = Array.isArray(raw) ? raw : (raw.projects || []);
+  return (list.find(p => p.id === id) || {}).defaults;
+};
+
+(async () => {
+  let up = false;
+  for (let i = 0; i < 80 && !exited; i++) {
+    try { const r = await fetch(BASE + '/api/health'); if (r.ok) { up = true; break; } } catch {}
+    await sleep(250);
+  }
+  if (exited) die(`server exited before it became ready — port ${PORT} collision or startup crash`);
+  if (!up) die(`server on port ${PORT} did not start`);
+  if (!(srvLog.includes('server started') && new RegExp(`"port":\\s*"?${PORT}"?`).test(srvLog))) {
+    die(`something answers /api/health on ${PORT} but our server never logged "server started"`);
+  }
+
+  const a = await api('POST', '/api/projects', { name: 'alpha', workdir: PROJ_A });
+  const b = await api('POST', '/api/projects', { name: 'beta', workdir: PROJ_B });
+  if (a.status !== 200 || !a.json?.id || b.status !== 200) die(`could not create the projects: ${a.text} / ${b.text}`);
+  const A = a.json.id, B = b.json.id;
+
+  console.log('\n— the global half —');
+  const bare = await defaultsOf('');
+  check('a value already in the local config.json is what a chat opens on', bare.effective.mode, 'task');
+  check('an empty LOCAL value falls through to the global, not to the built-in',
+    bare.effective.agent, 'multi');
+  check('the keys neither file names fall back to the built-ins',
+    [bare.effective.model, bare.effective.effort, bare.effective.turns], ['sonnet', 'auto', 50]);
+  // Back to the built-in agent for the rest of the file — as a real local pin,
+  // which also proves a VALID local value still outranks the global.
+  check('a valid local value wins over the global',
+    (await api('PUT', '/api/config/setting', { key: 'chatDefaults.agent', value: 'single' })).json?.setting?.effective,
+    'single');
+
+  // The settings form owns the global half. If the catalog entries went missing
+  // this is the assertion that says so.
+  const setModel = await api('PUT', '/api/config/setting', { key: 'chatDefaults.model', value: 'opus' });
+  check('the settings form accepts chatDefaults.model', setModel.status, 200);
+  check('and reports it as effective', setModel.json?.setting?.effective, 'opus');
+  const setTurns = await api('PUT', '/api/config/setting', { key: 'chatDefaults.turns', value: '5' });
+  check('the settings form accepts chatDefaults.turns', setTurns.status, 200);
+  check('a turns value outside #maxTurns’ own range is refused',
+    (await api('PUT', '/api/config/setting', { key: 'chatDefaults.turns', value: 9999 })).status, 400);
+  check('a model outside the CLI aliases is refused',
+    (await api('PUT', '/api/config/setting', { key: 'chatDefaults.model', value: 'gpt-4' })).status, 400);
+  // The settings row and the toolbar must coerce turns the SAME way, or the two
+  // show different limits for one dial.
+  check('the settings row refuses a numeric prefix the way the resolver does',
+    (await api('PUT', '/api/config/setting', { key: 'chatDefaults.turns', value: '12px' })).status, 400);
+  check('and truncates a float instead of storing it',
+    (await api('PUT', '/api/config/setting', { key: 'chatDefaults.turns', value: 7.9 })).json?.setting?.effective, 7);
+  await api('PUT', '/api/config/setting', { key: 'chatDefaults.turns', value: 5 });
+  const afterGlobal = await defaultsOf('');
+  check('the refused writes changed nothing', [afterGlobal.effective.model, afterGlobal.effective.turns], ['opus', 5]);
+
+  console.log('\n— the project half —');
+  const gotGlobal = await defaultsOf(A);
+  check('a project that pinned nothing inherits every dial',
+    gotGlobal.effective, { mode: 'task', agent: 'single', model: 'opus', effort: 'auto', turns: 5 });
+  check('and reports nothing as overridden', gotGlobal.overridden, []);
+
+  const pin = await api('PUT', `/api/projects/${A}/defaults`, { model: 'sonnet', turns: 10 });
+  check('pinning is accepted', pin.status, 200);
+  // The exact table from the issue body.
+  check('the effective config is the issue’s worked example',
+    pin.json.effective, { mode: 'task', agent: 'single', model: 'sonnet', effort: 'auto', turns: 10 });
+  check('exactly the pinned dials are reported as overridden', pin.json.overridden, ['model', 'turns']);
+  // The whole feature rests on this: a snapshot would pass every check above.
+  check('only the pinned keys reach projects.json', storedDefaults(A), { model: 'sonnet', turns: 10 });
+  check('the other project is untouched', storedDefaults(B), undefined);
+  check('and still inherits', (await defaultsOf(B)).effective.model, 'opus');
+
+  // Sparseness is what makes an unpinned dial follow the global later.
+  await api('PUT', '/api/config/setting', { key: 'chatDefaults.mode', value: 'planning' });
+  check('an unpinned dial follows the global when it changes', (await defaultsOf(A)).effective.mode, 'planning');
+  check('a pinned one does not', (await defaultsOf(A)).effective.model, 'sonnet');
+
+  console.log('\n— what a partial write may touch —');
+  const partial = await api('PUT', `/api/projects/${A}/defaults`, { agent: 'multi' });
+  check('naming one dial pins it', partial.json.effective.agent, 'multi');
+  check('and leaves the dials it did not name alone', storedDefaults(A), { model: 'sonnet', turns: 10, agent: 'multi' });
+  const unpin = await api('PUT', `/api/projects/${A}/defaults`, { agent: null });
+  check('sending a dial as null unpins just that one', storedDefaults(A), { model: 'sonnet', turns: 10 });
+  check('and it goes back to inheriting', unpin.json.effective.agent, 'single');
+
+  const wrapped = await api('PUT', `/api/projects/${A}/defaults`, { defaults: { effort: 'xhigh' } });
+  check('a {defaults:{...}} envelope is accepted too', wrapped.json.effective.effort, 'xhigh');
+  await api('PUT', `/api/projects/${A}/defaults`, { effort: null });
+
+  console.log('\n— refusals —');
+  const bad = await api('PUT', `/api/projects/${A}/defaults`, { model: 'gpt-4', turns: 10 });
+  check('an invalid value is refused', bad.status, 400);
+  check('and the offending key is named', bad.json.keys, ['model']);
+  check('nothing was written by the refused call', storedDefaults(A), { model: 'sonnet', turns: 10 });
+  check('a key outside the five is refused', (await api('PUT', `/api/projects/${A}/defaults`, { engine: 'api' })).status, 400);
+  // Sending an unknown key as null used to slip past as an unpin and answer 200.
+  check('an unknown key sent as null is still refused',
+    (await api('PUT', `/api/projects/${A}/defaults`, { notADial: null })).status, 400);
+  // A 200 here reads exactly like a reset that worked. Reset is the DELETE.
+  check('a null body is refused rather than answered as a no-op',
+    (await api('PUT', `/api/projects/${A}/defaults`, { defaults: null })).status, 400);
+  check('and so is a body that is not an object at all',
+    (await api('PUT', `/api/projects/${A}/defaults`, 'sonnet')).status, 400);
+  check('turns above the input’s own max is refused',
+    (await api('PUT', `/api/projects/${A}/defaults`, { turns: 9999 })).status, 400);
+  check('an unknown project is 404, not 500', (await api('PUT', '/api/projects/proj-nope/defaults', { model: 'opus' })).status, 404);
+  check('and so is a reset on one', (await api('DELETE', '/api/projects/proj-nope/defaults')).status, 404);
+  // A stale projectId answered 200 with an empty `overridden`, which the SPA
+  // cannot tell apart from a project that genuinely pinned nothing.
+  check('reading an unknown project is 404 too', (await api('GET', '/api/chat-defaults?projectId=proj-nope')).status, 404);
+  check('but no projectId at all is still the global row',
+    (await api('GET', '/api/chat-defaults')).status, 200);
+
+  console.log('\n— reset to defaults —');
+  const reset = await api('DELETE', `/api/projects/${A}/defaults`);
+  check('the reset is accepted', reset.status, 200);
+  check('every pin is gone from projects.json', storedDefaults(A), undefined);
+  check('and the project is back on the global row', reset.json.effective, reset.json.global);
+  check('with nothing left marked as overridden', reset.json.overridden, []);
+  check('resetting a project that pinned nothing is still fine',
+    (await api('DELETE', `/api/projects/${B}/defaults`)).status, 200);
+
+  // The global half resets through the same form row, by removing the key rather
+  // than writing the built-in in as an explicit value.
+  await api('DELETE', '/api/config/setting?key=chatDefaults.model');
+  check('resetting the global row falls back to the built-in', (await defaultsOf(A)).effective.model, 'sonnet');
+  check('and the key is gone from config.json',
+    JSON.parse(fs.readFileSync(path.join(APP_DIR, 'config.json'), 'utf8')).chatDefaults.model, undefined);
+  check('while its siblings in the same block survive',
+    JSON.parse(fs.readFileSync(path.join(APP_DIR, 'config.json'), 'utf8')).chatDefaults.turns, 5);
+
+  console.log('\n— what /api/projects hands the browser —');
+  await api('PUT', `/api/projects/${A}/defaults`, { model: 'haiku' });
+  const list = await api('GET', '/api/projects');
+  const listed = list.json.find(p => p.id === A);
+  check('the project row carries its overrides so the UI can badge them', listed.defaults, { model: 'haiku' });
+  check('and still carries no password field', 'password' in listed, false);
+
+  // The Settings UI renders whatever the resolver reports; an entry missing from
+  // the response is a section that silently loses a row.
+  const resolved = await api('GET', '/api/config/resolved');
+  check('the resolver reports all five rows',
+    resolved.json.settings.filter(s => s.section === 'defaults').map(s => s.key),
+    ['chatDefaults.mode', 'chatDefaults.agent', 'chatDefaults.model', 'chatDefaults.effort', 'chatDefaults.turns']);
+  check('and the section itself is declared', resolved.json.sections.includes('defaults'), true);
+
+  cleanup();
+  console.log(`\n${fail === 0 ? 'PASS' : 'FAIL'} — ${pass} passed, ${fail} failed`);
+  process.exit(fail === 0 ? 0 : 1);
+})().catch(e => die(String(e && e.stack || e)));
diff --git a/test/chat-defaults.test.js b/test/chat-defaults.test.js
new file mode 100644
index 00000000..20d03fb4
--- /dev/null
+++ b/test/chat-defaults.test.js
@@ -0,0 +1,163 @@
+// Global chat defaults + per-project overrides — issue #58, the pure half.
+//
+// What the resolver has to get right, and what breaks if it does not:
+//   - the chain is project > global > BUILTIN, and BUILTIN must still be exactly
+//     what the SPA hardcoded before this existed. Change one and every install
+//     that never opened the settings form silently changes behaviour.
+//   - a project stores ONLY the keys it pins. A full five-key snapshot would
+//     freeze each project at whatever the global happened to be that day, which
+//     is the opposite of what the issue asked for.
+//   - a bad value in a hand-edited config.json drops that one key, never the
+//     other four; a bad value in a WRITE is named, so the endpoint can refuse.
+//
+// Run: node test/chat-defaults.test.js
+'use strict';
+const assert = require('assert');
+const CD = require('../chat-defaults');
+
+let pass = 0, fail = 0;
+function check(label, actual, expected) {
+  try { assert.deepStrictEqual(actual, expected); pass++; console.log(`  ok   ${label}`); }
+  catch { fail++; console.error(`  FAIL ${label} — expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`); }
+}
+
+console.log('the built-ins are the behaviour that already shipped:');
+{
+  // These five are read off public/index.html as it was before #58: newTab()
+  // assigned 'auto'/'single' literally, MODEL_MAP's default is sonnet, the effort
+  // dial defaults to Auto (no flag), and #maxTurns ships value="50".
+  check('mode', CD.BUILTIN.mode, 'auto');
+  check('agent', CD.BUILTIN.agent, 'single');
+  check('model', CD.BUILTIN.model, 'sonnet');
+  check('effort', CD.BUILTIN.effort, 'auto');
+  check('turns', CD.BUILTIN.turns, 50);
+  check('and nothing else is a dial', CD.KEYS, ['mode', 'agent', 'model', 'effort', 'turns']);
+  // A choice list that drifts from the toolbar renders as "no button selected".
+  check('the model choices are exactly the CLI aliases', CD.CHOICES.model, ['haiku', 'sonnet', 'opus', 'fable']);
+  check('the agent choices are exactly the four agent_mode values',
+    CD.CHOICES.agent, ['single', 'multi', 'dispatch', 'conversation']);
+  check('effort spells its no-flag state as a real word, not ""',
+    CD.CHOICES.effort.includes('auto') && !CD.CHOICES.effort.includes(''), true);
+}
+
+console.log('\ncoercion:');
+{
+  check('a listed choice is taken', CD.coerce('model', 'opus'), { ok: true, value: 'opus' });
+  check('an unlisted one is refused', CD.coerce('model', 'gpt-4'), { ok: false, error: 'invalid_choice' });
+  check('a key outside the five is refused', CD.coerce('engine', 'api'), { ok: false, error: 'unknown_key' });
+  check('turns takes a number', CD.coerce('turns', 12), { ok: true, value: 12 });
+  check('turns takes the string a form sends', CD.coerce('turns', ' 12 '), { ok: true, value: 12 });
+  check('turns refuses nonsense', CD.coerce('turns', 'lots'), { ok: false, error: 'expected_number' });
+  // The bounds are #maxTurns' own min/max. Without them the form could store a
+  // value its own input refuses to display.
+  check('turns refuses 0', CD.coerce('turns', 0), { ok: false, error: 'out_of_range' });
+  check('turns refuses 201', CD.coerce('turns', 201), { ok: false, error: 'out_of_range' });
+  check('turns accepts the boundaries', [CD.coerce('turns', 1).value, CD.coerce('turns', 200).value], [1, 200]);
+  check('a float is truncated, not stored as a float', CD.coerce('turns', 7.9), { ok: true, value: 7 });
+  // The range is checked BEFORE the truncation, and config-resolve.coerceValue
+  // does the same for `int` rows. Let them drift and the Settings form and the
+  // toolbar disagree about the same dial.
+  check('a float over the max is out of range, not truncated into range',
+    CD.coerce('turns', 200.9), { ok: false, error: 'out_of_range' });
+  // parseInt('12px') is 12. Keeping the numeric prefix of a typo is worse than
+  // refusing it — the user sees a value they never typed.
+  check('a numeric prefix is not silently kept', CD.coerce('turns', '12px'), { ok: false, error: 'expected_number' });
+  check('an empty string is not zero', CD.coerce('turns', '   '), { ok: false, error: 'expected_number' });
+}
+
+console.log('\nsanitize keeps the good and names the bad:');
+{
+  const r = CD.sanitize({ mode: 'task', model: 'nope', turns: 10, engine: 'api' });
+  check('the valid pairs survive', r.value, { mode: 'task', turns: 10 });
+  check('the invalid ones are named, not dropped in silence', r.invalid.sort(), ['engine', 'model']);
+  // A hand-edited config.json is the reason this half is lenient.
+  check('one bad key does not blank the other four',
+    CD.sanitize({ mode: 'task', agent: 'multi', model: 'nope' }).value, { mode: 'task', agent: 'multi' });
+  check('an unset key is neither kept nor an error',
+    CD.sanitize({ mode: null, agent: undefined, model: '' }), { value: {}, invalid: [] });
+  // Membership is checked before the unpin sentinel: only a KNOWN dial may be
+  // unpinned. Otherwise `{notADial: null}` is a typo that reports success.
+  check('an unknown key is invalid even when sent as null',
+    CD.sanitize({ notADial: null }), { value: {}, invalid: ['notADial'] });
+  for (const junk of [null, undefined, 'string', 42, ['mode']]) {
+    check(`${JSON.stringify(junk)} yields an empty object, not a throw`,
+      CD.sanitize(junk), { value: {}, invalid: [] });
+  }
+}
+
+console.log('\nthe two-link chain:');
+{
+  const nothing = CD.resolveChatDefaults(null, null);
+  check('with no config at all the built-ins are what a chat opens on',
+    nothing.effective, { mode: 'auto', agent: 'single', model: 'sonnet', effort: 'auto', turns: 50 });
+  check('and nothing reads as overridden', nothing.overridden, []);
+
+  const globalOnly = CD.resolveChatDefaults({ model: 'opus', turns: 5 }, null);
+  check('a global default reaches a project that pinned nothing',
+    globalOnly.effective, { mode: 'auto', agent: 'single', model: 'opus', effort: 'auto', turns: 5 });
+  check('a global default is not an override', globalOnly.overridden, []);
+
+  const both = CD.resolveChatDefaults({ mode: 'task', model: 'opus', turns: 5 }, { model: 'sonnet', turns: 10 });
+  // This is the exact table from the issue body.
+  check('the project wins where it pinned, the global everywhere else',
+    both.effective, { mode: 'task', agent: 'single', model: 'sonnet', effort: 'auto', turns: 10 });
+  check('and exactly the pinned keys are reported as overridden', both.overridden, ['model', 'turns']);
+  check('the global row is still reported for the UI to show alongside',
+    both.global, { mode: 'task', agent: 'single', model: 'opus', effort: 'auto', turns: 5 });
+
+  // The sparseness IS the feature: change the global and an unpinned project follows.
+  const before = CD.resolveChatDefaults({ model: 'opus' }, { turns: 10 });
+  const after  = CD.resolveChatDefaults({ model: 'haiku' }, { turns: 10 });
+  check('an unpinned dial follows the global when it changes',
+    [before.effective.model, after.effective.model], ['opus', 'haiku']);
+  check('a pinned one does not', [before.effective.turns, after.effective.turns], [10, 10]);
+
+  check('garbage in the global config falls back per key, never wholesale',
+    CD.resolveChatDefaults({ model: 'gpt-4', mode: 'task' }, null).effective.model, 'sonnet');
+  check('and the sibling key it sat next to still applies',
+    CD.resolveChatDefaults({ model: 'gpt-4', mode: 'task' }, null).effective.mode, 'task');
+  check('garbage in a project override is ignored the same way',
+    CD.resolveChatDefaults({ model: 'opus' }, { model: 'gpt-4' }).effective.model, 'opus');
+  check('and it does not count as an override either',
+    CD.resolveChatDefaults({ model: 'opus' }, { model: 'gpt-4' }).overridden, []);
+
+  // The resolver must not hand the caller a reference into BUILTIN.
+  const a = CD.resolveChatDefaults(null, null);
+  a.effective.model = 'MUTATED';
+  check('the result is a fresh object, not a view onto BUILTIN', CD.BUILTIN.model, 'sonnet');
+  check('and a second call is unaffected', CD.resolveChatDefaults(null, null).effective.model, 'sonnet');
+}
+
+console.log('\nsanitising per LAYER is not the same as sanitising the merge:');
+{
+  // server.js spreads the two config files together before handing the result
+  // here. Spreading them RAW lets a local '' mask a valid global value, and the
+  // merged garbage then falls to BUILTIN rather than to the global — while the
+  // settings catalog, which walks the files separately, still reports the global
+  // as effective. This asserts the shape loadMergedConfig() must produce.
+  const g = { model: 'opus', mode: 'task' };
+  const lBad = { model: '', mode: 'nonsense' };
+
+  const rawMerge = CD.resolveChatDefaults({ ...g, ...lBad }, null).effective;
+  check('spreading raw loses the global — this is the shape to avoid',
+    [rawMerge.model, rawMerge.mode], ['sonnet', 'auto']);
+
+  const perLayer = CD.resolveChatDefaults({ ...CD.sanitize(g).value, ...CD.sanitize(lBad).value }, null).effective;
+  check('sanitising each layer first falls through to the global instead',
+    [perLayer.model, perLayer.mode], ['opus', 'task']);
+  check('and a VALID local value still wins over the global',
+    CD.resolveChatDefaults({ ...CD.sanitize(g).value, ...CD.sanitize({ model: 'haiku' }).value }, null).effective.model,
+    'haiku');
+}
+
+console.log('\nthe effort sentinel:');
+{
+  // The catalog and config.json say 'auto'; the SPA's <select> and the CLI flag
+  // both say ''. One translation, in one place.
+  check("'auto' means no flag", CD.effortToFlag('auto'), '');
+  check('an unset value means no flag either', CD.effortToFlag(undefined), '');
+  check('a real level passes through', CD.effortToFlag('xhigh'), 'xhigh');
+}
+
+console.log(`\n${fail === 0 ? 'PASS' : 'FAIL'} — ${pass} passed, ${fail} failed`);
+process.exit(fail === 0 ? 0 : 1);
diff --git a/test/config-resolve.test.js b/test/config-resolve.test.js
index 2e56e500..e0f9d1f4 100644
--- a/test/config-resolve.test.js
+++ b/test/config-resolve.test.js
@@ -142,13 +142,31 @@ console.log('\nfalsy config values follow the operator loadMergedConfig() actual
   const body = server.slice(server.indexOf('function loadMergedConfig()'));
   const merged = R.SETTINGS.filter(s => s.backing === 'config' && s.merge === 'merged');
   check('there are merged config keys to check at all', merged.length > 0, true);
-  const mismatched = merged.filter(s => {
+  // chatDefaults.* (issue #58) has no operator of its own to read: loadMergedConfig()
+  // spread-merges the whole object, and whether a falsy value survives is settled
+  // downstream, by chat-defaults.js:sanitize(). Those keys are checked by BEHAVIOUR
+  // below — which is a stronger statement than the regex, not a waiver. Every flat
+  // key still has to match its operator exactly.
+  const nested = merged.filter(s => String(s.path || '').includes('.'));
+  const flat = merged.filter(s => !nested.includes(s));
+  check('the operator check still covers the flat keys', flat.length > 0, true);
+  const mismatched = flat.filter(s => {
     const m = body.match(new RegExp('^\\s*' + s.key + ':\\s*(.+)$', 'm'));
     if (!m) return true;                       // key not resolved there → flag unverifiable
     const usesOr = / \|\| /.test(m[1]);
     return usesOr !== !!s.falsyFallsThrough;
   }).map(s => s.key);
   check('every falsyFallsThrough flag matches the operator in loadMergedConfig()', mismatched, []);
+
+  check('every nested key belongs to an object loadMergedConfig() actually merges',
+    nested.filter(s => !new RegExp('^\\s*' + s.path.split('.')[0] + ':\\s*\\{', 'm').test(body)).map(s => s.key), []);
+  const CD = require('../chat-defaults');
+  check('a nested key flagged falsyFallsThrough really does fall through',
+    nested.filter(s => {
+      const leaf = s.path.split('.').pop();
+      const eff = CD.resolveChatDefaults({ [leaf]: '' }, null).effective[leaf];
+      return !!s.falsyFallsThrough !== (eff === CD.BUILTIN[leaf]);
+    }).map(s => s.key), []);
 }
 
 // ── 3. Secret masking — nothing raw leaves resolveSetting() ─────────────────