dsh-fast-mode 1.5.32 → 1.5.34

package/BENCHMARK.md

@@ -2392,6 +2392,27 @@ python3 bench/suite-run.py --tasks debugfix,migrate --arms def15,combo3 --pairs
 - **时点臂仍在 HOLD，不进默认。** `combo2` 比 `combo3` 多出来的那一截（0.669 vs 0.742）指向 `d2g`，但两个臂的样本不是同一批 pair，n = 22 vs 11 也不足以给「多 7 个百分点」定论；`d2g` 在 `codeimpl` 上的负收益（见上一节结论 2）没有被这一轮推翻，默认仍是 `disciplineAfterSteps: 4`。
 - **诚实边界**：各一个块、两个任务族（`debugfix` 短、`migrate` 长），`combo3` 的符号检验 p = 0.113 只算方向提示；锚点臂有 2 格（`migrate` pair 2、11）判 `leak` 被剔除，剔除后仍配对 22 对，`combo2` 24 格全绿、无一格 `leak`。想复现就重跑上面两条命令，`bench/arms/combo2.yml`、`combo3.yml` 在仓库里。
 
+## 提速有多少是从「非模型时间」里挤出来的：没有，只占墙钟 5 % 且组合臂更轻
+
+外部评审担心的是「你把成本挪到插件自己身上，墙钟看着快了其实更重」。`wall`（任务下达到进程退出）与 `llm`（花在模型调用里的时间）两列本来就在每一行里，差值就是一切非模型开销：工具执行、宿主调度、插件每步的活。新脚本把这块单拉出来，成对看：
+
+```
+python3 bench/overhead.py --blocks COMBO2 --base def15 --arm combo2
+python3 bench/overhead.py --blocks COMBO3 --base def15 --arm combo3
+```
+
+| 口径 | 默认臂 | 组合臂 |
+|---|---|---|
+| `combo2`（22 对）每步非模型开销 | 0.64 s | **0.38 s** |
+| `combo2` 非模型开销占墙钟 | 5.9 % | 6.6 % |
+| `combo2` 成对开销比 | — | 中位 **0.953×**，16/22 对更轻 |
+| `combo3`（11 对）每步非模型开销 | 0.30 s | 0.39 s |
+| `combo3` 成对开销比 | — | 中位 **0.940×**，8/11 对更轻 |
+
+- **提速不来自压榨工具时间。** 非模型开销本来只占墙钟 3–8 %，就算压到 0 也只有几个百分点；实测组合臂的这块绝对值反而略轻（成对中位 0.94–0.95×，各 16/22 与 8/11 对更轻），因为总步数少了、固定开销也少收几遍。占比从 5.9 % 涨到 6.6 % 只是分母（墙钟）变小，不是开销变重。
+- **每步开销没有系统性变大。** `combo2` 每步 0.38 s vs 默认（同块）0.64 s；`combo3` 是 0.39 s vs 0.30 s，方向相反但绝对值都不到 0.1 s/步，且成对中位仍是 0.94×。插件每步的活是几十毫秒级的字符串拼接与一次 `inject`，落在这两列的噪声里，解释不了 30 % 的墙钟差。
+- **读法**：这一块不能用来证明快，只能用来排除「快的代价藏在别处」。墙钟比（0.687 中位 / 几何 0.669）与 `llm` 比的落点一致，说明省下来的确实是模型回合。
+
 ## 同一配置再跑一遍会差多少：块级差 4 %，任务级差 15–31 %（REP2，10 对）
 
 外部评审提的第一条是稳定性。这一块不新增任何开关，只把 `migrate`+`debugfix` 的同一批格子**用同一套配置再跑一遍**（`REP2`，20 次运行，顺序 ABBA 与之前的块一致），看同配置的两次独立测量互相差多少：
@@ -2440,3 +2461,75 @@ python3 bench/textshare.py --limit 5
 ```
 
 可见文字只占（可见文字 + 工具参数）的 1.28 %；把推理也算进来，**推理占模型全部发出字符的 99.6 %**。所以提速不来自「少说话」：省下来的是**步数**与**每步的推理量**，而提醒文案只是同时压这两者的手段。`bench/mechanism.py` 的报告里也多了 `prose / args / reasoning / emitted` 四行（168 对同题同配的结论：`reasoning` 几何比 0.75，`emitted` 0.82）。
+
+## 常驻宿主的堆：把最后 6 个无界缓存封顶，并用一个「不重启的宿主」证明它是平的（1.5.34）
+
+外部评审这一轮的建议是「先做稳定性修复，暂时不要加旋钮」。插件里能威胁稳定性的东西不多，但有一类是真的：**所有缓存都以永不重复的 id 为键**（会话 id、`callId`、`${sid}${cwd}`），而宿主的进程是活几周不重启的。1.5.32 封了 3 个，这一轮把剩下的全封了，并且补了一个黑盒浸泡脚本，让「它是平的」变成每次都能重跑的数字，而不是一句断言。
+
+### A. 审计：插件自己持有的 8 个缓存
+
+| 缓存 | 键 | 之前 | 现在 |
+| --- | --- | --- | --- |
+| `compacted`（`index.js`） | 会话 id | 200 条 FIFO | 200（改用 `trim`） |
+| `mapSent`（`index.js`） | `${sid}${cwd}` | **无界** | 500 |
+| `autoBudgets`（`index.js`） | 会话 id | 200 条 FIFO | 200（改用 `trim`） |
+| `startedAt`（`index.js`） | `callId` | **无界**（结果没回来的调用不会被 `delete`） | 2000 |
+| `warnedCaps` | `callId` | 有界 | 不变 |
+| `labels`（`src/metrics.js`） | 会话 id | **无界**，且 sink 关闭时也写 | 2000，且 sink 关闭时直接不写 |
+| `steps` / `open` / `pendingChunk`（`src/metrics.js`） | 步 / 会话 | **无界** | 2000 / 2000 / 1000 |
+| `sessions`（`src/auto.js`） | 会话 id | 200（LRU） | 200（改用 `trim`） |
+
+封顶全部走同一个新工具 `src/bounded.js` 的 `trim(cache, cap)`：插入顺序即淘汰顺序，返回同一个缓存以便链式使用，`cap <= 0` 时不动。之前每个缓存各写一遍淘汰循环，写法不一致是漏掉下一个缓存的原因。被淘汰不等于写错行：`labels` 里没了的会话，它的测量行记成 `mode: 'unknown'`，而不是借用别人的档位——这一条直接写成了测试（`test/bounded.test.js`）。
+
+### B. 先修的是测量工具本身：它最初报了个假泄漏
+
+新写的 `bench/soak.mjs` 用与 `test/plugin.test.js` 相同的假 Cordis 挂载真插件，然后扮演一个从不重启的宿主：N 个会话 × 4 轮，每轮走 `step/start` → `agent/request` → 工具调用 → `step/end`。第一次跑 4000 会话报 **+63.67 MB / 16.3 KB per session / FAIL**，而且 `--off` 一模一样——说明增长不在插件逻辑里。二分两下就定位了：
+
+| 控制 | 4000 会话的增长 |
+| --- | --- |
+| `--off`（插件禁用） | +63.67 MB（同样） |
+| `--no-event`（不发事件流） | +49.29 MB |
+| `--no-request`（不发 `agent/request`） | **−0.55 MB** |
+| `--one-id`（4000 个会话共用一个 id） | +49.30 MB（同样） |
+
+问题在**脚本**：`ctx.fire('agent/request', …)` 没有 `await`，16000 次调用留下 16000 个 pending 的 Promise 链，堆自然涨，而且与「会话数」无关而与「调用数」有关（`--one-id` 一样涨就是这个原因）。改成 `await` 后同规模是 **−0.61 MB**。这条写进脚本头注释里：浸泡测试自己的悬挂 Promise 会伪装成插件的泄漏，先怀疑它。
+
+（`/tmp/reqctl.mjs` 的独立控制给出同一结论：16000 次 await 过的请求 ≈ 2.43 MB，即 152 B/次，正是 `labels`；不 await 是 3 KB/次。）
+
+### C. 封顶之后：20000 个会话、242 400 步，堆是平的
+
+```
+node --expose-gc bench/soak.mjs --sessions 20000 --metrics
+sessions        20000 × 4 turns, 242400 steps
+heap warm       7.26 MB
+heap end        5.62 MB
+growth          -1.64 MB over 20000 sessions
+per session     -0.1 KB
+metrics         242400 steps written, caches trimmed
+```
+
+`--metrics` 是这一轮加的口子：让测量 sink 真的写盘（写进临时文件，跑完删掉），这样 `labels`/`steps`/`open`/`pendingChunk` 四个缓存也被搅动。带它跑 4000 会话是 **−0.58 MB**，不带它跑 20000 会话是 **−1.64 MB**；阈值是 0.004 KB/会话，失败时退出码非 0，可以直接进 CI。
+
+单点对照（`/tmp/labelctl.mjs`，20000 次 `label()`）：
+
+| 版本 | 堆增长 |
+| --- | --- |
+| 1.5.33（无界，sink 关闭也写） | **2.48 MB**（124 B/会话） |
+| 1.5.34（sink 关闭直接不写） | **0.01 MB** |
+| 1.5.34（sink 打开，封顶 2000） | **0.01 MB**（20000 次写入后仍只留 2000 条） |
+
+2.5 MB 不是能把宿主撑爆的量级——**这一条要诚实说清：真正的收益不是省了 2.5 MB，而是「插件里不再有随运行时长单调增长的缓存」**，而这个约束来自本机真实崩溃日志里的一条硬规则（堆内存要有上限）。上限也确实换了东西：`sink 关闭时不再记 label` 是一次纯粹的白拿。
+
+### D. 同一轮里对已发布版本的回归复核（`V1533`，12 次运行）
+
+改稳定性不能只看测试，还要确认「已发布的 1.5.33 源码在跑起来时没退化」。所以先跑了一班 `debugfix`+`migrate` 的 3 对 ABBA 块（`off` 与 `def15` 同块交替），用的是仓库源码（`node_modules/dsh-fast-mode` 指回仓库）：
+
+| 口径 | `def15` | `off` |
+| --- | --- | --- |
+| 6 次运行合计墙钟 | 654.0 s（**0.50×**） | 1304.5 s |
+| 输出 token | 60 135（0.57×） | 104 492 |
+| 步数 | 45（0.46×） | 99 |
+| 绿/运行 | **6/6** | 6/6 |
+| 逐对更快 | 5/6 | — |
+
+两族的逐对几何分别是 `debugfix` 0.50×、`migrate` 0.50×，与历史块同量级（这两个族本来就是插件收益最大的地方），说明封顶没有动到任何行为路径。

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 1.5.34（稳定性版：插件里最后 6 个随宿主任期增长的缓存全部封顶，附一个可重跑的浸泡测试）
+
+按外部评审这一轮的建议，不新增任何提醒时机、重复提醒或预算旋钮，默认值与全部开关一律不动。只做一件事：**让插件在「几周不重启的宿主」里不再积累任何东西**，并把这件事变成能重跑的数字。
+
+- **审计了插件自己持有的 8 个缓存，其中 6 个之前是无界的。** `mapSent`（`${sid}${cwd}`）、`startedAt`（`callId`，结果没回来的调用不会被 `delete`）、测量 sink 的 `labels`/`steps`/`open`/`pendingChunk` 都不封顶；`compacted`、`autoBudgets`、`sessions` 有上限但各写一遍淘汰循环。现在全部走同一个 `src/bounded.js` 的 `trim(cache, cap)`（插入顺序即淘汰顺序，`cap <= 0` 不动），上限分别是 500 / 2000 / 2000 / 2000 / 2000 / 1000。上限远高于任何真实并发量，正常使用不会淘汰活条目。
+- **sink 关闭时不再记 label。** `agent/request` 每个请求都会调 `label()`，而默认配置根本不写测量文件——1.5.33 及以前照样把每个会话的档位记进一个 Map。20000 次 `label()` 的堆增长因此从 **2.48 MB 降到 0.01 MB**（`/tmp/labelctl.mjs`）。淘汰也不会写错行：被淘汰会话的测量行记 `mode: 'unknown'`，不再可能借用别人的档位，这一条是 `test/bounded.test.js` 的断言。
+- **新增 `bench/soak.mjs`：一个从不重启的假宿主。** 用与 `test/plugin.test.js` 相同的假 Cordis 挂载真插件，跑 N 个会话 × 4 轮、每轮 `step/start` → `agent/request` → 工具调用 → `step/end`。20000 会话 / 242400 步：堆增长 **−1.64 MB（−0.1 KB/会话）**；加 `--metrics`（真的写盘，跑完删临时文件）跑 4000 会话是 −0.58 MB。阈值 0.004 KB/会话，超了退出码非 0。
+- **这个脚本第一次跑报的是假泄漏，值得记下。** 4000 会话 +63.67 MB，`--off` 一模一样；二分到 `--no-request` 变 −0.55 MB，`--one-id` 仍 +49 MB——根因是脚本自己 `ctx.fire('agent/request', …)` 没 `await`，16000 个 pending Promise 冒充成插件泄漏。改成 `await` 后同规模 −0.61 MB。脚本头注释里写清了这条，免得下次又去插件里找。
+- **同时复核了已发布源码没退化（`V1533`，12 次运行）：** `debugfix`+`migrate` 3 对 ABBA，`def15` 6 次合计墙钟 **654.0 s（0.50×）**、步数 0.46×、输出 0.57×、逐对 5/6 更快、两臂 **6/6 全绿**，与历史块同量级。
+- 测试 308 → **313 全绿**（新增 `test/bounded.test.js` 5 条）。动 `index.js`、`src/metrics.js`、`src/auto.js`、`src/bounded.js`、`bench/soak.mjs`、`BENCHMARK.md`、`docs/REFERENCE.md`；顺手把 `README.en.md` 里「右键有四行设置」改成五行（1.5.33 加了第五行，英文版漏改）。面板、配置、默认值零改动。
+
+## 1.5.33（把「多个开关一起开」里那个真正省时的开关做进面板：第五行「一次读多个文件」）
+
+- **面板多了第五行，`openBatch` 第一次能被用户点到。** 1.5.32 实测的 `combo3`（默认 + `workspaceMap` + `openBatch`，11 对 0.742×）里有一半来自 `openBatch`，但它之前只在配置里，面板够不着——等于「测出来了但用户开不了」。这一版把它做成和「先列文件清单」同级的逐会话开关：写 `sessions` 列里本会话条目的 `batch`，宿主侧映射成 `openBatch`（`src/state.js` 的 `configOverridesFor`），不动共享默认值，只影响本会话。
+- **默认仍然关。** 单独开 `openBatch` 测不到显著（0.882×，CI 跨 1），只有和清单一起开才有效；面板 tooltip 写的就是这句后果，不写成「更快」。默认值、`d2g` 的 HOLD 状态都不变。
+- **两侧字段表对齐。** `client.js` 的 `sanitiseChoices` 与 `src/state.js` 的 `sanitise` 同步接受 `batch`，避免出现「客户端写进去、宿主读出来丢掉」的假开关（这正是 1.5.17 那批死按钮的成因）。测试补了三处：状态层的 `batch → openBatch` 映射、面板行的默认值/逐会话写入、以及「共享 `openBatch` 为真但本会话条目为假」时面板按条目画。
+- 动 `client.js`、`src/state.js`、`src/config.js`（描述文案）、两份 README、`docs/REFERENCE.md`；测试 306 → 308 全绿。
+
 ## 1.5.32（先回答「多个开关一起开」：三开 **0.669×**、22 对里 18 对更快、隐藏测试 22/22 绿；附带一个内存上限修复）
 
 - **新增两个组合臂并真的跑了一遍**（此前只有逐个开关的消融，从没跑过「一起开」）：`combo2` = 默认 + `d2g` + `workspaceMap` + `openBatch`，`combo3` = 默认 + `workspaceMap` + `openBatch`。同块内与默认臂按 `(任务, pair)` 配对：

package/README.en.md

@@ -103,13 +103,16 @@ Legacy `fast` / `turbo` / `max` / `ludicrous` values are read as `auto` with a d
 
 ## The switch
 
-The bolt is the switch: one click writes on/off, per conversation, restored on reload. Right-click it for three shared settings:
+The bolt is the switch: one click writes on/off, per conversation, restored on reload. Right-click it for a five-row panel — the switch itself and four settings:
 
 - **Less narration** — master switch for the step-4 reminder; with it off, long tasks take about 2.7x longer and write about twice as much. On by default.
 - **Step cap** — `15` / `30` / off, off by default. At the cap it reports instead of truncating the task.
 - **Workspace inventory** — before the turn's first tool call, one inventory notice (relative paths + byte sizes + visible test entry points) so the turn does not open with `ls`/`find`. Off by default; over 23 pairs it measured 0.927x geometric with a slower tail and 10% more steps, so it stays a switch to try rather than a default.
+- **Read several files at once** — batches independent reads into one call. Off by default; the measured gain shows up when it is stacked with the inventory switch (below), not alone.
 
-All three apply from the next request. No dropdown, no multiplier estimate.
+All five rows take effect from the next request, per conversation. No dropdown, no multiplier estimate.
+
+**Turn several on at once?** Yes, but only the measured pair. Defaults plus inventory plus batched reads is **0.742x** over 11 pairs; adding the step-2 reminder timing (not a panel row, still on HOLD) reaches **0.669x** over 22 pairs, CI95 [0.554, 0.799], 18/22 faster, hidden tests green. Each switch alone lands at 0.80–0.88 with a confidence interval that crosses 1 — the gain comes from each one cutting a different share of the same cost, not from any single switch. The other knobs (`batchVerify`, `preferPatch`, step budget, wider fan-out) all land at 0.96–1.10; do not stack them.
 
 The idea draws on `dsh-batch-tool-calls` and `dsh-ops` (batched calls, bounded execution), but their widths are static while this width comes from the conversation's own call evidence; do not install all three. Context-compaction plugins coexist.
 

package/README.md

@@ -103,14 +103,17 @@
 
 ## 开关
 
-闪电就是开关：开/关即写，按会话独立，重启按会话恢复。右键闪电是一块四行的面板，四行都只影响当前会话：
+闪电就是开关：开/关即写，按会话独立，重启按会话恢复。右键闪电是一块五行的面板，五行都只影响当前会话：
 
 - **更快**：这个会话开不开快模式，和点闪电是同一件事。
 - **少写过程**：第 4 步那句「省着写」提醒的总开关，关掉后输出会变长、耗时变慢（长任务约 2.7×），默认开。
 - **最多几步**：`15` / `30` / 不限，默认不限。到上限只先汇报，不截断任务。
 - **先列文件清单**：开启后，回合的第一次工具调用之前先收到一份工作目录清单（相对路径 + 字节数 + 可见的测试入口），省掉开头的 `ls`/`find` 探路。默认关；23 个配对实测几何 0.927×，尾部变慢、步数 +10%，没有达到进默认的门槛，只作为可试的开关。
+- **一次读多个文件**：把互不依赖的读取合成一批发出，少几个来回。默认关；单独开测不到显著，和上一项一起开才有（见下）。
 
-四项都写在本会话的条目里，对下一个回合生效；另一个会话开不开、写成什么样，互不影响。没有下拉，没有倍数估算。
+五项都写在本会话的条目里，对下一个回合生效；另一个会话开不开、写成什么样，互不影响。没有下拉，没有倍数估算。
+
+**几个一起开会不会更快？** 会，但只有实测过的那几个。默认 + `workspaceMap` + `openBatch` 两开：11 对 **0.742×**；再把 `disciplineAfterSteps` 提前到 2（面板里没有这一项，属于 HOLD 的时点实验）三开：22 对 **0.669×**、CI95 [0.554, 0.799]、18/22 更快、隐藏测试全绿。单独开其中任何一个都测不到显著（0.80–0.88，置信区间全跨 1）——所以增益来自它们各自省掉的是同一类成本的不同份，不是哪个开关本身。其余开关（`batchVerify`、`preferPatch`、步数预算、更宽并行）叠上去都是 0.96–1.10，没有理由跟着一起开。细节见 [BENCHMARK.md](BENCHMARK.md) 的「直接跑一次多个开关一起开」。
 
 思路参考了 `dsh-batch-tool-calls` 与 `dsh-ops`（批量调用、有界执行），但它们的规则是静态的，这里的宽度来自会话自身的调用证据；不需要同时装。压缩类插件可以共存。
 

package/client.js

@@ -102,6 +102,8 @@ window.__ModuleLoader__.load({
       'panel.budgetTitle': '到上限先汇报，不截断任务',
       'panel.map': '先列文件清单',
       'panel.mapTitle': '开局把目录里的文件交给模型，省掉先翻一遍目录',
+      'panel.batch': '一次读多个文件',
+      'panel.batchTitle': '把互不依赖的读取合成一批发出，少几个来回',
     }
 
     const en = {
@@ -125,6 +127,8 @@ window.__ModuleLoader__.load({
       'panel.budgetTitle': 'Reports at the cap; never truncates the task',
       'panel.map': 'File list first',
       'panel.mapTitle': 'Hands the directory listing to the model up front, skipping a lookup',
+      'panel.batch': 'Read several files at once',
+      'panel.batchTitle': 'Batches independent reads into one call, fewer round trips',
     }
 
     const CSS = [
@@ -186,6 +190,8 @@ window.__ModuleLoader__.load({
       discipline: true,
       /** The workspace inventory switch for this conversation, off by default. */
       inventory: false,
+      /** Batches independent reads into one call for this conversation. */
+      batch: false,
       /** This conversation's step cap; 0 means no cap. */
       stepBudget: 0,
       /** The right-click panel is open. Store-backed, like every other paint. */
@@ -314,6 +320,7 @@ window.__ModuleLoader__.load({
         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 (typeof entry.batch === 'boolean') clean.batch = entry.batch
         if (Number.isFinite(entry.ts)) clean.ts = Number(entry.ts)
         if (
           clean.enabled === undefined
@@ -321,6 +328,7 @@ window.__ModuleLoader__.load({
           && clean.discipline === undefined
           && clean.stepBudget === undefined
           && clean.map === undefined
+          && clean.batch === undefined
         ) continue
         out[sessionId] = clean
       }
@@ -369,7 +377,7 @@ window.__ModuleLoader__.load({
      *
      * @param {Record<string, any>} map
      * @param {string|undefined} sessionId
-     * @param {{enabled?: boolean, gear?: string, discipline?: boolean|'late', stepBudget?: number, map?: boolean}} patch
+     * @param {{enabled?: boolean, gear?: string, discipline?: boolean|'late', stepBudget?: number, map?: boolean, batch?: boolean}} patch
      */
     function withOwn(map, sessionId, patch) {
       const next = { ...map }
@@ -382,6 +390,7 @@ window.__ModuleLoader__.load({
       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
+      if (typeof patch.batch === 'boolean') entry.batch = patch.batch
       next[sessionId] = entry
       return next
     }
@@ -525,6 +534,9 @@ window.__ModuleLoader__.load({
           const seenMap = own !== undefined && typeof own.map === 'boolean'
             ? own.map
             : value.workspaceMap === true
+          const seenBatch = own !== undefined && typeof own.batch === 'boolean'
+            ? own.batch
+            : value.openBatch === true
           store.phase = 'ready'
           store.error = ''
           store.ns = view.ns
@@ -534,6 +546,7 @@ window.__ModuleLoader__.load({
           store.discipline = seenDiscipline
           store.stepBudget = seenBudget
           store.inventory = seenMap
+          store.batch = seenBatch
           // 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.
@@ -587,7 +600,7 @@ window.__ModuleLoader__.load({
      *
      * @param {{settings: {update: (ns: string, patch: object, revision?: number) => Promise<any>}}} remote
      * @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]
+     * @param {{entry?: {enabled?: boolean, gear?: string, discipline?: boolean|'late', stepBudget?: number, map?: boolean, batch?: boolean}}} [options]
      * @returns {Promise<boolean>} whether the write was accepted
      */
     async function write(remote, patch, options = {}) {
@@ -610,6 +623,7 @@ window.__ModuleLoader__.load({
         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 entry.batch === 'boolean') store.batch = entry.batch
       }
       if (typeof shared.enabled === 'boolean') {
         store.enabled = shared.enabled
@@ -620,6 +634,7 @@ window.__ModuleLoader__.load({
       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
+      if (typeof shared.openBatch === 'boolean') store.batch = shared.openBatch
       emit()
       try {
         unwrap(await withTimeout(remote.settings.update(store.ns, outgoing, store.revision), 15000, 'settings/update'))
@@ -635,6 +650,7 @@ window.__ModuleLoader__.load({
         store.discipline = before.discipline
         store.stepBudget = before.stepBudget
         store.inventory = before.inventory
+        store.batch = before.batch
         store.pending = undefined
         store.writeError = describeError(error)
         emit()
@@ -843,6 +859,13 @@ window.__ModuleLoader__.load({
         emit()
       }
 
+      /** Same per-conversation tier as the file list, one call for many reads. */
+      const toggleBatch = () => {
+        void write(remote, undefined, { entry: { batch: !store.batch } })
+        store.panelOpen = false
+        emit()
+      }
+
       return react.createElement(
         'div',
         { className: 'fm-panel', role: 'menu', 'aria-label': t('panel.title') },
@@ -866,6 +889,15 @@ window.__ModuleLoader__.load({
           store.inventory,
           t('panel.mapTitle'),
         ),
+        row(
+          'menuitemcheckbox',
+          t('panel.batch'),
+          t(store.batch ? 'panel.on' : 'panel.off'),
+          canWrite,
+          toggleBatch,
+          store.batch,
+          t('panel.batchTitle'),
+        ),
         react.createElement('div', { className: 'fm-panel__scope' }, t('panel.scope')),
       )
     }

package/docs/REFERENCE.md

@@ -1,6 +1,6 @@
 # 参考手册：原理、配置与边界
 
-本手册描述 **dsh-fast-mode 1.5.17** 的实际行为（默认配置下的注入行为与 1.5.0 一致；1.5.14 起多了右键面板，1.5.17 面板为四行、四行都只影响本会话），对应仓库里的 `index.js`、`src/` 与 `client.js`。它不是宣传页：凡是能测量的地方给出数字，凡是没测量的地方直接说没测量。
+本手册描述 **dsh-fast-mode 1.5.34** 的实际行为（默认配置下的注入行为与 1.5.0 一致；1.5.14 起多了右键面板，1.5.33 面板为五行、五行都只影响本会话），对应仓库里的 `index.js`、`src/` 与 `client.js`。它不是宣传页：凡是能测量的地方给出数字，凡是没测量的地方直接说没测量。
 
 **唯一的契约：Fast 模式从不改变思考强度、thinking 预算或模型。** `agent/request` 钩子只做一件事——`await next()`，读一下请求携带的 `reasoningEffort` 记进测量，然后原样返回。用户选的是哪一档（会话里的 UI 选择，或者 profile 里 agent-default-model 固定下来的那一档），每个请求就用哪一档。
 
@@ -9,7 +9,7 @@
 ## 交互细节：闪电开关与会话归属
 
 - **一个图标就是开关。** 会话输入区的活动槽（`conversation.input.activity`）里只有一个闪电按钮：关闭时空心，开启时实心。点一下切换，再点一下切回；这一下只写当前会话。没有档位选择器，没有箭头，没有"选择 gear"的二级菜单。
-- **右键是面板。** 右键闪电打开四行，四行都只影响当前会话："更快"（`enabled`）、"少写过程"（`outputDiscipline`）、"最多几步"（`stepBudget`，循环 0/15/30）、"先列文件清单"（`workspaceMap`）。四行都把选择写进 `sessions` 列里本会话的条目，不碰共享默认值，下一个回合生效；只读或写入中时整块禁用，写失败回滚。没有条目的会话沿用配置里的默认值（`enabled`/`gear`/`outputDiscipline`/`stepBudget`/`workspaceMap`）。面板不暴露 `disciplineAfterSteps`、`disciplineEarlyCalls`、`shapeGate`、`finishLineSteps`、`shellParallel`、`disciplineRepeatAtSteps` 这些未证实或已判 HOLD 的旋钮。
+- **右键是面板。** 右键闪电打开五行，五行都只影响当前会话："更快"（`enabled`）、"少写过程"（`outputDiscipline`）、"最多几步"（`stepBudget`，循环 0/15/30）、"先列文件清单"（`workspaceMap`）、"一次读多个文件"（`openBatch`）。五行都把选择写进 `sessions` 列里本会话的条目，不碰共享默认值，下一个回合生效；只读或写入中时整块禁用，写失败回滚。没有条目的会话沿用配置里的默认值（`enabled`/`gear`/`outputDiscipline`/`stepBudget`/`workspaceMap`/`openBatch`）。面板不暴露 `disciplineAfterSteps`、`disciplineEarlyCalls`、`shapeGate`、`finishLineSteps`、`shellParallel`、`disciplineRepeatAtSteps` 这些未证实或已判 HOLD 的旋钮。
 - **会话之间互不影响，这是硬约束。** 每个会话的 `enabled`、`gear`、`outputDiscipline`、`stepBudget`、`workspaceMap` 都从 `sessions` 列里自己那一条解析：A 会话 `更快 + 少写过程`、B 会话 `更快 + 不写过程` 同时成立，C 会话没点过就沿用配置默认值。面板和闪电只写本会话的条目，从不写共享默认值；条目最多保留 200 个，按 `ts` 淘汰最旧的，被淘汰的会话回到默认值。
 - **按钮只表达一个问题：这个会话开不开。** `aria-pressed` 就是状态，tooltip 写清"仅本会话 · 思考强度不变 · 点击关闭"。为什么快、快在哪里、单次调用上限这类说明放在插件介绍（`meta.description` 与配置项描述）里，不再占用输入区。
 - **实时行引用的是被执行的数字**，而不是产品形容词：
@@ -165,7 +165,7 @@
 | `parallel` | 由档位推导，`auto` 下为 4 | 并行上限的初始值，1–8。`auto` 只把它当起点；设为 1 表示不注入批量提示段。 |
 | `sessions` | `''` | 插件自动维护的会话级覆盖，见上一节。**不要手改。** |
 | `outputDiscipline` | `'late'` | 输出纪律。`late`（默认）前 4 步不写任何输出约束，第 4 步起由调度器提醒一次；`true` 全程生效；`false` 关闭输出纪律，仍注入并行与有界调用规则。 |
-| `openBatch` | `false` | 开局批量：每轮第一步发一次「把已知要做的独立调用放进同一块、shell 命令用 `&&` 串起来」。短任务的钱几乎全是每步固定成本（首字延迟 ~0.5 s/次），少一次往返就省一次；只影响第一轮第一步，长任务可忽略。旧批次里它不优于默认，但那些数字已因测量缺陷撤回（运行目录在仓库内、指标按字节偏移切片），尚无干净重测。保持在 `false`，只作实验旋钮。 |
+| `openBatch` | `false` | 开局批量：每轮第一步发一次「把已知要做的独立调用放进同一块、shell 命令用 `&&` 串起来」。短任务的钱几乎全是每步固定成本（首字延迟 ~0.5 s/次），少一次往返就省一次；只影响第一轮第一步，长任务可忽略。旧批次里它不优于默认，但那些数字已因测量缺陷撤回（运行目录在仓库内、指标按字节偏移切片），尚无干净重测。保持在 `false`，但 1.5.33 起进面板（「一次读多个文件」），逐会话可开；和 `workspaceMap` 一起开 11 对 0.742×，再加 `disciplineAfterSteps: 2` 三开 22 对 0.669×〔CI 0.554–0.799〕，单独开仍测不到显著。 |
 | `shapeGate` | `false` | 形状闸门：本轮累计调用 ≥ 4 且其中写入类（不在只读名单里的工具）占比 ≥ 60 % 时，**整轮不再注入任何提醒**，行为退回原生。判断只用已有的工具名，不发请求、不加请求体字段。它给的是「不适合就别管我」的退路：写密集型的任务没有可并行的调用，每条提醒都只是一次它用不上的往返。显式设了 `stepBudget` 时该收尾线优先于闸门——「别加速」不等于「无视我叫停」。默认关，因为它会同时关掉本可以救回长尾的收尾提醒。 |
 | `preferPatch` | `false` | 整文件写入之后提醒一次「改已有文件时只发改动的行（edit hunk），不要重发整个文件」。本步 `write` 的正文 ≥ 2000 字符才武装，之后一步发一次，每轮最多一次；文本明确要求结果与原文件逐字节相同，不限制写什么、也不影响何时结束。默认关闭：它只作用于模型的输出形式（工具调用参数），正确性由文件内容决定、与发送形式无关；实测是否真省墙钟见 `BENCHMARK.md` 的 `pp16` 臂。 |
 | `compactRereadHint` | false | 压缩提醒里多一句「本回合写过的文件不要为确认整份重读」；不新增消息。实验旋钮，默认关 |
@@ -335,6 +335,7 @@ dsh-fast-mode-experiment stop         # 结束实验
 - **设置只能由这次点击改，且带 revision。** 没有后台静默改配置的路径；冲突写入会失败并回滚，原因是 tooltip。
 - **计量是本地的。** 只写 `metricsFile`；`--lan` 是唯一的出网路径，只读，需要显式 token。
 - **看门狗只改 signal。** 调用方原来的 signal 在 `finally` 里恢复；取消后调用体的 rejection 被吞掉，不会变成未处理的拒绝。
+- **每个缓存都有上限。** 插件持有的 8 个缓存全部以永不重复的 id 为键（会话 id、`callId`、`${sid}${cwd}`），而宿主进程会活几周，所以一个都不留无界：`compacted` 200、`mapSent` 500、`autoBudgets` 200、`startedAt` 2000、`warnedCaps` 有界、测量 sink 的 `labels` 2000 / `steps` 2000 / `open` 2000 / `pendingChunk` 1000、`src/auto.js` 的会话状态 200（LRU）。淘汰统一走 `src/bounded.js` 的 `trim(cache, cap)`，插入顺序即淘汰顺序。上限远高于真实并发量，所以正常使用不会淘汰活条目；真的淘汰了也不会写错行——测量行记 `mode: 'unknown'`，不会借用别人的档位。sink 关闭时 `label()` 直接不写（默认配置就是关闭）。`bench/soak.mjs` 用 20000 个会话的黑盒浸泡验证这条（−0.1 KB/会话）。
 
 ## 诚实的限制
 
@@ -369,7 +370,7 @@ dsh-fast-mode-experiment stop         # 结束实验
 - `src/metrics.js`：JSONL 计量与汇总；
 - `src/benchmark.js`：按会话哈希分配；
 - `src/peers.js`：冲突插件探测；
-- `client.js`：闪电开关、右键面板（四行，按会话写入 `sessions` 列）。
+- `client.js`：闪电开关、右键面板（五行，按会话写入 `sessions` 列）。
 
 跑测试：
 

package/index.js

@@ -60,6 +60,7 @@ import { appendFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 
+import { trim } from './src/bounded.js'
 import { CONTROL, createAssignment } from './src/benchmark.js'
 import { contentChars, GEARS, resolveConfig, stableKey } from './src/effort.js'
 import { buildGuidance, GUIDANCE_ORDER, GUIDANCE_SECTION } from './src/guidance.js'
@@ -97,9 +98,17 @@ 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.32'
+export const VERSION = '1.5.34'
 const GLOBAL_AGENT = '__global__'
 
+/**
+ * Ceilings for the two caches keyed by ids that never repeat. Both are read
+ * by the *current* session or call, so the caps sit far above any live working
+ * set and only exist to keep a process that never restarts from growing.
+ */
+const MAP_SENT_MAX = 500
+const STARTED_MAX = 2000
+
 /**
  * Insert notices after the last message the step claims to be answering.
  *
@@ -280,7 +289,11 @@ export function apply(ctx, rawConfig) {
   // The same listener remembers the compactions, so the two things that read the
   // event stream are read in one place and in one order.
   const compacted = new Set()
-  /** `${sid}${cwd}` pairs already given a workspace inventory. */
+  /**
+   * `${sid}${cwd}` pairs already given a workspace inventory. Capped for the
+   * same reason as `compacted`: the entry is only useful while that session is
+   * current, and a host that stays up for weeks accumulates them.
+   */
   const mapSent = new Set()
   /**
    * @param {{id?: string}} session
@@ -295,8 +308,8 @@ export function apply(ctx, rawConfig) {
       if (!sid) return
       // Bounded: a long-lived process sees thousands of sessions, and only the
       // next step of a just-compacted one needs the flag.
-      if (compacted.size >= 200) compacted.delete(compacted.values().next().value)
       compacted.add(sid)
+      trim(compacted, 200)
     } catch {
       // A reminder that cannot be scheduled must not affect the event stream.
     }
@@ -390,7 +403,12 @@ export function apply(ctx, rawConfig) {
    * oldest entries are dropped instead of kept forever.
    */
   const autoBudgets = new Map()
-  /** @type {Map<string, number>} */
+  /**
+   * Call id → start time. Deleted on `tools/post-execute`; a call whose result
+   * never arrives would otherwise keep its timestamp for the life of the
+   * process, so the map is capped as well.
+   * @type {Map<string, number>}
+   */
   const startedAt = new Map()
   /** Parallel caps already warned about. */
   const warnedCaps = new Set()
@@ -535,8 +553,8 @@ export function apply(ctx, rawConfig) {
         noteStep(auto, sid)
         notePolicy(auto, sid, cfg)
         const schedule = autoSchedule(auto, sid)
-        if (autoBudgets.size >= 200) autoBudgets.delete(autoBudgets.keys().next().value)
         autoBudgets.set(sid, schedule.stallBudgetMs)
+        trim(autoBudgets, 200)
         if (schedule.directive) {
           notices.push(createNoticeMessage(schedule.directive.text, schedule.directive.summary))
           if (initial.debug) {
@@ -569,6 +587,7 @@ export function apply(ctx, rawConfig) {
           }
           if (map) {
             mapSent.add(key)
+            trim(mapSent, MAP_SENT_MAX)
             notices.push(createNoticeMessage(map, 'auto: workspace inventory'))
           }
         }
@@ -649,7 +668,10 @@ export function apply(ctx, rawConfig) {
   }
 
   ctx.on('tools/pre-execute', async (exec, next) => {
-    if (exec && typeof exec.callId === 'string') startedAt.set(exec.callId, Date.now())
+    if (exec && typeof exec.callId === 'string') {
+      startedAt.set(exec.callId, Date.now())
+      trim(startedAt, STARTED_MAX)
+    }
     return next()
   })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-fast-mode",
-  "version": "1.5.32",
+  "version": "1.5.34",
   "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/auto.js

@@ -37,6 +37,8 @@
 
 import { statSync } from 'node:fs'
 import { isAbsolute, resolve as resolvePath } from 'node:path'
+
+import { trim } from './bounded.js'
 /** The gear id the adaptive scheduler runs under. */
 export const AUTO = 'auto'
 
@@ -299,10 +301,7 @@ function entryOf(state, agent) {
     turnUnsafe: 0,
   }
   state.sessions.set(key, entry)
-  if (state.sessions.size > AUTO_SESSIONS) {
-    const oldest = state.sessions.keys().next().value
-    if (oldest !== undefined) state.sessions.delete(oldest)
-  }
+  trim(state.sessions, AUTO_SESSIONS)
   return entry
 }
 

package/src/bounded.js

@@ -0,0 +1,31 @@
+/**
+ * Keep a long-lived cache inside a fixed number of entries.
+ *
+ * Every cache in this plugin is keyed by something that never repeats — a
+ * session id, a `callId`, a `${sid}${cwd}` pair. A host process stays up for
+ * weeks, so an uncapped cache grows with the number of sessions it has ever
+ * seen, and eventually the host dies of it. `index.js`, `auto.js` and
+ * `src/metrics.js` all take this one shape, so a cache added later cannot
+ * forget the cap by writing its own loop differently.
+ *
+ * Insertion order is the eviction order for both `Map` and `Set`, so the first
+ * key returned by `keys()` is the oldest write — unless the caller re-inserts on
+ * read, which is what the session cache does to get least-recently-used order.
+ *
+ * Deleting an entry never breaks a row: a session whose label was evicted is
+ * recorded as `unknown`, not as somebody else's mode.
+ *
+ * @template {Map<any, any> | Set<any>} T
+ * @param {T} cache
+ * @param {number} cap
+ * @returns {T} the same cache, so it can be used as an expression
+ */
+export function trim(cache, cap) {
+  if (!(cap > 0)) return cache
+  while (cache.size > cap) {
+    const oldest = cache.keys().next().value
+    if (oldest === undefined) break
+    cache.delete(oldest)
+  }
+  return cache
+}

package/src/config.js

@@ -157,7 +157,7 @@ export const Config = z.object({
     .boolean()
     .default(false)
     .description(
-      '开局批量 / Opening batch: 每轮第一步提醒一次「把已知要做的独立调用放进同一块、shell 命令用 && 串起来」。短任务的钱几乎全花在每步固定成本（首字延迟 ~0.5 s/次）上，少一次往返就省一次；只发一次，不改后续调度。',
+      '开局批量 / Opening batch（面板名「一次读多个文件」）: 每轮第一步提醒一次「把已知要做的独立调用放进同一块、shell 命令用 && 串起来」。短任务的钱几乎全花在每步固定成本（首字延迟 ~0.5 s/次）上，少一次往返就省一次；只发一次，不改后续调度。面板可逐会话开；和 `workspaceMap` 一起开时实测 0.742×（11 对），单独开测不到显著，所以默认仍是 false。',
     ),
 
   preferPatch: z

package/src/metrics.js

@@ -21,11 +21,28 @@
 import { appendFileSync, mkdirSync, renameSync, statSync } from 'node:fs'
 import { dirname } from 'node:path'
 
+import { trim } from './bounded.js'
 import { findUsage, readUsage } from './usage.js'
 
 /** The measurement format. Bumped when a field changes meaning. */
 export const METRICS_VERSION = 2
 
+/**
+ * Ceilings for the four long-lived caches below. A host process lives for weeks
+ * and these caches are keyed by ids that never repeat, so "one entry per session
+ * it has ever seen" is an unbounded ceiling in disguise. The caps are far above
+ * anything one process holds at a time (the harness runs a handful of sessions
+ * and a few calls concurrently), so in practice they never evict a live entry —
+ * they exist so a long uptime cannot turn into a heap that only a restart fixes.
+ */
+export const LABELS_MAX = 2000
+/** In-flight step accumulators; one per open step across all sessions. */
+export const STEPS_MAX = 2000
+/** Which step a session's first streamed chunk belongs to. */
+export const OPEN_MAX = 2000
+/** A chunk that arrived before its `step/start`. */
+export const PENDING_MAX = 1000
+
 /**
  * The size at which the step journal is rotated to `<file>.1`.
  *
@@ -190,6 +207,7 @@ export function createRecorder(options = {}) {
       seen: 0,
     }
     steps.set(key, entry)
+    trim(steps, STEPS_MAX)
     return { key, entry }
   }
 
@@ -209,6 +227,10 @@ export function createRecorder(options = {}) {
      */
     label(sid, label) {
       if (typeof sid !== 'string' || sid.length === 0) return
+      // With the sink off nothing will ever read this map, and the request hook
+      // calls this for every session: remembering labels for a file that does
+      // not exist is pure retention. (1.5.33 and earlier kept them anyway.)
+      if (!on) return
       const previous = labels.get(sid)
       if (previous && previous.mode === label.mode && previous.gear === label.gear
         && previous.effort === label.effort && previous.route === label.route) return
@@ -218,6 +240,7 @@ export function createRecorder(options = {}) {
         effort: label.effort,
         route: label.route,
       })
+      trim(labels, LABELS_MAX)
     },
 
     /** The last label recorded for a session. */
@@ -244,6 +267,8 @@ export function createRecorder(options = {}) {
         entry.started = time
         steps.set(key, entry)
         open.set(sid, key)
+        trim(steps, STEPS_MAX)
+        trim(open, OPEN_MAX)
         const early = pendingChunk.get(sid)
         if (early) {
           entry.chunkFirst = early.time
@@ -271,7 +296,10 @@ export function createRecorder(options = {}) {
         if (!entry) {
           // The live stream can arrive a few milliseconds before the durable
           // `step/start`; hold the first token until the step exists.
-          if (!pendingChunk.has(sid)) pendingChunk.set(sid, { time, kind: chunkType })
+          if (!pendingChunk.has(sid)) {
+            pendingChunk.set(sid, { time, kind: chunkType })
+            trim(pendingChunk, PENDING_MAX)
+          }
           return
         }
         if (entry.chunkFirst === undefined) {

package/src/state.js

@@ -106,6 +106,7 @@ function sanitise(input) {
     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 (typeof entry.batch === 'boolean') clean.batch = entry.batch
     if (Number.isFinite(entry.ts)) clean.ts = Number(entry.ts)
     if (
       clean.enabled === undefined
@@ -113,6 +114,7 @@ function sanitise(input) {
       && clean.discipline === undefined
       && clean.stepBudget === undefined
       && clean.map === undefined
+      && clean.batch === undefined
     ) continue
     out[sessionId] = clean
   }
@@ -137,6 +139,7 @@ export function choiceFor(raw, sessionId) {
   if (entry.discipline !== undefined) choice.discipline = entry.discipline
   if (entry.stepBudget !== undefined) choice.stepBudget = entry.stepBudget
   if (entry.map !== undefined) choice.map = entry.map
+  if (entry.batch !== undefined) choice.batch = entry.batch
   return choice
 }
 
@@ -161,6 +164,7 @@ export function configOverridesFor(raw, sessionId) {
   if (choice.discipline !== undefined) overrides.outputDiscipline = choice.discipline
   if (choice.stepBudget !== undefined) overrides.stepBudget = choice.stepBudget
   if (choice.map !== undefined) overrides.workspaceMap = choice.map
+  if (choice.batch !== undefined) overrides.openBatch = choice.batch
   return Object.keys(overrides).length === 0 ? undefined : overrides
 }
 
@@ -215,7 +219,7 @@ export function writeChoice(raw, sessionId, choice, now) {
   return { sessions: encodeChoices(map), map }
 }
 
-/** @typedef {{enabled?: boolean, gear?: string, discipline?: boolean|'late', stepBudget?: number, map?: boolean, ts?: number}} SessionEntry */
+/** @typedef {{enabled?: boolean, gear?: string, discipline?: boolean|'late', stepBudget?: number, map?: boolean, batch?: boolean, ts?: number}} SessionEntry */
 
 /**
  * Serialise the map, dropping the oldest entries beyond {@link SESSIONS_LIMIT}.