dsh-gokifu-compact 1.11.2 → 1.11.3

package/CHANGELOG.md

@@ -1,5 +1,71 @@
 # 更新记录
 
+## 1.11.3 — 2026-10-31
+
+### P0-1 · `exit` 判据收紧：不再被正文子串误判
+
+旧实现用 `slice(-200)` 在尾部 200 字符里**子串搜索** `[exit code: N]` ⇒ 命令**输出正文里提到**这串就误判成「有退出码」，
+且「标记之后还有输出」时前后结论不一致。
+
+- 新增 `lastLineExitCode()`：取**末条非空行**，**整行等于** `[exit code: N]` 才算有退出码；否则视为 no-exit。
+- `verify.mjs` 顶部注释同步；`_internal` 导出 `LOCAL_MUTATE_TOOLS` / `lastLineExitCode`。
+- 测试 +3（`verifier` OPT-V-1 / OPT-V-2、`weak-shell` S2b-14）；变异：退回 `slice(-200)` ⇒ OPT-V-1 变红。
+
+### P0-2 · `local-mutate` 从只读表拆出（不再被当成「只读工具」）
+
+`todo_write` / `update_goal` / `create_goal` / `hindsight_ingest_document` / `team_task_*` / `send_message` /
+`spawn_teammate` / `subagent` / `schedule_*` / `job_kill` … 这些**会改状态但不是文件写**的工具，原先把它们混在只读表里，
+分类结果自相矛盾。现在：
+
+- 新增 `LOCAL_MUTATE_TOOLS`；`toolClass()` 返回 **`local-mutate`**（与 `read-only` / `write` 并列）
+- `classify()` 对 local-mutate 给 **`unverified` + kind `none`，且不带 `weak`**（它既不是「进展」也不是「失败」）
+- `WRITE_TOOLS` / `present` 与 `isError` 的**优先级不变**
+- 变异：把 local-mutate 放回只读表 ⇒ S2b-14 + OPT-V-2 变红
+
+### 外部入口 · 新增 `dsh-gokifu-compact/graph` 与 `/persist`
+
+1.11.2 的 README 教外部工具去读 `node_modules/dsh-gokifu-compact/src/rooms/kifu-model.mjs` —— 那是**深层路径**，
+`exports` 里没有 ⇒ 现代 ESM 解析会直接拒绝。现在补两个正式入口：
+
+| 入口 | 目标 | 用途 |
+|---|---|---|
+| `dsh-gokifu-compact/graph` | `src/rooms/kifu-model.mjs` | `fromJSON` / `toJSON` / `decodeDeltaFrames` / `applyDelta` / `renderIndexMd` … |
+| `dsh-gokifu-compact/persist` | `src/rooms/kifu-persist.mjs` | `graphRoot` / `sessionPaths` / `createPersistStore` / `load` / `flush` … |
+
+- 新增 `test/package-exports.test.mjs`（**7 条**）：声明齐全、子路径可解析、真实 `import` 成功、导出面非空、不泄漏内部路径
+- README 的「怎么拿最新状态」一行改为指向这两个入口
+
+### 零失败边最小注入（OPTIONS 之后又一刀「别让热清单吃白饭」）
+
+**问题**：只读统计 **167 个真实会话**，**42 个（25.1%）零失败边** —— 它们照样要付一份完整热清单的 token。
+
+**改法**：
+
+- `ledger.mjs` 新增 `renderMinimalLedger`：`<chess-ledger>` 内只有三行 —— `GOAL` / `CONSTRAINTS: N` / `NO_FAILED_ATTEMPTS_YET`；
+  **`renderLedger` 一个字节不动**（167 会话新旧对比 `byteDiff=0`）
+- `hot-inject.decideInjection`：零失败边且 `hasLedgerState` ⇒ 用最小渲染走**原注入流程**（digest / 限流 / replace / fold 补回全不变）；空图仍 `skip no-ledger`
+- 实测（42 个零失败会话）：最小注入 **avg 25.4 tok / max 57**（同批会话的完整最小档 avg 386 / max 497）
+- 分布：root 覆盖 **42/42**、constraints **32/42**、完全空 **0**（不会出现「三行全空」的哑注入）
+- 测试 +4：OPT-E-1 触发与三项内容 / OPT-E-2 空图 skip / OPT-E-3 有失败边时字节不变（sha 钉死）/ OPT-E-4 fold 补回
+- 变异：零失败退回 skip ⇒ E-1/E-4 红；删 `NO_FAILED_ATTEMPTS_YET` 行 ⇒ E-1/E-4 红
+
+### tier-2 行为矩阵
+
+- 新增 `test/tier2.test.mjs`（**6 条**，engine 零改动）+ `engine-harness` 导出 4 个 helper —— 把此前「文档说有、代码没测」的第二档行为逐条核实。
+
+### 验证
+
+- 全量：**463 passed / 0 failed**（36 个测试文件；443 + 7 exports + 3 verify + 6 tier2 + 4 hot-inject）
+- `rooms` **15/0** · `hot-inject` **12/0** · `verify-install` **16/16**
+- `bench 2000`：**351 tokens** / 1.336 ms（81,260 / 386,945 字符、1.41 MB、2001 节点）
+- `npm pack --dry-run --json`：**70 文件**（数量不变）/ 562,344 B；`test/`·`tmp/` 命中 0
+
+**未验证（必须知道）**
+
+- 最小注入的**运行期收益未在真机观测** —— 25.4 tok 是离线夹具口径，167 会话统计是只读扫描。
+- tier-2 矩阵跑在假 ctx 上，不是真机行为。
+- README 里的「真实包 8/8 †」「真实进程 fold 3~6/6 †」带 **†** = 历史口径，**本版未复跑**。
+
 ## 1.11.2 — 2026-10-30
 
 ### 本包改成 DSH bundle（UI 挂载不再需要用户手改 YAML）

package/README.md

@@ -1,20 +1,24 @@
 # dsh-GOkifu-compact
 
-> 当前版本：**`1.11.2`** · npm [`dsh-gokifu-compact`](https://www.npmjs.com/package/dsh-gokifu-compact) · [GitHub Releases](https://github.com/MYCF711/dsh-GOkifu-compact/releases) · 更新记录见 [CHANGELOG.md](CHANGELOG.md)
+> 当前版本：**`1.11.3`** · npm [`dsh-gokifu-compact`](https://www.npmjs.com/package/dsh-gokifu-compact) · [GitHub Releases](https://github.com/MYCF711/dsh-GOkifu-compact/releases) · 更新记录见 [CHANGELOG.md](CHANGELOG.md)
 
-**DSH 的棋谱式上下文压缩后端 —— 把「历史 → 一段摘要」换成「历史 → 可复盘的棋谱 DAG + 每步只有 323 tokens 的热清单」。**
+**DSH 的棋谱式上下文压缩后端 —— 把「历史 → 一段摘要」换成「历史 → 可复盘的棋谱 DAG + 每步只有 351 tokens 的热清单」。**
 
 ```
-热清单     323 tokens       （2000 边压力测试；旧版全量渲染 28,800）
-失败保留   8 / 8            （真实模型对照；官方 8 段模板 4.67 / 8）
-清单开销   0.2% of prompt   （v1.3.1 起；事故会话的旧版是 21.3%）
-验证       443 项单测 · 真实包 8/8 · 真实进程 fold 3~6/6
+热清单     351 tokens       （2000 边合成夹具 · L5 降级档 · 2026-10-30/10-31 两次实测同值；旧版全量 28,800）
+失败保留   8 / 8            （历史口径 †；官方 8 段模板 4.67 / 8）
+清单开销   未复现/待测       （原载 0.2% = 历史单会话 v1.3.1 后实测；无复跑命令、无对照组；源 evidence/真实计费核对.md）
+验证       463 项单测 · 真实包 8/8 † · 真实进程 fold 3~6/6 †
 ```
 
 GO = 围棋，kifu = 棋谱，compact = 压缩。一局棋下完，棋谱上不只有落子顺序，还有每一手的评语。
 这个插件把 agent 的每一步变成一手棋（节点）、把当时的思考变成评语（目标 / 约束 / 失败原因），
 整个任务变成一局可以复盘的棋。**棋谱是给模型用的，不是给人看的** —— 热清单里的每个字都为模型决策服务。
 
+> **† 历史口径（未复现）**：`失败保留 8/8`、`真实包 8/8`、`真实进程 fold 3~6/6` 都是**早期真机测量**，**本轮没有复跑命令、没有复现**，不要当现行指标引用。
+>
+> **351 tokens 的口径**：这是 **2000 边合成夹具**在 **L5 降级档**下的结果，**不是真实会话均值**。真实会话里预算按 `字符数/3` 估算，实测**系统性低估 5.2%~22.1%（中位 9.7%）**（见 `计划表.md` 的 OPT-TOKENS 节）；**真实会话口径尚未校准** —— 正解是引入宿主 tokenizer（`ctx.tokenMeter`）后重测，**未做**。
+
 ---
 
 ## 功能
@@ -48,7 +52,7 @@ GO = 围棋，kifu = 棋谱，compact = 压缩。一局棋下完，棋谱上不
 | 压缩范围 | 从 surface 第一个非 system 节点起（**含上次 checkpoint**） | 上一个 checkpoint **之后** |
 | 保留率 | 每轮重摘 → 按 ρ^k 衰减（实测安全规则 5 轮后剩 10%） | 一段内容只摘一次 |
 | 失败记录 | 融进散文摘要，模型可以丢 | 规则抽取 + 逐字注入，模型无权丢 |
-| 热上下文 | 无 | 323 tokens / 步，带语义标记与报错原文 |
+| 热上下文 | 无 | 351 tokens / 步（**2000 边合成夹具 · L5 降级档**；真实会话口径未校准），带语义标记与报错原文 |
 
 ### ⚠ 棋谱落盘：`graph.json` 的语义（1.9.2 起）
 
@@ -67,7 +71,7 @@ graph.json = 最新             graph.json              = 上一个回合边界
 
 | 你要什么 | 怎么拿 |
 |---|---|
-| **最新状态**（推荐） | **基线 + 增量一起读**：`fromJSON(graph.json 文本)` → 用基线内容哈希 `decodeDeltaFrames(delta 文本, baseHash)` → 逐帧 `applyDelta(g, frame)`。三个函数都在 `src/graph.mjs`（插件源码随包发布：`node_modules/dsh-gokifu-compact/src/graph.mjs`） |
+| **最新状态**（推荐） | **基线 + 增量一起读**：`fromJSON(graph.json 文本)` → 用基线内容哈希 `decodeDeltaFrames(delta 文本, baseHash)` → 逐帧 `applyDelta(g, frame)`。三个函数都从包入口 `dsh-gokifu-compact/graph` 导出（源码 `src/rooms/kifu-model.mjs`，随包发布）；落盘/读盘侧（`graphRoot` / `sessionPaths` / `createPersistStore` 等）走 `dsh-gokifu-compact/persist` |
 | 上一回合基线（做 diff / 审计） | 直接读 `graph.json` 可以，但**要说明「这是基线不是最新」** |
 | 崩溃安全 | 每帧带 `baseHash`（generation）+ `checksum31`：半写帧解码时就地停止，加载时把 delta 截到最后一条好帧；**旧 generation 的帧整体忽略** |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-gokifu-compact",
-  "version": "1.11.2",
+  "version": "1.11.3",
   "description": "DSH context-compression backend with a go game record (kifu) DAG: node = position, edge = attempted move + result. Incremental fold (each span summarized once), failure memory that survives compaction, transposition detection (chess-engine style), and a tiny hot ledger rebuilt every step.",
   "repository": {
     "type": "git",
@@ -19,6 +19,8 @@
     },
     "./engine": "./src/engine.mjs",
     "./client": "./lib/client.js",
+    "./graph": "./src/rooms/kifu-model.mjs",
+    "./persist": "./src/rooms/kifu-persist.mjs",
     "./package.json": "./package.json",
     "./cordis.patch.yml": "./cordis.patch.yml"
   },

package/src/rooms/hot-inject.mjs

@@ -25,7 +25,7 @@
  */
 
 import { failureEdges, sha } from "./kifu-model.mjs";
-import { renderLedger } from "./ledger.mjs";
+import { renderLedger, renderMinimalLedger } from "./ledger.mjs";
 
 /** 限流：两次注入至少隔这么多事件。 */
 export const INJECT_MIN_EVENTS = 40;
@@ -47,6 +47,17 @@ export function messageText(message) {
     .join("\n");
 }
 
+/**
+ * ★ OPT-EMPTY（task-130）：这张图有没有「值得注入」的最小状态？
+ * 空图（连 root / agent / constraints 都没有）⇒ 仍然 skip，不拿一行空壳占位。
+ */
+export function hasLedgerState(graph) {
+  const nodes = graph?.nodes ?? {};
+  if ((graph?.rootUserNodeIds ?? []).some((id) => nodes[id])) return true;
+  if (Object.values(nodes).some((n) => n?.kind === "agent" && (n.goal || n.worldHash))) return true;
+  return Object.values(nodes).some((n) => (n.constraints ?? []).length > 0);
+}
+
 /**
  * 热上下文的「骨架摘要」：只由失败边 + 根目标 + 约束决定。
  * 不含 CURRENT PATH / CURRENT GOAL —— 它们每一步都变，用整段文本做 digest
@@ -187,14 +198,23 @@ export function decideInjection({
     // ★ 2026-10-29（三份评估共同的 P0-2）：压缩「连续失败」必须被看见。
     //   一条失败边都没有时也要注入 —— 「没有失败边 + 压缩坏了」才是最危险的组合。
     const warning = foldFailureWarning(state);
-    if (failureEdges(graph).length === 0 && warning === "") return { decision, action: "skip", reason: "no-ledger" };
+    // ★ OPT-EMPTY（task-130）：零失败边 **不再整段跳过** —— 26% 的真实会话没有任何失败边，
+    //   旧逻辑让它们连根目标/约束都拿不到。现在仍然走 renderLedger（零失败时它输出
+    //   ROOT / CONSTRAINTS / CURRENT GOAL / WORKING + 一行 NO_FAILED_ATTEMPTS_YET）；
+    //   只有**空图**（无 root / 无 agent / 无约束）才 skip。
+    //   限流与 digest 全部沿用既有规则：digest = 根目标 + 约束（零失败时天然稳定），
+    //   同源且清单还在 ⇒ same-digest skip；被 fold 遮蔽 ⇒ lostToFold 补回。
+    const zeroFailure = failureEdges(graph).length === 0 && warning === "";
+    if (zeroFailure && !hasLedgerState(graph)) return { decision, action: "skip", reason: "no-ledger" };
 
-    const ledger = renderLedger(graph, {
-      maxTokens: config.hotLedgerMaxTokens ?? 500,
-      markers: config.hotLedgerMarkers,
-      treeDir: sessionDir,
-      traceRoot: config.hotLedgerTraceRoot,
-    });
+    const ledger = zeroFailure
+      ? renderMinimalLedger(graph, { maxTokens: config.hotLedgerMaxTokens ?? 500 })
+      : renderLedger(graph, {
+          maxTokens: config.hotLedgerMaxTokens ?? 500,
+          markers: config.hotLedgerMarkers,
+          treeDir: sessionDir,
+          traceRoot: config.hotLedgerTraceRoot,
+        });
     // ★ P7：消费 fallback（over-budget 记 warn + overBudgetBy；impossible 记 error），并落盘给 doctor。
     try {
       onBudget(ledger, session);

package/src/rooms/ledger.mjs

@@ -768,6 +768,49 @@ export function renderLedger(g, { maxTokens = 500, tailFailures = 20, markers =
   };
 }
 
+/**
+ * ★ OPT-EMPTY（task-130）：**零失败边**会话的最小注入内容。
+ *
+ * 背景：真实 167 个会话里 42 个（25.1%）没有任何失败边 —— 旧版 `decideInjection` 直接
+ * `skip("no-ledger")`，这些会话连根目标/约束都拿不到。但它们**不是空的**：42/42 有 root，
+ * 32/42 有 constraints（见 ws-opt-empty-ledger/REPORT.md 的只读统计）。
+ *
+ * 为什么不用 `renderLedger` 的最小档：那档仍会带 ROOT 原文，实测 42 个零失败会话
+ * avg 386 tok / max 497 —— 对「没有任何失败记忆」的会话是纯噪声。
+ * 这里只给三行事实（仍是既有的 `<chess-ledger>` 包裹，不是新的消息格式）：
+ *   GOAL: …            （有 goal 用 goal，否则用 root 原话）
+ *   CONSTRAINTS: N     （数量，不展开原文）
+ *   NO_FAILED_ATTEMPTS_YET
+ *
+ * @returns {{text:string, tokens:number, level:number, omittedEdges:number, failureCount:number, shownFailures:number, fallback:string, budgetMax:number, overBudgetBy:number}}
+ */
+export function renderMinimalLedger(g, { maxTokens = 500 } = {}) {
+  const root = g?.rootNode ?? (g?.rootUserNodeIds ?? []).map((id) => g?.nodes?.[id]).filter(Boolean)[0];
+  const latest = latestAgentNode(g);
+  const goalText = clip(String(latest?.goal ?? root?.text ?? "").replace(/\s+/g, " ").trim(), 120);
+  const constraints = root?.constraints ?? [];
+  const lines = ["<chess-ledger>"];
+  if (goalText) lines.push(`GOAL: ${goalText}`);
+  lines.push(`CONSTRAINTS: ${constraints.length}`);
+  lines.push("NO_FAILED_ATTEMPTS_YET");
+  lines.push("</chess-ledger>");
+  const text = lines.join("\n");
+  const tokens = estimateTokens(text);
+  const over = Math.max(0, tokens - maxTokens);
+  return {
+    text,
+    tokens,
+    level: 5,
+    omittedEdges: 0,
+    failureCount: 0,
+    shownFailures: 0,
+    fallback: over > 0 ? "over-budget" : "none",
+    budgetMax: maxTokens,
+    overBudgetBy: over,
+    minimal: true,
+  };
+}
+
 /**
  * L4/L5 的裁决（C-17）。两个兜底档都可能越过预算，选的时候按三层优先：
  *   1. 预算内优先（`tokens <= maxTokens`）；

package/src/rooms/verify.mjs

@@ -12,8 +12,9 @@
  *
  *   现在的分层（顺序即优先级）：
  *     ① isError（宿主标记）                → failure（任何工具）
- *     ② 有 [exit code: N]：N≠0 → failure；N=0 → success（**最终裁决**）
- *     ②.b shell 但没有退出码                → unverified（**不猜**：输出可以是任何东西）
+ *     ①.b local-mutate（本地状态写入类）    → unverified + kind:"none"，**不带 weak**
+ *     ② 末条非空行**精确**是 [exit code: N]：N≠0 → failure；N=0 → success（**最终裁决**）
+ *     ②.b shell 但没有精确退出码             → unverified（**不猜**：输出可以是任何东西）
  *     ③ 非 shell：N passed / N failing      → success / failure
  *     ④ 非 shell：行首错误行                → failure
  *     ④.b 只读工具：行首硬错误（ENOENT…）    → failure（注释里的 EACCES 不算）
@@ -26,10 +27,15 @@
  *   为什么改这里而不是新加判据：`verify.kind === "read"` 就是 classify 自己给出的
  *   「只读工具、没抓到外部验证信号」的判定（toolClass 的显式表 + MCP query/mutate 词形），
  *   旧图里已经落盘了这个字段 —— 复用它，就不必在渲染阶段重新猜工具名。
- *   ⚠ 已知局限（实测）：toolClass 的只读表里混着 `todo_write` / `hindsight_ingest_document`
- *   这类「实际会改本地状态」的工具（25 个最新会话 641 条只读结果里 48 条，7.5%）。
- *   它们被标 weak 的语义仍然成立（工具自报无错、但无外部验证），但标记文案只用 `[weak]`，
- *   不说 "read-only"，避免把写操作说成读。
+ *
+ * ★ OPT-VERIFY（task-124）：上面那条「已知局限」已修 —— `todo_write` / `update_goal` /
+ *   `create_goal` / `hindsight_ingest_document` / `team_task_*` / `send_message` / `schedule_*` /
+ *   `job_kill` / `spawn_teammate` / `subagent` 这些**会改本地状态**的工具，已从只读表拆到
+ *   `LOCAL_MUTATE_TOOLS`（toolClass → `local-mutate`），classify 给
+ *   `result:"unverified"` + `kind:"none"` 且**不带 weak** ⇒ 不再进 WORKING 路径。
+ *   `weak:"read"` 现在只属于真正只读的工具（read / grep / web_fetch / list_* 等）。
+ *   兼容：旧图里这些工具已落盘 `kind:"read"` + `N chars`，`weakKindOf` 仍按旧形态识别它们
+ *   （历史数据不改写；新产生的边不再这样标）。
  *
  * 纯函数，零依赖，可单测。
  */
@@ -37,12 +43,37 @@
 const READ_ONLY_TOOLS = new Set([
   "read", "read_file", "glob", "grep", "ls", "list", "list_dir", "find",
   "web_search", "web_fetch", "read_page", "read_image", "library_search",
-  "todo_write", "todo_read", "todo_list", "ask_user_question",
-  "get_goal", "update_goal", "create_goal", "exit_plan_mode",
+  "todo_read", "todo_list", "ask_user_question",
+  "get_goal",
   "skill", "load_workspace_dependencies", "list_agents", "list_subagent_models",
   "job_list", "job_output", "team_task_list", "team_task_get",
 ]);
 
+/**
+ * ★ OPT-VERIFY（task-124）：**本地状态写入类**工具 —— 既不是只读，也不是仓库写入。
+ *
+ * 它们不产生外部验证信号（没有 exit code / 测试计数 / diff），但**确实改了本地状态**
+ * （todo 列表、goal、记忆库、任务板、消息、定时任务、子 agent、job）。
+ * 旧版把它们混在 `READ_ONLY_TOOLS` 里 ⇒ 走 ⑥ 兜底分支拿到 `weak:"read"`，
+ * 于是热清单的 WORKING 路径会把「写了一条 todo」当成「读过一眼的弱成功」——
+ * 25 个最新会话 641 条只读结果里 48 条（7.5%）正是这种形态（S2a 注释里已记为已知局限）。
+ *
+ * 现在的语义：`toolClass` 返回 **`local-mutate`**，`classify` 给
+ * `result:"unverified"` + `kind:"none"`，**不带任何 weak** —— 不进 WORKING 路径，
+ * 也不进 success / failureEdges / facts / tewari。
+ *
+ * ⚠ 与 `WRITE_TOOLS` 的区别：`WRITE_TOOLS` 是**仓库写入**（write / edit / present …），
+ * 它们的回执本身算成功信号（`kind:"write"` / `kind:"diff"`），**本刀一个字不改**。
+ */
+const LOCAL_MUTATE_TOOLS = new Set([
+  "todo_write", "update_goal", "create_goal", "exit_plan_mode",
+  "hindsight_ingest_document", "hindsight_capture_initiative",
+  "team_task_create", "team_task_update", "team_task_delete",
+  "send_message", "spawn_teammate", "subagent", "subagent_fork", "subagent_role",
+  "schedule_create", "schedule_update", "schedule_delete",
+  "job_kill", "job_start",
+]);
+
 const WRITE_TOOLS = new Set([
   "write", "edit", "write_file", "edit_file", "apply_patch", "multi_edit",
   "str_replace", "create_file", "delete_file", "notebook_edit", "present",
@@ -58,6 +89,8 @@ export function toolClass(name) {
   const n = raw.toLowerCase();
   if (SHELL_TOOLS.has(n)) return "shell";
   if (WRITE_TOOLS.has(n)) return "write";
+  // ★ 顺序要紧：local-mutate 必须排在 read 之前，否则这些工具又会被当只读。
+  if (LOCAL_MUTATE_TOOLS.has(n)) return "local-mutate";
   if (READ_ONLY_TOOLS.has(n)) return "read";
   const isMcp = n.startsWith("mcp__") || n.includes("__") || n.startsWith("hindsight_") || n.startsWith("bili_");
   if (isMcp) return MUTATE_RE.test(n) && !QUERY_RE.test(n) ? "mcp-write" : "mcp-read";
@@ -75,7 +108,28 @@ const ERR_LINE_RE = /^\s*(?:bash: line \d+: )?(?:Error:|error:|ERROR:|Exception\
 /** 行首硬错误（只读工具也认——读一个不存在的文件）。 */
 const HARD_LINE_RE = /^\s*(?:ENOENT|EACCES|EPERM|ETIMEDOUT|ECONNREFUSED|No such file|Permission denied|Error:|error:|Traceback|Cannot find module|MODULE_NOT_FOUND)/;
 
-const EXIT_RE = /\[exit code:\s*(-?\d+)\]/;
+/**
+ * ★ OPT-VERIFY（task-124）：退出码 marker 必须**独占最后一条非空行**（允许行内前后空白）。
+ *
+ * 旧写法 `EXIT_RE.exec(body.slice(-200))` 双向都有错：
+ *   ① 只搜末尾 200 字符 ⇒ 标记之后还有别的输出时，**真退出码直接丢失**（判成 no-exit）；
+ *   ② 只要落在末尾 200 字符内就命中 ⇒ `cat` 出来的源码里写着 `const text = "[exit code: 1]" + …`
+ *      这种**正文子串**会被误当成命令退出码（独立复核活证据 e8）。
+ * 现在的判据只有一条：末条非空行整行等于 `[exit code: N]`；否则一律 no-exit（**不猜**）。
+ */
+const EXIT_LINE_RE = /^\s*\[exit code:\s*(-?\d+)\]\s*$/;
+
+/** 末条非空行的精确退出码；不是精确 marker ⇒ `null`。 */
+export function lastLineExitCode(body) {
+  const lines = String(body ?? "").split("\n");
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    if (lines[i].trim().length === 0) continue;
+    const m = EXIT_LINE_RE.exec(lines[i]);
+    return m === null ? null : Number(m[1]);
+  }
+  return null;
+}
+
 const TEST_PASS_RE = /(\d+)\s+(?:passed|passing|tests? passed|个?通过)|all tests passed|0 failing/i;
 const TEST_FAIL_RE = /\b([1-9]\d*)\s+(?:failed|failing|个?失败|errors?)\b/i;
 const DIFF_RE = /(\d+)\s*(?:insertions?\(\+\)|deletions?\(-\))/;
@@ -224,6 +278,7 @@ export function classify({ tool, text, isError = false }) {
   const body = String(text ?? "");
   const cls = toolClass(tool);
   const readOnly = cls === "read" || cls === "mcp-read";
+  const localMutate = cls === "local-mutate";
 
   if (isError) {
     return {
@@ -233,16 +288,29 @@ export function classify({ tool, text, isError = false }) {
     };
   }
 
+  // ★ OPT-VERIFY（task-124）：本地状态写入类工具（todo_write / update_goal / send_message /
+  //   team_task_update / hindsight_ingest_document …）没有外部验证信号，也**不是**「读了一眼」。
+  //   ⇒ unverified + kind:"none" + **不带 weak**：不许进 WORKING 路径，更不许当进展证据。
+  //   放在 isError 之后、shell 之前：宿主报错仍然是 failure（isError 优先级最高，不变）。
+  if (localMutate) {
+    return {
+      result: "unverified",
+      verify: { kind: "none", summary: body ? `${body.length} chars` : "empty" },
+      errorSnippet: "",
+    };
+  }
+
   // ★ 退出码只对 shell 有意义。真实踩坑：`read` 读一个包含 `[exit code: 1]` 字样的测试文件，
   //   旧逻辑会把那行字当成「这个 read 的退出码」→ 整条 read 被判 failure。
   //   read/write/mcp 工具的输出是**内容**，不是执行结果。
   if (cls === "shell") {
     // P1-7：退出码只看**末尾**。DSH 把 `[exit code: N]` 追加在结果最后；
-    //   从全文第一处匹配会抓到输出正文里的字样（比如 sed 打印的测试文件里写着 `[exit code: 1]`），
-    //   把一条 exit 0 的命令判成失败（真实日志里 e119/e189/e227 都是这么误报的）。
-    const exit = EXIT_RE.exec(body.slice(-200));
-    if (exit) {
-      const code = Number(exit[1]);
+    // P1-7 → OPT-VERIFY（task-124）：判据从「末尾 200 字符里搜到 marker」改成
+    //   **末条非空行整行等于 `[exit code: N]`**。旧写法两头都错：标记后面还有输出时真退出码丢失；
+    //   正文里恰好出现 `[exit code: 1]` 子串时误判失败（复核活证据 e8）。
+    //   不是精确 marker ⇒ 走下面的 no-exit（**不猜**）。
+    const code = lastLineExitCode(body);
+    if (code !== null) {
       if (code !== 0) {
         return { result: "failure", verify: { kind: "exit", summary: `exit ${code}` }, errorSnippet: errorSnippet(body) };
       }
@@ -322,4 +390,4 @@ function firstLine(text) {
   return line.trim().slice(0, 160);
 }
 
-export const _internal = { READ_ONLY_TOOLS, WRITE_TOOLS, SHELL_TOOLS, firstLine, HARD_ERR_RE, ERR_LINE_RE, HARD_LINE_RE };
+export const _internal = { READ_ONLY_TOOLS, LOCAL_MUTATE_TOOLS, WRITE_TOOLS, SHELL_TOOLS, firstLine, lastLineExitCode, HARD_ERR_RE, ERR_LINE_RE, HARD_LINE_RE };