@andyqiu/codeforge 0.5.4 → 0.5.6

package/agents/codeforge.md

@@ -59,7 +59,7 @@ fallback_models:
 - ❌ 不允许**为并行而并行**：改同文件 / 步骤间有真实依赖时必须串行
 - ❌ 不允许在父对话直接吐长交付物内容
 - ❌ 不允许自动派 coder 修 BLOCK；REQUEST_CHANGES 允许自动派 coder 修，**最多 3 次**
-- ❌ **不允许自己主动调 `session_merge action=merge`** —— merge 由用户通过 `/merge` 命令触发（ADR:worktree-session-isolation）
+- ✅ codeforge 可在 review-fix-review APPROVE 后调 `session_merge action=merge`；其他 sub-agent 调此操作会被 guard 拦截（ADR:codeforge-merge-permission）；force=true 必须先告知用户并解释跳过 review 的理由
 
 ## 能力边界（场景分派表）
 
@@ -78,6 +78,7 @@ fallback_models:
 | **reviewer 报 REQUEST_CHANGES（代码 review，`code_review_loop_count` < 3）** | **自动派 coder 修**（带具体到行的 reviewer 意见 + 原 plan_id + sessionId），loop +1 | ❌ 同时派多个 coder；❌ 不带 reviewer 意见 |
 | **reviewer 报 REQUEST_CHANGES（loop = 3）** | 转告用户「reviewer 3 次仍 REQUEST_CHANGES」，问「接受 `/merge` / 手动改 / `/discard-session`」三选一 | ❌ 继续派 coder |
 | **reviewer 报 BLOCK** | 转告用户 + 建议派 planner 重设计（带原 plan_id + BLOCK 理由），等用户拍板 | ❌ 派 coder 强行绕过 BLOCK |
+| **review-fix-review 全部通过（APPROVE）** | codeforge orchestrator 自动调 `session_merge action=merge` 完成合入（ADR:codeforge-merge-permission）；用户也可通过 `/merge` 命令触发 | ❌ force=true 不告知用户；❌ 派其他 sub-agent 调 session_merge action=merge（会被 guard 拦截） |
 | **coder 回报「PRE 阻断、拒绝启动」** | 转告用户阻断点 + 解除路径，等用户拍板，**不自动派下一棒** | ❌ 自动重派 coder 并强塞 `pre_ack=` |
 | 用户中途插入新需求（原 task 未结束） | 询问用户「先取消 / 等当前完 / 并行」三选一 | ❌ 默默丢弃；❌ 同时派多个不告知 |
 | **可并行任务** | 自动判断依赖，无强依赖时自动并行调度 | ❌ 串行派 N 个独立 task |

package/commands/autonomy.md

@@ -12,6 +12,7 @@ description: 查看或切换当前 session 的自主度档位（step/semi/full/a
 - `/autonomy semi` — 危险工具确认，安全工具自动（默认）
 - `/autonomy full` — 全自动工具执行（reviewer APPROVE 后仍需 `/merge` 手动触发）
 - `/autonomy auto` — 全自动 + APPROVE 自动 merge（**最小干预模式**）
+- `/autonomy status` — **Phase 2.2** 显示实时状态（档位 / paused / 五维 budget / 全局今日 USD / block-pending）
 
 ## ⚠️ auto 模式须知
 
@@ -23,6 +24,7 @@ description: 查看或切换当前 session 的自主度档位（step/semi/full/a
 - **REQUEST_CHANGES** 自动循环（≤ 3 次），仍由 codeforge agent 派 coder 修
 - **BLOCK** 通过 channels 通知（需配置 `.codeforge/channels.json`）
   - channels 全失败时 fallback 写 `<runtimeDir>/sessions/autonomous-blocks.ndjson`
+  - **Phase 2.2**：下次 session.start 时 session-recovery plugin 自动扫描并提示用户处理
 - **仅根 session 生效**（子 session 一律跳过，防 orchestrator 嵌套）
 
 ### 默认预算上限（任一耗尽自动降回 semi）
@@ -34,6 +36,17 @@ description: 查看或切换当前 session 的自主度档位（step/semi/full/a
 | Wall clock | 30 分钟 |
 | auto merge 次数 | 5 |
 | REQUEST_CHANGES 循环 | 3 |
+| **全局每日 USD（Phase 2）** | **$10**（跨 session 累计；env `CODEFORGE_AUTONOMY_GLOBAL_MAX_USD` 或 `.codeforge/autonomy.json::global_max_usd_per_day` 覆盖） |
+
+### Phase 2.2 新增：stuck-detector
+
+driver 在每次 reviewer 完成时喂 progress 信号：
+- APPROVE → progress +1（任务推进）
+- REQUEST_CHANGES → progress 0（无推进）
+- BLOCK → progress -1（明显退步）
+
+连续 5 轮无进展 → 自动降回 semi + emit `autonomous.stuck` channel event。
+**用户 `/autonomy auto` 显式切回时自动 reset stuck 窗口**（清 stale 信号）。
 
 ### 逃生口
 
@@ -41,6 +54,7 @@ description: 查看或切换当前 session 的自主度档位（step/semi/full/a
 - `/discard-session` — 不可逆，硬丢 worktree + branch
 - budget 耗尽 — 自动降回 semi
 - BLOCK — 强制通知 + 降档
+- stuck 检测 — 5 轮无进展自动降档
 
 ## 行为对比
 
@@ -53,10 +67,25 @@ description: 查看或切换当前 session 的自主度档位（step/semi/full/a
 
 ## 配置存储
 
-`<runtimeDir>/autonomy/<sessionId>.json`（withFileLock 跨进程并发安全）
+- per-session：`<runtimeDir>/autonomy/<sessionId>.json`（withFileLock 跨进程并发安全）
+- 全局每日 USD：`<runtimeDir>/autonomy/global-budget-<YYYY-MM-DD>.json`（withFileLock）
 
 ## 关联 ADR
 
 - [autonomous-mode](../docs/adr/autonomous-mode.md) — 主 ADR（设计、双重验证、五维预算）
+- [autonomy-global-budget](../docs/adr/autonomy-global-budget.md) — Phase 2 全局 USD 预算 + stuck-detector + block-pending 消费
 - [plandex-three-autonomy-modes](../docs/adr/plandex-three-autonomy-modes.md) — 三档基线
 - [worktree-session-isolation](../docs/adr/worktree-session-isolation.md) — merge 闭环
+
+---
+
+## /autonomy status 处理流程（Phase 2.2）
+
+当用户输入 `/autonomy status`：
+
+1. 调 `tools/autonomy-status.ts::getAutonomyStatus(<absRoot>, <sessionId>)` 拿 `AutonomyStatusReport`
+2. 调 `renderAutonomyStatus(report)` 转 Markdown 文本
+3. 直接输出渲染结果到对话（无需 toast / channels）
+
+> 实现位置：`tools/autonomy-status.ts`（与 `tools/autonomy-mode.ts` 同款 ts 工具）。
+> agent 通过 read + 内联调用使用，无需 opencode tool 注册（零侵入约束）。

package/dist/index.js

@@ -8205,11 +8205,11 @@ function shouldStopByStuck(history, cfg) {
 async function withTimeout4(p, timeoutMs) {
   if (timeoutMs <= 0)
     return await p;
-  return await new Promise((resolve15, reject) => {
+  return await new Promise((resolve16, reject) => {
     const timer = setTimeout(() => reject(new Error(`timeout after ${timeoutMs}ms`)), timeoutMs);
     Promise.resolve(p).then((v) => {
       clearTimeout(timer);
-      resolve15(v);
+      resolve16(v);
     }, (err) => {
       clearTimeout(timer);
       reject(err);
@@ -13393,13 +13393,6 @@ async function getCurrentWorktreeHead(worktreePath) {
     return "";
   }
 }
-async function getCurrentMainHead(mainRoot) {
-  try {
-    return (await runGit2(path13.resolve(mainRoot), ["rev-parse", "HEAD"])).trim();
-  } catch {
-    return "";
-  }
-}
 async function isWorktreeDirty(worktreePath) {
   try {
     const out = (await runGit2(worktreePath, ["status", "--porcelain"])).trim();
@@ -13437,6 +13430,27 @@ Codeforge-Base: ${baseSha.slice(0, 12)}`;
   return subject + body + footer;
 }
 var ORPHAN_GRACE_MS = 60000;
+async function pruneDiscardedRegistryEntries(mainRoot, opts = {}) {
+  const keepRecent = opts.keepRecent ?? 50;
+  if (keepRecent < 0) {
+    throw new Error(`pruneDiscardedRegistryEntries: keepRecent 必须 ≥ 0，收到 ${keepRecent}`);
+  }
+  return await mutateRegistry(path13.resolve(mainRoot), (reg) => {
+    const discarded = [];
+    const others = [];
+    for (const e of reg.entries) {
+      if (e.status === "discarded")
+        discarded.push(e);
+      else
+        others.push(e);
+    }
+    discarded.sort((a, b) => a.updatedAt < b.updatedAt ? 1 : a.updatedAt > b.updatedAt ? -1 : 0);
+    const kept = discarded.slice(0, keepRecent);
+    const pruned = discarded.length - kept.length;
+    reg.entries = [...others, ...kept];
+    return { pruned, kept: kept.length };
+  });
+}
 async function pruneOrphanWorktrees(mainRoot) {
   const resolved = path13.resolve(mainRoot);
   const cleaned = [];
@@ -13554,7 +13568,12 @@ async function pruneOrphanWorktrees(mainRoot) {
       failed.push({ worktreePath: candidate, error: lastError ?? "unknown" });
     }
   }
-  return { cleaned, failed, skipped };
+  let discardedPruned = 0;
+  try {
+    const r = await pruneDiscardedRegistryEntries(resolved);
+    discardedPruned = r.pruned;
+  } catch {}
+  return { cleaned, failed, skipped, discardedPruned };
 }
 
 // lib/merge-loop.ts
@@ -14657,8 +14676,8 @@ async function sendParentNotice(client, sessionID, text, opts = {}) {
             id: makePartId(),
             type: "text",
             text,
-            synthetic: false,
-            ignored: false
+            synthetic: true,
+            ignored: true
           }
         ]
       }
@@ -15860,7 +15879,12 @@ var codeforgeToolsServer = async (ctx) => {
               ...sid ? { currentSessionId: sid } : {},
               ...sid ? {
                 sendProgress: async (state, detail) => {
-                  await sendParentNotice(ctx.client, sid, `[merge-loop] ${state}: ${detail}`, ctx.directory ? { directory: ctx.directory } : {});
+                  const client = ctx.client;
+                  if (typeof client?.tui?.showToast === "function") {
+                    await client.tui.showToast({
+                      body: { message: `[merge-loop] ${state}: ${detail}`, variant: "default", duration: 4000, title: "CodeForge" }
+                    });
+                  }
                 }
               } : {}
             });
@@ -17837,9 +17861,103 @@ var handler12 = modelFallbackServer;
 
 // plugins/subtask-heartbeat.ts
 import { promises as fsPromises } from "node:fs";
-import * as path18 from "node:path";
+import * as path19 from "node:path";
 init_runtime_paths();
 init_global_config();
+
+// lib/parent-map-store.ts
+init_runtime_paths();
+import { promises as fs15 } from "node:fs";
+import * as path18 from "node:path";
+var PARENT_MAP_VERSION = 1;
+var PARENT_MAP_LOCK_TIMEOUT_MS = 2000;
+function parentMapDir(mainRoot) {
+  return path18.join(runtimeDir(path18.resolve(mainRoot), { ensure: false }), "session-worktrees");
+}
+function parentMapPath(mainRoot) {
+  return path18.join(parentMapDir(mainRoot), "parent-map.json");
+}
+function parentMapLockPath(mainRoot) {
+  return path18.join(parentMapDir(mainRoot), "parent-map.lock");
+}
+async function readParentMapFile(mainRoot) {
+  const file = parentMapPath(mainRoot);
+  try {
+    const raw = await fs15.readFile(file, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== PARENT_MAP_VERSION || !Array.isArray(parsed.entries)) {
+      return { version: PARENT_MAP_VERSION, entries: [] };
+    }
+    return parsed;
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT")
+      return { version: PARENT_MAP_VERSION, entries: [] };
+    return { version: PARENT_MAP_VERSION, entries: [] };
+  }
+}
+async function writeParentMapFile(mainRoot, payload) {
+  const file = parentMapPath(mainRoot);
+  await fs15.mkdir(path18.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
+  await fs15.writeFile(tmp, JSON.stringify(payload, null, 2), "utf8");
+  await fs15.rename(tmp, file);
+}
+async function loadParentMap(mainRoot) {
+  const out = new Map;
+  let file;
+  try {
+    file = await readParentMapFile(mainRoot);
+  } catch {
+    return out;
+  }
+  for (const e of file.entries) {
+    if (!e || typeof e.childID !== "string" || typeof e.parentID !== "string")
+      continue;
+    if (!e.childID || !e.parentID)
+      continue;
+    const ts = typeof e.ts === "number" ? e.ts : Date.now();
+    out.set(e.childID, { parentID: e.parentID, ts });
+  }
+  return out;
+}
+async function writeParentMap(mainRoot, snapshot, opts = {}) {
+  const lockPath = parentMapLockPath(mainRoot);
+  await fs15.mkdir(path18.dirname(lockPath), { recursive: true });
+  const lockOpts = {
+    timeoutMs: opts.timeoutMs ?? PARENT_MAP_LOCK_TIMEOUT_MS,
+    ...opts
+  };
+  await withFileLock(lockPath, async () => {
+    const entries = [];
+    for (const [childID, v] of snapshot.entries()) {
+      entries.push({ childID, parentID: v.parentID, ts: v.ts });
+    }
+    await writeParentMapFile(mainRoot, { version: PARENT_MAP_VERSION, entries });
+  }, lockOpts);
+}
+async function appendParentEntry(mainRoot, childID, parentID, ts, opts = {}) {
+  if (!childID || !parentID)
+    return;
+  const lockPath = parentMapLockPath(mainRoot);
+  await fs15.mkdir(path18.dirname(lockPath), { recursive: true });
+  const lockOpts = {
+    timeoutMs: opts.timeoutMs ?? PARENT_MAP_LOCK_TIMEOUT_MS,
+    ...opts
+  };
+  await withFileLock(lockPath, async () => {
+    const current = await readParentMapFile(mainRoot);
+    const idx = current.entries.findIndex((e) => e.childID === childID);
+    if (idx >= 0) {
+      current.entries[idx] = { childID, parentID, ts };
+    } else {
+      current.entries.push({ childID, parentID, ts });
+    }
+    await writeParentMapFile(mainRoot, current);
+  }, lockOpts);
+}
+
+// plugins/subtask-heartbeat.ts
 var PLUGIN_NAME13 = "subtask-heartbeat";
 logLifecycle(PLUGIN_NAME13, "import", {});
 var HEARTBEAT_INTERVAL_MS2 = 30000;
@@ -17857,6 +17975,14 @@ var inflight3 = new Map;
 var pendingTask = new Map;
 var sessionParentMap = new Map;
 var _parentParseFailLogged = 0;
+var _persistRoot = null;
+function _bulkInjectSessionParentMap(entries) {
+  for (const e of entries) {
+    if (!e.childID || !e.parentID)
+      continue;
+    sessionParentMap.set(e.childID, { parentID: e.parentID, ts: e.ts });
+  }
+}
 function _snapshotInflight() {
   return [...inflight3.values()].map((r) => ({ ...r }));
 }
@@ -17865,21 +17991,29 @@ function recordSessionParent(childID, parentID, now = Date.now()) {
     return;
   if (sessionParentMap.has(childID)) {
     sessionParentMap.set(childID, { parentID, ts: now });
-    return;
-  }
-  if (sessionParentMap.size >= SESSION_PARENT_MAP_MAX_SIZE) {
-    let oldestKey = null;
-    let oldestTs = Number.POSITIVE_INFINITY;
-    for (const [k, v] of sessionParentMap.entries()) {
-      if (v.ts < oldestTs) {
-        oldestTs = v.ts;
-        oldestKey = k;
+  } else {
+    if (sessionParentMap.size >= SESSION_PARENT_MAP_MAX_SIZE) {
+      let oldestKey = null;
+      let oldestTs = Number.POSITIVE_INFINITY;
+      for (const [k, v] of sessionParentMap.entries()) {
+        if (v.ts < oldestTs) {
+          oldestTs = v.ts;
+          oldestKey = k;
+        }
       }
+      if (oldestKey !== null)
+        sessionParentMap.delete(oldestKey);
     }
-    if (oldestKey !== null)
-      sessionParentMap.delete(oldestKey);
+    sessionParentMap.set(childID, { parentID, ts: now });
+  }
+  if (_persistRoot) {
+    appendParentEntry(_persistRoot, childID, parentID, now).catch((err) => {
+      log7.warn("appendParentEntry 失败（已隔离）", {
+        error: err instanceof Error ? err.message : String(err),
+        childID
+      });
+    });
   }
-  sessionParentMap.set(childID, { parentID, ts: now });
 }
 function lookupParentSessionId(childID, now = Date.now()) {
   const entry = sessionParentMap.get(childID);
@@ -17893,6 +18027,15 @@ function lookupParentSessionId(childID, now = Date.now()) {
 }
 function deleteSessionParent(childID) {
   sessionParentMap.delete(childID);
+  if (_persistRoot) {
+    const snapshot = new Map(sessionParentMap);
+    writeParentMap(_persistRoot, snapshot).catch((err) => {
+      log7.warn("writeParentMap (delete) 失败（已隔离）", {
+        error: err instanceof Error ? err.message : String(err),
+        childID
+      });
+    });
+  }
 }
 function sweepExpiredSessionParents(now = Date.now()) {
   let removed = 0;
@@ -17902,6 +18045,15 @@ function sweepExpiredSessionParents(now = Date.now()) {
       removed++;
     }
   }
+  if (removed > 0 && _persistRoot) {
+    const snapshot = new Map(sessionParentMap);
+    writeParentMap(_persistRoot, snapshot).catch((err) => {
+      log7.warn("writeParentMap (sweep) 失败（已隔离）", {
+        error: err instanceof Error ? err.message : String(err),
+        removed
+      });
+    });
+  }
   return removed;
 }
 function detectUnparsedParentID(event) {
@@ -18199,7 +18351,7 @@ function buildFailureNotice(r, endedType, logPath, worktreePath, now = Date.now(
 }
 async function appendSubagentLog(filePath, line, log7) {
   try {
-    await fsPromises.mkdir(path18.dirname(filePath), { recursive: true });
+    await fsPromises.mkdir(path19.dirname(filePath), { recursive: true });
     await fsPromises.appendFile(filePath, line + `
 `, "utf8");
   } catch (err) {
@@ -18258,6 +18410,27 @@ var subtaskHeartbeatServer = async (ctx) => {
   });
   const client = ctx.client;
   const cwd = ctx.directory;
+  _persistRoot = cwd;
+  try {
+    const restored = await loadParentMap(cwd);
+    if (restored.size > 0) {
+      const entries = [...restored.entries()].map(([childID, v]) => ({
+        childID,
+        parentID: v.parentID,
+        ts: v.ts
+      }));
+      _bulkInjectSessionParentMap(entries);
+      safeWriteLog(PLUGIN_NAME13, {
+        hook: "activate",
+        type: "parent-map.restore",
+        restored: restored.size
+      });
+    }
+  } catch (err) {
+    log7.warn("loadParentMap 失败（已隔离），降级为空表", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
   const interval = setInterval(() => {
     safeAsync(PLUGIN_NAME13, "interval", async () => {
       const swept = sweepExpiredPendingTasks();
@@ -18532,7 +18705,7 @@ var handler14 = parallelStatusServer;
 
 // plugins/parallel-tool-nudge.ts
 import { readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync4 } from "node:fs";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 import { homedir as homedir6 } from "node:os";
 var PLUGIN_NAME15 = "parallel-tool-nudge";
 logLifecycle(PLUGIN_NAME15, "import", {});
@@ -18588,10 +18761,10 @@ function loadAgentToolsMap(rootDir, opts = {}) {
   const reader = opts.reader ?? defaultReader2;
   const dirReader = opts.dirReader ?? defaultDirReader2;
   const dirExists = opts.dirExists ?? defaultDirExists2;
-  const homeAgentsDir = opts.homeAgentsDir ?? join15(homedir6(), ".config", "opencode", "agents");
+  const homeAgentsDir = opts.homeAgentsDir ?? join16(homedir6(), ".config", "opencode", "agents");
   const candidateDirs = [
-    join15(rootDir, ".codeforge", "agents"),
-    join15(rootDir, "agents"),
+    join16(rootDir, ".codeforge", "agents"),
+    join16(rootDir, "agents"),
     homeAgentsDir
   ];
   const result = new Map;
@@ -18614,20 +18787,20 @@ function loadAgentToolsMap(rootDir, opts = {}) {
     for (const entry of entries) {
       if (!entry.endsWith(".md"))
         continue;
-      const path19 = join15(dir, entry);
+      const path20 = join16(dir, entry);
       let content;
       try {
-        content = reader(path19);
+        content = reader(path20);
       } catch (err) {
         log8.warn(`agent.md 读取失败（已跳过）`, {
-          path: path19,
+          path: path20,
           error: err instanceof Error ? err.message : String(err)
         });
         continue;
       }
       const parsed = parseAgentFrontmatter(content);
       if (!parsed) {
-        log8.warn(`agent frontmatter 解析失败（已跳过）`, { path: path19 });
+        log8.warn(`agent frontmatter 解析失败（已跳过）`, { path: path20 });
         continue;
       }
       if (result.has(parsed.name))
@@ -18818,19 +18991,19 @@ var handler16 = async (_ctx3) => {
 };
 
 // lib/event-stream.ts
-import { promises as fs15 } from "node:fs";
+import { promises as fs16 } from "node:fs";
 init_runtime_paths();
-import * as path19 from "node:path";
+import * as path20 from "node:path";
 async function loadSession(id, opts = {}) {
   const file = resolveSessionFile(id, opts);
-  const raw = await fs15.readFile(file, "utf8");
+  const raw = await fs16.readFile(file, "utf8");
   return parseJsonl(id, raw);
 }
 async function listSessions(opts = {}) {
   const dir = resolveDir(opts);
   let entries;
   try {
-    entries = await fs15.readdir(dir, { withFileTypes: true });
+    entries = await fs16.readdir(dir, { withFileTypes: true });
   } catch (err) {
     if (err.code === "ENOENT")
       return [];
@@ -18840,10 +19013,10 @@ async function listSessions(opts = {}) {
   for (const e of entries) {
     if (!e.isFile() || !e.name.endsWith(".jsonl"))
       continue;
-    const file = path19.join(dir, e.name);
+    const file = path20.join(dir, e.name);
     const id = e.name.replace(/\.jsonl$/, "");
     try {
-      const stat = await fs15.stat(file);
+      const stat = await fs16.stat(file);
       const headerLine = await readFirstLine(file);
       let started_at = stat.birthtimeMs;
       if (headerLine) {
@@ -18867,11 +19040,11 @@ async function listSessions(opts = {}) {
   return out;
 }
 function resolveDir(opts = {}) {
-  const root = path19.resolve(opts.root ?? process.cwd());
-  return opts.sessions_dir ? path19.resolve(root, opts.sessions_dir) : path19.join(runtimeDir(root), "sessions");
+  const root = path20.resolve(opts.root ?? process.cwd());
+  return opts.sessions_dir ? path20.resolve(root, opts.sessions_dir) : path20.join(runtimeDir(root), "sessions");
 }
 function resolveSessionFile(id, opts = {}) {
-  return path19.join(resolveDir(opts), `${id}.jsonl`);
+  return path20.join(resolveDir(opts), `${id}.jsonl`);
 }
 function parseJsonl(id, raw) {
   const events = [];
@@ -18906,7 +19079,7 @@ function isEvent(obj) {
 }
 async function readFirstLine(file) {
   const buf = Buffer.alloc(4096);
-  const fh = await fs15.open(file, "r");
+  const fh = await fs16.open(file, "r");
   try {
     const { bytesRead } = await fh.read(buf, 0, buf.length, 0);
     const s = buf.subarray(0, bytesRead).toString("utf8");
@@ -19133,6 +19306,92 @@ function isRecoveryWorthShowing(plan) {
   return hasSignal;
 }
 
+// lib/block-pending.ts
+init_runtime_paths();
+import { promises as fs17 } from "node:fs";
+import * as path21 from "node:path";
+function blockPendingFilePath(absRoot) {
+  const rd = runtimeDir(absRoot, { ensure: false });
+  return path21.join(rd, "sessions", "autonomous-blocks.ndjson");
+}
+function consumeLockPath(absRoot) {
+  return blockPendingFilePath(absRoot) + ".consume.lock";
+}
+async function scanBlockPending(absRoot, filterSessionId) {
+  const file = blockPendingFilePath(absRoot);
+  let raw;
+  try {
+    raw = await fs17.readFile(file, "utf8");
+  } catch {
+    return [];
+  }
+  if (!raw)
+    return [];
+  const consumed = new Set;
+  const entries = [];
+  for (const line of raw.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    let obj;
+    try {
+      obj = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (!obj || typeof obj !== "object")
+      continue;
+    if (obj["type"] === "consume") {
+      const sid = obj["sessionId"];
+      const ts = obj["timestamp"];
+      if (typeof sid === "string" && typeof ts === "string") {
+        consumed.add(`${sid}|${ts}`);
+      }
+      continue;
+    }
+    const sessionId = obj["sessionId"];
+    const timestamp = obj["timestamp"];
+    if (typeof sessionId !== "string" || typeof timestamp !== "string")
+      continue;
+    const entry = {
+      sessionId,
+      timestamp,
+      reason: typeof obj["reason"] === "string" ? obj["reason"] : undefined,
+      summary_excerpt: typeof obj["summary_excerpt"] === "string" ? obj["summary_excerpt"] : undefined,
+      consumed_at: typeof obj["consumed_at"] === "string" ? obj["consumed_at"] : undefined
+    };
+    entries.push(entry);
+  }
+  return entries.filter((e) => {
+    if (e.consumed_at)
+      return false;
+    if (consumed.has(`${e.sessionId}|${e.timestamp}`))
+      return false;
+    if (filterSessionId && e.sessionId !== filterSessionId)
+      return false;
+    return true;
+  });
+}
+async function markBlocksConsumed(absRoot, entries) {
+  if (entries.length === 0)
+    return;
+  const file = blockPendingFilePath(absRoot);
+  await fs17.mkdir(path21.dirname(file), { recursive: true });
+  const now = new Date().toISOString();
+  const lines = entries.map((e) => ({
+    type: "consume",
+    sessionId: e.sessionId,
+    timestamp: e.timestamp,
+    consumed_at: now
+  })).map((row) => JSON.stringify(row)).join(`
+`) + `
+`;
+  await withFileLock(consumeLockPath(absRoot), async () => {
+    await fs17.appendFile(file, lines, "utf8");
+  });
+}
+
 // plugins/session-recovery.ts
 var PLUGIN_NAME17 = "session-recovery";
 logLifecycle(PLUGIN_NAME17, "import", {});
@@ -19149,10 +19408,23 @@ async function processSessionStart(currentSessionId, opts = {}) {
     return { ok: false, injected: false, reason: "scan_error", error: r.error };
   }
   const plan = r.plan;
-  if (!isRecoveryWorthShowing(plan)) {
-    return { ok: true, injected: false, plan, reason: "no_signal" };
+  let pendingBlocks = [];
+  if (opts.root) {
+    try {
+      pendingBlocks = await scanBlockPending(opts.root);
+    } catch (err) {
+      opts.log?.warn?.(`[${PLUGIN_NAME17}] scanBlockPending 异常：${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  const hasPendingBlocks = pendingBlocks.length > 0;
+  if (!isRecoveryWorthShowing(plan) && !hasPendingBlocks) {
+    return { ok: true, injected: false, plan, reason: "no_signal", pendingBlocks };
   }
-  const prompt = renderPrompt(plan);
+  const blockPrompt = hasPendingBlocks ? renderBlockPendingPrompt(pendingBlocks) : "";
+  const recoveryPrompt = isRecoveryWorthShowing(plan) ? renderPrompt(plan) : "";
+  const prompt = [blockPrompt, recoveryPrompt].filter((s) => s.length > 0).join(`
+
+`);
   const injection = { source: "session-recovery", plan, prompt };
   if (opts.injectRecovery) {
     try {
@@ -19160,10 +19432,36 @@ async function processSessionStart(currentSessionId, opts = {}) {
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       opts.log?.warn?.(`[${PLUGIN_NAME17}] injectRecovery 异常：${msg}`);
-      return { ok: false, injected: false, plan, reason: "inject_error", error: msg };
+      return { ok: false, injected: false, plan, reason: "inject_error", error: msg, pendingBlocks };
     }
   }
-  return { ok: true, injected: true, plan, reason: "ok" };
+  if (hasPendingBlocks && opts.root) {
+    try {
+      await markBlocksConsumed(opts.root, pendingBlocks);
+    } catch (err) {
+      opts.log?.warn?.(`[${PLUGIN_NAME17}] markBlocksConsumed 异常：${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return { ok: true, injected: true, plan, reason: "ok", pendingBlocks };
+}
+function renderBlockPendingPrompt(entries) {
+  const lines = [];
+  lines.push(`⚠️ **${entries.length} 个未读 BLOCK 通知**（上次 auto 模式 reviewer 阻断、channels 通知失败）：`);
+  lines.push("");
+  entries.forEach((e, i) => {
+    const sidShort = e.sessionId.length > 12 ? e.sessionId.slice(0, 8) + "…" : e.sessionId;
+    const reasonPart = e.reason ? `：${e.reason}` : "";
+    lines.push(`${i + 1}. session \`${sidShort}\` @ ${e.timestamp}${reasonPart}`);
+    if (e.summary_excerpt) {
+      const excerpt = e.summary_excerpt.length > 200 ? e.summary_excerpt.slice(0, 200) + "…" : e.summary_excerpt;
+      lines.push(`   > ${excerpt.replace(/\n/g, `
+   > `)}`);
+    }
+  });
+  lines.push("");
+  lines.push("请按用户偏好处理上述 BLOCK（重派 reviewer / 用户决策），再继续其它工作。");
+  return lines.join(`
+`);
 }
 function renderPrompt(plan) {
   const lines = [];
@@ -19215,10 +19513,11 @@ var sessionRecoveryServer = async (ctx) => {
           ok: r.ok,
           injected: r.injected,
           reason: r.reason,
-          last_session_id: r.plan?.last_session_id
+          last_session_id: r.plan?.last_session_id,
+          pending_blocks_count: r.pendingBlocks?.length ?? 0
         });
         if (r.injected && r.plan) {
-          log9.info(`[${PLUGIN_NAME17}] 注入恢复提示（last=${r.plan.last_session_id?.slice(0, 8) ?? "?"}, reason=${r.plan.reason}）`);
+          log9.info(`[${PLUGIN_NAME17}] 注入恢复提示（last=${r.plan.last_session_id?.slice(0, 8) ?? "?"}, reason=${r.plan.reason}, pending_blocks=${r.pendingBlocks?.length ?? 0}）`);
         }
       });
     }
@@ -19227,8 +19526,8 @@ var sessionRecoveryServer = async (ctx) => {
 var handler17 = sessionRecoveryServer;
 
 // plugins/subtasks.ts
-import { promises as fs16 } from "node:fs";
-import * as path20 from "node:path";
+import { promises as fs18 } from "node:fs";
+import * as path22 from "node:path";
 
 // lib/parallel-merge.ts
 init_autonomy();
@@ -20046,14 +20345,14 @@ function describe8(err) {
   }
 }
 function sleep2(ms) {
-  return new Promise((resolve15) => setTimeout(resolve15, ms));
+  return new Promise((resolve16) => setTimeout(resolve16, ms));
 }
 
 // plugins/subtasks.ts
 init_runtime_paths();
 var PLUGIN_NAME18 = "subtasks";
 function getLogFile(root = process.cwd()) {
-  return path20.join(runtimeDir(root), "logs", "subtasks.log");
+  return path22.join(runtimeDir(root), "logs", "subtasks.log");
 }
 var VERB_RE = /^([a-zA-Z]{3,12})/;
 var CN_VERBS = [
@@ -20358,8 +20657,8 @@ async function writeLog(level, msg, data) {
 `;
   try {
     const logFile = getLogFile();
-    await fs16.mkdir(path20.dirname(logFile), { recursive: true });
-    await fs16.appendFile(logFile, line, "utf8");
+    await fs18.mkdir(path22.dirname(logFile), { recursive: true });
+    await fs18.appendFile(logFile, line, "utf8");
   } catch {}
 }
 logLifecycle(PLUGIN_NAME18, "import");
@@ -20875,12 +21174,12 @@ var tokenManagerServer = async (ctx) => {
 var handler20 = tokenManagerServer;
 
 // plugins/tool-policy.ts
-import { promises as fs17 } from "node:fs";
-import * as path22 from "node:path";
+import { promises as fs19 } from "node:fs";
+import * as path24 from "node:path";
 init_autonomy();
 
 // lib/file-regex-acl.ts
-import * as path21 from "node:path";
+import * as path23 from "node:path";
 function compileRule(r) {
   if (r instanceof RegExp)
     return r;
@@ -20946,7 +21245,7 @@ function normalizePath2(p) {
   let s = p.replace(/\\/g, "/");
   if (s.startsWith("./"))
     s = s.slice(2);
-  s = path21.posix.normalize(s);
+  s = path23.posix.normalize(s);
   return s;
 }
 function checkFileAccess(acl, file, op) {
@@ -21056,11 +21355,11 @@ function decideToolCall(ctx, cfg = {}, currentAgent) {
     action = "deny";
   return { action, reasons, autonomy: a, acl: aclResults };
 }
-var POLICY_PATH = path22.join(".codeforge", "policy.json");
+var POLICY_PATH = path24.join(".codeforge", "policy.json");
 async function loadPolicy(root = process.cwd()) {
-  const file = path22.join(root, POLICY_PATH);
+  const file = path24.join(root, POLICY_PATH);
   try {
-    const raw = await fs17.readFile(file, "utf8");
+    const raw = await fs19.readFile(file, "utf8");
     const data = JSON.parse(raw);
     return data;
   } catch {
@@ -21170,7 +21469,7 @@ var handler21 = toolPolicyServer;
 // plugins/update-checker.ts
 import { existsSync as existsSync5 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { join as join20 } from "node:path";
+import { join as join22 } from "node:path";
 
 // lib/update-checker-impl.ts
 import { createHash as createHash5 } from "node:crypto";
@@ -21187,7 +21486,7 @@ import {
   writeFileSync as writeFileSync2
 } from "node:fs";
 import { homedir as homedir7, tmpdir } from "node:os";
-import { dirname as dirname11, join as join19 } from "node:path";
+import { dirname as dirname13, join as join21 } from "node:path";
 import { fileURLToPath } from "node:url";
 import * as https from "node:https";
 import * as zlib from "node:zlib";
@@ -21195,7 +21494,7 @@ import * as zlib from "node:zlib";
 // lib/version-injected.ts
 function getInjectedVersion() {
   try {
-    const v = "0.5.4";
+    const v = "0.5.6";
     if (typeof v === "string" && /^\d+\.\d+\.\d+/.test(v)) {
       return v;
     }
@@ -21284,18 +21583,18 @@ function readLocalVersion() {
     return injected;
   try {
     const here = fileURLToPath(import.meta.url);
-    const root = dirname11(dirname11(here));
-    const pkg = JSON.parse(readFileSync5(join19(root, "package.json"), "utf8"));
+    const root = dirname13(dirname13(here));
+    const pkg = JSON.parse(readFileSync5(join21(root, "package.json"), "utf8"));
     return typeof pkg.version === "string" ? pkg.version : "0.0.0";
   } catch {
     return "0.0.0";
   }
 }
 function defaultCacheDir() {
-  return process.env["CODEFORGE_CACHE_DIR"] ?? join19(homedir7(), ".cache", "codeforge");
+  return process.env["CODEFORGE_CACHE_DIR"] ?? join21(homedir7(), ".cache", "codeforge");
 }
 function defaultCacheFile() {
-  return join19(defaultCacheDir(), "update-check.json");
+  return join21(defaultCacheDir(), "update-check.json");
 }
 function readCache(file) {
   try {
@@ -21313,7 +21612,7 @@ function readCache(file) {
 }
 function writeCache(file, entry) {
   try {
-    mkdirSync3(dirname11(file), { recursive: true });
+    mkdirSync3(dirname13(file), { recursive: true });
     writeFileSync2(file, JSON.stringify(entry, null, 2), "utf8");
   } catch {}
 }
@@ -21332,7 +21631,7 @@ function fetchLatestTagFromGitHub(repo) {
   });
 }
 function getJsonWithRedirect(url, hopsLeft) {
-  return new Promise((resolve15, reject) => {
+  return new Promise((resolve16, reject) => {
     const u = new URL(url);
     const headers = {
       "User-Agent": "codeforge-update-checker",
@@ -21356,12 +21655,12 @@ function getJsonWithRedirect(url, hopsLeft) {
           return;
         }
         const next = new URL(res.headers.location, url).toString();
-        getJsonWithRedirect(next, hopsLeft - 1).then(resolve15, reject);
+        getJsonWithRedirect(next, hopsLeft - 1).then(resolve16, reject);
         return;
       }
       if (status === 404) {
         res.resume();
-        resolve15(null);
+        resolve16(null);
         return;
       }
       if (status >= 400) {
@@ -21372,7 +21671,7 @@ function getJsonWithRedirect(url, hopsLeft) {
       let body = "";
       res.setEncoding("utf8");
       res.on("data", (chunk) => body += chunk);
-      res.on("end", () => resolve15(body));
+      res.on("end", () => resolve16(body));
     });
     req.on("timeout", () => {
       req.destroy();
@@ -21412,7 +21711,7 @@ async function fetchLatestFromNpm(opts) {
   return { version, tarballUrl, integrity };
 }
 function defaultHttpFetcher(url, timeoutMs) {
-  return new Promise((resolve15, reject) => {
+  return new Promise((resolve16, reject) => {
     const u = new URL(url);
     const headers = {
       "User-Agent": "codeforge-update-checker",
@@ -21429,7 +21728,7 @@ function defaultHttpFetcher(url, timeoutMs) {
       const status = res.statusCode ?? 0;
       if (status === 404) {
         res.resume();
-        resolve15(null);
+        resolve16(null);
         return;
       }
       if (status >= 400) {
@@ -21440,7 +21739,7 @@ function defaultHttpFetcher(url, timeoutMs) {
       let body = "";
       res.setEncoding("utf8");
       res.on("data", (chunk) => body += chunk);
-      res.on("end", () => resolve15(body));
+      res.on("end", () => resolve16(body));
     });
     req.on("timeout", () => {
       req.destroy();
@@ -21451,14 +21750,14 @@ function defaultHttpFetcher(url, timeoutMs) {
   });
 }
 async function downloadAndExtractBundle(opts) {
-  const tmpRoot = opts.tmpDir ?? mkdtempSync(join19(tmpdir(), "codeforge-update-"));
+  const tmpRoot = opts.tmpDir ?? mkdtempSync(join21(tmpdir(), "codeforge-update-"));
   mkdirSync3(tmpRoot, { recursive: true });
   const fetcher = opts.tarballFetcher ?? defaultBinaryFetcher;
   const tarballBuf = await fetcher(opts.tarballUrl);
   verifyIntegrity(tarballBuf, opts.expectedIntegrity);
   const tarBuf = zlib.gunzipSync(tarballBuf);
   extractTarToDir(tarBuf, tmpRoot);
-  const bundlePath = join19(tmpRoot, "package", "dist", "index.js");
+  const bundlePath = join21(tmpRoot, "package", "dist", "index.js");
   if (!existsSync4(bundlePath)) {
     throw new Error(`bundle_not_found: ${bundlePath}`);
   }
@@ -21498,11 +21797,11 @@ function extractTarToDir(tarBuf, destRoot) {
     offset += 512;
     if (typeFlag === "0" || typeFlag === "" || typeFlag === "\x00") {
       const fileBuf = tarBuf.subarray(offset, offset + size);
-      const dest = join19(destRoot, fullName);
-      mkdirSync3(dirname11(dest), { recursive: true });
+      const dest = join21(destRoot, fullName);
+      mkdirSync3(dirname13(dest), { recursive: true });
       writeFileSync2(dest, fileBuf);
     } else if (typeFlag === "5") {
-      mkdirSync3(join19(destRoot, fullName), { recursive: true });
+      mkdirSync3(join21(destRoot, fullName), { recursive: true });
     }
     offset += Math.ceil(size / 512) * 512;
   }
@@ -21511,7 +21810,7 @@ function defaultBinaryFetcher(url) {
   return downloadBinary(url, 3);
 }
 function downloadBinary(url, hopsLeft) {
-  return new Promise((resolve15, reject) => {
+  return new Promise((resolve16, reject) => {
     const u = new URL(url);
     const req = https.request({
       host: u.hostname,
@@ -21529,7 +21828,7 @@ function downloadBinary(url, hopsLeft) {
           return;
         }
         const next = new URL(res.headers.location, url).toString();
-        downloadBinary(next, hopsLeft - 1).then(resolve15, reject);
+        downloadBinary(next, hopsLeft - 1).then(resolve16, reject);
         return;
       }
       if (status >= 400) {
@@ -21539,7 +21838,7 @@ function downloadBinary(url, hopsLeft) {
       }
       const chunks = [];
       res.on("data", (chunk) => chunks.push(chunk));
-      res.on("end", () => resolve15(Buffer.concat(chunks)));
+      res.on("end", () => resolve16(Buffer.concat(chunks)));
     });
     req.on("timeout", () => {
       req.destroy();
@@ -21555,7 +21854,7 @@ function atomicReplaceBundle(opts) {
   if (!existsSync4(source)) {
     throw new Error(`atomic_source_missing: ${source}`);
   }
-  mkdirSync3(dirname11(target), { recursive: true });
+  mkdirSync3(dirname13(target), { recursive: true });
   const newPath = `${target}.new`;
   const backupPath = `${target}.bak.${oldVersion}`;
   let strategy = "rename";
@@ -21607,11 +21906,11 @@ function cleanupOldBackups(target, keep) {
   if (keep <= 0)
     return;
   try {
-    const dir = dirname11(target);
+    const dir = dirname13(target);
     const base = target.substring(dir.length + 1);
     const prefix = `${base}.bak.`;
     const all = readdirSync3(dir).filter((f) => f.startsWith(prefix)).map((f) => {
-      const full = join19(dir, f);
+      const full = join21(dir, f);
       let mtimeMs = 0;
       try {
         mtimeMs = statSync5(full).mtimeMs;
@@ -21633,7 +21932,7 @@ function loadCompatibility(opts) {
       const root = opts?.cwd ?? inferPluginRoot();
       if (!root)
         return null;
-      file = join19(root, "compatibility.json");
+      file = join21(root, "compatibility.json");
     }
     if (!existsSync4(file))
       return null;
@@ -21658,7 +21957,7 @@ function loadCompatibility(opts) {
 function inferPluginRoot() {
   try {
     const here = fileURLToPath(import.meta.url);
-    return dirname11(dirname11(here));
+    return dirname13(dirname13(here));
   } catch {
     return null;
   }
@@ -21853,14 +22152,14 @@ function detectOpencodeVersion() {
 }
 function getOpencodeBundlePath() {
   const candidates = [];
-  candidates.push(join20(homedir8(), ".config", "opencode", "codeforge", "index.js"));
+  candidates.push(join22(homedir8(), ".config", "opencode", "codeforge", "index.js"));
   if (process.platform === "win32") {
     const appData = process.env["APPDATA"];
     if (appData)
-      candidates.push(join20(appData, "opencode", "codeforge", "index.js"));
+      candidates.push(join22(appData, "opencode", "codeforge", "index.js"));
     const localAppData = process.env["LOCALAPPDATA"];
     if (localAppData)
-      candidates.push(join20(localAppData, "opencode", "codeforge", "index.js"));
+      candidates.push(join22(localAppData, "opencode", "codeforge", "index.js"));
   }
   for (const c of candidates) {
     if (existsSync5(c))
@@ -21921,11 +22220,11 @@ async function postToast(ctx, message) {
 var handler22 = updateCheckerServer;
 
 // plugins/workflow-engine.ts
-import * as path24 from "node:path";
+import * as path26 from "node:path";
 
 // lib/workflow-loader.ts
-import { promises as fs18 } from "node:fs";
-import * as path23 from "node:path";
+import { promises as fs20 } from "node:fs";
+import * as path25 from "node:path";
 import { z as z32 } from "zod";
 var ActionSchema = z32.object({
   tool: z32.string().min(1, "action.tool 不能为空"),
@@ -22011,7 +22310,7 @@ function parseWorkflowYaml(yaml, sourcePath = "<inline>") {
 async function loadWorkflowFromFile(filePath) {
   let txt;
   try {
-    txt = await fs18.readFile(filePath, "utf8");
+    txt = await fs20.readFile(filePath, "utf8");
   } catch (err) {
     return {
       ok: false,
@@ -22026,7 +22325,7 @@ async function loadWorkflowsFromDir(dir) {
   const failed = [];
   let entries;
   try {
-    entries = await fs18.readdir(dir);
+    entries = await fs20.readdir(dir);
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT")
@@ -22038,7 +22337,7 @@ async function loadWorkflowsFromDir(dir) {
       continue;
     if (!/\.ya?ml$/i.test(name))
       continue;
-    const full = path23.join(dir, name);
+    const full = path25.join(dir, name);
     const r = await loadWorkflowFromFile(full);
     if (r.ok)
       loaded.push(r);
@@ -22428,7 +22727,7 @@ async function handleCommandInvoked(raw, workflowsDir = "workflows") {
 }
 var workflowEngineServer = async (ctx) => {
   const directory = ctx.directory ?? process.cwd();
-  const workflowsDir = path24.join(directory, "workflows");
+  const workflowsDir = path26.join(directory, "workflows");
   ensureRegistry(workflowsDir).catch((err) => fallbackLog2.warn(`[${PLUGIN_NAME23}] preload workflows failed`, {
     error: err instanceof Error ? err.message : String(err)
   }));
@@ -22472,7 +22771,7 @@ var workflowEngineServer = async (ctx) => {
 var handler23 = workflowEngineServer;
 
 // plugins/session-worktree-guard.ts
-import path25 from "node:path";
+import path27 from "node:path";
 var PLUGIN_NAME24 = "session-worktree-guard";
 logLifecycle(PLUGIN_NAME24, "import", {});
 var WRITE_INTENT_RE = />(?!=)|\btee\b|\brm\b|\bmv\b|\bcp\b|\bmkdir\b|\btouch\b|\bchmod\b|\bchown\b|\bln\b/;
@@ -22501,7 +22800,7 @@ var WRITE_TOOLS = new Set(["write", "edit", "ast_edit"]);
 function rewritePath(value, mainRoot, worktreeRoot) {
   if (!value)
     return null;
-  const resolved = path25.isAbsolute(value) ? value : path25.resolve(mainRoot, value);
+  const resolved = path27.isAbsolute(value) ? value : path27.resolve(mainRoot, value);
   if (resolved === mainRoot)
     return worktreeRoot;
   const prefix = mainRoot.endsWith("/") ? mainRoot : mainRoot + "/";
@@ -22631,6 +22930,32 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
           }
         }
         const worktreePath = entry.worktreePath;
+        if (toolName === "session_merge") {
+          const action = argsObj["action"];
+          if (action === "merge") {
+            const caller = input.agent;
+            if (caller !== undefined && caller !== "codeforge") {
+              const reason = `[session-worktree-guard] DENIED: session_merge action=merge 仅 codeforge orchestrator 或用户可调；当前 caller=${caller}`;
+              log13.warn(reason, {
+                sessionId,
+                tool: toolName,
+                action,
+                caller
+              });
+              safeWriteLog(PLUGIN_NAME24, {
+                hook: "tool.execute.before",
+                tool: toolName,
+                sessionID: input.sessionID,
+                action: "deny",
+                source: "merge-caller-whitelist",
+                caller,
+                merge_action: "merge"
+              });
+              denied = new DeniedError(reason);
+              return;
+            }
+          }
+        }
         if (toolName !== "plan_read" && entry.requiredPlanId && entry.planReadOk !== true) {
           let isWriteOp = WRITE_TOOLS.has(toolName);
           if (!isWriteOp && toolName === "bash") {
@@ -22818,9 +23143,8 @@ var worktreeLifecyclePlugin = async (ctx) => {
             return;
           }
           try {
-            const mainHead = await getCurrentMainHead(mainRoot);
-            const worktreeHead = mainHead ? await getCurrentWorktreeHead(entry.worktreePath) : "";
-            if (worktreeHead && worktreeHead === mainHead) {
+            const worktreeHead = await getCurrentWorktreeHead(entry.worktreePath);
+            if (worktreeHead && worktreeHead === entry.baseSha) {
               const fastDirty = await isWorktreeDirty(entry.worktreePath);
               if (!fastDirty) {
                 await discardSession({ sessionId: ended.sessionID, mainRoot });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andyqiu/codeforge",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "CodeForge — opencode 的零侵入扩展包",
   "type": "module",
   "private": false,