dsh-fast-mode 1.5.35 → 1.6.1

package/BENCHMARK.md

@@ -2533,3 +2533,33 @@ metrics         242400 steps written, caches trimmed
 | 逐对更快 | 5/6 | — |
 
 两族的逐对几何分别是 `debugfix` 0.50×、`migrate` 0.50×，与历史块同量级（这两个族本来就是插件收益最大的地方），说明封顶没有动到任何行为路径。
+
+## 结果：`LZ1`（`lazy` 想太久就少想一点，1.6.0 新开关，三臂 36 次运行）——墙钟 **0.39× / 0.43×**，12 对里 11 对更快，判分 **216/216 全绿**
+
+`lazy` 是 1.6.0 唯一的默认关闭开关：它不改插件其余部分，只在「这一步已经想太久」时做两件事——给对话里放一段「先按已有信息定下去」的提示，以及（`lazyEffort: false` 可关）把下一次请求的 `reasoningEffort` 降一档。三臂设计就是为了把这两半分开：
+
+- `def15`：完全关闭（历史基准臂）；
+- `lazt16`：`lazy: true, lazyEffort: false`，**只发提示文字**，一个请求字段都不写；
+- `laz16`：`lazy: true`，提示文字 + 请求字段降档。
+
+`codeimpl`（14 项判分）与 `ledger`（22 项判分）两族各 6 对，ABBA 交替，共 **36 次运行、12 对**，同一台机器连续跑完（`bench/results/suite-LZ1.jsonl`）。
+
+| 口径 | `def15` | `lazt16`（只发文字） | `laz16`（文字 + 降档） |
+| --- | --- | --- | --- |
+| 12 次运行合计墙钟 | **2 795.9 s** | 1 040.9 s（**0.372×**） | 1 010.9 s（**0.362×**） |
+| 逐对几何墙钟比（对 `def15`） | — | **0.389×**，95 % CI [0.252, 0.600] | **0.430×**，95 % CI [0.273, 0.677] |
+| 逐对更快 | — | **11/12**，符号检验 p = 0.0032 | **11/12**，p = 0.0032 |
+| 单次墙钟中位 | 174.9 s | 57.4 s | 80.0 s |
+| 记录到的推理字符中位（独立于 usage 的第二通道） | 65 342 | 19 156（0.372× 几何） | 24 404（0.418× 几何） |
+| 可见输出字符中位 | 21 594 | 8 310 | 9 468 |
+| 步数合计 / 中位 | 116 / 8.0 | 70 / 5.5 | 58 / 4.5 |
+| 判分（隐藏测试） | **216/216**，12/12 绿 | **216/216**，12/12 绿 | **216/216**，12/12 绿 |
+
+分族看，`codeimpl` 上 `lazt16` 中位 51.7 s 对 `def15` 106.1 s、`laz16` 78.1 s；`ledger` 上 125.1 s / 239.3 s，`laz16` 85.0 s。两族方向一致，不是单族异常值撑起来的。
+
+**这一块能说什么、不能说什么：**
+
+- 能说：在 12 对同题同配的对照里，打开 `lazy` 后 11 对更快，几何 0.39–0.43×，判分与输出正确性没有任何一格变红；机制是「步数变少 + 每步推理字符变少」，两侧同时发生，不是纯粹少说话。
+- 能说：**收益主要来自提示文字那一半**。把两臂直接对打：`laz16 / lazt16` 的逐对几何是 **1.106×**（95 % CI [0.682, 1.792]，12 对里 5 对更快）——也就是说「降 `reasoningEffort`」这一半在这条路由上**没有测出额外收益，也没测出明显代价**。这与本文件早先的记录一致：这条路由的 usage 里 `reasoning` token 一直是 0，`reasoning_effort` 是否被上游当真从未被证明；`lazy` 的第二通道（流式推理字符）就是为这件事加的，读数显示两臂推理字符同量级（0.372× 对 0.418×）。
+- 不能说：这不是「所有题都变快 2.6 倍」。样本是这两族短任务、单机、单路由，`def15` 本块的中位偏慢侧（历史上 `codeimpl` 中位 161 s、`ledger` 649 s，本块 174.9 s 跨两族），逐对设计吸收了基线漂移，但换模型/换路由后倍数会变。也不要说 `lazy` 提高质量：它只做到「没把质量弄坏」——216/216 与 `def15` 持平，不是更好。
+- 一块**退役 0.9.x 教训**的验证：降档不跨轮、不跨会话、每步最多一次、每轮最多两次、工具报错后两步内不降、地板 `low`、从不升档，且每个请求都以「用户此刻选的档位」为基准重新计算（`agent/request` 读的是刚解好的 `reasoningEffort`）。所以用户中途换档，下一次请求就是用户的档，不会像 0.9.x 那样把会话钉在低档上。

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 1.6.1（1.6.0 的补包：npm 页面上那句「从不改 reasoningEffort」在 1.6.0 之后不准确了）
+
+- 1.6.0 加了 `lazy`（默认关闭，唯一会改 `reasoningEffort` 的路径），但 `package.json` 的 `description` 还是旧话「Never changes reasoning effort, the model, or the request body」，npm 首页会照抄这句。这一版只改这一句：**默认**不改推理强度、模型与请求体，例外是默认关闭的 `lazy`（想太久时降一档）。行为、默认值、测试零改动（336 全绿）。
+
+## 1.6.0（一个新开关 `lazy`「想太久就少想一点」：动态收思考强度 + 压过度思考，默认关闭；12 对 36 次运行实测 0.39–0.43×，判分 216/216 全绿）
+
+按这一轮的要求，只开**一个**新开关，不动任何默认值。它的理念照抄 [ponytail](https://github.com/dietrichgebert/ponytail) 的核心：先读懂再动手，然后从「最小能work的那一级」开始做，不为想象中的未来写代码；但**读完之前不许偷懒**，也不许省掉信任边界校验、安全、数据丢失处理、可访问性。`lazy` 就是把这条用在「思考」上：不是让它不读、不想，而是想够了就停。
+
+- **新开关 `lazy`，出现在面板第六行「想太久就少想一点」。** 默认 `false`，逐会话写入 `sessions` 列（`src/state.js` 的 `configOverridesFor` 映射），只影响本会话。它是本插件**唯一**一个会改变答案而不只是时延的开关，所以默认关、tooltip 也只说后果（「想太久时先按已有信息定下去，安全校验照旧」），不说「更快」。
+- **两半机制，可分开验证。** 提示侧：入场步在对话里放一段 `src/lazy.js` 的梯子文本（先缩小范围 → 复用现成实现 → 标准库/平台能力 → 已装依赖 → 一行 → 最小实现；并把「绝不省略」的四类写清楚），每轮一次；同一轮里推理字符超过 `HOT_CHARS`（1600）就补一条 nudge（最多 2 条，间隔按轮内累计 4000/8000 字符）。字段侧：那一步确实想太久时，把**下一次**请求的 `reasoningEffort` 降一档（`EFFORT_RUNGS` 里往 `low` 方向走，地板 `low`，从不升档），每步最多一次、每轮最多两次，工具报错后两步内不降。`lazyEffort: false` 只发文字、一个请求字段都不写，是这一块的对照臂。
+- **不会重演 0.9.x 把会话钉在低档的事故。** 0.9.x 的问题是改写值活过了它被授权的那个回合：值进了请求头，面板从请求头投影「上次用的强度」，于是一个本来跑在中档的会话会漂到低档并跨重启保留。这一版的基准值是**每个请求现读**的 `resolved.reasoningEffort`（用户此刻的选择），降档只写进这一个请求的返回值，没有任何跨请求/跨会话状态；用户中途换档，下一次就是用户的档。测试里有专门的源码扫描断言：全仓只允许这一处 `reasoningEffort:`，形状是 `planned.reduced ? { ...resolved, reasoningEffort: applied } : resolved`，且不允许出现 `thinking: {` 或任何 `decideEffort`。
+- **测量补齐两个此前拿不到的通道。** `src/metrics.js` 每行新增 `reasoningChars` / `textChars`（流式 chunk 的字符数，`text`、`delta`、`delta.text` 三种拼法都认，认不出就算 0，只做下界）。加这个是因为这条路由的 usage 里 `reasoning` token **一直是 0**（750 行 fit 数据、1888 步），`reasoning_effort` 是否被上游当真从未被证明——所以 `lazy` 的收益必须能从「实际流出了多少推理字符」独立读到，而不是相信一个恒为 0 的字段。降档发生时，行里同时有 `effort`（实际带出去的）与 `effortBase`（用户原本选的），两列同现就是降档的机器证据；下一个未降档的请求会显式清掉 `effortBase`，不会把它归因到后来每一步。
+- **实测（`LZ1`，12 对、36 次运行、两族任务、ABBA 交替）：** `lazt16`（只发文字）逐对几何墙钟 **0.389×**，95 % CI [0.252, 0.600]，**11/12 更快**，符号检验 p = 0.0032；`laz16`（文字 + 降档）**0.430×**，CI [0.273, 0.677]，同样 11/12。推理字符几何 0.372× / 0.418×，步数中位 8.0 → 5.5 / 4.5，判分 **216/216 全绿**（两臂与 `def15` 完全相同）。把两臂直接对打：`laz16 / lazt16` = **1.106×**（CI [0.682, 1.792]，5/12 更快），即**收益来自提示文字那一半，降 `reasoningEffort` 这一半没有测出额外收益**——这一条如实写进 `BENCHMARK.md`，不做成「双保险都有效」。
+- **没有动的东西：** 默认值一个没改（`enabled: false` 仍是出厂态）、`disciplineAfterSteps` 仍是 4、`d2`/`d2g`/`dr8` 仍然 HOLD、没有新增任何提醒时机或预算旋钮。外部评审建议「先做稳定性、别加旋钮」，这一轮只在用户明确要求下加这一个开关，其余仍是稳定性与测量。
+- 测试 313 → **336 全绿**（新增 `test/lazy.test.js` 15 条、`test/plugin.test.js` 6 条集成、`test/metrics.test.js` 2 条 `effortBase` 断言；源码扫描测试按「恰好一处、且是这一种形状」放宽）。动 `index.js`、`src/lazy.js`（新）、`src/config.js`、`src/effort.js`、`src/state.js`、`src/metrics.js`、`client.js`、`bench/suite-run.py`、`bench/arm-config.mjs`、`bench/arms/laz16.yml`（新）、`bench/arms/lazt16.yml`（新）、两份 README、`docs/REFERENCE.md`、`BENCHMARK.md`、`CHANGELOG.md`。
+
 ## 1.5.35（1.5.34 的补包：把 `bench/soak.mjs` 打进 npm 包）
 
 - 1.5.34 的 `BENCHMARK.md` 让人「自己跑一遍浸泡」，但 `bench/soak.mjs` 没在 `package.json` 的 `files` 里——装了包的人照着跑会发现文件不存在。这一版只补这一行 `files`（自包含：只 import `../index.js`），行为零改动，测试仍 313 全绿。

package/README.en.md

@@ -9,7 +9,7 @@
 
 <p align="center">
   <b>DeepSeek Harness's own fast mode: a few configs that set how fast a task runs.</b><br>
-  Never changes the model or its reasoning effort; it cuts redundant round trips and output through execution-strategy hints — the gain is fewer steps and fewer output tokens, not deleted narration.
+  Never changes the model, and by default not its reasoning effort either; it cuts redundant round trips and output through execution-strategy hints — the gain is fewer steps and fewer output tokens, not deleted narration. The one exception is the off-by-default `lazy` switch: one rung down when a turn keeps over-thinking, and the switch is yours.
 </p>
 
 <p align="center">
@@ -40,11 +40,11 @@ A step costs round-trip overhead × steps + decode time × output tokens + tool
 - **Output discipline.** Asks the model to skip call previews, restatements and progress reports, never to shorten the final answer. Honest scope: visible assistant prose is only **1.18 %** of the characters in (prose + tool arguments) (def15, 341 sessions / 3,327 messages / 3,569 calls, 51,366 prose vs 4,315,096 argument characters; excludes reasoning and tool results; recompute with `python3 bench/textshare.py --limit 0`), so the speedup cannot be attributed to deleted narration — it comes from fewer round trips and fewer output tokens (fewer repeat edits, re-reads and verification passes). That is not the same claim as "nothing about the work changes".
 - **Stall watchdog.** Shell/script calls get a 120–300 s adaptive cap; a stuck call is cancelled and "change the approach" is written back into the context.
 
-No model switch, no `reasoningEffort` rewrite, no request-field injection (`service_tier`, `max_tokens`, anything like them). While the mode is on, the model's input carries this plugin's own scheduling guidance and reminders — that is the mechanism; switch the mode off and they are gone. DeepSeek's official API, an OpenAI-compatible relay, a self-hosted gateway, Anthropic routes — all work the same.
+No model switch, no request-field injection, and no `reasoningEffort` byte written by default (`lazy` is the one off-by-default exception) (`service_tier`, `max_tokens`, anything like them). While the mode is on, the model's input carries this plugin's own scheduling guidance and reminders — that is the mechanism; switch the mode off and they are gone. DeepSeek's official API, an OpenAI-compatible relay, a self-hosted gateway, Anthropic routes — all work the same.
 
 ## Three boundaries
 
-- **The explicit promise**: the plugin does not change the model, does not rewrite `reasoningEffort`, and does not inject request fields. That is where quality degradation would most likely come from, and the plugin stays out of it.
+- **The explicit promise**: the plugin does not change the model, does not inject request fields, and by default does not rewrite `reasoningEffort`. With `lazy` on it moves at most one rung down, never up, never below `low`, at most twice per turn, and every request re-reads your own choice first. That is where quality degradation would most likely come from, and by default the plugin stays out of it.
 - **Honest mechanism**: execution-strategy hints cut redundant round trips and output. The evidence is falling steps and output tokens (whole-pool default arm: 0.806× steps, 0.818× output); no claim that the gain comes from deleting narration.
 - **Quality boundary**: quality is judged by hidden tests and real evaluations, and behaviour is not claimed to be fully equivalent. When the quality gate fails, quality wins: experimental knobs ship off, and the default is only adopted from batches where both arms' hidden assertions match cell by cell.
 
@@ -103,17 +103,20 @@ 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 a five-row panel — the switch itself and four settings:
+The bolt is the switch: one click writes on/off, per conversation, restored on reload. Right-click it for a six-row panel — the switch itself and five 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.
+- **Think less when it stalls** (`lazy`) — when a turn keeps pouring out reasoning, one notice asks for the cheapest rung that works and one rung less thinking on the next request. Off by default; it can change the answer, not only the timing.
 
-All five rows take effect from the next request, per conversation. No dropdown, no multiplier estimate.
+All six 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.
 
+`lazy` is not on that scale: it can change the answer, not only the timing, so even though the controlled block says it is faster (`LZ1`: 11 of 12 pairs faster, geometric 0.39–0.43×, 216/216 graded assertions green) it stays off by default and joins no default combination. The text-only arm's readings (`lazyEffort: false`) are in the same `LZ1` block of [BENCHMARK.md](BENCHMARK.md).
+
 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.
 
 ## Limits and next step

package/README.md

@@ -9,7 +9,7 @@
 
 <p align="center">
   <b>DeepSeek Harness 自己的快速模式：用几项配置控制任务的运行速度。</b><br>
-  不改模型、不改 reasoningEffort；用执行策略提示减少冗余回合与输出——收益来自步数与输出 token 下降，不是删旁白。
+  默认不改模型、不改 reasoningEffort；用执行策略提示减少冗余回合与输出——收益来自步数与输出 token 下降，不是删旁白。唯一的例外是默认关闭的 `lazy`：想太久时收一档，开关在你手里。
 </p>
 
 <p align="center">
@@ -40,11 +40,11 @@
 - **输出纪律**：提示模型不预告调用、不复述结果、不写进度报告，但**不缩短最终答案**。口径要说清：实测里可见助手正文只占「正文+工具参数」字符的 **1.19%**（def15 全量 385 会话 / 3,659 消息 / 4,007 调用，正文 57,101 / 参数 4,757,921 字符；不含 reasoning 与工具返回；`python3 bench/textshare.py --limit 0` 可复算），所以提速不能归因于删旁白——它来自回合数与输出 token 变少（少重复编辑、少回头读、少验证往返），这和「内容不受影响」不是一回事。
 - **卡顿看门狗**：给 shell/脚本类调用设 120–300 秒自适应上限，卡住的调用被取消并把“换做法”写回上下文。
 
-没有模型切换、没有 `reasoningEffort` 改写、没有请求字段注入；开着时模型输入里会多出本插件自己的调度提示与提醒（这是机制本身），关掉后连这些也不存在。DeepSeek 官方 API、OpenAI 兼容中转、自建网关、Anthropic 协议 —— 走哪条路由都成立。
+没有模型切换、没有请求字段注入；`reasoningEffort` 默认一个字节都不写（`lazy` 是唯一、默认关闭的例外）；开着时模型输入里会多出本插件自己的调度提示与提醒（这是机制本身），关掉后连这些也不存在。DeepSeek 官方 API、OpenAI 兼容中转、自建网关、Anthropic 协议 —— 走哪条路由都成立。
 
 ## 三条边界
 
-- **明确承诺**：不改模型、不改 `reasoningEffort`、不注入请求字段。降智风险最容易发生的地方，插件不碰。
+- **明确承诺**：不改模型、不注入请求字段、默认不改 `reasoningEffort`。打开 `lazy` 时它只降一档、从不升档、最低 `low`、每轮最多两次、下一个请求就从你的选择重新读起；降智风险最容易发生的地方，默认一个字段都不碰。
 - **机制诚实**：靠执行策略提示减少冗余回合与输出。证据是步数与输出 token 下降（全池默认臂 0.806× 步数、0.818× 输出）；不宣称收益来自「删旁白」。
 - **质量边界**：任务质量以隐藏测试判分与真实评测为准，不宣称行为完全等价。质量门槛不过就优先保质量：实验性旋钮默认关闭，默认配置只在两臂隐藏断言逐格相同的批次里采用。
 
@@ -103,18 +103,21 @@
 
 ## 开关
 
-闪电就是开关：开/关即写，按会话独立，重启按会话恢复。右键闪电是一块五行的面板，五行都只影响当前会话：
+闪电就是开关：开/关即写，按会话独立，重启按会话恢复。右键闪电是一块六行的面板，六行都只影响当前会话：
 
 - **更快**：这个会话开不开快模式，和点闪电是同一件事。
 - **少写过程**：第 4 步那句「省着写」提醒的总开关，关掉后输出会变长、耗时变慢（长任务约 2.7×），默认开。
 - **最多几步**：`15` / `30` / 不限，默认不限。到上限只先汇报，不截断任务。
 - **先列文件清单**：开启后，回合的第一次工具调用之前先收到一份工作目录清单（相对路径 + 字节数 + 可见的测试入口），省掉开头的 `ls`/`find` 探路。默认关；23 个配对实测几何 0.927×，尾部变慢、步数 +10%，没有达到进默认的门槛，只作为可试的开关。
 - **一次读多个文件**：把互不依赖的读取合成一批发出，少几个来回。默认关；单独开测不到显著，和上一项一起开才有（见下）。
+- **想太久就少想一点**（`lazy`）：一轮里思考文字明显超量时，先给一次"先找最省的一级、不扩范围、不砍校验"的提示，再把下一个请求的思考强度降一档。默认关；它动的是答案而不只是时延。
 
-五项都写在本会话的条目里，对下一个回合生效；另一个会话开不开、写成什么样，互不影响。没有下拉，没有倍数估算。
+六项都写在本会话的条目里，对下一个回合生效；另一个会话开不开、写成什么样，互不影响。没有下拉，没有倍数估算。
 
 **几个一起开会不会更快？** 会，但只有实测过的那几个。默认 + `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) 的「直接跑一次多个开关一起开」。
 
+`lazy` 不与上面这些同口径：它动的是答案而不只是时延，所以哪怕测出来更快（`LZ1`：12 对里 11 对更快，逐对几何 0.39–0.43×，判分 216/216 全绿）也仍然默认关闭，不进任何默认组合。纯提示臂（`lazyEffort: false`）的读数同样在 [BENCHMARK.md](BENCHMARK.md) 的 `LZ1` 块。
+
 思路参考了 `dsh-batch-tool-calls` 与 `dsh-ops`（批量调用、有界执行），但它们的规则是静态的，这里的宽度来自会话自身的调用证据；不需要同时装。压缩类插件可以共存。
 
 ## 边界与下一步

package/client.js

@@ -84,7 +84,7 @@ window.__ModuleLoader__.load({
     const zh = {
       'chip.on': 'Fast 模式已开启',
       'chip.off': 'Fast 模式已关闭',
-      'chip.titleOn': 'Fast 模式：已开启 · 仅本会话 · 思考强度不变，点击关闭 · 右键设置',
+      'chip.titleOn': 'Fast 模式：已开启 · 仅本会话 · 点击关闭 · 右键设置',
       'chip.titleOff': 'Fast 模式：已关闭 · 点击开启 · 右键设置',
       'chip.titleLoading': 'Fast 模式：正在读取配置，点击重试',
       'chip.readonly': 'Fast 模式配置为只读，无法从这里切换',
@@ -104,6 +104,8 @@ window.__ModuleLoader__.load({
       'panel.mapTitle': '开局把目录里的文件交给模型，省掉先翻一遍目录',
       'panel.batch': '一次读多个文件',
       'panel.batchTitle': '把互不依赖的读取合成一批发出，少几个来回',
+      'panel.lazy': '想太久就少想一点',
+      'panel.lazyTitle': '想太久时先按已有信息定下去，安全校验照旧',
     }
 
     const en = {
@@ -129,6 +131,8 @@ window.__ModuleLoader__.load({
       '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',
+      'panel.lazy': 'Think less when it stalls',
+      'panel.lazyTitle': 'Cuts a turn short when it keeps reasoning instead of deciding; safety checks stay',
     }
 
     const CSS = [
@@ -192,6 +196,8 @@ window.__ModuleLoader__.load({
       inventory: false,
       /** Batches independent reads into one call for this conversation. */
       batch: false,
+      /** The lazy switch: this conversation may be reasoned at a lower effort when it over-thinks. */
+      lazy: false,
       /** This conversation's step cap; 0 means no cap. */
       stepBudget: 0,
       /** The right-click panel is open. Store-backed, like every other paint. */
@@ -537,6 +543,9 @@ window.__ModuleLoader__.load({
           const seenBatch = own !== undefined && typeof own.batch === 'boolean'
             ? own.batch
             : value.openBatch === true
+          const seenLazy = own !== undefined && typeof own.lazy === 'boolean'
+            ? own.lazy
+            : value.lazy === true
           store.phase = 'ready'
           store.error = ''
           store.ns = view.ns
@@ -547,6 +556,7 @@ window.__ModuleLoader__.load({
           store.stepBudget = seenBudget
           store.inventory = seenMap
           store.batch = seenBatch
+          store.lazy = seenLazy
           // 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.
@@ -624,6 +634,7 @@ window.__ModuleLoader__.load({
         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 entry.lazy === 'boolean') store.lazy = entry.lazy
       }
       if (typeof shared.enabled === 'boolean') {
         store.enabled = shared.enabled
@@ -635,6 +646,7 @@ window.__ModuleLoader__.load({
       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
+      if (typeof shared.lazy === 'boolean') store.lazy = shared.lazy
       emit()
       try {
         unwrap(await withTimeout(remote.settings.update(store.ns, outgoing, store.revision), 15000, 'settings/update'))
@@ -651,6 +663,7 @@ window.__ModuleLoader__.load({
         store.stepBudget = before.stepBudget
         store.inventory = before.inventory
         store.batch = before.batch
+        store.lazy = before.lazy
         store.pending = undefined
         store.writeError = describeError(error)
         emit()
@@ -866,6 +879,16 @@ window.__ModuleLoader__.load({
         emit()
       }
 
+      /**
+       * The one switch that changes how much this conversation thinks. It can
+       * change the answer, not only its timing, so the row names that first.
+       */
+      const toggleLazy = () => {
+        void write(remote, undefined, { entry: { lazy: !store.lazy } })
+        store.panelOpen = false
+        emit()
+      }
+
       return react.createElement(
         'div',
         { className: 'fm-panel', role: 'menu', 'aria-label': t('panel.title') },
@@ -898,6 +921,15 @@ window.__ModuleLoader__.load({
           store.batch,
           t('panel.batchTitle'),
         ),
+        row(
+          'menuitemcheckbox',
+          t('panel.lazy'),
+          t(store.lazy ? 'panel.on' : 'panel.off'),
+          canWrite,
+          toggleLazy,
+          store.lazy,
+          t('panel.lazyTitle'),
+        ),
         react.createElement('div', { className: 'fm-panel__scope' }, t('panel.scope')),
       )
     }

package/docs/REFERENCE.md

@@ -1,17 +1,19 @@
 # 参考手册：原理、配置与边界
 
-本手册描述 **dsh-fast-mode 1.5.35** 的实际行为（默认配置下的注入行为与 1.5.0 一致；1.5.14 起多了右键面板，1.5.33 面板为五行、五行都只影响本会话），对应仓库里的 `index.js`、`src/` 与 `client.js`。它不是宣传页：凡是能测量的地方给出数字，凡是没测量的地方直接说没测量。
+本手册描述 **dsh-fast-mode 1.6.0** 的实际行为（默认配置下的注入行为与 1.5.0 一致；1.5.14 起多了右键面板，1.5.33 面板为五行，1.6.0 起为六行，六行都只影响本会话），对应仓库里的 `index.js`、`src/` 与 `client.js`。它不是宣传页：凡是能测量的地方给出数字，凡是没测量的地方直接说没测量。
 
-**唯一的契约：Fast 模式从不改变思考强度、thinking 预算或模型。** `agent/request` 钩子只做一件事——`await next()`，读一下请求携带的 `reasoningEffort` 记进测量，然后原样返回。用户选的是哪一档（会话里的 UI 选择，或者 profile 里 agent-default-model 固定下来的那一档），每个请求就用哪一档。
+**默认契约：Fast 模式不改变思考强度、thinking 预算或模型。** `agent/request` 钩子默认只做一件事——`await next()`，读一下请求携带的 `reasoningEffort` 记进测量，然后原样返回。用户选的是哪一档（会话里的 UI 选择，或者 profile 里 agent-default-model 固定下来的那一档），每个请求就用哪一档。
+
+**唯一的例外是 1.6.0 起逐会话可点的 `lazy`，默认关闭。** 它只在「上一请求流出的思考字符明显超量」时把**下一个请求**降一档（最低 `low`，从不升档，每轮最多两次，工具报错后两步内不降），而且每个请求都从用户当次的选择重新读起，所以下一次请求就恢复；它不改模型、不写 thinking 预算、不加任何 provider 字段，`lazyEffort: false` 时一个字段都不写。见下面"六、`lazy`：想太久就少想一点"。
 
 快的部分只来自三件事：更少的往返、更少的冗余输出、更少的卡顿等待。下面逐条说明。
 
 ## 交互细节：闪电开关与会话归属
 
 - **一个图标就是开关。** 会话输入区的活动槽（`conversation.input.activity`）里只有一个闪电按钮：关闭时空心，开启时实心。点一下切换，再点一下切回；这一下只写当前会话。没有档位选择器，没有箭头，没有"选择 gear"的二级菜单。
-- **右键是面板。** 右键闪电打开五行，五行都只影响当前会话："更快"（`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` 与配置项描述）里，不再占用输入区。
+- **右键是面板。** 右键闪电打开六行，六行都只影响当前会话："更快"（`enabled`）、"少写过程"（`outputDiscipline`）、"最多几步"（`stepBudget`，循环 0/15/30）、"先列文件清单"（`workspaceMap`）、"一次读多个文件"（`openBatch`）、"想太久就少想一点"（`lazy`）。六行都把选择写进 `sessions` 列里本会话的条目，不碰共享默认值，下一个回合生效；只读或写入中时整块禁用，写失败回滚。没有条目的会话沿用配置里的默认值（`enabled`/`gear`/`outputDiscipline`/`stepBudget`/`workspaceMap`/`openBatch`/`lazy`）。面板不暴露 `disciplineAfterSteps`、`disciplineEarlyCalls`、`shapeGate`、`finishLineSteps`、`shellParallel`、`disciplineRepeatAtSteps` 这些未证实或已判 HOLD 的旋钮。
+- **会话之间互不影响，这是硬约束。** 每个会话的 `enabled`、`gear`、`outputDiscipline`、`stepBudget`、`workspaceMap`、`lazy` 都从 `sessions` 列里自己那一条解析：A 会话 `更快 + 少写过程`、B 会话 `更快 + 不写过程` 同时成立，C 会话没点过就沿用配置默认值。面板和闪电只写本会话的条目，从不写共享默认值；条目最多保留 200 个，按 `ts` 淘汰最旧的，被淘汰的会话回到默认值。
+- **按钮只表达一个问题：这个会话开不开。** `aria-pressed` 就是状态，tooltip 写清"仅本会话 · 点击关闭 · 右键设置"。为什么快、快在哪里、单次调用上限这类说明放在插件介绍（`meta.description` 与配置项描述）里，不再占用输入区。
 - **实时行引用的是被执行的数字**，而不是产品形容词：
   - 开启、看门狗有上限：`自动调度 · 并行 2–8 · 单次调用 ≤ 2 分`
   - 开启、看门狗关闭（`stallGuard: false`，或 `toolTimeoutMs` 为负数）：`自动调度 · 并行 2–8 · 单次调用不限时`
@@ -29,9 +31,9 @@
 
 1. `const resolved = await next()`；
 2. 读 `resolved.reasoningEffort`、路由名，写进测量标签；
-3. `return resolved`。
+3. `lazy` 关闭时 `return resolved`，一个字段都不动；`lazy` 打开且 `lazyEffort !== false` 时，只有 `src/lazy.js` 的账本里有证据（上一请求流出的思考字符超过阈值、没有报错冷却、本轮降档次数未用完、当前档在 `low` 之上）才 `return { ...resolved, reasoningEffort: 下一档 }`，否则仍然原样返回。
 
-它不写 `reasoningEffort`，不写 thinking 预算，不换模型，也不添加任何 provider 专用字段。因此"更快"只剩下三个真实杠杆：并行扇出（减少往返）、输出纪律（减少过程文字）、卡顿看门狗（减少工具等待）。思考深度和解码速度不在其中——前者是用户的契约，后者任何提示词都做不到。
+除这一个可点的例外，它不写 thinking 预算，不换模型，也不添加任何 provider 专用字段。因此常备的"更快"杠杆仍是三个：并行扇出（减少往返）、输出纪律（减少过程文字）、卡顿看门狗（减少工具等待）；`lazy` 是第四个，默认关闭，因为它动的是答案而不只是时延。思考深度和解码速度不在常备杠杆里——前者是用户的契约，后者任何提示词都做不到。
 
 ### 二、自适应调度器：`gear: auto`
 
@@ -136,6 +138,19 @@
 
 上限是 200 个会话，超出时淘汰 `ts` 最旧的条目——这是内存与配置文件体积的边界，不是权限模型。host 端的实现（`src/state.js`）和浏览器里的副本（`client.js`）是两份代码，测试用同一组 fixture 锁住它们的读写一致。
 
+### 六、`lazy`：想太久就少想一点（1.6.0，默认关闭）
+
+Ponytail 那句"最好的代码是没写的代码"在这里只借一半：**先读懂，再省**。这一节是插件里唯一会改动 `reasoningEffort` 的路径，所以它默认关闭、逐会话可点、并且每个请求都从用户当次的选择重新读起。
+
+两个动作，都只在有证据时发生：
+
+- **提示侧（`lazy: true` 时始终生效）。** 每轮第一步发一条 notice：先找最省的一级（能不能不做 → 有没有现成 helper → 标准库/平台 → 已装的依赖 → 一行 → 最小实现），确认必须写才写；不许扩范围；不许砍信任边界校验、数据丢失处理、安全与可访问性；结尾用一行说清跳过了什么、风险在哪。文本在 `src/lazy.js` 的 `DIRECTIVE`，`lazyEffort: false` 也照样发。
+- **effort 侧（`lazy: true` 且 `lazyEffort !== false`）。** 账本记两件事：上一步流出的思考字符（`agent/assistant-stream` 的 `reasoning-delta`）与本轮累计。上一步 ≥ 1600 字符，或本轮累计越过 4000 / 8000 字符，就把**下一个请求**降一档（`src/lazy.js` 的 `EFFORT_RUNGS` 顺序，最低到 `low`，从不升档）；每轮最多降两次、每步最多降一次（重试不会连降），工具结果报错后两步内不降——报错通常说明该想得更多，不是更少。
+
+为什么不会像 0.9.x 那样把会话"卡"在低档：`agent/request` 每次都从 `resolved.reasoningEffort`（用户当下的选择）重新读基准，降档只作用于它自己那一次返回值，所以用户切回 High 之后的第一个请求就是 High；面板里关掉 `lazy` 同样立刻恢复。测量口径上，`lazyEffort: false` 是"只发文字、一个字段都不写"的对照臂，用来分辨收益来自提示词还是 provider 真的更低档；`agent/assistant-stream` 记的 `reasoningChars` 是第二条独立通道（不依赖 provider 报 `reasoning_tokens`）。两块数字见 `BENCHMARK.md` 的 `LZ1` 块（12 对、36 次运行）：「只发文字」臂逐对几何墙钟 **0.389×**（95 % CI [0.252, 0.600]，11/12 更快，p = 0.0032），「文字 + 降档」臂 **0.430×**（CI [0.273, 0.677]，11/12），推理字符 0.372× / 0.418×，两臂判分 **216/216 全绿**。两臂直接对打 `laz16 / lazt16` = 1.106×（CI 跨 1），所以诚实的结论是：**收益主要来自提示文字那一半；降 `reasoningEffort` 这一半在这条路由上没有测出额外收益，也没测出代价。** 样本是两个短任务族、单机、单路由，别把它读成「所有题都快 2.5 倍」。
+
+不改的东西：模型、`thinking` 预算、`output_config`、provider 专用字段、以及档位词汇本身（路由声明的档位名不认识时原样放过，不猜）。
+
 ## 配置
 
 放在 profile 的 `cordis.patch.yml` 里：
@@ -166,6 +181,8 @@
 | `sessions` | `''` | 插件自动维护的会话级覆盖，见上一节。**不要手改。** |
 | `outputDiscipline` | `'late'` | 输出纪律。`late`（默认）前 4 步不写任何输出约束，第 4 步起由调度器提醒一次；`true` 全程生效；`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〕，单独开仍测不到显著。 |
+| `lazy` | `false` | 想太久就少想一点：每轮第一步给一次"先找最省的一级、不扩范围、不砍校验"的提示，并在思考字符明显超量时把下一个请求降一档思考强度（最低 `low`，从不升档，每轮最多两次，报错后两步内不降）。默认关闭：它是唯一会改变答案而不只是时延的开关。1.6.0 起进面板（"想太久就少想一点"），逐会话可点。 |
+| `lazyEffort` | `true` | `lazy` 的 effort 半边。设为 `false` 时只发提示文字，一个请求字段都不写——这是分辨"提示词有效"与"provider 真降档"的对照臂。 |
 | `shapeGate` | `false` | 形状闸门：本轮累计调用 ≥ 4 且其中写入类（不在只读名单里的工具）占比 ≥ 60 % 时，**整轮不再注入任何提醒**，行为退回原生。判断只用已有的工具名，不发请求、不加请求体字段。它给的是「不适合就别管我」的退路：写密集型的任务没有可并行的调用，每条提醒都只是一次它用不上的往返。显式设了 `stepBudget` 时该收尾线优先于闸门——「别加速」不等于「无视我叫停」。默认关，因为它会同时关掉本可以救回长尾的收尾提醒。 |
 | `preferPatch` | `false` | 整文件写入之后提醒一次「改已有文件时只发改动的行（edit hunk），不要重发整个文件」。本步 `write` 的正文 ≥ 2000 字符才武装，之后一步发一次，每轮最多一次；文本明确要求结果与原文件逐字节相同，不限制写什么、也不影响何时结束。默认关闭：它只作用于模型的输出形式（工具调用参数），正确性由文件内容决定、与发送形式无关；实测是否真省墙钟见 `BENCHMARK.md` 的 `pp16` 臂。 |
 | `compactRereadHint` | false | 压缩提醒里多一句「本回合写过的文件不要为确认整份重读」；不新增消息。实验旋钮，默认关 |
@@ -193,7 +210,7 @@
 
 三条规则让它们真的能一起用：
 
-1. **不抢同一个字段。** 本插件不碰 `reasoningEffort`、`thinking`、`output_config`，所以没有任何"两个组件同时钳制 effort"的问题。
+1. **不抢同一个字段。** 本插件默认不碰 `reasoningEffort`、`thinking`、`output_config`；`lazy` 打开时也只在 `agent/request` 的返回值上降一档，不写配置、不写 thinking，压缩器与它没有共享字段——所以没有"两个组件同时钳制 effort"的问题。
 2. **压缩步骤不需要特殊照顾。** 1.0.0 没有"按住某一步"的概念；历史折叠发生在请求发出之前，本插件看到的只是一个普通请求。
 3. **摘要调用碰不到。** 压缩器自己的摘要请求往往跑在它自己的进程或 HTTP 层里，不经过 `agent/request`，本插件既不影响它，也不被它影响。
 
@@ -233,12 +250,12 @@
 
 **完全支持，而且不需要任何配置。** 官方 DeepSeek API（`deepseek-official`）、官方 API 前面挂的代理和中转、自建网关（如 `litellm` + Anthropic Messages）、OpenAI 兼容端点，行为完全一样，原因很简单：
 
-- 请求体原样进出。本插件不写 `reasoningEffort`、不写 `thinking`、不写 `output_config`，也不添加任何 provider 专用字段；
+- 请求体原样进出。本插件默认不写 `reasoningEffort`、不写 `thinking`、不写 `output_config`，也不添加任何 provider 专用字段；`lazy` 打开时 `reasoningEffort` 只会被换成一个该路由已经在用的更省档位（不认识当前档位就原样放过），路由不报 reasoning token 也不影响提示侧照常工作；
 - 不做"这条路由声明了哪些档位"的过滤和降档。没有 `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 原样发出去。
+所以无论 provider 声明的是 `off/low/high/max`、还是 `minimal/low/medium/high`、还是只有一档、还是什么都没声明，本插件的行为都一样：它注入提示段、给 shell 调用设上限，然后把你选的 effort 原样发出去（`lazy` 关闭时；打开时只在此前确实想太久的那一步之后降一档，见「六、`lazy`」）。
 
 ## 测量、实验与报告
 
@@ -254,7 +271,8 @@
 | `ts` | 这一步结束的 ISO 时间 |
 | `sid` / `turn` / `step` | 会话 id、轮次、步号 |
 | `mode` / `gear` | `on` 或 `off`；关闭时 gear 记为 `off` |
-| `effort` | **请求实际携带的思考强度，原样记录，不做任何改写**——这是"插件没有动 effort"的证据 |
+| `effort` | **请求实际携带的思考强度**。默认就是你在 UI 里选的那档，一字不改；`lazy` 降档时这里是降后的值 |
+| `effortBase` | 仅在 `lazy` 降档时出现：用户原本选的那档。和 `effort` 的差就是降档证据 |
 | `route` | 路由/模型的标签，仅用于分组 |
 | `ttftMs` | 首字延迟：步开始到第一条 assistant 消息 |
 | `llmMs` | 模型耗时：步开始到最后一条 assistant 消息 |
@@ -264,7 +282,7 @@
 | `cacheRead` / `cacheWrite` | 上游 usage 的缓存读写 token |
 | `assistantMessages` | 本步的 assistant 消息数 |
 
-`effort` 这一列是理解 1.0.0 的关键：它记录的是请求**实际带出去的**值。如果你在 UI 里选了 `high`，每一行就是 `high`；插件不会把它改成别的。
+`effort` 这一列是理解请求路径的关键：它记录的是请求**实际带出去的**值。默认情况下它就是你在 UI 里选的那档（选了 `high`，每一行就是 `high`）；只有开了 `lazy` 且那一步确实想太久时，它才会变成降后的值，同时 `effortBase` 记下你原本的选择。两列同时出现就是「降档发生过」的机器证据。
 
 ### 每个会话自己的开关
 
@@ -331,7 +349,7 @@ dsh-fast-mode-experiment stop         # 结束实验
 ## 安全边界
 
 - **只观察，不改写。** `tools/pre-execute` / `tools/post-execute` 是纯观察者（记录开始时间和调用结果），`agent/request` 原样返回请求。除了注入提示段和两条 producer-owned notice（压缩后提醒、调度指令），插件不往会话里写任何东西。
-- **模型与 effort 不可写。** 源码里没有对 `reasoningEffort` 的赋值；测试会扫描源码，防止将来有人把它加回来。
+- **模型不可写，effort 只有一处可写。** 源码里只有 `src/lazy.js` 的降档路径会写 `reasoningEffort`（`agent/request` 返回值上的一个字段，`lazy` 默认关闭）；`test/effort.test.js` 扫描源码，要求这个赋值恰好一处、形状固定，并且仍然禁止 `thinking:` 与 0.9.x 的 `decideEffort`。
 - **设置只能由这次点击改，且带 revision。** 没有后台静默改配置的路径；冲突写入会失败并回滚，原因是 tooltip。
 - **计量是本地的。** 只写 `metricsFile`；`--lan` 是唯一的出网路径，只读，需要显式 token。
 - **看门狗只改 signal。** 调用方原来的 signal 在 `finally` 里恢复；取消后调用体的 rejection 被吞掉，不会变成未处理的拒绝。
@@ -364,13 +382,14 @@ dsh-fast-mode-experiment stop         # 结束实验
 - `src/guidance.js`：模型可见的提示文本；
 - `src/stallguard.js`：看门狗与预算优先级；
 - `src/effort.js`：档位表与旧名字归一化（不再有 effort 阶梯）；
+- `src/lazy.js`：`lazy` 的提示文本、思考字符账本与降一档的判定；
 - `src/config.js`：schema 与表单字段；
 - `src/state.js`：`sessions` 列的解析与编码；
 - `src/notices.js`：producer-owned notice 的构造与来源校验；
 - `src/metrics.js`：JSONL 计量与汇总；
 - `src/benchmark.js`：按会话哈希分配；
 - `src/peers.js`：冲突插件探测；
-- `client.js`：闪电开关、右键面板（五行，按会话写入 `sessions` 列）。
+- `client.js`：闪电开关、右键面板（六行，按会话写入 `sessions` 列）。
 
 跑测试：
 
@@ -378,6 +397,6 @@ dsh-fast-mode-experiment stop         # 结束实验
 node --test test/*.test.js
 ```
 
-当前 223 个测试在 Node 20.20.2、22.23.4 与 24 上全部通过（每个版本 223/223，0 失败）。测试覆盖：调度器宽度与指令、预算优先级、提示段的开关条件、`sessions` 列在 host 与浏览器两份实现间的一致性、notice 来源校验、计量字段、分配哈希、报告与实验 CLI 的参数解析，以及一条扫描源码、确认没有改写 `reasoningEffort` 的回归测试。
+当前 336 个测试在 Node 24.16.0 上全部通过（336/336，0 失败）。测试覆盖：调度器宽度与指令、预算优先级、提示段的开关条件、`sessions` 列在 host 与浏览器两份实现间的一致性、notice 来源校验、计量字段、分配哈希、报告与实验 CLI 的参数解析，`lazy` 的账本与降档边界（15 条单元测试）、以及一条扫描源码、确认 `reasoningEffort` 只有那一处受控赋值的回归测试。
 
 文档入口：`README.md`（中文）、`README.en.md`（English）、`BENCHMARK.md`（测量方法与历史数据）、`CHANGELOG.md`（每个版本删了什么、加了什么）。

package/index.js

@@ -85,6 +85,7 @@ import { createRecorder } from './src/metrics.js'
 import { readOutputTokens } from './src/usage.js'
 import { configOverridesFor } from './src/state.js'
 import { buildShellParallelTool } from './src/parallel.js'
+import { beginStep as lazyBeginStep, createLazyWatch, DIRECTIVE_SUMMARY as LAZY_SUMMARY, NUDGE_SUMMARY as LAZY_NUDGE_SUMMARY, noteReasoning as lazyNoteReasoning, noteToolResult as lazyNoteToolResult, planEffort as lazyPlanEffort } from './src/lazy.js'
 
 /**
  * The settings-page schema. Re-exported from here because the Loader reads
@@ -98,7 +99,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.35'
+export const VERSION = '1.6.1'
 const GLOBAL_AGENT = '__global__'
 
 /**
@@ -140,6 +141,26 @@ function latestUserText(messages) {
   return ''
 }
 
+/**
+ * How many messages in this turn came from the human. Plugin notices are also
+ * `role: 'user'`, so a bare role count would move every time this plugin spoke
+ * and every turn would look new.
+ *
+ * @param {unknown} messages
+ * @returns {number}
+ */
+function claimedUserCount(messages) {
+  if (!Array.isArray(messages)) return 0
+  let count = 0
+  for (const m of messages) {
+    if (!m || m.role !== 'user') continue
+    const source = m.source
+    if (source && typeof source === 'object' && source.form === 'notice') continue
+    count += 1
+  }
+  return count
+}
+
 function insertAfterClaimed(messages, claimed, notices) {
   const list = Array.isArray(messages) ? messages : []
   if (notices.length === 0) return list
@@ -189,6 +210,18 @@ function routeOf(resolved) {
   return typeof provider === 'string' && typeof model === 'string' ? `${provider}/${model}` : 'unknown'
 }
 
+/**
+ * The effort label a journal row carries: the resolved value when it is a
+ * string, otherwise `undefined`. Kept separate from the value itself so a route
+ * that hands back a non-string can never be stringified into a fake rung.
+ *
+ * @param {unknown} value
+ * @returns {string | undefined}
+ */
+function summaryEffort(value) {
+  return typeof value === 'string' ? value : undefined
+}
+
 /**
  * Log, once per load, whether this entry's namespace is actually served by the
  * `settings` service — the fact the chip's state depends on.
@@ -396,6 +429,11 @@ export function apply(ctx, rawConfig) {
   // The scheduler's memory, one entry per conversation: what has been tried, how
   // long calls have been taking, and how many steps went by without a new result.
   const auto = createAutoState()
+  const lazyWatch = createLazyWatch()
+  // Which human turn each session is in. `agent/pre-step` carries no turn number,
+  // so the count of claimed (non-plugin) user messages is the boundary: it moves
+  // exactly when the user speaks again.
+  const lazyTurnKey = new Map()
   /**
    * Live stall ceilings per conversation, as computed by the scheduler.
    * Bounded like `compacted`: a long-lived host process sees thousands of
@@ -481,13 +519,27 @@ export function apply(ctx, rawConfig) {
   // `attemptId` whose prefix is the session. They carry no turn or step, so the
   // recorder attributes them to the step that session has open.
   ctx.on('agent/assistant-stream', (payload) => {
-    if (!metrics.enabled) return
     const frame = payload && payload.frame
     if (!frame || frame.type !== 'chunk' || typeof frame.attemptId !== 'string') return
     const cut = frame.attemptId.lastIndexOf(':')
     if (cut <= 0) return
+    const sid = frame.attemptId.slice(0, cut)
     try {
-      metrics.record({ id: frame.attemptId.slice(0, cut) }, {
+      // Lazy mode reads the same stream, and must keep reading when the journal
+      // is off: the effort step-down is decided from how much the route actually
+      // streamed, not from a usage field this route reports as zero.
+      if (lazyWatch.runs.has(sid)) {
+        const chunk = frame.chunk
+        const kind = chunk && typeof chunk === 'object' ? chunk.type : undefined
+        if (kind === 'reasoning-delta') {
+          const text = typeof chunk.text === 'string'
+            ? chunk.text
+            : typeof chunk.delta === 'string' ? chunk.delta : ''
+          lazyNoteReasoning(lazyWatch, sid, text.length)
+        }
+      }
+      if (!metrics.enabled) return
+      metrics.record({ id: sid }, {
         type: 'assistant/chunk',
         time: frame.time,
         data: { chunk: frame.chunk },
@@ -568,6 +620,25 @@ export function apply(ctx, rawConfig) {
           }
         }
       }
+      if (cfg.lazy === true) {
+        // Lazy mode's two prompt-side mechanisms: the ladder text on the first
+        // step of a turn, and at most two nudges when a turn's streamed reasoning
+        // passes its threshold. The tail of a long turn is where over-thinking
+        // costs the most and where a reminder changes the next step rather than
+        // the one already paid for.
+        const key = `${sid}\u0000${claimedUserCount(payload?.messages)}`
+        const fresh = lazyTurnKey.get(sid) !== key
+        if (fresh) {
+          lazyTurnKey.set(sid, key)
+          trim(lazyTurnKey, 200)
+        }
+        const plan = lazyBeginStep(lazyWatch, sid, { firstStep: fresh })
+        if (plan && plan.directive) notices.push(createNoticeMessage(plan.directive, LAZY_SUMMARY))
+        if (plan && plan.nudge) notices.push(createNoticeMessage(plan.nudge, LAZY_NUDGE_SUMMARY))
+        if (plan && initial.debug) {
+          appendDebug(initial.debugFile, `lazy v${VERSION}: turn=${key.split('\u0000').pop()} directive=${plan.directive ? 'yes' : 'no'} nudge=${plan.nudge ? 'yes' : 'no'}`)
+        }
+      }
       if (cfg.workspaceMap === true) {
         // One inventory per session, before the model spends a step finding out
         // what is in the directory (35.7 % of the recorded calls were exactly
@@ -714,6 +785,9 @@ export function apply(ctx, rawConfig) {
         // The scheduler reads the same observation: a call that returns the same
         // bytes for the same arguments is the raw material of the long tail.
         noteTool(auto, agent, observation)
+        // An error result is the one signal that the model may need more room to
+        // think, so it cancels any pending effort step-down for a couple of steps.
+        lazyNoteToolResult(lazyWatch, agent, observation)
       }
     } catch {
       // Observation is best-effort. A failure here must not affect the tool
@@ -729,30 +803,44 @@ export function apply(ctx, rawConfig) {
     const sid = agentKey(payload?.agent)
     const agent = sid === GLOBAL_AGENT ? undefined : sid
     const cfg = configFor(agent)
-    const effort = resolved?.reasoningEffort
+    const baseEffort = resolved?.reasoningEffort
     const route = routeOf(resolved)
-    const label = effort === undefined ? undefined : String(effort)
-
-    // Fast mode does not touch the thinking budget, on purpose. The route and the
-    // effort are the user's contract with the model: a mode that quietly thinks
-    // less produces a different answer, not a faster one, and the measured public
-    // benchmarks showed the effort ladder bought no wall-clock on this route
-    // anyway (0 reasoning tokens in every arm). What is left is the part that
-    // makes the same thinking finish sooner — wider steps, bounded calls, and a
-    // breaker for the sessions that only look busy.
+
+    // The rule this plugin kept for five releases was "never touch the thinking
+    // budget", and it is still the rule unless the user turns on the one switch
+    // that says otherwise. See `src/lazy.js`: it lowers effort only after a step
+    // visibly over-thought, never below the user's own floor, twice a turn at
+    // most, and it restores the resolved value on the very next request — the
+    // 0.9.x damage was that a rewrite outlived the turn that justified it.
     if (!cfg.enabled) {
-      metrics.label(sid, { mode: 'off', gear: 'off', effort: label, route })
+      metrics.label(sid, { mode: 'off', gear: 'off', effort: summaryEffort(baseEffort), effortBase: null, route })
       return resolved
     }
 
     const schedule = cfg.gear === AUTO ? autoSchedule(auto, sid, { emit: false }) : undefined
     checkParallelCap(cfg, schedule?.parallel)
-    metrics.label(sid, { mode: 'on', gear: cfg.gear, effort: label, route })
+    const planned = cfg.lazy === true && cfg.lazyEffort === true
+      ? lazyPlanEffort(lazyWatch, sid, baseEffort)
+      : undefined
+    const applied = planned && planned.reduced ? planned.effort : baseEffort
+    // The journal keeps both halves in one call: `effort` is what the request
+    // carried, `effortBase` is what the user chose, so a comparison can tell a
+    // lazy step-down from a session that was simply started at a lower rung.
+    // `null`, not omitted, on a step that did not step down — otherwise the
+    // previous reduction would leak into every following row.
+    metrics.label(sid, {
+      mode: 'on',
+      gear: cfg.gear,
+      effort: summaryEffort(applied),
+      effortBase: planned && planned.reduced ? summaryEffort(baseEffort) : null,
+      route,
+    })
 
     if (cfg.debug) {
       appendDebug(
         cfg.debugFile,
-        `turn=${payload?.turn} step=${payload?.step} gear=${cfg.gear} effort=${String(label)} (unchanged)`
+        `turn=${payload?.turn} step=${payload?.step} gear=${cfg.gear} effort=${String(summaryEffort(baseEffort))}`
+          + (planned && planned.reduced ? `->${String(applied)} (lazy step-down)` : ' (unchanged)')
           + ` route=${route}`
           + (schedule
             ? ` parallel=${schedule.parallel} budget=${schedule.stallBudgetMs}ms`
@@ -762,17 +850,18 @@ export function apply(ctx, rawConfig) {
       )
     }
 
-    return resolved
+    return planned && planned.reduced ? { ...resolved, reasoningEffort: applied } : resolved
   })
 
   ctx.logger?.info?.(
-    '%s v%s loaded: enabled=%s gear=%s parallel=%d adaptive=%s reasoningEffort=untouched metrics=%s',
+    '%s v%s loaded: enabled=%s gear=%s parallel=%d adaptive=%s reasoningEffort=%s metrics=%s',
     TAG,
     VERSION,
     initial.enabled,
     initial.gear,
     initial.parallel,
     initial.adaptive === true,
+    initial.lazy === true ? (initial.lazyEffort === false ? 'lazy-text-only' : 'lazy') : 'untouched',
     metrics.enabled ? metrics.file : 'off',
   )
   if (initial.legacyGear) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-fast-mode",
-  "version": "1.5.35",
-  "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).",
+  "version": "1.6.1",
+  "description": "DeepSeek Harness fast mode: fewer round trips at the same thinking effort. Adaptive parallel tool fan-out, output discipline that never trims the answer, a cancellable stall guard, and one off-by-default switch (lazy) that steps a stalled turn one rung down. By default it never changes reasoning effort, the model, or the request body. Provider-agnostic, one dependency (@deepseek-ai/schemastery).",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/regrevia/dsh-fast-mode.git"

package/src/config.js

@@ -10,7 +10,7 @@
  *   why the on/off switch and the gear selector exist there without a line of
  *   client code.
  *
- * The seven form fields (`enabled`, `gear`, `parallel`, `sessions`,
+ * The form fields (`enabled`, `gear`, `parallel`, `sessions`,
  * `outputDiscipline`, `stepBudget`, `workspaceMap`) are `.volatile()`: that is
  * what makes them appear in the generated form *and* what lets an edit reach a
  * running fiber instead of forcing a remount. A non-volatile declaration is
@@ -18,7 +18,7 @@
  * keeps only volatile nodes, and `update()` refuses the path with "is not
  * volatile".
  *
- * The panel's three rows are volatile for exactly that reason: the client half
+ * The panel's rows are volatile for exactly that reason: the client half
  * has one channel to read state from, `describe()`, so a non-volatile field is a
  * row it can write into `sessions` but never paint — it would keep showing the
  * built-in default (`late` / 0 / off) while a hand-written `cordis.patch.yml`
@@ -39,9 +39,10 @@
  * the form.
  *
  * `enabled` defaults to **false** on purpose: opt-in is what makes "off means
- * completely off" verifiable. Nothing here can change the model's thinking
- * effort — the old `floor` / `ladder` / `aliases` knobs are gone, along with the
- * code that read them.
+ * completely off" verifiable. The old `floor` / `ladder` / `aliases` knobs are
+ * gone, along with the code that read them; the one field that can still move
+ * effort is `lazy`, and it is off by default because it can change the answer,
+ * not only the timing.
  *
  * @module dsh-fast-mode/config
  */
@@ -160,6 +161,21 @@ export const Config = z.object({
       '开局批量 / Opening batch（面板名「一次读多个文件」）: 每轮第一步提醒一次「把已知要做的独立调用放进同一块、shell 命令用 && 串起来」。短任务的钱几乎全花在每步固定成本（首字延迟 ~0.5 s/次）上，少一次往返就省一次；只发一次，不改后续调度。面板可逐会话开；和 `workspaceMap` 一起开时实测 0.742×（11 对），单独开测不到显著，所以默认仍是 false。',
     ),
 
+  lazy: z
+    .boolean()
+    .default(false)
+    .volatile()
+    .description(
+      '想太久就少想一点 / Think less when it stalls（面板「想太久就少想一点」）: 每轮第一步给一次「先找最省的一级、不扩范围、不砍信任边界校验/数据丢失处理/安全/可访问性」的提示；当上一步流出的思考字符 ≥ 1600、或本轮累计超过 4000/8000 时，把下一个请求的思考强度降一档（最低 low、从不升档、每轮最多两次、工具报错后两步内不降）。每个请求都从用户当下的选择重新读基准，所以下一次请求就恢复。默认关闭：它是唯一会改变答案而不只是时延的开关。',
+    ),
+
+  lazyEffort: z
+    .boolean()
+    .default(true)
+    .description(
+      'lazy 的思考强度半边 / Lazy effort step-down: 设为 false 时 lazy 只发提示文字，一个请求字段都不写。对照臂，用来分辨收益来自提示词还是 provider 真的更低档；默认 true。',
+    ),
+
   preferPatch: z
     .boolean()
     .default(false)

package/src/effort.js

@@ -276,6 +276,15 @@ export function resolveConfig(raw, overrides) {
     finishLineSteps: gear.directive
       ? Math.max(0, Math.floor(number(config.finishLineSteps, 0)))
       : 0,
+    /**
+     * Lazy mode: the one switch that may cut deliberation instead of only round
+     * trips. Off by default, because it changes what the model thinks about and
+     * every other switch keeps the "same depth, sooner" promise. `lazyEffort:
+     * false` keeps the ladder text and the nudge but never rewrites effort, so
+     * the two halves can be measured apart.
+     */
+    lazy: gear.directive && config.lazy === true,
+    lazyEffort: gear.directive && config.lazy === true && config.lazyEffort !== false,
     /**
      * The stall guard, the one *hard* bound this plugin owns: it cancels a single
      * tool call at its deadline. On by default; `false` or a negative

package/src/lazy.js

@@ -0,0 +1,220 @@
+/**
+ * Lazy mode: the one switch in this plugin that is allowed to touch how much the
+ * model deliberates.
+ *
+ * Everything else here buys speed while holding effort still — the promise is
+ * "same depth, sooner". This module is the deliberate exception, and it is the
+ * only place in the package that rewrites `reasoningEffort`. It exists because
+ * a long turn loses time in a way parallelism cannot fix: the model keeps
+ * expanding a problem it has already understood. The idea is borrowed from
+ * `ponytail` — a lazy senior developer solves the whole problem with the least
+ * new code, and is lazy about the solution but never about the reading.
+ *
+ * Three mechanisms, cheapest first:
+ *
+ * 1. **The ladder, in the prompt.** One short text asks for the first rung that
+ *    works and a one-line "what I skipped". Cost is input tokens once per turn;
+ *    it changes nothing about the harness.
+ * 2. **The nudge.** When a turn's streamed reasoning passes a threshold without
+ *    a new tool result, one notice says so. It is observation, not policy: it
+ *    repeats what the transcript already proves.
+ * 3. **The effort step-down.** Only when a step visibly over-thought (the
+ *    streamed reasoner block is large) does the next request ask for one rung
+ *    less. It never goes below `FLOOR` (the user's own floor, `low`), never
+ *    fires twice in a row after an error, and is capped per turn.
+ *
+ * What is never cut, in this module or its text: validation at a trust boundary,
+ * error handling that protects data, security, accessibility, and the
+ * deliverable itself. `DIRECTIVE` says so explicitly, because a model told
+ * "write less" drops the wrong things first.
+ *
+ * ## Why the step-down keeps its own ledger
+ *
+ * The 0.9.x release lowered effort from step two of *every* turn. Measured
+ * later, that bought no wall clock on this route and did real damage: the
+ * rewrite reached the provider as a request header, so the composer showed an
+ * effort the user never chose, and it stayed there across restarts. So this
+ * module lowers effort only after evidence, restores the resolved value on the
+ * next request, and is off unless `lazy: true`.
+ */
+
+/** The prompt section. Short on purpose: it is paid on every request of a turn. */
+export const DIRECTIVE = `Work like a lazy senior developer: the best step is the one not taken.
+
+- Read before deciding. Trace the real flow of the code the change touches, then decide. Being lazy about the solution never means being lazy about the reading.
+- Once a step fully does the job, stop planning it. No option, abstraction, or "for later" code nobody asked for.
+- Take the first rung that works: what this repo already has, then the platform or a tool you already hold, then one line, then the minimum that works.
+- Never cut these to save code or time: validation where input crosses a trust boundary, error handling that protects data, security, accessibility, and the deliverable the user asked for.
+- End the turn with one line: what you skipped, and the risk that carries.`
+
+const DIRECTIVE_SUMMARY = 'lazy mode: first rung that works, no scope beyond the task'
+
+/** Reasoning rungs a route may name, weakest first. */
+export const EFFORT_RUNGS = Object.freeze(['minimal', 'low', 'medium', 'high', 'xhigh', 'max'])
+
+/**
+ * The lowest rung this module will ask for. Effort is the user's contract; a
+ * watchdog may spend a little of the headroom a high setting leaves, and stops
+ * where the default would have been.
+ */
+const FLOOR = 'low'
+
+/**
+ * Streamed reasoning characters in one step that count as over-thinking. On the
+ * measured route a normal step streams a few hundred characters and a step stuck
+ * on scope streams thousands, so this is deliberately not a tight bound.
+ */
+const HOT_CHARS = 1600
+
+/** Reasoning characters a turn may spend before the first nudge. */
+const NUDGE_CHARS = 4000
+
+/** How many notices one turn may receive. Two: one early, one late. */
+const MAX_NUDGES = 2
+
+/** How many effort reductions one turn may use. */
+const MAX_REDUCTIONS = 2
+
+/** Steps a reduction is off limits for after an error result (the step it fired on plus two). */
+const ERROR_COOLDOWN = 2
+
+/**
+ * The next rung down, or `undefined` when the value is not a rung this module
+ * understands (a route may use its own vocabulary — never guess at it) or is
+ * already at `FLOOR`.
+ *
+ * @param {string} value
+ * @returns {string | undefined}
+ */
+export function cheaperEffort(value) {
+  const at = EFFORT_RUNGS.indexOf(value)
+  if (at <= 0) return undefined
+  const floor = EFFORT_RUNGS.indexOf(FLOOR)
+  if (at <= floor) return undefined
+  return EFFORT_RUNGS[at - 1]
+}
+
+/** Per-session bookkeeping; one turn at a time is all a session runs. */
+const newTurn = () => ({
+  step: 0,
+  hot: false,
+  stepChars: 0,
+  turnChars: 0,
+  nudges: 0,
+  reductions: 0,
+  coolUntil: 0,
+  nudgedAt: 0,
+  reducedStep: -1,
+})
+
+/**
+ * Create the per-session ledger. Pure and dependency-free so the policy can be
+ * tested without a harness.
+ */
+export function createLazyWatch() {
+  return { runs: new Map() }
+}
+
+/** @param {{runs: Map<string, any>}} watch @param {string} sid */
+const runOf = (watch, sid) => {
+  let run = watch.runs.get(sid)
+  if (run === undefined) {
+    run = newTurn()
+    watch.runs.set(sid, run)
+    if (watch.runs.size > 64) watch.runs.delete(watch.runs.keys().next().value)
+  }
+  return run
+}
+
+/**
+ * Count streamed reasoning characters. Called from the stream tap, i.e. before
+ * the step ends, which is what makes the effort decision possible at all: the
+ * decision has to be made for the *next* request.
+ *
+ * @param {{runs: Map<string, any>}} watch @param {string} sid @param {number} chars
+ */
+export function noteReasoning(watch, sid, chars) {
+  if (!Number.isFinite(chars) || chars <= 0) return
+  const run = runOf(watch, sid)
+  run.stepChars += chars
+  run.turnChars += chars
+}
+
+/**
+ * Open a step: close the previous one's verdict, and say whether this step is
+ * the one that carries the ladder text.
+ *
+ * @param {{runs: Map<string, any>}} watch @param {string} sid
+ * @param {{turn?: number, step?: number, firstStep?: boolean}} where
+ * @returns {{directive?: string, nudge?: string} | undefined}
+ */
+export function beginStep(watch, sid, where) {
+  const run = runOf(watch, sid)
+  const step = Number.isFinite(where?.step) ? Math.floor(where.step) : run.step + 1
+  const newTurnStart = where?.firstStep === true || step <= 1
+  if (newTurnStart) {
+    const fresh = newTurn()
+    fresh.step = step
+    watch.runs.set(sid, fresh)
+    return { directive: DIRECTIVE }
+  }
+  // The previous step's streamed volume is the evidence the next request acts on.
+  run.hot = run.stepChars >= HOT_CHARS
+  run.stepChars = 0
+  run.step = step
+  const plan = {}
+  if (run.nudges < MAX_NUDGES && run.turnChars >= NUDGE_CHARS * (run.nudges + 1) && run.turnChars > run.nudgedAt) {
+    run.nudges += 1
+    run.nudgedAt = run.turnChars
+    run.hot = true
+    plan.nudge = `You have streamed about ${run.turnChars} characters of reasoning this turn. Use what you already have: decide, take the next rung, and say in one line what you skipped. Do not open a new line of investigation unless the last result contradicted an assumption.`
+  }
+  return Object.keys(plan).length === 0 ? undefined : plan
+}
+
+/**
+ * A tool result came back. An error is the one signal that the model may need
+ * *more* thinking, so it cancels any pending step-down for a couple of steps.
+ *
+ * @param {{runs: Map<string, any>}} watch @param {string} sid @param {{isError?: boolean}} observation
+ */
+export function noteToolResult(watch, sid, observation) {
+  if (observation?.isError !== true) return
+  const run = runOf(watch, sid)
+  run.hot = false
+  run.coolUntil = run.step + ERROR_COOLDOWN + 1
+}
+
+/**
+ * The effort this request should carry.
+ *
+ * Returns `base` untouched unless the ledger holds evidence: a hot previous
+ * step, no pending cooldown, budget left, and a base that is a rung above
+ * `FLOOR`. The caller must treat `effort === base` as "nothing happened".
+ *
+ * @param {{runs: Map<string, any>}} watch @param {string} sid
+ * @param {string | undefined} base - the effort the harness resolved.
+ * @returns {{effort: string | undefined, reduced: boolean}}
+ */
+export function planEffort(watch, sid, base) {
+  if (typeof base !== 'string') return { effort: base, reduced: false }
+  const run = runOf(watch, sid)
+  if (run.reducedStep === run.step) {
+    // One step, one reduction: a retry inside the same step must not walk the
+    // effort ladder down twice before anything has been measured again.
+    return { effort: base, reduced: false }
+  }
+  if (!run.hot || run.step < run.coolUntil || run.reductions >= MAX_REDUCTIONS) {
+    return { effort: base, reduced: false }
+  }
+  const cheaper = cheaperEffort(base)
+  if (cheaper === undefined) return { effort: base, reduced: false }
+  run.reductions += 1
+  run.reducedStep = run.step
+  return { effort: cheaper, reduced: true }
+}
+
+/** The notice body for the nudge, built where it is sent (see `index.js`). */
+export const NUDGE_SUMMARY = 'lazy mode: decide with what you have'
+
+export { DIRECTIVE_SUMMARY }

package/src/metrics.js

@@ -113,6 +113,21 @@ const chunkKind = (chunk) => {
   return typeof chunk.type === 'string' ? chunk.type : 'unknown'
 }
 
+/**
+ * The text a delta chunk carries. Adapters spell it `text` or `delta`; anything
+ * else is counted as zero characters rather than guessed at, so the column can
+ * be read as a lower bound and never as an estimate.
+ *
+ * @param {any} chunk
+ */
+const deltaText = (chunk) => {
+  if (!chunk || typeof chunk !== 'object') return ''
+  if (typeof chunk.text === 'string') return chunk.text
+  if (typeof chunk.delta === 'string') return chunk.delta
+  const nested = chunk.delta
+  return nested && typeof nested === 'object' && typeof nested.text === 'string' ? nested.text : ''
+}
+
 const payloadOf = (event) => {
   const data = event && typeof event === 'object' ? event.data : undefined
   return data && typeof data === 'object' ? data : (event ?? {})
@@ -144,7 +159,7 @@ export function createRecorder(options = {}) {
   const on = file.length > 0
   /** @type {Map<string, any>} */
   const steps = new Map()
-  /** @type {Map<string, {mode: string, gear: string, effort?: string, route?: string}>} */
+  /** @type {Map<string, {mode: string, gear: string, effort?: string, effortBase?: string, route?: string}>} */
   const labels = new Map()
   let prepared = false
 
@@ -205,6 +220,8 @@ export function createRecorder(options = {}) {
       calls: 0,
       errors: 0,
       seen: 0,
+      reasoningChars: 0,
+      textChars: 0,
     }
     steps.set(key, entry)
     trim(steps, STEPS_MAX)
@@ -222,8 +239,14 @@ export function createRecorder(options = {}) {
      * Tell the next step rows which stance produced them. Called from the
      * request hook, which is the only place that knows the resolved gear.
      *
+     * A call may carry only some fields: the omitted ones keep the session's
+     * previous value, so a later call cannot blank the gear it does not know
+     * about. `effortBase: null` is the one explicit clear, used when a step did
+     * *not* step down — without it the previous reduction would be attributed to
+     * every following row.
+     *
      * @param {string|undefined} sid
-     * @param {{mode: string, gear: string, effort?: string, route?: string}} label
+     * @param {{mode?: string, gear?: string, effort?: string, effortBase?: string|null, route?: string}} label
      */
     label(sid, label) {
       if (typeof sid !== 'string' || sid.length === 0) return
@@ -232,14 +255,19 @@ export function createRecorder(options = {}) {
       // 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
-      labels.set(sid, {
-        mode: label.mode,
-        gear: label.gear,
-        effort: label.effort,
-        route: label.route,
-      })
+      const next = {
+        mode: label.mode !== undefined ? label.mode : previous && previous.mode,
+        gear: label.gear !== undefined ? label.gear : previous && previous.gear,
+        effort: label.effort !== undefined ? label.effort : previous && previous.effort,
+        effortBase: label.effortBase === null
+          ? undefined
+          : label.effortBase !== undefined ? label.effortBase : previous && previous.effortBase,
+        route: label.route !== undefined ? label.route : previous && previous.route,
+      }
+      if (previous && previous.mode === next.mode && previous.gear === next.gear
+        && previous.effort === next.effort && previous.effortBase === next.effortBase
+        && previous.route === next.route) return
+      labels.set(sid, next)
       trim(labels, LABELS_MAX)
     },
 
@@ -302,6 +330,13 @@ export function createRecorder(options = {}) {
           }
           return
         }
+        // Streaming volume is the only live view of how much the model is
+        // deliberating: this route reports zero reasoning *tokens* in `usage`
+        // even when it streams a long reasoner block, so the character count is
+        // the measurement that can actually be compared across arms.
+        const carried = deltaText(data.chunk)
+        if (chunkType === 'reasoning-delta') entry.reasoningChars += carried.length
+        else if (chunkType === 'text-delta') entry.textChars += carried.length
         if (entry.chunkFirst === undefined) {
           entry.chunkFirst = time
           entry.chunkKind = chunkType
@@ -354,6 +389,7 @@ export function createRecorder(options = {}) {
         mode: label ? label.mode : 'unknown',
         gear: label ? label.gear : 'unknown',
         effort: label ? label.effort : undefined,
+        effortBase: label ? label.effortBase : undefined,
         route: label ? label.route : undefined,
         // `ttftMs` is queue + prefill: `step/start` to the first streamed chunk.
         // `decodeMs` is the generation window that follows it. `llmMs` stays the
@@ -370,6 +406,8 @@ export function createRecorder(options = {}) {
         input: entry.input,
         output: entry.output,
         reasoning: entry.reasoning,
+        reasoningChars: entry.reasoningChars,
+        textChars: entry.textChars,
         cacheRead: entry.cacheRead,
         cacheWrite: entry.cacheWrite,
         assistantMessages: entry.seen,

package/src/state.js

@@ -14,7 +14,7 @@
  *   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
+ *   enabled, gear, discipline, stepBudget, map, batch, lazy, ts } }` as a compact JSON
  *   string. It is volatile, so a write lands in the running plugin without a
  *   remount.
  *
@@ -107,6 +107,7 @@ function sanitise(input) {
     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 (typeof entry.lazy === 'boolean') clean.lazy = entry.lazy
     if (Number.isFinite(entry.ts)) clean.ts = Number(entry.ts)
     if (
       clean.enabled === undefined
@@ -115,6 +116,7 @@ function sanitise(input) {
       && clean.stepBudget === undefined
       && clean.map === undefined
       && clean.batch === undefined
+      && clean.lazy === undefined
     ) continue
     out[sessionId] = clean
   }
@@ -140,6 +142,7 @@ export function choiceFor(raw, sessionId) {
   if (entry.stepBudget !== undefined) choice.stepBudget = entry.stepBudget
   if (entry.map !== undefined) choice.map = entry.map
   if (entry.batch !== undefined) choice.batch = entry.batch
+  if (entry.lazy !== undefined) choice.lazy = entry.lazy
   return choice
 }
 
@@ -165,6 +168,7 @@ export function configOverridesFor(raw, sessionId) {
   if (choice.stepBudget !== undefined) overrides.stepBudget = choice.stepBudget
   if (choice.map !== undefined) overrides.workspaceMap = choice.map
   if (choice.batch !== undefined) overrides.openBatch = choice.batch
+  if (choice.lazy !== undefined) overrides.lazy = choice.lazy
   return Object.keys(overrides).length === 0 ? undefined : overrides
 }
 
@@ -215,11 +219,13 @@ export function writeChoice(raw, sessionId, choice, now) {
   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
+  if (typeof choice.batch === 'boolean') next.batch = choice.batch
+  if (typeof choice.lazy === 'boolean') next.lazy = choice.lazy
   map[sessionId] = next
   return { sessions: encodeChoices(map), map }
 }
 
-/** @typedef {{enabled?: boolean, gear?: string, discipline?: boolean|'late', stepBudget?: number, map?: boolean, batch?: boolean, ts?: number}} SessionEntry */
+/** @typedef {{enabled?: boolean, gear?: string, discipline?: boolean|'late', stepBudget?: number, map?: boolean, batch?: boolean, lazy?: boolean, ts?: number}} SessionEntry */
 
 /**
  * Serialise the map, dropping the oldest entries beyond {@link SESSIONS_LIMIT}.