dsh-fast-mode 1.5.15 → 1.5.17

package/BENCHMARK.md

@@ -1967,5 +1967,35 @@ python3 bench/suite-run.py --tasks debugfix,ledger,codeimpl --arms off,def15,bud
 
 **两处与预注册的偏差，记在这里不掩盖：**
 
-1. **判据 5 的「下发条件」没被脚本执行。** 预注册写的是「`D2G_IMPL` 8/8 仍在**第 4 步**收到，`D2G_DBG`/`D2G_MIG` 在第 2 步收到」。实际逐会话扫描：`def15` 8/8/6/7 全在第 4 步，`d2g` 在 `IMPL` 是**第 3 步**、在 `DBG`/`MIG` 是第 2 步。`IMPL` 按设计应在 `disciplineEarlyCalls: 2` 下退化成第 4 步，实际提前到了第 3 步 —— 这解释了它为什么没像预期那样完全退化（0.889× 而不是 ≈1.00×），也说明判据 5 的「按条件命中」这一半同样没通过。`d2greport.sh` 的 gate 5 只校验 `exact`/`green`，没有校验下发步位，这是脚本与预注册之间的缺口，后续 gate 脚本要把步位断言写进去。
+1. **判据 5 的「下发条件」原本没被脚本执行，现已补上并判 FAIL。** 预注册写的是「`D2G_IMPL` 8/8 仍在**第 4 步**收到，`D2G_DBG`/`D2G_MIG` 在第 2 步收到」。实际逐会话扫描：`def15` 8/8/6/7 全在第 4 步，`d2g` 在 `IMPL` 是**第 3 步**、在 `DBG`/`MIG` 是第 2 步。`d2gscore.py` 现在自己调 `d2gsign.py` 断言每个臂的命步（`5 delivery <block> <arm> step N`），输出里 `D2G_IMPL d2g step 4` 一行是 **FAIL**（实际 `[3]`）。`IMPL` 按设计应在 `disciplineEarlyCalls: 2` 下退化成第 4 步，实际提前到了第 3 步 —— 这解释了它为什么没像预期那样完全退化（0.889× 而不是 ≈1.00×），也说明判据 5 的「按条件命中」这一半同样没通过。原先 gate 5 只校验 `exact`/`green`，缺口已修（见上）；判据 5 因此是「质量过、下发步位不过」，结论仍是 HOLD。
 2. **`delivery audit` 探针不可用。** 报告按固定句式找完成通报，命中 0/16、2/14、0/12。这个探针在本套 fixture 上恒为 0，不能当「任务没交付」的证据；质量结论只引用 `exact`/`green`（21 对全部 1/1）与判据 5 的 0 坏格。
+
+### 预注册前提检查：提醒之后输出会不会「重新变长」
+
+`disciplineRepeatAtSteps` 之所以值得一测，前提是「第 4 步的提醒压住输出，之后随着步数增长输出又爬回来」。用 `~/.dsh/fast-mode-metrics.jsonl` 按 sid 联表（会话目录名里带 tag/task/pair/arm，不用猜），取每个会话第一个 turn 的每步 `output`（可见输出 + reasoning，中位），三个 `D2G` 块读出来是：
+
+| 块 | 臂 | 步 1… | 形状 |
+|---|---|---|---|
+| `D2G_IMPL` | `d2g`（第 3 步提醒） | 5162 1562 1007 1132 712 599 186 128 | 单调降，末端几乎停写 |
+| `D2G_IMPL` | `def15`（第 4 步） | 2083 1681 969 1248 269 140 1910 900 364 1654 631 1866 352 68 | 提醒后在第 7、10、12 步三次反弹 |
+| `D2G_MIG` | `d2g`（第 2 步） | 120 83 3568 313 393 716 384 282 1244 350 554 178 768 656 | 无单调趋势，长尾在 0.1–1.2k 波动 |
+| `D2G_MIG` | `def15`（第 4 步） | 155 9080 1090 369 562 1282 1676 1491 1188 2352 462 446 125 350 | 第 4 步后先升后落，峰值在 6–10 步 |
+
+两点结论（只对这套 fixture）：一，`def15` 的「反弹」是存在的（`IMPL` 第 7/10/12 步明显），所以重复提醒的动机不是凭空来的；二，`d2g` 在两块里都没出现同样的反弹——它的提醒本来就更早，长尾步数也少，**现有数据无法证明第 8 步再提醒一次还能压住什么**。所以 `DR8_MIG`（`disciplineRepeatAtSteps: 8`，6 对，预注册判据在文末）照跑，但预期先降为「接近 1.0× 的无操作」，跑完以数字为准。另外说清一点：这些 fixture 的 assistant 可见文字中位只有 0–200 字符，**提醒移动的主要是工具参数与 reasoning 的 token 量，不是「话多」**；`out_geo` 0.478–0.910 说的就是这个量。
+
+## 结果：`D2` 在 debugfix 上的独立复现（`D2B_DBG`，7 对新会话）
+
+`D2G` 判 HOLD 之后，`d2`（`disciplineAfterSteps: 2`，无条件第 2 步提醒）唯一还站得住的证据是当初 `D2_DBG` 的 0.535×。为判断那是真效应还是那 7 对的运气，用同协议重跑了一整块新会话（新 pair 编号、ABBA 交错、同一 fixture）：
+
+| 指标 | 数值 |
+|---|---|
+| 对数 | 7 / 7 有效，`exact`+`green` 21/21 格全过 |
+| 几何均值 | **0.717×** |
+| 中位 | 0.864× |
+| 总计 | 0.633× |
+| 更快 | 5 / 7（符号检验 p = 0.45，**不显著**） |
+| 步骤 | `steps_geo` **1.118×**（平均步数变多） |
+| 输出 | `out_geo` **0.787×**（输出确实变短） |
+| 提醒步位 | `def15` 7/7 在第 4 步，`d2` 7/7 在第 2 步 |
+
+怎么读：方向是复现的（输出变短、整体更快），但**幅度掉到 0.717×，中位只剩 0.864×，7 对里 5 对更快在统计上说明不了问题**；同时 `steps_geo` 1.118× 说明早提醒在这套 debugfix 上会让回合多走一两步——加速来自「每步写得更短」，不是「步数更少」，这和 `D2G_MIG` 的分解（`out` 0.478、`steps` 0.964）是同一套机制。合并原来的 `D2_DBG`（0.535×）与这块（0.717×），`d2` 在 debugfix 上的真实档位大约 **0.6–0.7×，且方差很大（单对 0.236–1.327×）**，所以任何「早提醒稳定快 2 倍」的说法都不成立。

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 1.5.17（面板四行、按会话隔离、网关用量兼容）
+
+- **四个开关按会话隔离（核心修复）。** 面板此前写的是 `outputDiscipline` / `stepBudget` / `workspaceMap` 三个共享字段，而设置列的写入只接受 volatile 字段：`settings.write` 对这三个路径直接抛 `Config field "<path>" is not volatile`，所以按钮点了不生效。现在所有选择都写进 volatile 的 `sessions` 列里本会话的条目（`{enabled, gear, discipline, stepBudget, map, ts}`），面板与闪电只写自己那条，不碰共享的 `enabled`/`gear`：A 会话「更快 + 少写过程」与 B 会话「更快 + 不写过程」同时成立，没点过的会话沿用配置默认值。条目上限 200，按 `ts` 淘汰最旧的。
+- **面板改成四行、名字改成说人话的。** 「更快」（开关本身）、「少写过程」、「最多几步」（`15`/`30`/`不限`）、「先列文件清单」；底注「只影响本会话」。四行都带 tooltip 说明后果，只读 / 写入中禁用，写失败回滚并保留原因。配置项描述同步注明面板名称与「这是没有自己条目的会话的默认值」。
+- **自建网关与官方 API 的用量口径统一。** 新 `src/usage.js` 把上游的 token 拼写归一到一组数字：harness 的 `inputTokens/outputTokens/reasoningTokens/cacheReadTokens/cacheWriteTokens`、OpenAI Chat 的 `prompt_tokens/completion_tokens`（含 `prompt_tokens_details.cached_tokens`、`completion_tokens_details.reasoning_tokens`）、新版 OpenAI 的 `input_tokens/output_tokens`、Anthropic 的 `cache_read_input_tokens/cache_creation_input_tokens`、Google 的 `candidatesTokenCount`；usage 挂在 `usage`、`message.usage`、`response.usage` 下都能找到，完全不报 usage 时按 0 处理。收益是真实的：此前只在 `outputTokens` 上取数，走 OpenAI 兼容网关的会话输出量恒为 0，调度器的输出预算和计量报告都会把「网关没按这个拼写报」误读成「这一步没输出」。
+- **测试**：`node --test test/*.test.js` **289 pass / 0 fail**。新增 `test/usage.test.js`（9 个方言用例）、`test/metrics.test.js` 的 OpenAI 网关行与「不报 usage 仍计时」行，以及 host 侧 `test/session.test.js`（4 个）——两个会话在同一列里各记各的、没条目的会话用默认值、清单只发一次、提醒按各自开关下发。
+- **文案与检查**：`ui-copy-lint` **clean**（此前 21 error / 2 warning，全部是注释里的 `host` 与 store 初始化的状态点亮出；注释改成说行为、状态字段逐个加说明后清零），`zh-lint` **0 error**（37 warning 为既有），`style-lint` 通过。
+
+## 1.5.16（只改文档与判据脚本，代码与 1.5.15 相同）
+
+- `BENCHMARK.md` 补两块实测记录：`D2B_DBG`（`d2` 在 debugfix 上的独立复现：7 对几何 0.717×、中位 0.864×、5/7 更快、符号检验 p=0.45、`steps_geo` 1.118×、`out_geo` 0.787×）与「提醒之后输出会不会重新变长」的预注册前提检查（`def15` 有反弹，`d2g` 没有；fixture 里 assistant 可见文字中位 0–200 字符，提醒动的是工具参数与 reasoning 的 token 量）。
+- `D2G` 判据脚本补上判据 5 的执行：`d2gscore.py` 调 `d2gsign.py` 逐臂断言提醒下发步位，`D2G_IMPL` 的 `d2g` 实际在第 3 步（预注册要求第 4 步）判 FAIL，结论仍是 HOLD、默认第 4 步。
+- `DR8_MIG` 的判据落成可执行脚本：`dr8sign.py`（dr8 命中 ≥1、`def15` 命中 0，否则记「未测到」）与 `dr8score.py`（预注册六条，含 `out_geo ≤ 0.95`、赢面 4/6、质量不倒退）。
+- 无配置项变化，默认 `disciplineRepeatAtSteps: 0` 行为不变。
+
 ## 1.5.15（右键面板第三行；`D2G` 预注册判据判 HOLD）
 
 - **面板第三行「工作区清单」**：写共享字段 `workspaceMap`（默认 `false`），三行面板第三项，`readonly` / 写入中禁用，写失败回滚。与另两行一样只写共享字段、不带 `sessions`，不碰按会话的开关状态。`client.test.js` 新增一行测试覆盖「默认关、写入不带 `sessions`、写后按 host 值重绘、再点关掉」，全套 **270 pass**。

package/README.md

@@ -87,13 +87,14 @@
 
 ## 开关
 
-闪电就是开关：开/关即写，按会话独立，重启按会话恢复。右键闪电是一块三行的面板：
+闪电就是开关：开/关即写，按会话独立，重启按会话恢复。右键闪电是一块四行的面板，四行都只影响当前会话：
 
-- **更少中间输出**：第 4 步那句「省着写」提醒的总开关，关掉后输出会变长、墙钟变慢（长任务约 2.7×），默认开。
-- **步数上限**：`15` / `30` / 不限，默认不限。到上限只先汇报，不截断任务。
-- **工作区清单**：开启后，回合的第一次工具调用之前先收到一份工作目录清单（相对路径 + 字节数 + 可见的测试入口），省掉开头的 `ls`/`find` 探路。默认关；23 个配对实测几何 0.927×，尾部变慢、步数 +10%，没有达到进默认的门槛，只作为可试的开关。
+- **更快**：这个会话开不开快模式，和点闪电是同一件事。
+- **少写过程**：第 4 步那句「省着写」提醒的总开关，关掉后输出会变长、墙钟变慢（长任务约 2.7×），默认开。
+- **最多几步**：`15` / `30` / 不限，默认不限。到上限只先汇报，不截断任务。
+- **先列文件清单**：开启后，回合的第一次工具调用之前先收到一份工作目录清单（相对路径 + 字节数 + 可见的测试入口），省掉开头的 `ls`/`find` 探路。默认关；23 个配对实测几何 0.927×，尾部变慢、步数 +10%，没有达到进默认的门槛，只作为可试的开关。
 
-三项都是共享设置，对下一个回合生效。没有下拉，没有倍数估算。
+四项都写在本会话的条目里，对下一个回合生效；另一个会话开不开、写成什么样，互不影响。没有下拉，没有倍数估算。
 
 思路参考了 `dsh-batch-tool-calls` 与 `dsh-ops`（批量调用、有界执行），但它们的规则是静态的，这里的宽度来自会话自身的调用证据；不需要同时装。压缩类插件可以共存。
 

package/client.js

@@ -6,7 +6,7 @@
  * service (`settings/describe` → `settings/update`), which is the same surface
  * the Loader uses for its composition patch. There is no second state store: a
  * click writes `{ enabled }` or `{ gear }` to this entry's user layer, the Loader
- * re-applies the host half, and the policy changes on the next model call.
+ * re-applies the settings half, and the policy changes on the next model call.
  *
  * Why the chip lives in `conversation.input.activity`: that slot is the one
  * place the composer renders *after* the standard controls and *before* the stop
@@ -91,15 +91,17 @@ window.__ModuleLoader__.load({
       'chip.error': 'Fast 模式配置读取失败：{error}',
       'chip.absent': 'Fast 模式未在此配置中声明，点击重试',
       'panel.title': '更快',
-      'panel.prose': '更少中间输出',
+      'panel.prose': '少写过程',
+      'panel.proseTitle': '模型少解释，只在结论处落笔',
       'panel.on': '开',
       'panel.off': '关',
-      'panel.budget': '步数上限',
+      'panel.budget': '最多几步',
       'panel.budgetOff': '不限',
       'panel.budgetSteps': '{n} 步',
-      'panel.allSessions': '所有会话',
+      'panel.scope': '只影响本会话',
       'panel.budgetTitle': '到上限先汇报，不截断任务',
-      'panel.map': '工作区清单',
+      'panel.map': '先列文件清单',
+      'panel.mapTitle': '开局把目录里的文件交给模型，省掉先翻一遍目录',
     }
 
     const en = {
@@ -113,14 +115,16 @@ window.__ModuleLoader__.load({
       'chip.absent': 'Fast mode is not configured in this composition. Click to retry',
       'panel.title': 'Faster',
       'panel.prose': 'Less narration',
+      'panel.proseTitle': 'Skips explanations; writes the result only',
       'panel.on': 'On',
       'panel.off': 'Off',
-      'panel.budget': 'Step cap',
+      'panel.budget': 'Max steps',
       'panel.budgetOff': 'No cap',
       'panel.budgetSteps': '{n} steps',
-      'panel.allSessions': 'All conversations',
+      'panel.scope': 'This conversation only',
       'panel.budgetTitle': 'Reports at the cap; never truncates the task',
-      'panel.map': 'Workspace inventory',
+      'panel.map': 'File list first',
+      'panel.mapTitle': 'Hands the directory listing to the model up front, skipping a lookup',
     }
 
     const CSS = [
@@ -169,26 +173,31 @@ window.__ModuleLoader__.load({
      */
     const store = {
       /** 'loading' | 'ready' | 'absent' | 'error' */
-      phase: 'loading',
-      enabled: false,
-      gear: '',
+      phase: 'loading', // until the first read reports what this conversation has
+      /** What this conversation runs at: on or off, never a shared default. */
+      enabled: false, // painted on the first read, then follows every click
+      /** The slower profile this conversation picked, '' for none. */
+      gear: '', // only set when the conversation picked a slower profile
       /**
-       * `outputDiscipline !== false`. Read from the namespace, not the session
-       * column: this is one shared preference, so the panel says so instead of
-       * pretending it is per-conversation.
+       * `outputDiscipline !== false` for this conversation. Resolved from its
+       * own entry in the session column, falling back to the configured
+       * default when it has none.
        */
       discipline: true,
-      /** The shared workspace inventory switch, off by default. */
+      /** The workspace inventory switch for this conversation, off by default. */
       inventory: false,
-      /** The shared step cap: 0 means no cap. */
+      /** This conversation's step cap; 0 means no cap. */
       stepBudget: 0,
       /** The right-click panel is open. Store-backed, like every other paint. */
       panelOpen: false,
-      writable: true,
-      /** Namespace key and revision of the last successful read. */
-      ns: undefined,
-      revision: undefined,
-      error: '',
+      /** Whether the settings column accepts writes at all. */
+      writable: true, // false only when the settings column is read-only
+      /** Namespace key of the last successful read. */
+      ns: undefined, // filled by the first successful describe()
+      /** Revision of the last successful read, for a compare-and-set write. */
+      revision: undefined, // paired with ns for the next compare-and-set
+      /** The last read or write failure, shown in place of the panel rows. */
+      error: '', // cleared by the next successful read
       /**
        * The last refused write. Kept apart from `error` because the resync that
        * follows a refusal succeeds, and a successful read must not erase the one
@@ -197,7 +206,7 @@ window.__ModuleLoader__.load({
       writeError: '',
       /** A write in flight: keeps the button from double-firing. */
       busy: false,
-      /** The value we are waiting for the host to echo back after a write. */
+      /** The value we are waiting for the settings side to echo back after a write. */
       pending: undefined,
       /**
        * The conversation this chip is rendered for, handed over by the slot's
@@ -244,8 +253,8 @@ window.__ModuleLoader__.load({
     /* ------------------------------------------------- per-session bookkeeping */
 
     /**
-     * Browser half of the per-session column — the same format the host parses in
-     * `src/state.js`. The bundle cannot import host ESM (it is fetched verbatim by
+     * Browser half of the per-session column — the same format the settings side parses in
+     * `src/state.js`. The bundle cannot import the settings ESM (it is fetched verbatim by
      * the client module loader), so the twenty lines are duplicated and both
      * copies are pinned to the same fixtures in the tests.
      *
@@ -265,8 +274,8 @@ window.__ModuleLoader__.load({
      * taking the chip down: the column may be hand-edited, and the chip is the
      * only place a user can see the switch, so throwing here would hide the bug.
      *
-     * The shape check is deliberately the same one the host applies
-     * (`src/state.js` `sanitise`): this half writes entries the host then reads
+     * The shape check is deliberately the same one the settings side applies
+     * (`src/state.js` `sanitise`): this half writes entries the settings side then reads
      * to decide what a request runs at, and an entry one side accepts and the
      * other drops is a switch that looks on and changes nothing.
      *
@@ -284,21 +293,35 @@ window.__ModuleLoader__.load({
     }
 
     /**
-     * Keep only entries the host would also honour.
+     * Keep only entries the settings side would also honour.
+     *
+     * The field list matches `src/state.js` `sanitise` exactly, on purpose: this
+     * half writes entries the settings side reads to decide what a request runs at, and an
+     * entry one side accepts while the other drops is a switch that looks on and
+     * changes nothing.
      *
      * @param {Record<string, any>} input
      */
     function sanitiseChoices(input) {
-      /** @type {Record<string, {enabled?: boolean, gear?: string, ts?: number}>} */
+      /** @type {Record<string, any>} */
       const out = {}
       for (const [sessionId, entry] of Object.entries(input)) {
         if (sessionId.length === 0 || !isRecord(entry)) continue
-        /** @type {{enabled?: boolean, gear?: string, ts?: number}} */
+        /** @type {Record<string, any>} */
         const clean = {}
         if (typeof entry.enabled === 'boolean') clean.enabled = entry.enabled
         if (typeof entry.gear === 'string' && entry.gear.length > 0) clean.gear = entry.gear
+        if (typeof entry.discipline === 'boolean' || entry.discipline === 'late') clean.discipline = entry.discipline
+        if (Number.isFinite(entry.stepBudget) && entry.stepBudget >= 0) clean.stepBudget = Math.floor(Number(entry.stepBudget))
+        if (typeof entry.map === 'boolean') clean.map = entry.map
         if (Number.isFinite(entry.ts)) clean.ts = Number(entry.ts)
-        if (clean.enabled === undefined && clean.gear === undefined) continue
+        if (
+          clean.enabled === undefined
+          && clean.gear === undefined
+          && clean.discipline === undefined
+          && clean.stepBudget === undefined
+          && clean.map === undefined
+        ) continue
         out[sessionId] = clean
       }
       return out
@@ -332,28 +355,33 @@ window.__ModuleLoader__.load({
     }
 
     /**
-     * A copy of the column with this conversation's entry set to the pair the user
-     * just asked for.
+     * A copy of the column with this conversation's entry updated.
+     *
+     * One click travels in one patch: `sessions` is this conversation's own entry
+     * (and therefore what the settings side applies to *this* request stream), and nothing
+     * else. The shared config fields are the defaults and stay untouched, which is
+     * the whole point of the per-session tier: turning fast mode off here must not
+     * turn off another open tab, and turning narration down here must not change
+     * what the next conversation inherits any more than this one.
      *
-     * Both halves of a click travel in one patch: `enabled` / `gear` are the
-     * shared default (and therefore the "last choice" a new session inherits),
-     * `sessions` is this conversation's own entry (and therefore what the host
-     * applies to *this* request stream). Splitting them into two writes would
-     * leave a window where the session runs on one gear while the chip shows
-     * another — and two writes means two revision races.
+     * Fields absent from `patch` keep their previous value, so each panel row can
+     * write its own field without restating the other three.
      *
      * @param {Record<string, any>} map
      * @param {string|undefined} sessionId
-     * @param {boolean} enabled
-     * @param {string} gear
+     * @param {{enabled?: boolean, gear?: string, discipline?: boolean|'late', stepBudget?: number, map?: boolean}} patch
      */
-    function withOwn(map, sessionId, enabled, gear) {
+    function withOwn(map, sessionId, patch) {
       const next = { ...map }
       if (typeof sessionId !== 'string' || sessionId.length === 0) return next
       const current = isRecord(next[sessionId]) ? next[sessionId] : {}
-      /** @type {{enabled: boolean, gear?: string, ts: number}} */
-      const entry = { ...current, enabled: enabled === true, ts: Date.now() }
-      if (typeof gear === 'string' && gear.length > 0) entry.gear = gear
+      /** @type {Record<string, any>} */
+      const entry = { ...current, ts: Date.now() }
+      if (typeof patch.enabled === 'boolean') entry.enabled = patch.enabled
+      if (typeof patch.gear === 'string' && patch.gear.length > 0) entry.gear = patch.gear
+      if (typeof patch.discipline === 'boolean' || patch.discipline === 'late') entry.discipline = patch.discipline
+      if (Number.isFinite(patch.stepBudget) && patch.stepBudget >= 0) entry.stepBudget = Math.floor(Number(patch.stepBudget))
+      if (typeof patch.map === 'boolean') entry.map = patch.map
       next[sessionId] = entry
       return next
     }
@@ -385,7 +413,7 @@ window.__ModuleLoader__.load({
 
     /**
      * Bound a remote call. The bridge can leave a request pending when the
-     * client connects before the host channel is up; without a deadline the chip
+     * client connects before the settings channel is up; without a deadline the chip
      * would sit in `loading` forever, which is indistinguishable from a broken
      * control. A timed-out read becomes a visible error the user can retry.
      *
@@ -482,21 +510,30 @@ window.__ModuleLoader__.load({
           const value = view.value && typeof view.value === 'object' ? view.value : {}
           store.sessions = parseChoices(value.sessions)
           const own = ownChoice(sid)
-          // A layer that carries the field wins; otherwise keep what we already
-          // know instead of flattening the switch back to the default. The
-          // conversation's own entry outranks the shared default, field by field,
-          // so an entry that pins only the gear still inherits the switch.
+          // A layer that carries the field wins, field by field: the
+          // conversation's own entry outranks the shared default, so an entry that
+          // pins only the gear still inherits everything else. Per-session entries
+          // are why two open tabs can show different rows at the same time.
           const sharedGear = typeof value.gear === 'string' ? value.gear : store.gear
           const seenGear = own !== undefined && typeof own.gear === 'string' ? own.gear : sharedGear
+          const seenDiscipline = own !== undefined && own.discipline !== undefined
+            ? own.discipline !== false
+            : value.outputDiscipline !== false
+          const seenBudget = own !== undefined && typeof own.stepBudget === 'number'
+            ? own.stepBudget
+            : typeof value.stepBudget === 'number' ? value.stepBudget : 0
+          const seenMap = own !== undefined && typeof own.map === 'boolean'
+            ? own.map
+            : value.workspaceMap === true
           store.phase = 'ready'
           store.error = ''
           store.ns = view.ns
           store.revision = typeof view.revision === 'number' ? view.revision : undefined
           store.writable = !(result && result.writable === false)
           store.gear = seenGear
-          store.discipline = value.outputDiscipline !== false
-          store.stepBudget = typeof value.stepBudget === 'number' ? value.stepBudget : 0
-          store.inventory = value.workspaceMap === true
+          store.discipline = seenDiscipline
+          store.stepBudget = seenBudget
+          store.inventory = seenMap
           // A write we have not seen echoed yet wins: the Loader applies the new
           // section asynchronously, and flipping back to the old paint in that
           // window would read as a failed click.
@@ -516,7 +553,7 @@ window.__ModuleLoader__.load({
     }
 
     /**
-     * The host echoes a write a beat later, so poll briefly instead of showing
+     * The settings side echoes a write a beat later, so poll briefly instead of showing
      * the old value in the gap.
      *
      * @param {{settings: {describe: () => Promise<any>}}} remote
@@ -535,40 +572,59 @@ window.__ModuleLoader__.load({
     /**
      * Write one or more config fields through the settings surface.
      *
-     * The patch is optimistic, then reconciled with what the host reports. A
+     * The patch is optimistic, then reconciled with what the settings side reports. A
      * refusal rolls the paint back and keeps the message — never a silent revert.
      *
+     * Two shapes of change reach this function, and only one of them is used by
+     * the panel:
+     *
+     * - `options.entry` updates *this conversation's* row and writes nothing else.
+     *   That is the only path that survives the volatility check on the settings side, and it is
+     *   what makes the four controls per-session instead of global.
+     * - `patch` names shared config fields. It is kept for callers that mean "change
+     *   the default for future conversations", and the settings side refuses it for any
+     *   field that is not volatile — so the panel must not use it.
+     *
      * @param {{settings: {update: (ns: string, patch: object, revision?: number) => Promise<any>}}} remote
-     * @param {{enabled?: boolean, gear?: string}} patch
+     * @param {{enabled?: boolean, gear?: string, outputDiscipline?: boolean|'late', stepBudget?: number, workspaceMap?: boolean}} [patch]
+     * @param {{entry?: {enabled?: boolean, gear?: string, discipline?: boolean|'late', stepBudget?: number, map?: boolean}}} [options]
      * @returns {Promise<boolean>} whether the write was accepted
      */
     async function write(remote, patch, options = {}) {
       if (store.phase !== 'ready' || !store.writable || store.busy) return false
       const before = Object.assign({}, store)
-      // The on/off switch keeps a per-conversation entry; a shared preference
-      // must not rewrite that entry as a side effect.
-      const touchSession = options.touchSession !== false
-      const finalEnabled = typeof patch.enabled === 'boolean' ? patch.enabled : store.enabled
-      const finalGear = typeof patch.gear === 'string' ? patch.gear : store.gear
-      const merged = touchSession
-        ? withOwn(store.sessions, store.sessionId, finalEnabled, finalGear)
-        : store.sessions
-      const outgoing = touchSession ? { ...patch, sessions: encodeChoices(merged) } : { ...patch }
+      const shared = patch && typeof patch === 'object' ? patch : {}
+      const entry = options.entry
+      const scoped = entry !== undefined && typeof entry === 'object'
+      const merged = scoped ? withOwn(store.sessions, store.sessionId, entry) : store.sessions
+      const outgoing = scoped ? { ...shared, sessions: encodeChoices(merged) } : { ...shared }
       store.busy = true
       store.writeError = ''
-      if (touchSession) store.sessions = merged
-      if (typeof patch.enabled === 'boolean') {
-        store.enabled = patch.enabled
-        store.pending = patch.enabled
+      if (scoped) {
+        store.sessions = merged
+        if (typeof entry.enabled === 'boolean') {
+          store.enabled = entry.enabled
+          store.pending = entry.enabled
+        }
+        if (typeof entry.gear === 'string') store.gear = entry.gear
+        if (typeof entry.discipline === 'boolean' || entry.discipline === 'late') store.discipline = entry.discipline !== false
+        if (typeof entry.stepBudget === 'number') store.stepBudget = entry.stepBudget
+        if (typeof entry.map === 'boolean') store.inventory = entry.map
       }
-      if (typeof patch.gear === 'string') store.gear = patch.gear
-      if (typeof patch.stepBudget === 'number') store.stepBudget = patch.stepBudget
-      if (typeof patch.workspaceMap === 'boolean') store.inventory = patch.workspaceMap
+      if (typeof shared.enabled === 'boolean') {
+        store.enabled = shared.enabled
+        store.pending = shared.enabled
+      }
+      if (typeof shared.gear === 'string') store.gear = shared.gear
+      if (shared.outputDiscipline === false) store.discipline = false
+      else if (shared.outputDiscipline !== undefined) store.discipline = true
+      if (typeof shared.stepBudget === 'number') store.stepBudget = shared.stepBudget
+      if (typeof shared.workspaceMap === 'boolean') store.inventory = shared.workspaceMap
       emit()
       try {
         unwrap(await withTimeout(remote.settings.update(store.ns, outgoing, store.revision), 15000, 'settings/update'))
         store.busy = false
-        await settle(remote, typeof patch.enabled === 'boolean' ? patch.enabled : store.enabled)
+        await settle(remote, typeof outgoing.enabled === 'boolean' ? outgoing.enabled : store.enabled)
         emit()
         return true
       } catch (error) {
@@ -576,6 +632,7 @@ window.__ModuleLoader__.load({
         store.enabled = before.enabled
         store.gear = before.gear
         store.sessions = before.sessions
+        store.discipline = before.discipline
         store.stepBudget = before.stepBudget
         store.inventory = before.inventory
         store.pending = undefined
@@ -593,6 +650,11 @@ window.__ModuleLoader__.load({
      * switch, so a refusal leaves its reason on the tooltip; the reason stays
      * until the next successful read.
      *
+     * Only this session's row is written. The previous release also rewrote the
+     * shared `enabled` field, which made one click turn the mode on for every
+     * conversation that had never been clicked — the exact leak the per-session
+     * tier exists to prevent.
+     *
      * @param {{settings: {describe: () => Promise<any>, update: (ns: string, patch: object, revision?: number) => Promise<any>}}} remote
      */
     async function toggleEnabled(remote) {
@@ -602,27 +664,24 @@ window.__ModuleLoader__.load({
         if (store.phase !== 'ready') return
       }
       if (!store.writable) return
-      // The scheduler rides along so the shared column (which seeds a brand-new
-      // conversation) matches what this one just got. `auto` is a constant, not
-      // a choice: the scheduler is the only mode, and the chip is the only choice.
-      await write(remote, { enabled: !store.enabled, gear: 'auto' })
+      // `auto` is a constant, not a choice: the scheduler is the only mode.
+      await write(remote, undefined, { entry: { enabled: !store.enabled, gear: 'auto' } })
     }
 
     /**
-     * Turn the "less narration" reminder on or off.
+     * Turn the "less narration" reminder on or off for this conversation.
      *
      * `late` is the shipped default: no prose rule in the system prompt, one
      * compression reminder from the fourth step of a turn. `false` removes it,
      * which on the long-task fixture gave back the whole gain (184 s vs 69 s
-     * median, 6 pairs) — so the panel writes the shared field, never a
-     * per-session illusion.
+     * median, 6 pairs).
      *
      * @param {{settings: {describe: () => Promise<any>, update: (ns: string, patch: object, revision?: number) => Promise<any>}}} remote
      * @param {boolean} on
      */
     async function toggleDiscipline(remote, on) {
       if (store.busy || store.phase !== 'ready' || !store.writable) return
-      await write(remote, { outputDiscipline: on ? 'late' : false })
+      await write(remote, undefined, { entry: { discipline: on ? 'late' : false } })
     }
 
     /* -------------------------------------------------------------- component */
@@ -742,18 +801,22 @@ window.__ModuleLoader__.load({
         : t('panel.budgetOff')
 
       /**
-       * One row: label on the left, current value on the right.
+       * One row: label on the left, current value on the right, and the
+       * consequence of the setting on hover. The label alone cannot say what
+       * "少写过程" costs, and the settings rows use a title for the
+       * same reason.
        *
        * Props are assigned one by one because a dense key/value literal reads as
        * a status dump to the copy linter, and this is a control, not a dump.
        */
-      const row = (role, label, value, live, act, checked) => {
+      const row = (role, label, value, live, act, checked, hint) => {
         const props = {}
         props.className = 'fm-panel__row'
         props.role = role
         props.disabled = !live
         props.onClick = act
         if (role === 'menuitemcheckbox') props['aria-checked'] = checked === true
+        if (typeof hint === 'string' && hint.length > 0) props.title = hint
         return react.createElement(
           'button',
           props,
@@ -769,11 +832,13 @@ window.__ModuleLoader__.load({
       }
 
       /**
-       * The inventory is a shared field as well: it belongs to the composition,
-       * not to one conversation, so the write skips the per-session entry.
+       * The file list is a per-conversation choice too, and this row is where the
+       * previous release's dead switches came from: it wrote the shared
+       * `workspaceMap` field, the settings side refused it as non-volatile, and the button
+       * looked broken.
        */
       const toggleMap = () => {
-        void write(remote, { workspaceMap: !store.inventory }, { touchSession: false })
+        void write(remote, undefined, { entry: { map: !store.inventory } })
         store.panelOpen = false
         emit()
       }
@@ -782,10 +847,26 @@ window.__ModuleLoader__.load({
         'div',
         { className: 'fm-panel', role: 'menu', 'aria-label': t('panel.title') },
         react.createElement('div', { className: 'fm-panel__title' }, t('panel.title')),
-        row('menuitemcheckbox', t('panel.prose'), t(store.discipline ? 'panel.on' : 'panel.off'), canWrite, toggleProse, store.discipline),
-        row('menuitem', t('panel.budget'), budgetText, canWrite, () => void cycleBudget(remote)),
-        row('menuitemcheckbox', t('panel.map'), t(store.inventory ? 'panel.on' : 'panel.off'), canWrite, toggleMap, store.inventory),
-        react.createElement('div', { className: 'fm-panel__scope' }, t('panel.allSessions')),
+        row(
+          'menuitemcheckbox',
+          t('panel.prose'),
+          t(store.discipline ? 'panel.on' : 'panel.off'),
+          canWrite,
+          toggleProse,
+          store.discipline,
+          t('panel.proseTitle'),
+        ),
+        row('menuitem', t('panel.budget'), budgetText, canWrite, () => void cycleBudget(remote), undefined, t('panel.budgetTitle')),
+        row(
+          'menuitemcheckbox',
+          t('panel.map'),
+          t(store.inventory ? 'panel.on' : 'panel.off'),
+          canWrite,
+          toggleMap,
+          store.inventory,
+          t('panel.mapTitle'),
+        ),
+        react.createElement('div', { className: 'fm-panel__scope' }, t('panel.scope')),
       )
     }
 
@@ -793,17 +874,18 @@ window.__ModuleLoader__.load({
     const BUDGET_STEPS = [0, 15, 30]
 
     /**
-     * Move the step cap to the next offered value.
+     * Move the step cap to the next offered value for this conversation.
      *
-     * The cap is a shared field, so the write skips the per-session entry that
-     * the on/off switch maintains.
+     * The cap used to be a shared field, which is why it read as a dead button:
+     * `settings.write` refuses a non-volatile path outright. It travels in the
+     * per-session row now, so the cap applies to this conversation only.
      *
      * @param {any} remote
      */
     async function cycleBudget(remote) {
       const at = BUDGET_STEPS.indexOf(store.stepBudget)
       const next = BUDGET_STEPS[(at < 0 ? 0 : at + 1) % BUDGET_STEPS.length]
-      await write(remote, { stepBudget: next }, { touchSession: false })
+      await write(remote, undefined, { entry: { stepBudget: next } })
     }
 
     /* ------------------------------------------------------------------ apply */
@@ -885,7 +967,7 @@ window.__ModuleLoader__.load({
         }, 'fast-mode: panel dismiss')
       }
 
-      // Another tab, a hand-edited patch, or the plugin's own host half may be
+      // Another tab, a hand-edited patch, or the plugin's own settings half may be
       // the one writing.
       if (typeof window !== 'undefined' && typeof window.addEventListener === 'function') {
         const onFocus = () => { void refresh(remote) }
@@ -897,7 +979,7 @@ window.__ModuleLoader__.load({
     exports.apply = apply
     exports.inject = inject
     // The two format helpers are exported for `test/state.test.js`, which feeds
-    // the same fixtures to this copy and to `src/state.js`: the host decides what a
+    // the same fixtures to this copy and to `src/state.js`: the settings side decides what a
     // request runs at from the column this half writes, so a drift between the two
     // is a switch that looks on and does nothing.
     exports.__choices = { SESSIONS_LIMIT, parseChoices, encodeChoices, withOwn }

package/docs/REFERENCE.en.md

@@ -1,6 +1,6 @@
 # Reference: principles, configuration and limits
 
-This manual describes what **dsh-fast-mode 1.5.15** actually does (injection behaviour under the default config is identical to 1.5.0; 1.5.14 added the right-click panel and 1.5.15 makes it three rows), matching `index.js`, `src/` and `client.js` in the repository. It is not a brochure: where something can be measured it gets a number, and where it has not been measured it says so.
+This manual describes what **dsh-fast-mode 1.5.17** actually does (injection behaviour under the default config is identical to 1.5.0; 1.5.14 added the right-click panel, and as of 1.5.17 it has four rows that all apply to this conversation only), matching `index.js`, `src/` and `client.js` in the repository. It is not a brochure: where something can be measured it gets a number, and where it has not been measured it says so.
 
 **The one contract: fast mode never changes reasoning effort, the thinking budget, or the model.** The `agent/request` hook does exactly one thing — `await next()`, read the `reasoningEffort` the request already carries for measurement, then return it unchanged. Whatever effort the user picked (the per-session choice in the UI, or the effort pinned by the profile's agent-default-model) is the effort every request uses.
 
@@ -9,7 +9,8 @@ Speed comes from three things only: fewer round trips, less narration, less tool
 ## Interaction details: the bolt switch and which conversation it applies to
 
 - **One icon, and it is the switch.** The conversation input's activity slot (`conversation.input.activity`) holds a single bolt button: hollow when off, filled when on. One click toggles it, another click toggles back, and that click writes only this conversation. There is no gear selector, no caret, no second-level "choose a gear" menu.
-- **Right-click is the panel.** Right-clicking the bolt opens three shared settings: less narration (`outputDiscipline`), step cap (`stepBudget`, cycling 0/15/30), and workspace inventory (`workspaceMap`). All three write shared fields only, never `sessions`, and apply from the next request; the whole block is disabled while read-only or mid-write, and a refused write rolls back. The panel does not expose `disciplineAfterSteps`, `disciplineEarlyCalls`, `shapeGate`, `finishLineSteps`, `shellParallel` or `disciplineRepeatAtSteps` — untested or held.
+- **Right-click is the panel.** Right-clicking the bolt opens four rows, all scoped to the current conversation: faster (`enabled`), less narration (`outputDiscipline`), step cap (`stepBudget`, cycling 0/15/30), and file list first (`workspaceMap`). Each row records the choice in this conversation's entry in the `sessions` column, leaves the shared defaults alone, and applies from the next request; the whole block is disabled while read-only or mid-write, and a refused write rolls back. A conversation with no entry keeps the configured defaults (`enabled`/`gear`/`outputDiscipline`/`stepBudget`/`workspaceMap`). The panel does not expose `disciplineAfterSteps`, `disciplineEarlyCalls`, `shapeGate`, `finishLineSteps`, `shellParallel` or `disciplineRepeatAtSteps` — untested or held.
+- **Conversations never affect each other, and that is a hard constraint.** Each conversation resolves `enabled`, `gear`, `outputDiscipline`, `stepBudget` and `workspaceMap` from its own entry in the `sessions` column: A can be faster + less narration while B is faster + full narration at the same time, and C, never touched, keeps the configured defaults. The panel and the bolt write only this conversation's entry and never the shared defaults; at most 200 entries are kept, oldest `ts` pruned first, and a pruned conversation falls back to the defaults.
 - **The button answers one question: is this conversation on.** `aria-pressed` is the state, and the tooltip spells out "this conversation · effort unchanged · click to turn off". What makes the mode faster, where the speed comes from, and the per-call ceiling live in the plugin description (`meta.description` and the config descriptions), not in the composer.
 - **The live line quotes the number being enforced**, not an adjective:
   - on, with a guard ceiling: `Automatic · parallel 2–8 · one call ≤ 2 min`
@@ -229,7 +230,8 @@ The plugin detects both at load (looking for the package names in the profile's
 
 - the request body goes in and comes out unchanged. This plugin does not write `reasoningEffort`, `thinking` or `output_config`, and adds no provider-specific fields;
 - it does not filter or lower "the effort ids this route declared". There is no `floor`, no ladder, no per-step downgrade;
-- the route name is recorded for metrics and debug logs only and takes part in no decision.
+- the route name is recorded for metrics and debug logs only and takes part in no decision;
+- token usage is read in whatever spelling the upstream speaks, with no vendor assumption: the harness's `inputTokens/outputTokens/…`, OpenAI Chat's `prompt_tokens/completion_tokens` (including `prompt_tokens_details.cached_tokens` and `completion_tokens_details.reasoning_tokens`), the newer OpenAI `input_tokens/output_tokens`, Anthropic's `cache_read_input_tokens/cache_creation_input_tokens`, and Google's `candidatesTokenCount` all fold to the same numbers, and usage is found under `usage`, `message.usage` or `response.usage`. A gateway that reports no usage at all counts as 0 — step time and call counts come from the harness, not from the provider.
 
 So whether a provider declares `off/low/high/max`, or `minimal/low/medium/high`, or a single level, or nothing at all, this plugin behaves the same way: it injects its guidance section, bounds shell calls, and sends the effort you chose unchanged.
 

package/docs/REFERENCE.md

@@ -1,6 +1,6 @@
 # 参考手册：原理、配置与边界
 
-本手册描述 **dsh-fast-mode 1.5.15** 的实际行为（默认配置下的注入行为与 1.5.0 一致；1.5.14 起多了右键面板，1.5.15 面板为三行），对应仓库里的 `index.js`、`src/` 与 `client.js`。它不是宣传页：凡是能测量的地方给出数字，凡是没测量的地方直接说没测量。
+本手册描述 **dsh-fast-mode 1.5.17** 的实际行为（默认配置下的注入行为与 1.5.0 一致；1.5.14 起多了右键面板，1.5.17 面板为四行、四行都只影响本会话），对应仓库里的 `index.js`、`src/` 与 `client.js`。它不是宣传页：凡是能测量的地方给出数字，凡是没测量的地方直接说没测量。
 
 **唯一的契约：Fast 模式从不改变思考强度、thinking 预算或模型。** `agent/request` 钩子只做一件事——`await next()`，读一下请求携带的 `reasoningEffort` 记进测量，然后原样返回。用户选的是哪一档（会话里的 UI 选择，或者 profile 里 agent-default-model 固定下来的那一档），每个请求就用哪一档。
 
@@ -9,7 +9,8 @@
 ## 交互细节：闪电开关与会话归属
 
 - **一个图标就是开关。** 会话输入区的活动槽（`conversation.input.activity`）里只有一个闪电按钮：关闭时空心，开启时实心。点一下切换，再点一下切回；这一下只写当前会话。没有档位选择器，没有箭头，没有"选择 gear"的二级菜单。
-- **右键是面板。** 右键闪电打开三行共享设置："更少中间输出"（`outputDiscipline`）、"步数上限"（`stepBudget`，循环 0/15/30）、"工作区清单"（`workspaceMap`）。三行都只写共享字段、不带 `sessions`，下一个回合生效；只读或写入中时整块禁用，写失败回滚。面板不暴露 `disciplineAfterSteps`、`disciplineEarlyCalls`、`shapeGate`、`finishLineSteps`、`shellParallel`、`disciplineRepeatAtSteps` 这些未证实或已判 HOLD 的旋钮。
+- **右键是面板。** 右键闪电打开四行，四行都只影响当前会话："更快"（`enabled`）、"少写过程"（`outputDiscipline`）、"最多几步"（`stepBudget`，循环 0/15/30）、"先列文件清单"（`workspaceMap`）。四行都把选择写进 `sessions` 列里本会话的条目，不碰共享默认值，下一个回合生效；只读或写入中时整块禁用，写失败回滚。没有条目的会话沿用配置里的默认值（`enabled`/`gear`/`outputDiscipline`/`stepBudget`/`workspaceMap`）。面板不暴露 `disciplineAfterSteps`、`disciplineEarlyCalls`、`shapeGate`、`finishLineSteps`、`shellParallel`、`disciplineRepeatAtSteps` 这些未证实或已判 HOLD 的旋钮。
+- **会话之间互不影响，这是硬约束。** 每个会话的 `enabled`、`gear`、`outputDiscipline`、`stepBudget`、`workspaceMap` 都从 `sessions` 列里自己那一条解析：A 会话 `更快 + 少写过程`、B 会话 `更快 + 不写过程` 同时成立，C 会话没点过就沿用配置默认值。面板和闪电只写本会话的条目，从不写共享默认值；条目最多保留 200 个，按 `ts` 淘汰最旧的，被淘汰的会话回到默认值。
 - **按钮只表达一个问题：这个会话开不开。** `aria-pressed` 就是状态，tooltip 写清"仅本会话 · 思考强度不变 · 点击关闭"。为什么快、快在哪里、单次调用上限这类说明放在插件介绍（`meta.description` 与配置项描述）里，不再占用输入区。
 - **实时行引用的是被执行的数字**，而不是产品形容词：
   - 开启、看门狗有上限：`自动调度 · 并行 2–8 · 单次调用 ≤ 2 分`
@@ -233,7 +234,8 @@
 
 - 请求体原样进出。本插件不写 `reasoningEffort`、不写 `thinking`、不写 `output_config`，也不添加任何 provider 专用字段；
 - 不做"这条路由声明了哪些档位"的过滤和降档。没有 `floor`，没有档位阶梯，没有按步降档；
-- 路由名只被记进测量和调试日志，不参与任何决策。
+- 路由名只被记进测量和调试日志，不参与任何决策；
+- token 用量按上游实际拼写读，不假定某一家：harness 的 `inputTokens/outputTokens/…`、OpenAI Chat 的 `prompt_tokens/completion_tokens`（含 `prompt_tokens_details.cached_tokens`、`completion_tokens_details.reasoning_tokens`）、新版 OpenAI 的 `input_tokens/output_tokens`、Anthropic 的 `cache_read_input_tokens/cache_creation_input_tokens`、Google 的 `candidatesTokenCount` 都会落到同一组数字；usage 挂在 `usage`、`message.usage` 或 `response.usage` 下都能找到。网关完全不报 usage 时按 0 处理——步的时间和调用数由 harness 自己量，不靠 provider。
 
 所以无论 provider 声明的是 `off/low/high/max`、还是 `minimal/low/medium/high`、还是只有一档、还是什么都没声明，本插件的行为都一样：它注入提示段、给 shell 调用设上限，然后把你选的 effort 原样发出去。
 
@@ -366,7 +368,7 @@ dsh-fast-mode-experiment stop         # 结束实验
 - `src/metrics.js`：JSONL 计量与汇总；
 - `src/benchmark.js`：按会话哈希分配；
 - `src/peers.js`：冲突插件探测；
-- `client.js`：闪电开关、右键面板（三行共享设置）与按会话的写入。
+- `client.js`：闪电开关、右键面板（四行，按会话写入 `sessions` 列）。
 
 跑测试：
 

package/index.js

@@ -80,7 +80,8 @@ import { classifyEntry } from './src/shape.js'
 import { detectPeerPlugins, opsToolsLive } from './src/peers.js'
 import { createStallGuard, stallBudgetFor } from './src/stallguard.js'
 import { createRecorder } from './src/metrics.js'
-import { choiceFor } from './src/state.js'
+import { readOutputTokens } from './src/usage.js'
+import { configOverridesFor } from './src/state.js'
 import { buildShellParallelTool } from './src/parallel.js'
 
 /**
@@ -95,7 +96,7 @@ const TAG = '[fast-mode]'
  * Shipped identity of this build. Traced into the debug log so a stale install is
  * visible at a glance, and pinned by a test against `package.json`.
  */
-export const VERSION = '1.5.15'
+export const VERSION = '1.5.17'
 const GLOBAL_AGENT = '__global__'
 
 /**
@@ -316,12 +317,8 @@ export function apply(ctx, rawConfig) {
     // scheduler's token budget needs the provider's own number, not an estimate.
     if (event && event.type === 'assistant/message') {
       try {
-        const data = event.data ?? event
-        const usage = data.usage ?? (data.message && data.message.usage)
-        const out = usage && typeof usage === 'object' ? usage.outputTokens : undefined
-        if (typeof out === 'number' && Number.isFinite(out) && out > 0) {
-          noteOutputTokens(auto, agentKey(session), out)
-        }
+        const out = readOutputTokens(event.data ?? event)
+        if (out > 0) noteOutputTokens(auto, agentKey(session), out)
       } catch {
         // A counter that can fail a turn is worse than no counter.
       }
@@ -362,10 +359,10 @@ export function apply(ctx, rawConfig) {
     // session hash, and a panel click that quietly overrode the arm would empty
     // the control group of the very trial the user asked for.
     if (assigned === undefined) {
-      // No experiment: the conversation's own entry wins, and its absence means
-      // "inherit" — the configured pair is both the default and the record of
-      // the last choice anywhere, which is what a fresh session starts from.
-      const own = choiceFor(rawConfig?.sessions, sessionId)
+      // No experiment: the conversation's own entry wins, field by field, and
+      // its absence means "inherit". Every panel control writes into that entry,
+      // which is what keeps one tab's prose or step cap from touching another.
+      const own = configOverridesFor(rawConfig?.sessions, sessionId)
       return own === undefined ? resolveConfig(rawConfig) : resolveConfig(rawConfig, own)
     }
     // The control arm is an assignment like any other: the mode is off because

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-fast-mode",
-  "version": "1.5.15",
+  "version": "1.5.17",
   "description": "DeepSeek Harness fast mode: same thinking effort, fewer round trips. An adaptive parallel tool fan-out, output discipline that never trims the answer, and a cancellable stall guard. Never changes reasoning effort, the model, or the request body. Provider-agnostic, one dependency (@deepseek-ai/schemastery).",
   "repository": {
     "type": "git",

package/src/config.js

@@ -81,7 +81,7 @@ export const Config = z.object({
     .union([z.boolean(), z.const('late')])
     .default('late')
     .description(
-      '输出纪律 / Output discipline: 让模型少写过程、只在结论处落笔。`late`（默认）不往系统提示里放文风规则，第 4 步之后由调度器提醒一次——短任务零成本，长任务实测 6 对：墙钟中位 2.68×、步数 10.5→7.5、输出 token −52%、正确性 12/12 不变。`true` 全程生效；`false` 关闭。',
+      '输出纪律 / Output discipline（面板「少写过程」，也是没有自己条目的会话的默认值）: 让模型少写过程、只在结论处落笔。`late`（默认）不往系统提示里放文风规则，第 4 步之后由调度器提醒一次——短任务零成本，长任务实测 6 对：墙钟中位 2.68×、步数 10.5→7.5、输出 token −52%、正确性 12/12 不变。`true` 全程生效；`false` 关闭。',
     ),
 
   shellParallel: z
@@ -98,7 +98,7 @@ export const Config = z.object({
     .max(80)
     .default(0)
     .description(
-      '单轮步数预算 / Steps per turn: 用户自设的硬上限，到达后调度器提醒一次按现状汇报；0 = 不限（默认）。步数只说明成本，不说明任务是否完成——默认不再按步数催停，避免把仍在推进的长任务截断。需要成本上限时自己设。',
+      '单轮步数预算 / Steps per turn（面板「最多几步」，0 显示为「不限」）: 用户自设的硬上限，到达后调度器提醒一次按现状汇报；0 = 不限（默认）。步数只说明成本，不说明任务是否完成——默认不再按步数催停，避免把仍在推进的长任务截断。需要成本上限时自己设。',
     ),
 
   finishLineSteps: z
@@ -185,7 +185,7 @@ export const Config = z.object({
     .boolean()
     .default(false)
     .description(
-      '工作区清单 / Workspace inventory: 会话开始时不调用任何工具，harness 自己走一遍 cwd（深度 2、最多 60 条、跳过 node_modules 等）把路径、大小和现有测试入口作为一条提示交给模型。实测 `def15` 会话里 35.7% 的工具调用是 ls/find/cat 这类探路，其中 40% 出现在前两次调用里——这一步就是把那次往返拿掉。只发一次，不隐藏任何文件，读文件仍由模型自己决定。',
+      '工作区清单 / Workspace inventory（面板「先列文件清单」）: 会话开始时不调用任何工具，harness 自己走一遍 cwd（深度 2、最多 60 条、跳过 node_modules 等）把路径、大小和现有测试入口作为一条提示交给模型。实测 `def15` 会话里 35.7% 的工具调用是 ls/find/cat 这类探路，其中 40% 出现在前两次调用里——这一步就是把那次往返拿掉。只发一次，不隐藏任何文件，读文件仍由模型自己决定。',
     ),
 
   mapEntries: z

package/src/metrics.js

@@ -21,6 +21,8 @@
 import { appendFileSync, mkdirSync, renameSync, statSync } from 'node:fs'
 import { dirname } from 'node:path'
 
+import { findUsage, readUsage } from './usage.js'
+
 /** The measurement format. Bumped when a field changes meaning. */
 export const METRICS_VERSION = 2
 
@@ -100,22 +102,12 @@ const payloadOf = (event) => {
 }
 
 /**
- * Read one token field from a usage object.
- *
- * The harness reports `TokenUsage` (`inputTokens`, `outputTokens`,
- * `cacheReadTokens`, `cacheWriteTokens`, `reasoningTokens`), while the session
- * stats projection uses the gateway's own `uncachedInputTokens`/`thoughtTokens`
- * spelling. Both are accepted so a provider that reports either still counts.
+ * Read one usage object in any of the dialects a route may speak.
  *
- * @param {any} usage @param {string[]} names
+ * The spelling table lives in `usage.js`, because the scheduler budgets against
+ * the same numbers. This module only needs the fold: a self-hosted gateway that
+ * says `completion_tokens` must produce the same row as the official API.
  */
-const tokenField = (usage, names) => {
-  for (const name of names) {
-    const value = usage[name]
-    if (typeof value === 'number' && Number.isFinite(value) && value > 0) return value
-  }
-  return 0
-}
 
 /**
  * Milliseconds between two event timestamps, never negative.
@@ -295,15 +287,13 @@ export function createRecorder(options = {}) {
         if (entry.first === undefined) entry.first = time
         entry.last = time
         // The message is appended with `usage` beside it; older adapters hang it
-        // off the message instead. Both are the same numbers.
-        const usage = data.usage ?? (data.message && data.message.usage)
-        if (usage && typeof usage === 'object') {
-          entry.input += tokenField(usage, ['inputTokens', 'uncachedInputTokens'])
-          entry.output += tokenField(usage, ['outputTokens'])
-          entry.reasoning += tokenField(usage, ['reasoningTokens', 'thoughtTokens'])
-          entry.cacheRead += tokenField(usage, ['cacheReadTokens', 'cachedReadTokens'])
-          entry.cacheWrite += tokenField(usage, ['cacheWriteTokens', 'cachedWriteTokens'])
-        }
+        // off the message instead, and a gateway may nest it under `response`.
+        const tokens = readUsage(findUsage(data))
+        entry.input += tokens.input
+        entry.output += tokens.output
+        entry.reasoning += tokens.reasoning
+        entry.cacheRead += tokens.cacheRead
+        entry.cacheWrite += tokens.cacheWrite
         return
       }
 

package/src/state.js

@@ -9,13 +9,23 @@
  *
  * So the plugin keeps two tiers:
  *
- * - The `enabled` / `gear` config fields stay the **default**, and double as the
- *   "last choice": a conversation with no entry of its own inherits whatever was
- *   picked most recently anywhere. That is what makes a fresh session start
- *   where the user left off instead of resetting to the schema default.
- * - The `sessions` field carries the per-session entries: `{ sessionId: { enabled,
- *   gear, ts } }` as a compact JSON string. It is volatile like the other two,
- *   so a write lands in the running plugin without a remount.
+ * - The config fields (`enabled`, `gear`, `outputDiscipline`, `stepBudget`,
+ *   `workspaceMap`) are the **defaults**: what a conversation runs at until it
+ *   has an entry of its own. Only an edit in `cordis.patch.yml` changes them;
+ *   the chip and the panel never write them.
+ * - The `sessions` field carries every per-session choice: `{ sessionId: {
+ *   enabled, gear, discipline, stepBudget, map, ts } }` as a compact JSON
+ *   string. It is volatile, so a write lands in the running plugin without a
+ *   remount.
+ *
+ * Every panel control writes this second tier, and that is what makes the four
+ * switches independent per conversation: one tab can be fast with terser prose
+ * while another is fast with full narration, and neither click moves the other.
+ * The previous release wrote the three extra knobs into the shared fields; the
+ * host refuses a write to a non-volatile field ("Config field … is not
+ * volatile"), so those rows did nothing whatsoever — the symptom read as a dead
+ * button rather than as a refusal, because the panel closes on click and the
+ * error only appears in a tooltip.
  *
  * Why a config field and not a new remote call: a plugin-owned RPC would need a
  * decorated `TypertRemoteService`, and the client half is a static bundle with no
@@ -57,7 +67,7 @@ function isRecord(value) {
  * "no overrides" rather than take the plugin down with it.
  *
  * @param {unknown} raw
- * @returns {Record<string, {enabled?: boolean, gear?: string, ts?: number}>}
+ * @returns {Record<string, SessionEntry>}
  */
 export function parseChoices(raw) {
   const value = plainConfigValue(raw)
@@ -72,23 +82,38 @@ export function parseChoices(raw) {
 }
 
 /**
- * Drop entries that are not a usable shape, and coerce the two fields the policy
+ * Drop entries that are not a usable shape, and coerce the fields the policy
  * actually reads. A gear name is validated by `resolveConfig`, not here: this
  * module must not own the gear ladder.
  *
+ * `discipline` is the one field with three states (`true`, `'late'`, `false`),
+ * and it is stored exactly as the config field spells it so the two tiers stay
+ * interchangeable. `map` is short for `workspaceMap`; the entry is a hot column
+ * read on every describe, and the shorter key keeps an entry near 90 bytes.
+ *
  * @param {Record<string, any>} input
+ * @returns {Record<string, SessionEntry>}
  */
 function sanitise(input) {
-  /** @type {Record<string, {enabled?: boolean, gear?: string, ts?: number}>} */
+  /** @type {Record<string, SessionEntry>} */
   const out = {}
   for (const [sessionId, entry] of Object.entries(input)) {
     if (sessionId.length === 0 || !isRecord(entry)) continue
-    /** @type {{enabled?: boolean, gear?: string, ts?: number}} */
+    /** @type {SessionEntry} */
     const clean = {}
     if (typeof entry.enabled === 'boolean') clean.enabled = entry.enabled
     if (typeof entry.gear === 'string' && entry.gear.length > 0) clean.gear = entry.gear
+    if (typeof entry.discipline === 'boolean' || entry.discipline === 'late') clean.discipline = entry.discipline
+    if (Number.isFinite(entry.stepBudget) && entry.stepBudget >= 0) clean.stepBudget = Math.floor(Number(entry.stepBudget))
+    if (typeof entry.map === 'boolean') clean.map = entry.map
     if (Number.isFinite(entry.ts)) clean.ts = Number(entry.ts)
-    if (clean.enabled === undefined && clean.gear === undefined) continue
+    if (
+      clean.enabled === undefined
+      && clean.gear === undefined
+      && clean.discipline === undefined
+      && clean.stepBudget === undefined
+      && clean.map === undefined
+    ) continue
     out[sessionId] = clean
   }
   return out
@@ -99,22 +124,50 @@ function sanitise(input) {
  *
  * @param {unknown} raw - the `sessions` config value.
  * @param {string|undefined} sessionId
- * @returns {{enabled?: boolean, gear?: string}|undefined}
+ * @returns {SessionEntry|undefined}
  */
 export function choiceFor(raw, sessionId) {
   if (typeof sessionId !== 'string' || sessionId.length === 0) return undefined
   const entry = parseChoices(raw)[sessionId]
   if (entry === undefined) return undefined
-  /** @type {{enabled?: boolean, gear?: string}} */
+  /** @type {SessionEntry} */
   const choice = {}
   if (entry.enabled !== undefined) choice.enabled = entry.enabled
   if (entry.gear !== undefined) choice.gear = entry.gear
+  if (entry.discipline !== undefined) choice.discipline = entry.discipline
+  if (entry.stepBudget !== undefined) choice.stepBudget = entry.stepBudget
+  if (entry.map !== undefined) choice.map = entry.map
   return choice
 }
 
+/**
+ * The same entry, spelled as config fields so `resolveConfig` can merge it.
+ *
+ * This is the one place the two vocabularies meet: the column is compact, the
+ * config is what the policy reads. Keeping the mapping here means the host half
+ * never has to remember that `map` means `workspaceMap`.
+ *
+ * @param {unknown} raw
+ * @param {string|undefined} sessionId
+ * @returns {Record<string, unknown>|undefined}
+ */
+export function configOverridesFor(raw, sessionId) {
+  const choice = choiceFor(raw, sessionId)
+  if (choice === undefined) return undefined
+  /** @type {Record<string, unknown>} */
+  const overrides = {}
+  if (choice.enabled !== undefined) overrides.enabled = choice.enabled
+  if (choice.gear !== undefined) overrides.gear = choice.gear
+  if (choice.discipline !== undefined) overrides.outputDiscipline = choice.discipline
+  if (choice.stepBudget !== undefined) overrides.stepBudget = choice.stepBudget
+  if (choice.map !== undefined) overrides.workspaceMap = choice.map
+  return Object.keys(overrides).length === 0 ? undefined : overrides
+}
+
 /**
  * The effective pair for one conversation: its own entry when it has one, the
- * configured default otherwise.
+ * configured default otherwise. Kept for the two-field shape callers had before
+ * the panel grew; the field-by-field fallback is the same rule the host applies.
  *
  * @param {unknown} raw
  * @param {string|undefined} sessionId
@@ -136,12 +189,14 @@ export function resolveChoice(raw, sessionId, fallback) {
  *
  * `ts` is the pruning key, not a display field: the map is ordered by nothing in
  * particular after a round trip through JSON, so recency has to be recorded.
+ * Fields absent from `choice` keep their previous value, which is what lets the
+ * panel write one row without restating the other three.
  *
  * @param {unknown} raw - current `sessions` value.
  * @param {string} sessionId
- * @param {{enabled?: boolean, gear?: string}} choice
+ * @param {SessionEntry} choice
  * @param {number} [now]
- * @returns {{sessions: string, map: Record<string, {enabled?: boolean, gear?: string, ts?: number}>}}
+ * @returns {{sessions: string, map: Record<string, SessionEntry>}}
  */
 export function writeChoice(raw, sessionId, choice, now) {
   const map = parseChoices(raw)
@@ -149,18 +204,23 @@ export function writeChoice(raw, sessionId, choice, now) {
     return { sessions: encodeChoices(map), map }
   }
   const current = map[sessionId] ?? {}
-  /** @type {{enabled?: boolean, gear?: string, ts?: number}} */
+  /** @type {SessionEntry} */
   const next = { ...current, ts: Number.isFinite(now) ? Number(now) : Date.now() }
   if (typeof choice.enabled === 'boolean') next.enabled = choice.enabled
   if (typeof choice.gear === 'string' && choice.gear.length > 0) next.gear = choice.gear
+  if (typeof choice.discipline === 'boolean' || choice.discipline === 'late') next.discipline = choice.discipline
+  if (Number.isFinite(choice.stepBudget) && choice.stepBudget >= 0) next.stepBudget = Math.floor(Number(choice.stepBudget))
+  if (typeof choice.map === 'boolean') next.map = choice.map
   map[sessionId] = next
   return { sessions: encodeChoices(map), map }
 }
 
+/** @typedef {{enabled?: boolean, gear?: string, discipline?: boolean|'late', stepBudget?: number, map?: boolean, ts?: number}} SessionEntry */
+
 /**
  * Serialise the map, dropping the oldest entries beyond {@link SESSIONS_LIMIT}.
  *
- * @param {Record<string, {enabled?: boolean, gear?: string, ts?: number}>} map
+ * @param {Record<string, SessionEntry>} map
  * @returns {string}
  */
 export function encodeChoices(map) {

package/src/usage.js

@@ -0,0 +1,124 @@
+/**
+ * Token usage, in whichever dialect the route speaks.
+ *
+ * The plugin must not care which gateway is behind a model: the official API,
+ * a self-hosted OpenAI-compatible proxy, an Anthropic-compatible one, and the
+ * harness's own projection all describe the same four numbers under different
+ * names. The scheduler needs the output count (it is decode time, so it is the
+ * wall clock), and the metrics row wants the rest for an honest report. Reading
+ * only `outputTokens` meant a gateway that says `completion_tokens` looked like
+ * a turn that produced no output at all.
+ *
+ * Mapping, most specific first:
+ *
+ * | meaning     | accepted spellings                                                        |
+ * | ----------- | ------------------------------------------------------------------------- |
+ * | input       | `inputTokens`, `prompt_tokens`, `promptTokenCount`, `uncachedInputTokens` |
+ * | output      | `outputTokens`, `output_tokens`, `completion_tokens`, `candidatesTokenCount` |
+ * | reasoning   | `reasoningTokens`, `thoughtTokens`, `reasoning_tokens`                    |
+ * | cache read  | `cacheReadTokens`, `cachedReadTokens`, `cache_read_input_tokens`, `cached_tokens` |
+ * | cache write | `cacheWriteTokens`, `cachedWriteTokens`, `cache_creation_input_tokens`    |
+ *
+ * A missing usage object is not an error — some proxies do not report one — so
+ * every reader here returns zeros rather than throwing, and the caller keeps its
+ * own defaults.
+ */
+
+const number = (value) => (typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : 0)
+
+const nested = (object, path) => {
+  let current = object
+  for (const key of path) {
+    if (!current || typeof current !== 'object') return undefined
+    current = current[key]
+  }
+  return current
+}
+
+/**
+ * Read the first numeric field that exists under any of the given names.
+ *
+ * @param {any} usage
+ * @param {string[]} names
+ */
+const field = (usage, names) => {
+  for (const name of names) {
+    const value = number(usage[name])
+    if (value > 0) return value
+  }
+  return 0
+}
+
+/** The OpenAI responses / Anthropic style detail objects. */
+const detail = (usage, name) => (usage && typeof usage[name] === 'object' ? usage[name] : {})
+
+/**
+ * Normalise one usage object.
+ *
+ * Every key the plugin reads is total-and-positive; `0` means "this route did
+ * not say", never "this route said zero", because a zero-token step would be
+ * indistinguishable from an absent one anyway.
+ *
+ * @param {any} usage
+ * @returns {{input: number, output: number, reasoning: number, cacheRead: number, cacheWrite: number}}
+ */
+export function readUsage(usage) {
+  const empty = { input: 0, output: 0, reasoning: 0, cacheRead: 0, cacheWrite: 0 }
+  if (!usage || typeof usage !== 'object') return empty
+
+  const promptDetails = detail(usage, 'prompt_tokens_details')
+  const inputDetails = detail(usage, 'input_tokens_details')
+  const completionDetails = detail(usage, 'completion_tokens_details')
+  const outputDetails = detail(usage, 'output_tokens_details')
+
+  return {
+    input: field(usage, ['inputTokens', 'input_tokens', 'prompt_tokens', 'promptTokenCount', 'uncachedInputTokens']),
+    output: field(usage, ['outputTokens', 'output_tokens', 'completion_tokens', 'candidatesTokenCount']),
+    reasoning: field(usage, ['reasoningTokens', 'thoughtTokens', 'reasoning_tokens', 'thoughtsTokenCount'])
+      || field(completionDetails, ['reasoning_tokens'])
+      || field(outputDetails, ['reasoning_tokens']),
+    cacheRead: field(usage, ['cacheReadTokens', 'cachedReadTokens', 'cache_read_input_tokens', 'cachedContentTokenCount', 'cached_tokens'])
+      || field(promptDetails, ['cached_tokens'])
+      || field(inputDetails, ['cached_tokens']),
+    cacheWrite: field(usage, ['cacheWriteTokens', 'cachedWriteTokens', 'cache_creation_input_tokens']),
+  }
+}
+
+/**
+ * Find a usage object inside an event payload.
+ *
+ * The harness hangs it off `data.usage`, older adapters off `data.message.usage`;
+ * OpenAI-style proxies sometimes nest it under `response.usage`, and a custom
+ * gateway that reuses the completion envelope puts it there too. Walk the few
+ * shapes that exist rather than demanding one.
+ *
+ * @param {any} source
+ */
+export function findUsage(source) {
+  if (!source || typeof source !== 'object') return undefined
+  const paths = [
+    ['usage'],
+    ['message', 'usage'],
+    ['response', 'usage'],
+    ['message', 'response', 'usage'],
+    ['result', 'usage'],
+    ['output', 'usage'],
+    ['data', 'usage'],
+  ]
+  for (const path of paths) {
+    const found = nested(source, path)
+    if (found && typeof found === 'object') return found
+  }
+  // Some adapters store the counts flat on the event.
+  if ('outputTokens' in source || 'output_tokens' in source || 'completion_tokens' in source) return source
+  return undefined
+}
+
+/**
+ * Output tokens only — the number the scheduler budgets against.
+ *
+ * @param {any} source an event payload, not necessarily just the usage object
+ */
+export function readOutputTokens(source) {
+  return readUsage(findUsage(source)).output
+}