dsh-gokifu-compact 1.11.1 → 1.11.3

package/CHANGELOG.md

@@ -1,5 +1,112 @@
 # 更新记录
 
+## 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）
+
+**这是第一个 UI bundle 版。** 以前装完包要**手改 profile 的 `cordis.patch.yml`** 加一条
+`- insert: [{id: gokifu-ui, name: 'dsh-gokifu-compact'}]` 才能挂上 UI。手改有两个后患：
+
+1. **双挂载**：用户升级包后手工行还留着，和 bundle 通道同时挂 ⇒ 两个 host 半注册同一个 `/gokifu/api` 前缀 ⇒ **启动即失败**（duplicate prefix route）；
+2. **没挂载**：`dsh plugin add` 不会自己补挂载行 ⇒ 「装好了但没生效」，且**没有任何报错**。
+
+**改法**
+
+- 新增 **`cordis.patch.yml`（28 行）**：只做一件事 —— `- insert: [{id: gokifu-ui, name: 'dsh-gokifu-compact'}]`。
+  **引擎不在这里**：压缩后端必须挂在 **agent preset 的 compaction group 内部**，profile/bundle 级 patch 打不到 `preset.config.plugins`；那一行仍由 `install.mjs` 改 preset。
+  `id` 保持 `gokifu-ui`（与历史手工行一致）⇒ 从手工通道切过来时，日志/文档/doctor 口径都不用改。
+- `package.json`：`dsh.bundle.patch = "./cordis.patch.yml"` · `dsh.manifestVersion = 1` · `files`/`exports` 补 `cordis.patch.yml`；`main` 与 `dsh.client` 不变。
+- **`scripts/install.mjs` 改 bundle 优先**：
+  - `findManualUiRow` / `removeManualUiRow`：定位并（带备份）删除 profile 里的旧手工行
+  - `patchProfileBundles()`：把本包**追加**进 `dsh.profile.bundles`，保持既有顺序；写前备份 profile/`package.json`
+  - `ensureBundleChannel()` = **先加 bundle、再删手工行** —— 顺序保证任何中断都不会出现「两条都没有」的空窗
+  - `git`/`registry` 规格**不改写成 `link`**
+- **`test/verify-install.mjs` 判据升级**：旧判据「bundles 里没有它」→ **「UI 挂载通道二选一，不双挂载」**：两条都在 = 红（双挂载）、都没有 = 红（没挂载）；检查项总数仍 **16**。
+- **`test/ws-install.test.mjs`**：健康夹具改走 bundle 通道；**新增 S11 四种态**（bundle-only 绿 / manual-only 绿 / both 红 / neither 红）。
+- **`test/install-link.test.mjs`** 夹具同步。
+- **新增 `test/bundle.test.mjs`（6 条）**：B-1 声明齐全 · B-2 patch 只插 UI 一行 · B-3 `findManualUiRow` 三态 · B-4 bundle 优先+备份+幂等 · B-5 dry-run 零写 · B-6 registry 规格不被改写。
+- **变异自检（4 条，逐条实测红）**：删 `dsh.bundle` ⇒ B-1；patch 塞引擎行 ⇒ B-2；安装器不删手工行 ⇒ B-4；判据退回「bundle 里不许有」⇒ S11 + S10e-1。
+
+### 验证
+
+- 全量：**443 passed / 0 failed**（36 个测试文件；436 + 6 bundle + 1）
+- `rooms` **15/0** · `ws-install` **14/0** · `install-link` **29/0** · `bundle` **6/0** · `verify-install` **16/16**
+- `bench 2000`：**351 tokens** / 1.423 ms（81,260 / 386,945 字符、1.41 MB、2001 节点）
+- `npm pack --dry-run --json`：**70 文件**（69 + `cordis.patch.yml`）/ 558,113 B；`test/`·`tmp/` 命中 0
+- live 当前仍是**手工通道**（`bundle=无｜手工行=有`）—— `verify-install` 按「二选一」判据通过
+
+**未验证（必须知道）**
+
+- **未跑 live install**：`--apply` 到真实 profile 的 bundle 切换没有执行过（只在 dry-run 与夹具上验证）。
+- **未启 DSH**：bundle 通道在真实插件树里的加载行为未观测。
+- 从手工通道切换到 bundle 的**中断恢复**只在单测里模拟（顺序保证 + 备份），真机未演练。
+
 ## 1.11.1 — 2026-10-30
 
 ### P6-C 落地：未落地尝试不再被当成残留（**热清单新增 OPTIONS 段**）

package/README.md

@@ -1,20 +1,24 @@
 # dsh-GOkifu-compact
 
-> 当前版本：**`1.11.1`** · 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%）
-验证       436 项单测 · 真实包 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/cordis.patch.yml

@@ -0,0 +1,28 @@
+# dsh-gokifu-compact bundle patch
+#
+# 这是本包的 `dsh.bundle.patch` 层（`package.json` 的 `dsh.bundle.patch` 指向本文件）。
+# 它只做一件事：**把 UI 的 host 半插进插件树**（`/gokifu/api` + 详情页数据/写配置）。
+#
+# 为什么现在改成 bundle：以前靠 `dsh plugin add` 之后**手改 profile 的 cordis.patch.yml**
+# 加一条 `- insert: [{id: gokifu-ui, name: 'dsh-gokifu-compact'}]`。手改有两个后患：
+#   ① 用户升级包之后，这条手工行留在 profile 里，和 bundle 通道**同时**挂载 ⇒ 两个 host 半
+#      注册同一个 `/gokifu/api` 前缀 ⇒ 启动即失败（duplicate prefix route）；
+#   ② `dsh plugin add` 不会自己补挂载行 ⇒ 「装好了但没生效」，且没有任何报错。
+# 声明成本包的 patch 层之后，profile 只要把本包写进 `dsh.profile.bundles`，补丁会被自动合并，
+# 与手工行**语义完全等价**（同样是 `- insert:` 一行），但不再需要用户改任何 YAML。
+#
+# ⚠ 两条通道**只能二选一**：
+#   · bundle 通道：`dsh.profile.bundles` 含 `dsh-gokifu-compact`，profile 自己的
+#     `cordis.patch.yml` 里**不得**再有 `id: gokifu-ui` 的手工行；
+#   · 手工通道：profile 自己的 `cordis.patch.yml` 有那一行，且 bundles 里**不得**含本包。
+#   `scripts/install.mjs` 切到 bundle 通道时会**备份并删除**旧手工行；
+#   `test/verify-install.mjs` 有「二选一、不双挂载」的机器判据（两条都在 = 红）。
+#
+# 引擎（压缩后端）不在这里：它必须挂在 **agent preset 的 compaction group 内部**，
+# profile/bundle 级 patch 打不到 preset 的 `config.plugins`（见 docs/DSH-技术测绘.md §7.6）。
+# 那一行由 `scripts/install.mjs` 改 preset 完成；本文件只管 UI。
+#
+# id 保持 `gokifu-ui`（与历史手工行一致）：从手工通道切过来时，日志/文档/doctor 都不用改口径。
+- insert:
+    - id: gokifu-ui
+      name: 'dsh-gokifu-compact'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-gokifu-compact",
-  "version": "1.11.1",
+  "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,7 +19,10 @@
     },
     "./engine": "./src/engine.mjs",
     "./client": "./lib/client.js",
-    "./package.json": "./package.json"
+    "./graph": "./src/rooms/kifu-model.mjs",
+    "./persist": "./src/rooms/kifu-persist.mjs",
+    "./package.json": "./package.json",
+    "./cordis.patch.yml": "./cordis.patch.yml"
   },
   "engines": {
     "node": ">=20"
@@ -33,6 +36,7 @@
     "docs",
     "evidence",
     "scripts",
+    "cordis.patch.yml",
     "CHANGELOG.md",
     "QUICKSTART.md",
     "LICENSE"
@@ -79,6 +83,10 @@
     "dsh-gokifu-compact": "./scripts/cli.mjs"
   },
   "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "manifestVersion": 1,
     "client": {
       "platform": "web",
       "inject": []

package/scripts/install.mjs

@@ -158,6 +158,127 @@ export function patchProfileForUi(profileDir, log = () => {}, dryRun = false) {
   return { changed: true, backup };
 }
 
+
+/* ─────────────── ②·b bundle 通道（task-118） ─────────────── */
+
+/** 手工行的 id（历史值，保持兼容：日志/doctor/文档都用这个口径）。 */
+const MANUAL_UI_ID = "gokifu-ui";
+
+/**
+ * 在 profile 的 cordis.patch.yml 里定位手工 UI 行（`- insert:` + `- id: gokifu-ui`）。
+ *
+ * 纯函数：只算行号，不改任何东西（方便测试与 dry-run）。找不到返回 null。
+ * 结构不认识时返回 `{ unsupported: true }` —— 调用方必须**拒绝改**，绝不能猜着删。
+ * @returns {{startLine:number,endLine:number,start:number,end:number,wholeBlock:boolean}|{unsupported:true,reason:string}|null}
+ */
+export function findManualUiRow(text) {
+  const lines = String(text).split("\n");
+  const childIdx = lines.findIndex((l) => new RegExp("^\\s*- id:\\s*" + MANUAL_UI_ID + "\\s*$").test(l));
+  if (childIdx < 0) return null;
+  // 往上找父级 `- insert:`（最多 12 行内；缩进必须比子行浅）
+  const childIndent = lines[childIdx].match(/^\s*/)[0].length;
+  let parentIdx = -1;
+  for (let i = childIdx - 1; i >= Math.max(0, childIdx - 12); i -= 1) {
+    const m = /^(\s*)- insert:\s*$/.exec(lines[i]);
+    if (m && m[1].length < childIndent) {
+      parentIdx = i;
+      break;
+    }
+  }
+  if (parentIdx < 0) return { unsupported: true, reason: "找不到 `- insert:` 父行" };
+  // 父块范围 = 从父行到下一条**缩进 ≤ 父缩进**的非空行
+  const parentIndent = lines[parentIdx].match(/^\s*/)[0].length;
+  let endIdx = lines.length;
+  for (let i = parentIdx + 1; i < lines.length; i += 1) {
+    if (lines[i].trim().length === 0) continue;
+    if (lines[i].match(/^\s*/)[0].length <= parentIndent && /^\s*- /.test(lines[i])) {
+      endIdx = i;
+      break;
+    }
+  }
+  // 这个 insert 块里还有别的子行吗？（有 ⇒ 只删本行；没有 ⇒ 整块删）
+  const otherChildren = lines
+    .slice(parentIdx + 1, endIdx)
+    .some((l) => l.match(/^\s*/)[0].length === childIndent && /^\s*- /.test(l) && !new RegExp("^\\s*- id:\\s*" + MANUAL_UI_ID + "\\s*$").test(l));
+  return { startLine: childIdx, endLine: childIdx, start: parentIdx, end: endIdx - 1, wholeBlock: !otherChildren };
+}
+
+/**
+ * 从 profile 的 cordis.patch.yml 删除手工 UI 行（**带备份**）。
+ * 只在 `wholeBlock` 时连注释一起删：注释是与那一行配套的说明，留着会变成误导性死注释。
+ */
+export function removeManualUiRow(profileDir, log = () => {}, dryRun = false) {
+  const file = nodePath.join(profileDir, "cordis.patch.yml");
+  if (!nodeFs.existsSync(file)) return { changed: false, reason: "没有 profile cordis.patch.yml" };
+  const text = nodeFs.readFileSync(file, "utf8");
+  const found = findManualUiRow(text);
+  if (found === null) return { changed: false, reason: "没有手工 UI 行" };
+  if (found.unsupported) return { changed: false, reason: `手工行结构不认识（${found.reason}），拒绝改` };
+  const lines = text.split("\n");
+  let start = found.start;
+  let end = found.end;
+  if (found.wholeBlock) {
+    // 连带删除紧贴其上、提到 gokifu 的连续注释行
+    while (start - 1 >= 0 && /^\s*#/.test(lines[start - 1]) && /gokifu|上下文压缩/i.test(lines[start - 1])) start -= 1;
+  } else {
+    start = found.startLine;
+    end = found.endLine;
+  }
+  let next = [...lines.slice(0, start), ...lines.slice(end + 1)].join("\n");
+  next = next.replace(/\n{3,}/g, "\n\n");
+  if (dryRun) {
+    log("  [dry] profile cordis.patch.yml 会删掉手工 gokifu-ui 行（改走 bundle 通道）");
+    return { changed: true, dryRun: true };
+  }
+  const backup = `${file}.bak-before-gokifu-ui-${Date.now()}`;
+  nodeFs.copyFileSync(file, backup);
+  nodeFs.writeFileSync(file, next, "utf8");
+  log(`  ✓ profile cordis.patch.yml 已删手工 gokifu-ui 行（备份 ${nodePath.basename(backup)}）`);
+  return { changed: true, backup };
+}
+
+/**
+ * 确保 profile 的 `dsh.profile.bundles` 含本包（**追加在末尾**，保持既有顺序）。
+ * 为什么这是主通道：bundle 声明了 patch 层 ⇒ 装载器自动合并本包的 cordis.patch.yml，
+ * 与手写那一行语义等价，但用户不用改 YAML，升级也不会漏。
+ */
+export function patchProfileBundles(profileDir, log = () => {}, dryRun = false) {
+  const file = nodePath.join(profileDir, "package.json");
+  if (!nodeFs.existsSync(file)) return { changed: false, reason: "没有 profile/package.json" };
+  let pkg;
+  try {
+    pkg = JSON.parse(nodeFs.readFileSync(file, "utf8"));
+  } catch (error) {
+    return { changed: false, reason: `profile/package.json 不是合法 JSON（${error.message}）` };
+  }
+  const dsh = pkg.dsh && typeof pkg.dsh === "object" ? pkg.dsh : {};
+  const profile = dsh.profile && typeof dsh.profile === "object" ? dsh.profile : {};
+  const bundles = Array.isArray(profile.bundles) ? profile.bundles : [];
+  if (bundles.includes(PKG_NAME)) return { changed: false, reason: "已在 dsh.profile.bundles" };
+  const next = [...bundles, PKG_NAME];
+  if (dryRun) {
+    log(`  [dry] profile/package.json 的 dsh.profile.bundles 会追加 ${PKG_NAME}（现 ${bundles.length} 项）`);
+    return { changed: true, dryRun: true };
+  }
+  nodeFs.copyFileSync(file, `${file}.bak-before-gokifu-${Date.now()}`);
+  pkg.dsh = { ...dsh, profile: { ...profile, bundles: next } };
+  nodeFs.writeFileSync(file, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+  log(`  ✓ profile/package.json 的 dsh.profile.bundles 已追加 ${PKG_NAME}（${bundles.length} → ${next.length} 项）`);
+  return { changed: true, bundles: next };
+}
+
+/**
+ * **bundle 优先**：先把本包写进 `dsh.profile.bundles`，再删掉旧的手工 gokifu-ui 行（带备份）。
+ * 顺序不能反：先加 bundle 再删手工行，任何一步中断都**不会**出现「两条通道都没有」的空窗。
+ */
+export function ensureBundleChannel(profileDir, log = () => {}, dryRun = false) {
+  const bundle = patchProfileBundles(profileDir, log, dryRun);
+  if (bundle.changed === false) log(`  · UI（bundle 通道）：${bundle.reason}`);
+  const manual = removeManualUiRow(profileDir, log, dryRun);
+  if (manual.changed === false && manual.reason !== "没有手工 UI 行") log(`  · 手工行：${manual.reason}`);
+  return { bundle, manual };
+}
+
 export function run(argv = process.argv.slice(2)) {
   const opts = parseArgs(argv);
   const { dryRun, profile, dshHome, log } = opts;
@@ -234,6 +355,11 @@ export function run(argv = process.argv.slice(2)) {
       samePath(spec.target.realPath, PROJECT_DIR);
     if (correct) {
       log(`  · profile/package.json 的 ${PKG_NAME} 已指向本目录：${declared}`);
+      } else if (spec !== null && spec.kind === "other") {
+        // ★ task-118：用户把手上的依赖写成 registry / git / tarball 规格时**不许改写成 link**。
+        //   那是用户的选择（例如从 npm 装正式版），改写会让「装的是哪个」不可追溯；
+        //   本地调试请自己显式写 file:/link:，安装器不替用户做这个决定。
+        log(`  · profile/package.json 的 ${PKG_NAME} 是 ${declared} 规格（非 file:/link:）—— 保持原样，不改写成 link`);
     } else if (dryRun) {
       log(`  [dry] 会${declared === null ? "加" : "修"} profile/package.json 的 ${PKG_NAME}：${declared ?? "(无)"} → ${want}`);
     } else {
@@ -299,9 +425,11 @@ export function run(argv = process.argv.slice(2)) {
     log(`  ✓ ${t.file} 已换后端（备份 ${nodePath.basename(backup)}）`);
   }
 
-  /* ③ 挂 UI 的 host 半（profile 级）：裸包名，客户端 bundle 靠它被发现 */
-  const ui = patchProfileForUi(profileDir, (m) => log(m), dryRun);
-  if (ui.changed === false) log(`  · UI host 半：${ui.reason}`);
+  /* ③ 挂 UI 的 host 半：**bundle 通道优先**（本包自带 cordis.patch.yml，声明在 dsh.bundle.patch）。
+     旧做法是手改 profile 的 cordis.patch.yml 加 `- insert: {id: gokifu-ui}`；那条路已废弃 ——
+     升级后手工行与 bundle 会同时挂载，两个 host 半抢同一个 /gokifu/api 前缀，启动直接失败。
+     ⇒ 这里把本包写进 dsh.profile.bundles，并**备份后删除**旧手工行，保证任何时候只有一条通道。 */
+  ensureBundleChannel(profileDir, (m) => log(m), dryRun);
 
   if (dryRun) {
     log("\n这是预演，什么都没改。真装去掉 --dry-run。");

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