dsh-gokifu-compact 1.11.2 → 1.11.4

package/CHANGELOG.md

@@ -1,5 +1,119 @@
 # 更新记录
 
+## 1.11.4 — 2026-10-31
+
+### 发布脚本加固：坏 remote 在预演阶段就红，git 步骤事务化
+
+**背景是一起真实事故**：1.11.3 发布时 `scripts/release.mjs --yes --npm` 返回 **EXIT 1** ——
+仓库 `remote.origin.url` 被写成 `git+https://…`（那串正是 `package.json` 的 `repository.url`，
+在 npm 里是规范写法，**但不是合法的 git remote**）。旧体检用正则匹配 `github.com:` 照样通过；
+真做时 `git push` 全崩，**而脚本继续建 Release、继续 `npm publish`**，留下
+「npm 已发 / Release 已建 / main 没推 / tag 指向旧 commit」的半途状态。
+
+**新增 `scripts/release-lib.mjs`**（纯逻辑、可单测、零副作用）
+
+| 导出 | 作用 |
+|---|---|
+| `parseRepo(url)` | 只认 scp 式 `git@github.com:o/r(.git)`、`ssh://git@github.com/o/r`、`https://github.com/o/r`；`git+*`、`file://`、非 GitHub、空 → `null` |
+| `classifyRemote(url)` | **先判 scheme 再判仓库**；`git+…` 直接拒，并给出可执行的修法（`git remote set-url origin git@github.com:<owner>/<repo>.git`） |
+| `runTransaction(steps)` | 顺序执行 + **首步失败即中止**，返回 `{ok, done, failed, error, aborted}` |
+
+**`scripts/release.mjs` 体检从 5 项增到 8 项**
+
+- ⑤ **remote 必须是合法 GitHub URL**（不再「正则匹配到 github.com 就算过」）
+- ⑥ **`git ls-remote --heads origin` 必须成功** —— 远端不可达直接红
+- ⑦ **`git fetch` 失败从 note 改成 red** —— 旧版把「不知道远端正不正常」当成「跳过检查继续发版」
+- ⑧ **tag 已存在时区分两种情况**：指向本 commit ⇒「不能发两次」；**指向别的 commit**（1.11.3 的现场：Release API 自动建了轻量 tag）⇒ **不自动 force**，报错并给 `git push --force origin refs/tags/<tag>:refs/tags/<tag>` 的人工修法
+
+**真做改成事务**：`runTransaction([push 分支, tag -a && push tag])` → 任一失败即 `abort()`，
+打印「已完成 / 未执行：tag · npm · Release」；**`npm publish` 移到 Release 之前** ——
+npm 失败就不建 Release（避免「Release 说有、npm 上没有」）；Release 失败仍 exit 1。
+
+**`scripts/check-maintenance.mjs` 也补了两项**（日常维护就能提前发现）
+
+- ⑧ `remote.origin` 必须是合法 GitHub URL（复用 `classifyRemote`，同一份判据）
+- ⑨ `git rev-parse --show-toplevel` 必须等于 cwd（防串仓 —— `ROOT` 取 `process.cwd()`，
+  在子目录或别人的仓库里跑会把版本号/CHANGELOG/tag 写错对象而看起来一切正常）
+
+**验证**
+
+- 全量：**473 passed / 0 failed**（36 个测试文件；463 + 10 条 `release-hardening`）
+- `check-maintenance`：**9 项**
+- `npm pack --dry-run --json`：**71 文件**（70 + `scripts/release-lib.mjs`；`release.mjs` 运行时依赖它，必须随包）
+- **预演**：release-ready 的临时克隆上 `node scripts/release.mjs` → **EXIT 0**；
+  同一克隆把 remote 换成 `git+https://…` → **EXIT 1**，报错点名协议并给修法
+
+**未验证**
+
+- 未改 `.github/workflows/release.yml`（存在时脚本走「推 tag 自动建 Release」分支，本次未触碰）。
+- `check-maintenance` 的 ⑧ 只判 URL 形状，**不探远端可达性**（保持「不需要网络」的定位；可达性由 `release.mjs` 的 ⑥ 在发版时把关）。
+
+## 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.4`** · 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）
+验证       473 项单测 · 真实包 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.4",
   "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/scripts/check-maintenance.mjs

@@ -18,6 +18,7 @@
 import { readFileSync, existsSync } from "node:fs"
 import { join, resolve } from "node:path"
 import { spawnSync } from "node:child_process"
+import { classifyRemote } from "./release-lib.mjs"
 
 const ROOT = resolve(process.argv[2] ?? ".")
 const results = []
@@ -141,6 +142,28 @@ ok(usesAnnotated,
    "用 lightweight tag ⇒ Release 页没有 tag 说明、`git cat-file -t` 只看到 commit，历史无法解释",
    '把 scripts/release.mjs 里的 "git tag <tag>" 改成 "git tag -a <tag> -m \\"release <tag>\\""')
 
+// ── ⑧ remote 必须是合法的 GitHub URL ─────────────────────────────────
+// 2026-10-31 事故：`remote.origin.url` 被写成 `git+https://github.com/…`（从 package.json 的
+// repository.url 抄来的写法）。旧判据用正则匹配 `github.com:` ⇒ 照样通过；真做时 `git push`
+// 全崩（git 去找 remote helper `git-remote-git+https`）。这里复用 release-lib 的同一份判据，
+// 让日常维护就能提前发现坏 remote，而不是等到发版那一刻。
+const remoteUrl = git(["config", "--get", "remote.origin.url"]) ?? ""
+const remoteCheck = classifyRemote(remoteUrl)
+ok(remoteCheck.ok,
+   "remote.origin 是合法的 GitHub URL",
+   remoteCheck.ok ? "" : remoteCheck.reason,
+   "git remote set-url origin git@github.com:<owner>/<repo>.git")
+
+// ── ⑨ 当前目录必须就是仓库根（防串仓）──────────────────────────────
+// `ROOT` 取 `process.cwd()`：若在子目录或另一个仓库里跑，版本号 / CHANGELOG / tag
+// 全会指向错误的对象，而输出看起来一切正常。
+const topLevel = git(["rev-parse", "--show-toplevel"])
+const sameRepo = !!topLevel && resolve(topLevel) === resolve(ROOT)
+ok(sameRepo,
+   "当前目录就是仓库根（git rev-parse --show-toplevel === cwd）",
+   sameRepo ? "" : `cwd=${ROOT}，仓库根=${topLevel || "(取不到)"} —— 发布脚本会写错对象`,
+   "cd 到 git rev-parse --show-toplevel 打印的那个目录再跑")
+
 // ── 输出 ──────────────────────────────────────────────────────────────
 
 report()

package/scripts/release-lib.mjs

@@ -0,0 +1,103 @@
+/**
+ * release-lib.mjs —— `release.mjs` 的纯逻辑层（可单测，零副作用）
+ *
+ * 为什么单独拆出来：2026-10-31 的真实事故 —— 仓库 `remote.origin.url` 被写成
+ * `git+https://github.com/…`（非法 scheme），`release.mjs` 的体检**照样通过**（正则能匹配
+ * `github.com:`），直到真做 `git push` 才炸；而当时的执行顺序是「push → tag → **Release → npm**」，
+ * 于是留下「npm 已发、Release 已建、但 main 没推、tag 指向错误 commit」的半途状态。
+ *
+ * 本文件把两件事变成可测的纯函数：
+ *   ① `classifyRemote()`：**先判 scheme 再判仓库**，`git+*` 直接拒，并给出可执行的修法；
+ *   ② `runTransaction()`：**顺序执行 + 首个失败即中止**，让「git 步骤成功之后才允许副作用」成为结构保证，
+ *      而不是散落在调用点的 if。
+ */
+
+/** 非法 remote scheme 前缀：`git+https:` / `git+ssh:` / `git+file:` … */
+const BAD_SCHEME_RE = /^git\+/i
+
+/** GitHub 仓库的三种合法写法：scp 式 ssh、`ssh://`、`https://`。 */
+const SSH_RE = /^[a-z0-9._-]+@github\.com:([^/\s]+)\/([^/\s]+)$/i
+const SSH_URL_RE = /^ssh:\/\/(?:[a-z0-9._-]+@)?github\.com(?::\d+)?\/([^/\s]+)\/([^/\s]+)\/?$/i
+const HTTPS_RE = /^https?:\/\/github\.com\/([^/\s]+)\/([^/\s]+)\/?$/i
+
+/**
+ * 解析 GitHub remote。
+ * @returns {{owner:string, repo:string}|null} 不是 GitHub 或用了非法 scheme 时返回 null
+ */
+export function parseRepo(url) {
+  const raw = String(url ?? "").trim()
+  if (!raw || BAD_SCHEME_RE.test(raw)) return null
+  for (const re of [SSH_RE, SSH_URL_RE, HTTPS_RE]) {
+    const m = raw.match(re)
+    if (m) {
+      const repo = m[2].replace(/\.git$/i, "")
+      if (!m[1] || !repo) return null
+      return { owner: m[1], repo }
+    }
+  }
+  return null
+}
+
+/**
+ * 判断 remote 能不能用，并给出人话理由。
+ * @returns {{ok:true, repo:{owner:string,repo:string}, url:string} | {ok:false, reason:string}}
+ */
+export function classifyRemote(url) {
+  const raw = String(url ?? "").trim()
+  if (!raw) {
+    return { ok: false, reason: "remote.origin.url 为空 —— 没有远端就发不了版（git remote add origin …）" }
+  }
+  if (BAD_SCHEME_RE.test(raw)) {
+    const scheme = raw.split(":").slice(0, 2).join(":").split("+")[0]
+    return {
+      ok: false,
+      reason:
+        `remote.origin.url 用了非法协议（${raw.slice(0, raw.indexOf(":") + 1)}…）—— ` +
+        `git 会去找 remote helper「git-remote-${scheme}+」并报 "is not a git command"。` +
+        `改成 git@github.com:<owner>/<repo>.git（推荐）或 https://github.com/<owner>/<repo>.git：` +
+        `git remote set-url origin git@github.com:<owner>/<repo>.git`,
+    }
+  }
+  const repo = parseRepo(raw)
+  if (!repo) {
+    return { ok: false, reason: `remote.origin.url 不是 GitHub 仓库（${raw}）—— 这个脚本只处理 GitHub` }
+  }
+  return { ok: true, repo, url: raw }
+}
+
+/**
+ * 顺序执行一串步骤，**第一个失败就停**，后面的步骤一律不执行。
+ *
+ * 这就是「git push 成功之后才允许 npm / Release」的结构保证：把有副作用的动作排进 steps，
+ * 前面任何一步抛错，`ok` 就是 false，调用方据此直接退出（不再执行剩余副作用）。
+ *
+ * @param {{name:string, run:() => any}[]} steps
+ * @param {{
+ *   onStart?:(step:{name:string}, index:number)=>void,
+ *   onSettled?:(step:{name:string}, error:any, value:any)=>void,
+ * }} [opts]
+ * @returns {{ok:boolean, done:string[], failed:string|null, error:any, aborted:string[]}}
+ */
+export function runTransaction(steps, opts = {}) {
+  const list = Array.isArray(steps) ? steps : []
+  const done = []
+  for (let i = 0; i < list.length; i++) {
+    const step = list[i]
+    if (opts.onStart) opts.onStart(step, i)
+    try {
+      const value = step.run()
+      if (opts.onSettled) opts.onSettled(step, null, value)
+      done.push(step.name)
+    } catch (error) {
+      if (opts.onSettled) opts.onSettled(step, error, undefined)
+      return {
+        ok: false,
+        done,
+        failed: step.name,
+        error,
+        aborted: list.slice(i + 1).map((s) => s.name),
+      }
+    }
+  }
+  return { ok: true, done, failed: null, error: null, aborted: [] }
+}

package/scripts/release.mjs

@@ -13,8 +13,12 @@
 // 体检项（任一不过就退出码 1，且 --yes 也不动手）：
 //   ① package.json 有 version               ② CHANGELOG 有这一版那一段
 //   ③ 工作区干净                            ④ 当前在默认分支
-//   ⑤ 不落后远端                            ⑥ tag 还没被占
-//   ⑦ 推得上去（远端可达）
+//   ⑤ remote 是合法 GitHub URL（拒 git+https 之类）  ⑥ 远端可达（ls-remote 必须成功）
+//   ⑦ 不落后远端（fetch 必须成功，失败=红，不再吞成 note）  ⑧ tag 还没被占
+//
+// 执行顺序（**事务化**：前一步失败 ⇒ 后面一步根本不执行）：
+//   push 分支 → tag -a + push tag → npm publish（--npm 时）→ GitHub Release
+//   ⇒ git 步骤没过，绝不会出现「npm 已发 / Release 已建，但 main 没推」的半途状态。
 //
 // 需要 GitHub token 才能建 Release：
 //   GITHUB_TOKEN / GH_TOKEN 环境变量。没有也能跑 —— 它会打印手工建 Release 的命令。
@@ -22,6 +26,7 @@
 import { execSync, execFileSync } from "node:child_process"
 import { readFileSync, existsSync } from "node:fs"
 import { join } from "node:path"
+import { classifyRemote, runTransaction } from "./release-lib.mjs"
 
 const ROOT = process.cwd()
 const argv = new Set(process.argv.slice(2))
@@ -136,40 +141,70 @@ if (branch) {
   if (!dirty) bad("工作区有未提交的改动 —— 发布的内容必须和提交一致")
 }
 
-/** owner/repo —— 支持 ssh 与 https 两种 remote */
-function parseRepo(url) {
-  const m = String(url).match(/github\.com[:/]([^/]+)\/([^/.]+?)(?:\.git)?$/)
-  return m ? { owner: m[1], repo: m[2] } : null
-}
-const gh = remote ? parseRepo(remote) : null
-if (!gh) bad(`remote.origin 不是 GitHub 仓库（${remote || "空"}）—— 这个脚本只处理 GitHub`)
+/**
+ * remote 能不能用 —— 先判 scheme 再判仓库。
+ * 这一层是 2026-10-31 事故的直接产物：`git+https://…` 曾被当成合法 GitHub URL，
+ * 体检全绿、push 全崩。判定逻辑在 release-lib.mjs 里（可单测）。
+ */
+const remoteCheck = remote ? classifyRemote(remote) : { ok: false, reason: "没有 remote.origin" }
+const gh = remoteCheck.ok ? remoteCheck.repo : null
+if (!remoteCheck.ok) bad(remoteCheck.reason)
 
 let behind = 0
 if (gh && branch) {
-  try {
-    sh("git fetch origin --quiet")
-    const counts = sh(`git rev-list --left-right --count origin/${branch}...HEAD`)
-    const [b, a] = counts.split(/\s+/).map(Number)
-    behind = b || 0
-    if (behind > 0) bad(`落后远端 ${behind} 个提交 —— 先 pull / merge，别在旧基线上发版`)
-    if (a > 0) note(`本地领先远端 ${a} 个提交（发布时会一起推上去）`)
-  } catch {
-    note("git fetch 失败 —— 跳过「是否落后远端」检查")
+  // ⑤/⑥ 远端可达：ls-remote 必须成功。失败 ⇒ 红（不许「跳过检查」继续发版）。
+  if (!shOk("git ls-remote --heads origin")) {
+    bad(
+      "git ls-remote origin 失败 —— 远端不可达（URL 写错 / 凭据失效 / 网络不通）。" +
+        "先跑 `git ls-remote origin` 亲自确认能通，再发版。",
+    )
+  } else {
+    try {
+      sh("git fetch origin --quiet")
+      const counts = sh(`git rev-list --left-right --count origin/${branch}...HEAD`)
+      const [b, a] = counts.split(/\s+/).map(Number)
+      behind = b || 0
+      if (behind > 0) bad(`落后远端 ${behind} 个提交 —— 先 pull / merge，别在旧基线上发版`)
+      if (a > 0) note(`本地领先远端 ${a} 个提交（发布时会一起推上去）`)
+    } catch (e) {
+      // ⑦ fetch 失败不再是 note —— 那就是「不知道远端正不正常」，不能发版。
+      bad(`git fetch origin 失败（${String(e.stderr || e.message).trim().split("\n")[0]}）—— 远端状态未知，先修好再发版`)
+    }
   }
 }
 
-// ── ⑥ tag 是否已被占 ─────────────────────────────────────────────────
+// ── ⑧ tag 是否已被占（并区分「指向本 commit」与「指向别的 commit」）──────
+// 1.11.3 的现场：Release API 在 push 失败后**自动建了一个轻量 tag**，指向当时远端的旧 commit。
+// 那种情况不能默默 force —— 必须让人确认「这个 tag 是不是发错了」。
 
 let tagExistsLocal = false
 let tagExistsRemote = false
+let tagCommitLocal = ""
+let tagCommitRemote = ""
 if (gh) {
   tagExistsLocal = shOk(`git rev-parse -q --verify refs/tags/${tag}`)
+  if (tagExistsLocal) tagCommitLocal = sh(`git rev-parse -q --verify refs/tags/${tag}^{commit}`)
   try {
     const out = sh(`git ls-remote --tags origin refs/tags/${tag}`)
     tagExistsRemote = out.length > 0
+    // ls-remote 对 annotated tag 会同时给 `<tagobj>\trefs/tags/x` 和 `<commit>\trefs/tags/x^{}`；
+    // 取 deref 行（`^{}`）的 sha 才是它指向的 commit。
+    const deref = out.split("\n").find((l) => l.includes(`refs/tags/${tag}^{}`))
+    const plain = out.split("\n").find((l) => l.endsWith(`refs/tags/${tag}`))
+    tagCommitRemote = (deref ?? plain ?? "").split(/\s+/)[0] ?? ""
   } catch {}
+  const headSha = shOk("git rev-parse HEAD") ? sh("git rev-parse HEAD") : ""
+  const pointsAtHead = (sha) => !!sha && !!headSha && (sha === headSha || headSha.startsWith(sha))
   if (tagExistsLocal || tagExistsRemote) {
-    bad(`tag ${tag} 已存在 —— 同一个版本号不能发两次；先 bump version`)
+    if (tagExistsRemote && tagCommitRemote && !pointsAtHead(tagCommitRemote)) {
+      bad(
+        `远端 tag ${tag} 已存在，但指向 ${tagCommitRemote.slice(0, 12)}（不是 HEAD ${headSha.slice(0, 12)}）—— ` +
+          `可能是上次发布中断时由 Release API 自动建的轻量 tag。脚本**不会自动 force**。` +
+          `确认这个 tag 发错之后，手工修：git push --force origin refs/tags/${tag}:refs/tags/${tag}`,
+      )
+    } else {
+      bad(`tag ${tag} 已存在 —— 同一个版本号不能发两次；先 bump version`)
+    }
   }
 }
 
@@ -205,16 +240,16 @@ for (const n of notes) console.log(C.yellow(`  ! ${n}`))
 // ── 计划 ─────────────────────────────────────────────────────────────
 
 const plan = []
-plan.push({ what: `git push origin ${branch}`, why: "第 4 步：git 源检测看默认分支 HEAD" })
+plan.push({ what: `git push origin ${branch}`, why: "第 4 步：git 源检测看默认分支 HEAD（**失败即中止，后面一步都不做**）" })
 plan.push({ what: `git tag -a ${tag} -m "release ${tag}" && git push origin ${tag}`, why: "第 6 步：annotated tag（带消息）让「某 bug 出在哪版」可查，且 GitHub Release 才有说明" })
+if (ALSO_NPM) {
+  const script = pkg.scripts?.["publish:npm"] ? "npm run publish:npm" : "npm publish"
+  plan.push({ what: script, why: "第 5 步：npm 源的用户比 registry 上的 version（**排在 Release 之前**：npm 失败就不建 Release）" })
+}
 plan.push({
   what: `POST /repos/${gh.owner}/${gh.repo}/releases`,
   why: `第 6 步：Release 正文 = CHANGELOG 的 ${version} 段（${releaseBody.split("\n").length} 行，已去掉 > 起因）`,
 })
-if (ALSO_NPM) {
-  const script = pkg.scripts?.["publish:npm"] ? "npm run publish:npm" : "npm publish"
-  plan.push({ what: script, why: "第 5 步：npm 源的用户比 registry 上的 version" })
-}
 plan.push({ what: "四条验证", why: "第 7 步：npm 版本 / tarball 内容 / magpie plugin list / Release 在" })
 
 console.log(C.bold("计划：\n"))
@@ -228,27 +263,84 @@ if (DRY) {
   process.exit(0)
 }
 
-// ── 真做 ─────────────────────────────────────────────────────────────
+// ── 真做（事务化：前一步失败 ⇒ 后面一步根本不执行）────────────────────
 
 const token = process.env.GITHUB_TOKEN || process.env.GH_TOKEN || ""
 console.log()
 
-function run(cmd, label) {
-  process.stdout.write(`  ${label} … `)
+const doneSteps = []
+
+/**
+ * 失败即中止：把「后面还有什么没做」写清楚，然后退出 1。
+ * 这是 2026-10-31 事故的教训 —— 当时 push/tag 全失败，脚本却继续建 Release、继续 npm publish，
+ * 留下「npm 有、main 没推、tag 指向旧 commit」的半途状态。
+ */
+function abort(step, detail) {
+  console.log(C.red(`\n✗ 已中止：${step} 失败 —— 后续步骤全部未执行`))
+  console.log(C.dim(`  已完成：${doneSteps.length ? doneSteps.join(" → ") : "（无）"}`))
+  if (detail) console.log(C.dim(`  ${detail}`))
+  console.log(
+    C.dim(
+      `  未执行：${["tag -a " + tag, ALSO_NPM ? "npm publish" : null, "GitHub Release"]
+        .filter(Boolean)
+        .join(" · ")}`,
+    ),
+  )
+  console.log(C.dim("  ⇒ 没有任何新的对外副作用被制造出来。修好远端后重跑同一条命令。\n"))
+  process.exit(1)
+}
+
+// ①② 推分支 + annotated tag —— 走 runTransaction（首步失败 ⇒ tag 步根本不执行）
+const gitTx = runTransaction(
+  [
+    {
+      name: `push ${branch}`,
+      label: `push ${branch}`,
+      run: () => sh(`git push origin ${branch}`, { stdio: "pipe" }),
+      hint: "远端不可达或被拒。**tag / npm / Release 一件都没做。**",
+    },
+    {
+      name: `tag ${tag}`,
+      label: `tag ${tag}`,
+      run: () => sh(`git tag -a ${tag} -m "release ${tag}" && git push origin ${tag}`, { stdio: "pipe" }),
+      hint: "本地 tag 可能已建；远端 tag 没上去。修好后单独补：git push origin " + tag,
+    },
+  ],
+  {
+    onStart: (step) => process.stdout.write(`  ${step.label} … `),
+    onSettled: (step, err) => {
+      if (!err) return console.log(C.green("ok"))
+      console.log(C.red("失败"))
+      console.log(C.dim(String(err.stderr || err.message).trim().split("\n").slice(0, 4).join("\n")))
+    },
+  },
+)
+if (!gitTx.ok) {
+  const failedStep = gitTx.done.length === 0 ? `git push origin ${branch}` : `tag -a ${tag} && git push origin ${tag}`
+  const hint = gitTx.done.length === 0
+    ? "远端不可达或被拒。**tag / npm / Release 一件都没做。**"
+    : "本地 tag 可能已建；远端 tag 没上去。修好后单独补：git push origin " + tag
+  abort(failedStep, hint)
+}
+doneSteps.push(`push ${branch}`, `tag ${tag}`)
+
+// ③ npm 发布（在 Release 之前：npm 失败就不该留下一个「Release 说有、npm 上没有」的状态）
+let published = null
+if (ALSO_NPM) {
+  const npmScript = pkg.scripts?.["publish:npm"] ? "npm run publish:npm" : "npm publish"
+  console.log(C.dim(`\n  ${npmScript}（npm 登记有 1~2 分钟延迟，别在这窗口里重试）\n`))
   try {
-    sh(cmd, { stdio: "pipe" })
-    console.log(C.green("ok"))
-    return true
-  } catch (e) {
-    console.log(C.red("失败"))
-    console.log(C.dim(String(e.stderr || e.message).trim().split("\n").slice(0, 4).join("\n")))
-    return false
+    execSync(npmScript, { cwd: ROOT, stdio: "inherit" })
+    published = true
+    doneSteps.push(`npm publish ${version}`)
+  } catch {
+    published = false
+  }
+  if (!published) {
+    abort(`${npmScript}`, "npm 没发出去（OTP / 2FA / 权限 / 网络）。**GitHub Release 未创建。**")
   }
 }
 
-const pushed = run(`git push origin ${branch}`, `push ${branch}`)
-const tagged = run(`git tag -a ${tag} -m "release ${tag}" && git push origin ${tag}`, `tag ${tag}`)
-
 let released = false
 
 /** 这个仓库有没有 release.yml（有的话推 tag 就会自动建 Release，我们不该再建一遍） */
@@ -354,19 +446,6 @@ if (token) {
   console.log(C.dim("    正文直接把 CHANGELOG 里 " + version + " 那一段粘过去"))
 }
 
-let published = null
-if (ALSO_NPM) {
-  const script = pkg.scripts?.["publish:npm"] ? "npm run publish:npm" : "npm publish"
-  console.log(C.dim(`\n  ${script}（npm 登记有 1~2 分钟延迟，别在这窗口里重试）\n`))
-  try {
-    execSync(script, { cwd: ROOT, stdio: "inherit" })
-    published = true
-  } catch {
-    published = false
-    console.log(C.red("  npm 发布失败"))
-  }
-}
-
 // ── 第 7 步留给人看的清单 ─────────────────────────────────────────────
 
 console.log(C.bold("\n第 7 步 · 四条验证（逐条跑，别只看版本号）：\n"))
@@ -385,5 +464,11 @@ console.log(
   ),
 )
 
-const failed = !pushed || !tagged || (ALSO_NPM && !published)
+// 走到这里说明 push / tag /（npm）全部成功。Release 失败仍是失败（否则「npm 有、Release 没有」）。
+const failed = !!token && !released
+if (failed) {
+  console.log(C.red("\n✗ GitHub Release 没建成 —— push/tag/npm 都已完成，只差 Release："))
+  console.log(C.dim("  手工建：GitHub → Releases → Draft a new release → 选 " + tag))
+  console.log(C.dim("  或重跑本脚本（tag 已存在会先被 ⑧ 拦住；那就手工建一次）"))
+}
 process.exit(failed ? 1 : 0)

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 };