@andyqiu/codeforge 0.5.3 → 0.5.5

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

@@ -0,0 +1,91 @@
+---
+name: autonomy
+description: 查看或切换当前 session 的自主度档位（step/semi/full/auto）
+---
+
+查看或切换当前 session 的自主执行模式（autonomy）。
+
+## 用法
+
+- `/autonomy` — 显示当前档位和 budget 状态
+- `/autonomy step` — 每个工具调用都要确认
+- `/autonomy semi` — 危险工具确认，安全工具自动（默认）
+- `/autonomy full` — 全自动工具执行（reviewer APPROVE 后仍需 `/merge` 手动触发）
+- `/autonomy auto` — 全自动 + APPROVE 自动 merge（**最小干预模式**）
+- `/autonomy status` — **Phase 2.2** 显示实时状态（档位 / paused / 五维 budget / 全局今日 USD / block-pending）
+
+## ⚠️ auto 模式须知
+
+切到 `auto` 等同 plandex `auto` 档位 —— **最小干预**而非零干预：
+
+- reviewer **APPROVE** 后自动合并，无需手动 `/merge`
+  - **双重验证**：必须 reviewer 摘要 Decision=APPROVE **且** `approval-store` 存在对应 APPROVE 记录，缺一不可
+  - 任一失败 → fail-safe（不 merge，emit `autonomous.decision.parse_error` event + toast）
+- **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）
+
+| 维度 | 默认值 |
+|---|---|
+| 总 tokens | 50,000 |
+| 总 USD | $3 |
+| 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 信号）。
+
+### 逃生口
+
+- `/pause` — 立刻退回 semi（不打断在途 merge）
+- `/discard-session` — 不可逆，硬丢 worktree + branch
+- budget 耗尽 — 自动降回 semi
+- BLOCK — 强制通知 + 降档
+- stuck 检测 — 5 轮无进展自动降档
+
+## 行为对比
+
+| 场景 | step | semi | full | auto |
+|---|---|---|---|---|
+| bash / edit 执行 | confirm | confirm | auto | auto |
+| read / search 执行 | confirm | auto | auto | auto |
+| reviewer APPROVE 后 | 手动 `/merge` | 手动 `/merge` | 手动 `/merge` | **自动 merge** |
+| reviewer BLOCK 后 | 用户处理 | 用户处理 | 用户处理 | **channels 通知 + 降档** |
+
+## 配置存储
+
+- 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/commands/pause.md

@@ -0,0 +1,18 @@
+---
+name: pause
+description: 立刻暂停当前 session 的 auto 模式，降回 semi
+---
+
+暂停当前 session 的自主执行模式（auto），降回 semi 模式。
+
+**行为说明**：
+
+- 如果按下时**正在进行自动 merge**，当次 merge 会**继续跑完**（`session_merge` 是原子事务：worktree commit + squash + commit + cleanup 一气呵成，无法中段抢断）
+- `paused` 标志设置后，driver 会在**下一次** `task.completed` / `session.idle` 事件时生效
+- 如需**立刻放弃**所有改动，请使用 `/discard-session`（不可逆，硬丢 worktree）
+
+**恢复 auto 模式**：使用 `/autonomy auto`（会自动清除 paused 标志，允许 driver 重新激活）
+
+**配置存储**：`<runtimeDir>/autonomy/<sessionId>.json`，跨进程并发安全（withFileLock）
+
+**关联 ADR**：[autonomous-mode](../docs/adr/autonomous-mode.md)

package/dist/index.js

@@ -76,6 +76,9 @@ function planFilePath(absRoot, title) {
   const slug = titleToSlug(title);
   return normalize2(path2.join(dir, `${ts}-${slug}.md`));
 }
+function subagentLogPath(absRoot, parentID, childID) {
+  return normalize2(path2.join(runtimeDir(absRoot, { ensure: false }), "subagents", parentID, `${childID}.log`));
+}
 function normalize2(p) {
   return path2.normalize(path2.resolve(p));
 }
@@ -168,6 +171,20 @@ function globalConfigDir(env = process.env) {
 function projectConfigDir(root = process.cwd()) {
   return path3.join(root, ".codeforge");
 }
+function getCodeforgeConfig(opts = {}) {
+  const root = opts.root ?? process.cwd();
+  const env = opts.env ?? process.env;
+  const cacheKey = `codeforge:${root}`;
+  const cached = cacheGet(cacheKey);
+  if (cached !== undefined)
+    return cached;
+  const builtin = {};
+  const globalCfg = readJsonObject(path3.join(globalConfigDir(env), "codeforge.json"));
+  const projectCfg = readJsonObject(path3.join(projectConfigDir(root), "codeforge.json"));
+  const merged = { ...builtin, ...globalCfg, ...projectCfg };
+  cacheSet(cacheKey, merged);
+  return merged;
+}
 function getKhConfig(opts = {}) {
   const root = opts.root ?? process.cwd();
   const env = opts.env ?? process.env;
@@ -1021,6 +1038,14 @@ var init_autonomy = __esm(() => {
       read: "auto",
       search: "auto",
       other: "auto"
+    },
+    auto: {
+      bash: "auto",
+      edit: "auto",
+      webfetch: "auto",
+      read: "auto",
+      search: "auto",
+      other: "auto"
     }
   };
   RISK_PATTERNS = [
@@ -13361,6 +13386,13 @@ async function markInterruptedDirty(opts) {
     }
   });
 }
+async function getCurrentWorktreeHead(worktreePath) {
+  try {
+    return (await runGit2(path13.resolve(worktreePath), ["rev-parse", "HEAD"])).trim();
+  } catch {
+    return "";
+  }
+}
 async function isWorktreeDirty(worktreePath) {
   try {
     const out = (await runGit2(worktreePath, ["status", "--porcelain"])).trim();
@@ -13398,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 = [];
@@ -13515,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
@@ -17797,6 +17855,10 @@ var modelFallbackServer = async (ctx) => {
 var handler12 = modelFallbackServer;
 
 // plugins/subtask-heartbeat.ts
+import { promises as fsPromises } from "node:fs";
+import * as path18 from "node:path";
+init_runtime_paths();
+init_global_config();
 var PLUGIN_NAME13 = "subtask-heartbeat";
 logLifecycle(PLUGIN_NAME13, "import", {});
 var HEARTBEAT_INTERVAL_MS2 = 30000;
@@ -17807,11 +17869,75 @@ var PENDING_TASK_TTL_MS = 60000;
 var PENDING_TASK_MAX_PARENTS = 64;
 var PENDING_TASK_MAX_PER_PARENT = 16;
 var DESCRIPTION_MAX_LEN = 60;
+var SESSION_PARENT_MAP_TTL_MS = 30 * 60000;
+var SESSION_PARENT_MAP_MAX_SIZE = 256;
+var PARENT_PARSE_FAIL_MAX_LOG = 10;
 var inflight3 = new Map;
 var pendingTask = new Map;
+var sessionParentMap = new Map;
+var _parentParseFailLogged = 0;
 function _snapshotInflight() {
   return [...inflight3.values()].map((r) => ({ ...r }));
 }
+function recordSessionParent(childID, parentID, now = Date.now()) {
+  if (!childID || !parentID)
+    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;
+      }
+    }
+    if (oldestKey !== null)
+      sessionParentMap.delete(oldestKey);
+  }
+  sessionParentMap.set(childID, { parentID, ts: now });
+}
+function lookupParentSessionId(childID, now = Date.now()) {
+  const entry = sessionParentMap.get(childID);
+  if (!entry)
+    return;
+  if (now - entry.ts > SESSION_PARENT_MAP_TTL_MS) {
+    sessionParentMap.delete(childID);
+    return;
+  }
+  return entry.parentID;
+}
+function deleteSessionParent(childID) {
+  sessionParentMap.delete(childID);
+}
+function sweepExpiredSessionParents(now = Date.now()) {
+  let removed = 0;
+  for (const [k, v] of [...sessionParentMap.entries()]) {
+    if (now - v.ts > SESSION_PARENT_MAP_TTL_MS) {
+      sessionParentMap.delete(k);
+      removed++;
+    }
+  }
+  return removed;
+}
+function detectUnparsedParentID(event) {
+  if (!event || typeof event !== "object")
+    return false;
+  const e = event;
+  if (e.type !== "session.created")
+    return false;
+  if (extractCreatedChild(event))
+    return false;
+  try {
+    const json = JSON.stringify(event);
+    return /\bparent[_-]?[iI][dD]\b/.test(json);
+  } catch {
+    return false;
+  }
+}
 function getInflightSnapshot() {
   return _snapshotInflight();
 }
@@ -17928,7 +18054,8 @@ function registerInflight(payload, now = Date.now()) {
     description: payload.description ?? null,
     startedAt: now,
     lastBeatAt: now,
-    lastTool: null
+    lastTool: null,
+    pendingCalls: new Map
   };
   inflight3.set(payload.childID, r);
   return r;
@@ -18027,6 +18154,94 @@ function buildEndToast(r, type, now = Date.now()) {
     variant
   };
 }
+function sanitizeInputSummary(toolName, args) {
+  if (!args || typeof args !== "object")
+    return `${toolName} (no args)`;
+  const a = args;
+  const PATH_KEYS = [
+    "path",
+    "file",
+    "filePath",
+    "file_path",
+    "filepath",
+    "target"
+  ];
+  for (const k of PATH_KEYS) {
+    const v = a[k];
+    if (typeof v === "string" && v.length > 0 && v.length <= 200) {
+      return `${toolName} ${v}`;
+    }
+  }
+  const cmd = a["command"];
+  if (typeof cmd === "string" && cmd.length > 0) {
+    const head = cmd.replace(/\s+/g, " ").trim().slice(0, 60);
+    return `${toolName} $ ${head}`;
+  }
+  return `${toolName} (no path)`;
+}
+function buildBeforeLogLine(toolName, args, now = Date.now()) {
+  return JSON.stringify({
+    ts: Math.floor(now / 1000),
+    tool: toolName,
+    phase: "before",
+    input_summary: sanitizeInputSummary(toolName, args)
+  });
+}
+function buildAfterLogLine(toolName, ok, durationMs, now = Date.now()) {
+  return JSON.stringify({
+    ts: Math.floor(now / 1000),
+    tool: toolName,
+    phase: "after",
+    ok,
+    duration_ms: durationMs
+  });
+}
+function buildSuccessNotice(r, logPath, now = Date.now()) {
+  const agent = r.agent ? titleCase(r.agent) : "subagent";
+  const elapsed = fmtElapsed(now - r.startedAt);
+  return [`✅ ${agent} 完成（${elapsed}）`, `\uD83D\uDCC4 完整日志: ${logPath}`].join(`
+`);
+}
+function buildFailureNotice(r, endedType, logPath, worktreePath, now = Date.now()) {
+  const agent = r.agent ? titleCase(r.agent) : "subagent";
+  const elapsed = fmtElapsed(now - r.startedAt);
+  const verb = endedType === "session.deleted" ? "被取消" : "失败";
+  const lines = [
+    `❌ ${agent} ${verb}（${endedType}, ${elapsed}）`,
+    `\uD83D\uDCC4 完整日志: ${logPath}`
+  ];
+  if (worktreePath)
+    lines.push(`\uD83D\uDD0D worktree 保留: ${worktreePath}`);
+  lines.push(`\uD83D\uDCA1 排查: cat ${logPath} | tail -50`);
+  return lines.join(`
+`);
+}
+async function appendSubagentLog(filePath, line, log7) {
+  try {
+    await fsPromises.mkdir(path18.dirname(filePath), { recursive: true });
+    await fsPromises.appendFile(filePath, line + `
+`, "utf8");
+  } catch (err) {
+    log7?.debug?.("appendSubagentLog 失败（已隔离）", {
+      error: err instanceof Error ? err.message : String(err),
+      file: filePath
+    });
+  }
+}
+function isLogPersistenceEnabled(cwd) {
+  try {
+    const cfg = getCodeforgeConfig({ root: cwd });
+    const runtime = cfg.runtime;
+    if (runtime && typeof runtime === "object") {
+      const v = runtime.subagent_log_persistence;
+      if (v === false)
+        return false;
+    }
+    return true;
+  } catch {
+    return true;
+  }
+}
 function normalizeVariant2(raw) {
   if (raw === "info" || raw === "warning")
     return "default";
@@ -18061,12 +18276,17 @@ var subtaskHeartbeatServer = async (ctx) => {
     intervalMs: HEARTBEAT_INTERVAL_MS2
   });
   const client = ctx.client;
+  const cwd = ctx.directory;
   const interval = setInterval(() => {
     safeAsync(PLUGIN_NAME13, "interval", async () => {
       const swept = sweepExpiredPendingTasks();
       if (swept > 0) {
         safeWriteLog(PLUGIN_NAME13, { hook: "interval", pending_task_swept: swept });
       }
+      const sweptParents = sweepExpiredSessionParents();
+      if (sweptParents > 0) {
+        safeWriteLog(PLUGIN_NAME13, { hook: "interval", session_parent_swept: sweptParents });
+      }
       const beats = pickHeartbeats();
       if (beats.length === 0)
         return;
@@ -18091,8 +18311,29 @@ var subtaskHeartbeatServer = async (ctx) => {
   return {
     event: async ({ event }) => {
       await safeAsync(PLUGIN_NAME13, "event", async () => {
+        try {
+          if (detectUnparsedParentID(event) && _parentParseFailLogged < PARENT_PARSE_FAIL_MAX_LOG) {
+            _parentParseFailLogged++;
+            log7.warn("session.created 含 parentID 关键字但 extractCreatedChild 解析失败，可能 SDK schema 变更", {
+              sample_count: _parentParseFailLogged,
+              hint: "如频繁出现请检查 plugins/subtask-heartbeat.ts::extractCreatedChild 是否适配新 SDK"
+            });
+            safeWriteLog(PLUGIN_NAME13, {
+              hook: "event",
+              type: "session.created.unparsed-parent-id",
+              sample_count: _parentParseFailLogged
+            });
+          }
+        } catch {}
         const created = extractCreatedChild(event);
         if (created) {
+          try {
+            recordSessionParent(created.childID, created.parentID);
+          } catch (err) {
+            log7.warn("recordSessionParent 抛错（已隔离）", {
+              error: err instanceof Error ? err.message : String(err)
+            });
+          }
           const pending = dequeuePendingTask(created.parentID);
           const record = registerInflight({
             childID: created.childID,
@@ -18122,6 +18363,11 @@ var subtaskHeartbeatServer = async (ctx) => {
         }
         const ended = extractEndedSessionID(event);
         if (ended) {
+          if (ended.type === "session.deleted") {
+            try {
+              deleteSessionParent(ended.sessionID);
+            } catch {}
+          }
           const r = clearInflight2(ended.sessionID);
           if (r) {
             const t = buildEndToast(r, ended.type);
@@ -18134,6 +18380,32 @@ var subtaskHeartbeatServer = async (ctx) => {
               toast_sent: sent,
               end_toast_message: t.message
             });
+            const logPath = subagentLogPath(cwd, r.parentID, r.childID);
+            const isSuccess = ended.type === "session.idle";
+            let text;
+            if (isSuccess) {
+              text = buildSuccessNotice(r, logPath);
+            } else {
+              let worktreePath = null;
+              try {
+                const entry = await getSessionWorktree(r.childID, cwd);
+                worktreePath = entry?.worktreePath ?? null;
+              } catch {}
+              text = buildFailureNotice(r, ended.type, logPath, worktreePath);
+            }
+            const ocClient = ctx.client;
+            const noticeSent = await sendParentNotice(ocClient, r.parentID, text, {
+              directory: cwd,
+              log: (lvl, msg, data) => log7[lvl === "info" ? "info" : "warn"](msg, data)
+            });
+            safeWriteLog(PLUGIN_NAME13, {
+              hook: "event",
+              type: `${ended.type}.notice`,
+              child: r.childID,
+              parent: r.parentID,
+              notice_sent: noticeSent,
+              success: isSuccess
+            });
           }
         }
       });
@@ -18167,8 +18439,44 @@ var subtaskHeartbeatServer = async (ctx) => {
             });
           }
         }
-        if (inflight3.has(input.sessionID)) {
+        const rec = inflight3.get(input.sessionID);
+        if (rec) {
           recordToolBeat(input.sessionID, input.tool);
+          if (!rec.pendingCalls)
+            rec.pendingCalls = new Map;
+          if (typeof input.callID === "string") {
+            rec.pendingCalls.set(input.callID, Date.now());
+          }
+          if (isLogPersistenceEnabled(cwd)) {
+            const args = output?.args ?? null;
+            const line = buildBeforeLogLine(input.tool, args);
+            const file = subagentLogPath(cwd, rec.parentID, rec.childID);
+            appendSubagentLog(file, line, log7);
+          }
+        }
+      });
+    },
+    "tool.execute.after": async (input, _output) => {
+      if (inflight3.size === 0)
+        return;
+      await safeAsync(PLUGIN_NAME13, "tool.execute.after", async () => {
+        if (!input || typeof input.sessionID !== "string" || typeof input.tool !== "string")
+          return;
+        const rec = inflight3.get(input.sessionID);
+        if (!rec)
+          return;
+        let durationMs = 0;
+        if (rec.pendingCalls && typeof input.callID === "string") {
+          const startedAt = rec.pendingCalls.get(input.callID);
+          if (typeof startedAt === "number") {
+            durationMs = Date.now() - startedAt;
+            rec.pendingCalls.delete(input.callID);
+          }
+        }
+        if (isLogPersistenceEnabled(cwd)) {
+          const line = buildAfterLogLine(input.tool, true, durationMs);
+          const file = subagentLogPath(cwd, rec.parentID, rec.childID);
+          appendSubagentLog(file, line, log7);
         }
       });
     }
@@ -18325,20 +18633,20 @@ function loadAgentToolsMap(rootDir, opts = {}) {
     for (const entry of entries) {
       if (!entry.endsWith(".md"))
         continue;
-      const path18 = join15(dir, entry);
+      const path19 = join15(dir, entry);
       let content;
       try {
-        content = reader(path18);
+        content = reader(path19);
       } catch (err) {
         log8.warn(`agent.md 读取失败（已跳过）`, {
-          path: path18,
+          path: path19,
           error: err instanceof Error ? err.message : String(err)
         });
         continue;
       }
       const parsed = parseAgentFrontmatter(content);
       if (!parsed) {
-        log8.warn(`agent frontmatter 解析失败（已跳过）`, { path: path18 });
+        log8.warn(`agent frontmatter 解析失败（已跳过）`, { path: path19 });
         continue;
       }
       if (result.has(parsed.name))
@@ -18531,7 +18839,7 @@ var handler16 = async (_ctx3) => {
 // lib/event-stream.ts
 import { promises as fs15 } from "node:fs";
 init_runtime_paths();
-import * as path18 from "node:path";
+import * as path19 from "node:path";
 async function loadSession(id, opts = {}) {
   const file = resolveSessionFile(id, opts);
   const raw = await fs15.readFile(file, "utf8");
@@ -18551,7 +18859,7 @@ async function listSessions(opts = {}) {
   for (const e of entries) {
     if (!e.isFile() || !e.name.endsWith(".jsonl"))
       continue;
-    const file = path18.join(dir, e.name);
+    const file = path19.join(dir, e.name);
     const id = e.name.replace(/\.jsonl$/, "");
     try {
       const stat = await fs15.stat(file);
@@ -18578,11 +18886,11 @@ async function listSessions(opts = {}) {
   return out;
 }
 function resolveDir(opts = {}) {
-  const root = path18.resolve(opts.root ?? process.cwd());
-  return opts.sessions_dir ? path18.resolve(root, opts.sessions_dir) : path18.join(runtimeDir(root), "sessions");
+  const root = path19.resolve(opts.root ?? process.cwd());
+  return opts.sessions_dir ? path19.resolve(root, opts.sessions_dir) : path19.join(runtimeDir(root), "sessions");
 }
 function resolveSessionFile(id, opts = {}) {
-  return path18.join(resolveDir(opts), `${id}.jsonl`);
+  return path19.join(resolveDir(opts), `${id}.jsonl`);
 }
 function parseJsonl(id, raw) {
   const events = [];
@@ -18844,6 +19152,92 @@ function isRecoveryWorthShowing(plan) {
   return hasSignal;
 }
 
+// lib/block-pending.ts
+init_runtime_paths();
+import { promises as fs16 } from "node:fs";
+import * as path20 from "node:path";
+function blockPendingFilePath(absRoot) {
+  const rd = runtimeDir(absRoot, { ensure: false });
+  return path20.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 fs16.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 fs16.mkdir(path20.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 fs16.appendFile(file, lines, "utf8");
+  });
+}
+
 // plugins/session-recovery.ts
 var PLUGIN_NAME17 = "session-recovery";
 logLifecycle(PLUGIN_NAME17, "import", {});
@@ -18860,10 +19254,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 prompt = renderPrompt(plan);
+  const hasPendingBlocks = pendingBlocks.length > 0;
+  if (!isRecoveryWorthShowing(plan) && !hasPendingBlocks) {
+    return { ok: true, injected: false, plan, reason: "no_signal", pendingBlocks };
+  }
+  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 {
@@ -18871,10 +19278,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 };
+    }
+  }
+  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" };
+  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 = [];
@@ -18926,10 +19359,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}）`);
         }
       });
     }
@@ -18938,8 +19372,8 @@ var sessionRecoveryServer = async (ctx) => {
 var handler17 = sessionRecoveryServer;
 
 // plugins/subtasks.ts
-import { promises as fs16 } from "node:fs";
-import * as path19 from "node:path";
+import { promises as fs17 } from "node:fs";
+import * as path21 from "node:path";
 
 // lib/parallel-merge.ts
 init_autonomy();
@@ -19764,7 +20198,7 @@ function sleep2(ms) {
 init_runtime_paths();
 var PLUGIN_NAME18 = "subtasks";
 function getLogFile(root = process.cwd()) {
-  return path19.join(runtimeDir(root), "logs", "subtasks.log");
+  return path21.join(runtimeDir(root), "logs", "subtasks.log");
 }
 var VERB_RE = /^([a-zA-Z]{3,12})/;
 var CN_VERBS = [
@@ -20069,8 +20503,8 @@ async function writeLog(level, msg, data) {
 `;
   try {
     const logFile = getLogFile();
-    await fs16.mkdir(path19.dirname(logFile), { recursive: true });
-    await fs16.appendFile(logFile, line, "utf8");
+    await fs17.mkdir(path21.dirname(logFile), { recursive: true });
+    await fs17.appendFile(logFile, line, "utf8");
   } catch {}
 }
 logLifecycle(PLUGIN_NAME18, "import");
@@ -20586,12 +21020,12 @@ var tokenManagerServer = async (ctx) => {
 var handler20 = tokenManagerServer;
 
 // plugins/tool-policy.ts
-import { promises as fs17 } from "node:fs";
-import * as path21 from "node:path";
+import { promises as fs18 } from "node:fs";
+import * as path23 from "node:path";
 init_autonomy();
 
 // lib/file-regex-acl.ts
-import * as path20 from "node:path";
+import * as path22 from "node:path";
 function compileRule(r) {
   if (r instanceof RegExp)
     return r;
@@ -20657,7 +21091,7 @@ function normalizePath2(p) {
   let s = p.replace(/\\/g, "/");
   if (s.startsWith("./"))
     s = s.slice(2);
-  s = path20.posix.normalize(s);
+  s = path22.posix.normalize(s);
   return s;
 }
 function checkFileAccess(acl, file, op) {
@@ -20767,11 +21201,11 @@ function decideToolCall(ctx, cfg = {}, currentAgent) {
     action = "deny";
   return { action, reasons, autonomy: a, acl: aclResults };
 }
-var POLICY_PATH = path21.join(".codeforge", "policy.json");
+var POLICY_PATH = path23.join(".codeforge", "policy.json");
 async function loadPolicy(root = process.cwd()) {
-  const file = path21.join(root, POLICY_PATH);
+  const file = path23.join(root, POLICY_PATH);
   try {
-    const raw = await fs17.readFile(file, "utf8");
+    const raw = await fs18.readFile(file, "utf8");
     const data = JSON.parse(raw);
     return data;
   } catch {
@@ -20881,7 +21315,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 join21 } from "node:path";
 
 // lib/update-checker-impl.ts
 import { createHash as createHash5 } from "node:crypto";
@@ -20898,7 +21332,7 @@ import {
   writeFileSync as writeFileSync2
 } from "node:fs";
 import { homedir as homedir7, tmpdir } from "node:os";
-import { dirname as dirname10, join as join19 } from "node:path";
+import { dirname as dirname12, join as join20 } from "node:path";
 import { fileURLToPath } from "node:url";
 import * as https from "node:https";
 import * as zlib from "node:zlib";
@@ -20906,7 +21340,7 @@ import * as zlib from "node:zlib";
 // lib/version-injected.ts
 function getInjectedVersion() {
   try {
-    const v = "0.5.3";
+    const v = "0.5.5";
     if (typeof v === "string" && /^\d+\.\d+\.\d+/.test(v)) {
       return v;
     }
@@ -20995,18 +21429,18 @@ function readLocalVersion() {
     return injected;
   try {
     const here = fileURLToPath(import.meta.url);
-    const root = dirname10(dirname10(here));
-    const pkg = JSON.parse(readFileSync5(join19(root, "package.json"), "utf8"));
+    const root = dirname12(dirname12(here));
+    const pkg = JSON.parse(readFileSync5(join20(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"] ?? join20(homedir7(), ".cache", "codeforge");
 }
 function defaultCacheFile() {
-  return join19(defaultCacheDir(), "update-check.json");
+  return join20(defaultCacheDir(), "update-check.json");
 }
 function readCache(file) {
   try {
@@ -21024,7 +21458,7 @@ function readCache(file) {
 }
 function writeCache(file, entry) {
   try {
-    mkdirSync3(dirname10(file), { recursive: true });
+    mkdirSync3(dirname12(file), { recursive: true });
     writeFileSync2(file, JSON.stringify(entry, null, 2), "utf8");
   } catch {}
 }
@@ -21162,14 +21596,14 @@ function defaultHttpFetcher(url, timeoutMs) {
   });
 }
 async function downloadAndExtractBundle(opts) {
-  const tmpRoot = opts.tmpDir ?? mkdtempSync(join19(tmpdir(), "codeforge-update-"));
+  const tmpRoot = opts.tmpDir ?? mkdtempSync(join20(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 = join20(tmpRoot, "package", "dist", "index.js");
   if (!existsSync4(bundlePath)) {
     throw new Error(`bundle_not_found: ${bundlePath}`);
   }
@@ -21209,11 +21643,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(dirname10(dest), { recursive: true });
+      const dest = join20(destRoot, fullName);
+      mkdirSync3(dirname12(dest), { recursive: true });
       writeFileSync2(dest, fileBuf);
     } else if (typeFlag === "5") {
-      mkdirSync3(join19(destRoot, fullName), { recursive: true });
+      mkdirSync3(join20(destRoot, fullName), { recursive: true });
     }
     offset += Math.ceil(size / 512) * 512;
   }
@@ -21266,7 +21700,7 @@ function atomicReplaceBundle(opts) {
   if (!existsSync4(source)) {
     throw new Error(`atomic_source_missing: ${source}`);
   }
-  mkdirSync3(dirname10(target), { recursive: true });
+  mkdirSync3(dirname12(target), { recursive: true });
   const newPath = `${target}.new`;
   const backupPath = `${target}.bak.${oldVersion}`;
   let strategy = "rename";
@@ -21318,11 +21752,11 @@ function cleanupOldBackups(target, keep) {
   if (keep <= 0)
     return;
   try {
-    const dir = dirname10(target);
+    const dir = dirname12(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 = join20(dir, f);
       let mtimeMs = 0;
       try {
         mtimeMs = statSync5(full).mtimeMs;
@@ -21344,7 +21778,7 @@ function loadCompatibility(opts) {
       const root = opts?.cwd ?? inferPluginRoot();
       if (!root)
         return null;
-      file = join19(root, "compatibility.json");
+      file = join20(root, "compatibility.json");
     }
     if (!existsSync4(file))
       return null;
@@ -21369,7 +21803,7 @@ function loadCompatibility(opts) {
 function inferPluginRoot() {
   try {
     const here = fileURLToPath(import.meta.url);
-    return dirname10(dirname10(here));
+    return dirname12(dirname12(here));
   } catch {
     return null;
   }
@@ -21564,14 +21998,14 @@ function detectOpencodeVersion() {
 }
 function getOpencodeBundlePath() {
   const candidates = [];
-  candidates.push(join20(homedir8(), ".config", "opencode", "codeforge", "index.js"));
+  candidates.push(join21(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(join21(appData, "opencode", "codeforge", "index.js"));
     const localAppData = process.env["LOCALAPPDATA"];
     if (localAppData)
-      candidates.push(join20(localAppData, "opencode", "codeforge", "index.js"));
+      candidates.push(join21(localAppData, "opencode", "codeforge", "index.js"));
   }
   for (const c of candidates) {
     if (existsSync5(c))
@@ -21632,11 +22066,11 @@ async function postToast(ctx, message) {
 var handler22 = updateCheckerServer;
 
 // plugins/workflow-engine.ts
-import * as path23 from "node:path";
+import * as path25 from "node:path";
 
 // lib/workflow-loader.ts
-import { promises as fs18 } from "node:fs";
-import * as path22 from "node:path";
+import { promises as fs19 } from "node:fs";
+import * as path24 from "node:path";
 import { z as z32 } from "zod";
 var ActionSchema = z32.object({
   tool: z32.string().min(1, "action.tool 不能为空"),
@@ -21722,7 +22156,7 @@ function parseWorkflowYaml(yaml, sourcePath = "<inline>") {
 async function loadWorkflowFromFile(filePath) {
   let txt;
   try {
-    txt = await fs18.readFile(filePath, "utf8");
+    txt = await fs19.readFile(filePath, "utf8");
   } catch (err) {
     return {
       ok: false,
@@ -21737,7 +22171,7 @@ async function loadWorkflowsFromDir(dir) {
   const failed = [];
   let entries;
   try {
-    entries = await fs18.readdir(dir);
+    entries = await fs19.readdir(dir);
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT")
@@ -21749,7 +22183,7 @@ async function loadWorkflowsFromDir(dir) {
       continue;
     if (!/\.ya?ml$/i.test(name))
       continue;
-    const full = path22.join(dir, name);
+    const full = path24.join(dir, name);
     const r = await loadWorkflowFromFile(full);
     if (r.ok)
       loaded.push(r);
@@ -22139,7 +22573,7 @@ async function handleCommandInvoked(raw, workflowsDir = "workflows") {
 }
 var workflowEngineServer = async (ctx) => {
   const directory = ctx.directory ?? process.cwd();
-  const workflowsDir = path23.join(directory, "workflows");
+  const workflowsDir = path25.join(directory, "workflows");
   ensureRegistry(workflowsDir).catch((err) => fallbackLog2.warn(`[${PLUGIN_NAME23}] preload workflows failed`, {
     error: err instanceof Error ? err.message : String(err)
   }));
@@ -22183,7 +22617,7 @@ var workflowEngineServer = async (ctx) => {
 var handler23 = workflowEngineServer;
 
 // plugins/session-worktree-guard.ts
-import path24 from "node:path";
+import path26 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/;
@@ -22212,7 +22646,7 @@ var WRITE_TOOLS = new Set(["write", "edit", "ast_edit"]);
 function rewritePath(value, mainRoot, worktreeRoot) {
   if (!value)
     return null;
-  const resolved = path24.isAbsolute(value) ? value : path24.resolve(mainRoot, value);
+  const resolved = path26.isAbsolute(value) ? value : path26.resolve(mainRoot, value);
   if (resolved === mainRoot)
     return worktreeRoot;
   const prefix = mainRoot.endsWith("/") ? mainRoot : mainRoot + "/";
@@ -22295,6 +22729,29 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
           if (!isWriteOperation(toolName, argsObj, mainRoot)) {
             return;
           }
+          try {
+            const parentId = lookupParentSessionId(sessionId);
+            if (parentId) {
+              const parentEntry = await getSessionWorktree(parentId, mainRoot);
+              if (parentEntry && parentEntry.status === "active") {
+                entry = parentEntry;
+                log13.debug?.(`[child-inherit] session ${sessionId} 继承父 ${parentId} 的 worktree`, { parentSessionId: parentId, worktreePath: parentEntry.worktreePath });
+                safeWriteLog(PLUGIN_NAME24, {
+                  hook: "tool.execute.before",
+                  tool: toolName,
+                  sessionID: input.sessionID,
+                  action: "child-inherit",
+                  parent_session_id: parentId,
+                  parent_branch: parentEntry.branch,
+                  parent_worktree: parentEntry.worktreePath
+                });
+              }
+            }
+          } catch (lookupErr) {
+            log13.debug?.("[child-inherit] lookupParentSessionId 抛错（已隔离，退回 lazy-bind）", { error: lookupErr instanceof Error ? lookupErr.message : String(lookupErr) });
+          }
+        }
+        if (!entry) {
           try {
             entry = await bindSessionWorktree({ sessionId, mainRoot });
             log13.info(`[lazy-bind] auto-created worktree for session ${sessionId}`, { branch: entry.branch, path: entry.worktreePath });
@@ -22319,6 +22776,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") {
@@ -22337,8 +22820,16 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
             }
           }
           if (isWriteOp) {
-            const reason = `[session-worktree-guard] DENIED: 当前 session 要求先调用 plan_read(plan_id="${entry.requiredPlanId}") 再执行写操作`;
-            log13.warn(reason, { tool: toolName, sessionId, requiredPlanId: entry.requiredPlanId });
+            const inherited = entry.sessionId !== sessionId;
+            const reasonBase = `[session-worktree-guard] DENIED: 当前 session 要求先调用 plan_read(plan_id="${entry.requiredPlanId}") 再执行写操作`;
+            const reason = inherited ? `${reasonBase}
+[gate-deny] child session=${sessionId} 继承父 entry 但父 session planReadOk=false，父 session=${entry.sessionId} 需先调 plan_read(plan_id="${entry.requiredPlanId}")` : reasonBase;
+            log13.warn(reason, {
+              tool: toolName,
+              sessionId,
+              requiredPlanId: entry.requiredPlanId,
+              inheritedFromParent: inherited ? entry.sessionId : undefined
+            });
             safeWriteLog(PLUGIN_NAME24, {
               hook: "tool.execute.before",
               tool: toolName,
@@ -22497,6 +22988,30 @@ var worktreeLifecyclePlugin = async (ctx) => {
             });
             return;
           }
+          try {
+            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 });
+                safeWriteLog(PLUGIN_NAME25, {
+                  hook: "event",
+                  type: ended.type,
+                  sessionID: ended.sessionID,
+                  action: "discard-empty-fast-path",
+                  branch: entry.branch,
+                  worktreePath: entry.worktreePath
+                });
+                lastIdleToastAt.delete(ended.sessionID);
+                return;
+              }
+            }
+          } catch (err) {
+            log14.warn(`[lifecycle] empty-worktree fast-path 检测失败 (回退到常规路径)`, {
+              sessionId: ended.sessionID,
+              error: err instanceof Error ? err.message : String(err)
+            });
+          }
           let hadDirty = false;
           try {
             hadDirty = await isWorktreeDirty(entry.worktreePath);
@@ -22646,6 +23161,7 @@ function createCodeforgeServer(opts) {
     const commandExecuteBeforeBucket = [];
     const chatParamsBucket = [];
     const toolExecuteBeforeBucket = [];
+    const toolExecuteAfterBucket = [];
     const chatMessagesTransformBucket = [];
     const chatSystemTransformBucket = [];
     const eventBucket = [];
@@ -22659,6 +23175,8 @@ function createCodeforgeServer(opts) {
         chatParamsBucket.push(h["chat.params"]);
       if (h["tool.execute.before"])
         toolExecuteBeforeBucket.push(h["tool.execute.before"]);
+      if (h["tool.execute.after"])
+        toolExecuteAfterBucket.push(h["tool.execute.after"]);
       if (h["experimental.chat.messages.transform"]) {
         chatMessagesTransformBucket.push(h["experimental.chat.messages.transform"]);
       }
@@ -22675,6 +23193,7 @@ function createCodeforgeServer(opts) {
       "command.execute.before": makeSerialHook("command.execute.before", commandExecuteBeforeBucket),
       "chat.params": makeSerialHook("chat.params", chatParamsBucket),
       "tool.execute.before": makeSerialHook("tool.execute.before", toolExecuteBeforeBucket),
+      "tool.execute.after": makeSerialHook("tool.execute.after", toolExecuteAfterBucket),
       "experimental.chat.messages.transform": makeSerialHook("experimental.chat.messages.transform", chatMessagesTransformBucket),
       "experimental.chat.system.transform": makeSerialHook("experimental.chat.system.transform", chatSystemTransformBucket),
       event: async (envelope) => {

package/package.json

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