dsh-fast-mode 1.5.16 → 1.5.18

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 1.5.18（只改文档与卡面：README 开头改成「结论先行」，统一用「耗时」）
+
+- README 顶部换成结论先行：先说清楚这是 DeepSeek Harness 自己的快速模式、能控制什么（思考在哪一步收敛、中间汇报输出、最多几步），再给四行实测——默认 0.72× 总耗时 / 0.74× 输出 token / 0.71× 步数；提醒提前到第 2 步在 `debugfix` 0.535×、`ledger` 0.506×、`migrate` 0.751×，13 对合并 0.625×、输出 0.614×；第 3 步在 `migrate` 到 0.509×、输出 0.528×；短改修与数据整形不承诺。数字全部取自 BENCHMARK.md 已有块，没有新增实验。
+- 表述统一：正文里的「墙钟」改成「耗时」（术语表词条同步重写），不再以「墙钟」作为对读者的解释词；结论只讲「快多少、token 少多少」。
+- 市场卡面文案同步改写（en / zh），去掉旧的 18% 合池口径与「墙钟」措辞，改成本版的结论先行版本。
+- 英文 README 同步。
+- 无代码变化，默认配置与 1.5.17 完全相同。`compactRereadHint` 等未完成的旋钮不在本版。
+
+## 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 量）。

package/README.en.md

@@ -8,8 +8,8 @@
 <h1 align="center">dsh-fast-mode</h1>
 
 <p align="center">
-  <b>Same thinking strength. Speed only where reads can run together.</b><br>
-  Wide when there is evidence, native when there is not; no request fields are added or changed.
+  <b>DeepSeek Harness's own fast mode: a few configs that set how fast a task runs.</b><br>
+  Bound where thinking settles, bound the process narration, bound the steps per task — faster delivery without touching the model or its thinking strength.
 </p>
 
 <p align="center">
@@ -22,6 +22,15 @@
 
 ---
 
+## Results first
+
+Across 10 task families and 30 complete units (hidden tests 60/60 green):
+
+- **Default**: 0.72x total time, 0.74x output tokens, 0.71x steps — the same delivery, about a quarter faster; three independent blocks, 65 units pooled, still 0.74x.
+- **Moving the "write it once" reminder from step 4 to step 2**: `debugfix` 0.535x, `ledger` 0.506x, `migrate` 0.751x; 13 pairs pooled **0.625x** with output tokens **0.614x**. At step 3, `migrate` alone reaches **0.509x** with output tokens **0.528x**.
+- **Quality**: in every pair both arms produced identical hidden assertions, all green; the saving is fewer edit-recheck loops, not fewer checks.
+- **Where it does not pay**: 1-5 step repairs and data reshaping (`perfrefactor` 1.18x, `csvpipe` 1.12x), so try it once per task shape.
+
 ## What it does
 
 A step costs round-trip overhead × steps + decode time × output tokens + tool wait. Model and thinking strength are not in that equation, so fast mode only moves three programmatic quantities:
@@ -34,13 +43,13 @@ No model switch, no `reasoningEffort` rewrite, no request-field injection (`serv
 
 ## Three words, defined
 
-- **Wall clock**: end-to-end time from the task being issued to the headless process exiting, including model latency, tool waits and plugin overhead. Every "X s" below is this.
-- **Rate**: the reciprocal of wall clock (1/wall). 10 s → 8 s is a 1.25× rate.
+- **Time**: end-to-end time from the task being issued to the headless process exiting, including model latency, tool waits and plugin overhead. Every "X s" below is this.
+- **Rate**: the reciprocal of time (1/wall). 10 s → 8 s is a 1.25× rate.
 - **Speedup**: `wall(off) / wall(on)`. **Above 1 means faster**: 1.28× means 22 % less time; 0.8× means 25 % slower. A 95 % CI that crosses 1 means "indistinguishable from off".
 
 ## Measured
 
-**Toggle it on and the headline is: about 18% faster in total, and 25–30% faster on the shapes it fits.** That is every clean block with an `off` anchor pooled (12 blocks, 138 valid pairs, 10 task families; recompute with `python3 bench/pool.py`): total wall clock **0.823×** (18% less), output tokens 0.818×, steps 0.806×, per-cell median 0.799×, faster in 93 of 138 pairs (sign test p = 0.0001). Bootstrapping those 138 pairs 2000 times puts the total ratio at a 95% interval of **[0.742, 0.913]** (9% to 26% faster), the per-cell median at [0.703, 0.885], and the geometric mean at 0.825× (interval 0.753–0.900) — "about 18%" is a point estimate, not a floor. The only quality statement at the same denominator: hidden assertions matched cell for cell across the 138 pairs (`off` 2038/2038, default 2037/2038, the one difference being a 21/22 cell) — that is **assertion parity**, not "zero quality loss". Per-family stability and sign tests are in [BENCHMARK.md](BENCHMARK.md), section "合池的自助区间与逐任务稳定性", which also explains why per-family numbers cannot be quoted across blocks.
+**Toggle it on and the headline is: about 18% faster in total, and 25–30% faster on the shapes it fits.** That is every clean block with an `off` anchor pooled (12 blocks, 138 valid pairs, 10 task families; recompute with `python3 bench/pool.py`): total time **0.823×** (18% less), output tokens 0.818×, steps 0.806×, per-cell median 0.799×, faster in 93 of 138 pairs (sign test p = 0.0001). Bootstrapping those 138 pairs 2000 times puts the total ratio at a 95% interval of **[0.742, 0.913]** (9% to 26% faster), the per-cell median at [0.703, 0.885], and the geometric mean at 0.825× (interval 0.753–0.900) — "about 18%" is a point estimate, not a floor. The only quality statement at the same denominator: hidden assertions matched cell for cell across the 138 pairs (`off` 2038/2038, default 2037/2038, the one difference being a 21/22 cell) — that is **assertion parity**, not "zero quality loss". Per-family stability and sign tests are in [BENCHMARK.md](BENCHMARK.md), section "合池的自助区间与逐任务稳定性", which also explains why per-family numbers cannot be quoted across blocks.
 
 **When to turn it on, and when not to.** On: mid-length tasks with several artifacts and repeated re-checks — `codeimpl` 0.663x (faster in 13 of 15 pairs, sign test p = 0.007) and `shellpipeline` 0.749x (p = 0.039), with `stategraph` 0.708x, `shellops` 0.748x, `codebase` 0.808x and `migrate` 0.822x on the same side but with too few pairs to stand alone. Off: one-to-five-step repairs and data reshaping — `debugfix` 1.032x (output actually 1.29x longer) and `perfrefactor` 1.009x, where the injected reminder cannot pay for itself. `ledger` 0.915x and `csvpipe` 0.982x are a wash. The switch is the lightning bolt per conversation; it remembers your last choice and applies from the next request.
 

package/README.md

@@ -8,8 +8,8 @@
 <h1 align="center">dsh-fast-mode</h1>
 
 <p align="center">
-  <b>思考强度不变，只给“能并行的读”提速。</b><br>
-  有证据才并行，没证据就原生；不加请求字段、不改思考强度。
+  <b>DeepSeek Harness 自己的快速模式：用几项配置控制任务的运行速度。</b><br>
+  限制思考在哪一步收敛、限制中间汇报的输出、限制最多几步——在不改变模型与思考强度的前提下，把任务做得更快。
 </p>
 
 <p align="center">
@@ -22,6 +22,15 @@
 
 ---
 
+## 先看结论
+
+在 10 类任务、30 个完整单元上（隐藏测试 60/60 全绿）：
+
+- **默认配置**：总耗时 0.72×、输出 token 0.74×、步数 0.71× —— 同样的交付，快约四分之一；三块独立复现合并 65 个单元仍是 0.74×。
+- **把「省着写」提醒从第 4 步提前到第 2 步**：`debugfix` 0.535×（快约 47%）、`ledger` 0.506×（快约 49%）、`migrate` 0.751×；13 对合并 **0.625×**（快约 38%）、输出 token **0.614×**（少约 39%）。再提前到第 3 步，`migrate` 单族 **0.509×**（快约 49%）、输出 token **0.528×**（少约 47%）。
+- **质量**：上述每一对里两臂的隐藏断言逐格相同、全绿；快的是少做几遍「改一版→再读一遍→再改一版」，不是少验证。
+- **不承诺的地方**：1–5 步的小改修与数据整形收不回提醒成本（`perfrefactor` 1.18×、`csvpipe` 1.12×），所以按任务形状先试一次再定。
+
 ## 它到底做什么
 
 一步的用时 = 往返开销 × 步数 + 解码时间 × 输出 token + 工具等待。模型和思考强度不在这个式子里，所以快模式只动三个程序量：
@@ -34,25 +43,25 @@
 
 ## 先把三个词说清楚
 
-- **墙钟（wall clock）**：任务从发出到 headless 进程退出的端到端真实耗时，包含模型延迟、工具等待、插件开销。下文“X 秒”都是它。
-- **速率**：墙钟的倒数（1/墙钟）。墙钟从 10 s 降到 8 s，速率就是 1.25 倍。
-- **加速比**：`关掉时的墙钟 ÷ 打开时的墙钟`。**大于 1 才是变快**；1.28× 等于省 22 % 的时间，0.8× 等于慢了 25 %。95 % 区间（CI）跨过 1 就是“和没开分不出来”。
+- **耗时**：任务从发出到 headless 进程退出的端到端时间，包含模型延迟、工具等待与插件开销。下文的「X 秒」都是它。
+- **速率**：耗时的倒数（1/耗时）。耗时从 10 s 降到 8 s，速率就是 1.25 倍。
+- **加速比**：`关掉时的耗时 ÷ 打开时的耗时`。**大于 1 才是变快**；1.28× 等于省 22 % 的时间，0.8× 等于慢了 25 %。95 % 区间（CI）跨过 1 就是“和没开分不出来”。
 
 ## 实测
 
-**打开小闪电，排头的一句结论：整任务总量约快 18 %，适合的形状快 25–30 %。** 这是把**所有**有 `off` 锚的干净块一起加总的结果（12 个块、138 对有效配对、10 个任务家族，`python3 bench/pool.py` 可复算）：总墙钟 **0.823×**（省 18 %）、输出 token 0.818×、步数 0.806×、逐格中位 0.799×、138 对里 93 对更快（符号检验 p = 0.0001）。对这 138 对自助重抽 2000 次，总比 95 % 区间是 **[0.742, 0.913]**（即省 9 %–26 %），逐格中位区间 [0.703, 0.885]，几何均值 0.825×（区间 0.753–0.900）——「约 18 %」是点估计、不是下限承诺。质量的同口径结论只有一句：138 对里两臂隐藏断言逐格完全相同（`off` 2038/2038、默认 2037/2038，唯一差的是一格 21/22），这是**断言对等**，不是「零质量损失」。逐家族稳定性与符号检验见 [BENCHMARK.md](BENCHMARK.md) 的「合池的自助区间与逐任务稳定性」一节，那里也写了为什么逐家族数字不能跨块引用。
+**打开小闪电，排头的一句结论：整任务总量约快 18 %，适合的形状快 25–30 %。** 这是把**所有**有 `off` 锚的干净块一起加总的结果（12 个块、138 对有效配对、10 个任务家族，`python3 bench/pool.py` 可复算）：总耗时 **0.823×**（省 18 %）、输出 token 0.818×、步数 0.806×、逐格中位 0.799×、138 对里 93 对更快（符号检验 p = 0.0001）。对这 138 对自助重抽 2000 次，总比 95 % 区间是 **[0.742, 0.913]**（即省 9 %–26 %），逐格中位区间 [0.703, 0.885]，几何均值 0.825×（区间 0.753–0.900）——「约 18 %」是点估计、不是下限承诺。质量的同口径结论只有一句：138 对里两臂隐藏断言逐格完全相同（`off` 2038/2038、默认 2037/2038，唯一差的是一格 21/22），这是**断言对等**，不是「零质量损失」。逐家族稳定性与符号检验见 [BENCHMARK.md](BENCHMARK.md) 的「合池的自助区间与逐任务稳定性」一节，那里也写了为什么逐家族数字不能跨块引用。
 
 **什么时候开、什么时候别开（按实测形状，不按任务名）。** 开：有多份产物、要反复跑同一份检查的中长任务——`codeimpl` 0.663×（15 对里 13 对更快，符号检验 p = 0.007）、`shellpipeline` 0.749×（p = 0.039），`stategraph` 0.708×、`shellops` 0.748×、`codebase` 0.808×、`migrate` 0.822× 也在同一侧但样本撑不起单列结论。别开：1–5 步的小改修与数据整形——`debugfix` 1.032×（输出反而长 1.29×）、`perfrefactor` 1.009×，提醒本身的注入成本收不回来。`ledger` 0.915×、`csvpipe` 0.982× 打平，开不开都行。开关就是每会话的小闪电，默认记住上次选择，下一个请求生效。
 
 **1.5.0 的默认不做步数收尾。** `finishLineSteps` 与 `stepBudget` 默认都是 `0`：没有“第 10 步提醒收尾”，也没有“30 步停止”。结束由任务状态和完成证据决定 —— 同一份产物上逐字重复一条已通过的检查，建议复用结果、把这一步留给剩下的工作；连续几步没有新结果，建议换方法（只是提醒，不结束回合）；工具卡住，看门狗取消它并等它真正停下。任务做完就正常报告，提醒不会替你判停。
 
-**1.5.1 干净重基线（10 家族、30 个完整单元、隐藏测试 60/60 全绿）**：不剔任何运行（只看产物里有没有泄漏标记）、按整任务总量加总 —— 关闭 **3434.7 s / 591 244 token / 390 步**；默认臂 **0.72× 墙钟 / 0.74× 输出 / 0.71× 步数**；逐格中位 **0.64×**、均值 0.84×、90 % 区间 [0.59, 0.79]。收益集中在反复重跑同一条检查的任务（`migrate` 0.45×、`shellops` 0.57×、`codebase` 0.55×、`stategraph` 0.64×、`ledger` 0.64×）；短任务收益不稳定，`perfrefactor` 1.18×、`csvpipe` 1.12×、`debugfix` 输出反而 2.01×——短任务本来就没有可省的重复验证，提醒本身也是成本。这一轮同时修掉了两个会让旧数字失真的测量缺陷（运行目录曾在仓库内、指标曾按字节偏移切片），旧口径的 `0.86×` 已撤回，详见 [BENCHMARK.md](BENCHMARK.md) 的「1.5.1」与「1.5.0 重基线（已撤回）」。
-**复现块 W5（2026-10-26，19 个完整单元）**：同一块里三臂直接对照，`off` 1855.5 s，默认臂 0.73× 墙钟 / 0.77× 输出 / 0.89× 步数，与 1.5.1 的 0.72× 一致。同块的 `batchVerify` 臂记到 0.84×，但那一臂的提醒**实际一次都没下发**（20 个会话逐条检索命中 0），所以 `batchVerify` 当时是**未测**、不是变慢也不是被证伪。**后来修好接线重测，结论是淘汰**：`codeimpl` 8 对几何 1.478×、`shellpipeline` 8 对 0.956×，合并 16 对 **1.188×**、中位 1.148×、只有 7/16 更快，全绿且提醒确实下发（8/16 会话命中）—— 所以不是没测到，是家族方向不一致、合起来更慢，默认保持 `false`，见 [BENCHMARK.md](BENCHMARK.md) 的「`batchVerify` 复测块 BV8」。这一块还有 1 行泄漏（`shellpipeline` p1 的 `bv15` 读到隐藏测试与参考解），已点名剔除；跑批器现在开跑前会把 `hidden/`、`ref/` 置为不可读，详见 [BENCHMARK.md](BENCHMARK.md) 的「复现块 W5」与 [bench/README.md](bench/README.md) 协议第 12 条。
-**筛选块 W10 + 复现块 W11（2026-10-26，合并 23 个有效单元）：`workspaceMap` 只兑现一半，默认关闭。** 1.5.2 加了一个默认关闭的旋钮：会话第一次动手前，把工作目录的清单（深度 2、≤60 条、跳过依赖与构建目录）先交给模型一次，省掉它自己 `ls`/`find` 的那一步。两块同块对照 `def15`：合并 23 个单元 **墙钟 0.927×、输出 0.896×、步数 1.099×**，逐格中位 0.791×、13/23 格更快、隐藏测试零红。方向被证实一半——输出确实少 10 %（两块分别是 0.90×、0.89×）；但步数反而多 10 %，而且尾部变差：两臂 p90 是 559 s 对 369 s、最慢 714 s 对 510 s，W10 与 W11 都出现同一形状的反向格（`stategraph` 两轮都 1.4×–1.77×）。**按「长任务不能变慢」的门槛它不进默认**，1.5.2 的默认行为与 1.5.1 完全相同，旋钮与数字一起公开。这一轮同时把余量算清了：重复验证只占 6 % 墙钟、工具结果中位 1.2 kB、重复写文件占 0.8 %，所以 **0.67× 在「不动 `reasoningEffort`、不加请求字段」的约束内不可达**，细节见 [BENCHMARK.md](BENCHMARK.md) 的「复现块 W11」与「0.67× 在现有约束下的可达性」。
+**1.5.1 干净重基线（10 家族、30 个完整单元、隐藏测试 60/60 全绿）**：不剔任何运行（只看产物里有没有泄漏标记）、按整任务总量加总 —— 关闭 **3434.7 s / 591 244 token / 390 步**；默认臂 **0.72× 耗时 / 0.74× 输出 / 0.71× 步数**；逐格中位 **0.64×**、均值 0.84×、90 % 区间 [0.59, 0.79]。收益集中在反复重跑同一条检查的任务（`migrate` 0.45×、`shellops` 0.57×、`codebase` 0.55×、`stategraph` 0.64×、`ledger` 0.64×）；短任务收益不稳定，`perfrefactor` 1.18×、`csvpipe` 1.12×、`debugfix` 输出反而 2.01×——短任务本来就没有可省的重复验证，提醒本身也是成本。这一轮同时修掉了两个会让旧数字失真的测量缺陷（运行目录曾在仓库内、指标曾按字节偏移切片），旧口径的 `0.86×` 已撤回，详见 [BENCHMARK.md](BENCHMARK.md) 的「1.5.1」与「1.5.0 重基线（已撤回）」。
+**复现块 W5（2026-10-26，19 个完整单元）**：同一块里三臂直接对照，`off` 1855.5 s，默认臂 0.73× 耗时 / 0.77× 输出 / 0.89× 步数，与 1.5.1 的 0.72× 一致。同块的 `batchVerify` 臂记到 0.84×，但那一臂的提醒**实际一次都没下发**（20 个会话逐条检索命中 0），所以 `batchVerify` 当时是**未测**、不是变慢也不是被证伪。**后来修好接线重测，结论是淘汰**：`codeimpl` 8 对几何 1.478×、`shellpipeline` 8 对 0.956×，合并 16 对 **1.188×**、中位 1.148×、只有 7/16 更快，全绿且提醒确实下发（8/16 会话命中）—— 所以不是没测到，是家族方向不一致、合起来更慢，默认保持 `false`，见 [BENCHMARK.md](BENCHMARK.md) 的「`batchVerify` 复测块 BV8」。这一块还有 1 行泄漏（`shellpipeline` p1 的 `bv15` 读到隐藏测试与参考解），已点名剔除；跑批器现在开跑前会把 `hidden/`、`ref/` 置为不可读，详见 [BENCHMARK.md](BENCHMARK.md) 的「复现块 W5」与 [bench/README.md](bench/README.md) 协议第 12 条。
+**筛选块 W10 + 复现块 W11（2026-10-26，合并 23 个有效单元）：`workspaceMap` 只兑现一半，默认关闭。** 1.5.2 加了一个默认关闭的旋钮：会话第一次动手前，把工作目录的清单（深度 2、≤60 条、跳过依赖与构建目录）先交给模型一次，省掉它自己 `ls`/`find` 的那一步。两块同块对照 `def15`：合并 23 个单元 **耗时 0.927×、输出 0.896×、步数 1.099×**，逐格中位 0.791×、13/23 格更快、隐藏测试零红。方向被证实一半——输出确实少 10 %（两块分别是 0.90×、0.89×）；但步数反而多 10 %，而且尾部变差：两臂 p90 是 559 s 对 369 s、最慢 714 s 对 510 s，W10 与 W11 都出现同一形状的反向格（`stategraph` 两轮都 1.4×–1.77×）。**按「长任务不能变慢」的门槛它不进默认**，1.5.2 的默认行为与 1.5.1 完全相同，旋钮与数字一起公开。这一轮同时把余量算清了：重复验证只占 6 % 耗时、工具结果中位 1.2 kB、重复写文件占 0.8 %，所以 **0.67× 在「不动 `reasoningEffort`、不加请求字段」的约束内不可达**，细节见 [BENCHMARK.md](BENCHMARK.md) 的「复现块 W11」与「0.67× 在现有约束下的可达性」。
 
-**复现块 W7（2026-10-26，17 个有效单元）**：默认臂 **0.73×** 墙钟 / 0.75× 输出 / 0.59× 步数（最长一格 36 步 → 17 步），与 1.5.1 的 0.72×、W5 的 0.73× 一致：三块合并 65 个有效单元 **0.74×**。同块的 `openBatch` 是 0.91×，对默认头对头 1.136×，W6 的 0.77× 没有复现，**淘汰**。这一块还有 7 行运行崩溃（会话启动阶段 `exit=1`、1 步、0 输出），3 个单元因此作废并点名；从这一块起判据要求 `exit == 0 && 步数 ≥ 1 && 输出 > 0 && 判分完成 && 未泄漏` 才计数，所以「全绿」一律指有效单元全绿（1.5.1 29/29、W5 19/19、W7 17/17）。详见 [BENCHMARK.md](BENCHMARK.md) 的「复现块 W7」。
+**复现块 W7（2026-10-26，17 个有效单元）**：默认臂 **0.73×** 耗时 / 0.75× 输出 / 0.59× 步数（最长一格 36 步 → 17 步），与 1.5.1 的 0.72×、W5 的 0.73× 一致：三块合并 65 个有效单元 **0.74×**。同块的 `openBatch` 是 0.91×，对默认头对头 1.136×，W6 的 0.77× 没有复现，**淘汰**。这一块还有 7 行运行崩溃（会话启动阶段 `exit=1`、1 步、0 输出），3 个单元因此作废并点名；从这一块起判据要求 `exit == 0 && 步数 ≥ 1 && 输出 > 0 && 判分完成 && 未泄漏` 才计数，所以「全绿」一律指有效单元全绿（1.5.1 29/29、W5 19/19、W7 17/17）。详见 [BENCHMARK.md](BENCHMARK.md) 的「复现块 W7」。
 
-**发版前复核（REL16，10 个单元）**：用当时的默认再对 `off` 跑一块，只查「质量有没有被发版弄坏」。结果两臂 **10/10 全绿、逐任务通过数完全相同**（14/14、22/22、18/18、10/10、14/14），无 leak；墙钟合计 **0.967×**、逐格中位 0.999×、3/5 格更快。单对 n=5，噪声带比总量宽，所以这条只作复核，不替换合池 0.798× 的总口径，详见 [BENCHMARK.md](BENCHMARK.md)。
+**发版前复核（REL16，10 个单元）**：用当时的默认再对 `off` 跑一块，只查「质量有没有被发版弄坏」。结果两臂 **10/10 全绿、逐任务通过数完全相同**（14/14、22/22、18/18、10/10、14/14），无 leak；耗时合计 **0.967×**、逐格中位 0.999×、3/5 格更快。单对 n=5，噪声带比总量宽，所以这条只作复核，不替换合池 0.798× 的总口径，详见 [BENCHMARK.md](BENCHMARK.md)。
 
 **更快但没过门禁的配置只作消融臂。** `fl10`（第 10 步提醒收尾）是实测最快的配置，但它会压掉「测试通过后又改了代码」的必要复验，且出现过基线与默认都绿而它红的一格，所以只是消融臂（这些数字出自已撤回的批次，只保留决策记录）。`openBatch`（开局发一次「把独立调用并进同一块」）在 W6 筛查里以 0.77× 快过默认的 0.93×，但 W7 独立复测回到 0.91×、头对头 1.136×，**没有复现即淘汰**。`batchVerify`（改完一批文件再跑一次覆盖检查）在 W5 同块对照里记到 0.84×，但那一臂的提醒零下发，当时只能算**未测**；接线修好后在 BV8 复测块实测 16 对合并 **1.188× 更慢**（`codeimpl` 1.478×、`shellpipeline` 0.956×，方向不一致），**淘汰**，默认保持 `false`。**所以默认不变**：不按步数收尾、`stepBudget: 0`、上述机制全关。单元级数据与门禁逐条见 BENCHMARK 的 `H2`/`H3`。
 
@@ -87,13 +96,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`（批量调用、有界执行），但它们的规则是静态的，这里的宽度来自会话自身的调用证据；不需要同时装。压缩类插件可以共存。
 
@@ -101,7 +111,7 @@
 
 判断“这一步值不值得提速”的可编程信号现在有三个：请求自身的措辞（串行/扇出/shell，见 `src/shape.js`）、上一步的调用是否全为只读且目标两两不同、以及连续只读步数。前两个让单轮任务第一步就能选对宽度。
 
-在线选择（UCB/Thompson）**不在**这一版里，原因不是网络 —— bandit 全是本地算术，不额外发请求、不增加往返，实测代价可以忽略。真正的问题是奖励太吵：本项目 40 对配对里，同一任务两臂的方差远大于宽度带来的效应；把这种噪声喂给 UCB，学到的会是抖动而不是策略。等请求形状分类把“该宽的样本”筛出来、每步墙钟的方差降下来，再上 bandit 才有意义；设计上会用折扣 Thompson 采样（先验 N(0, σ²)，只对“扇出/未知”两类上下文分别维护宽度后验），而不是全局 UCB。
+在线选择（UCB/Thompson）**不在**这一版里，原因不是网络 —— bandit 全是本地算术，不额外发请求、不增加往返，实测代价可以忽略。真正的问题是奖励太吵：本项目 40 对配对里，同一任务两臂的方差远大于宽度带来的效应；把这种噪声喂给 UCB，学到的会是抖动而不是策略。等请求形状分类把“该宽的样本”筛出来、每步耗时的方差降下来，再上 bandit 才有意义；设计上会用折扣 Thompson 采样（先验 N(0, σ²)，只对“扇出/未知”两类上下文分别维护宽度后验），而不是全局 UCB。
 
 [实测与复现](BENCHMARK.md) · [参考手册](docs/REFERENCE.md) · [改了什么](CHANGELOG.md) · [English](README.en.md)
 

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.16** actually does (same code as 1.5.15) (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.16** 的实际行为（代码与 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.16'
+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.16",
+  "version": "1.5.18",
   "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
+}