@andyqiu/codeforge 0.5.2 → 0.5.4

package/bin/codeforge.mjs

@@ -316,7 +316,8 @@ function cmdUpgrade(args) {
   log(`步骤 2/2：codeforge install --global`)
 
   if (!dryRun) {
-    const code = installOpencode({ scope: "global", dryRun: false, extraArgs: [] })
+    const skipBuildFlag = process.platform === "win32" ? "-SkipBuild" : "--skip-build"
+    const code = installOpencode({ scope: "global", dryRun: false, extraArgs: [skipBuildFlag] })
     if (code !== 0) {
       err(`install --global 失败 (exit=${code})`)
       return 1

package/commands/autonomy.md

@@ -0,0 +1,62 @@
+---
+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（**最小干预模式**）
+
+## ⚠️ 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`
+- **仅根 session 生效**（子 session 一律跳过，防 orchestrator 嵌套）
+
+### 默认预算上限（任一耗尽自动降回 semi）
+
+| 维度 | 默认值 |
+|---|---|
+| 总 tokens | 50,000 |
+| 总 USD | $3 |
+| Wall clock | 30 分钟 |
+| auto merge 次数 | 5 |
+| REQUEST_CHANGES 循环 | 3 |
+
+### 逃生口
+
+- `/pause` — 立刻退回 semi（不打断在途 merge）
+- `/discard-session` — 不可逆，硬丢 worktree + branch
+- budget 耗尽 — 自动降回 semi
+- BLOCK — 强制通知 + 降档
+
+## 行为对比
+
+| 场景 | 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 通知 + 降档** |
+
+## 配置存储
+
+`<runtimeDir>/autonomy/<sessionId>.json`（withFileLock 跨进程并发安全）
+
+## 关联 ADR
+
+- [autonomous-mode](../docs/adr/autonomous-mode.md) — 主 ADR（设计、双重验证、五维预算）
+- [plandex-three-autonomy-modes](../docs/adr/plandex-three-autonomy-modes.md) — 三档基线
+- [worktree-session-isolation](../docs/adr/worktree-session-isolation.md) — merge 闭环

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,20 @@ async function markInterruptedDirty(opts) {
     }
   });
 }
+async function getCurrentWorktreeHead(worktreePath) {
+  try {
+    return (await runGit2(path13.resolve(worktreePath), ["rev-parse", "HEAD"])).trim();
+  } catch {
+    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();
@@ -17797,6 +17836,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 +17850,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 +18035,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 +18135,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 +18257,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 +18292,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 +18344,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 +18361,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 +18420,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 +18614,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 +18820,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 +18840,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 +18867,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 = [];
@@ -18939,7 +19228,7 @@ var handler17 = sessionRecoveryServer;
 
 // plugins/subtasks.ts
 import { promises as fs16 } from "node:fs";
-import * as path19 from "node:path";
+import * as path20 from "node:path";
 
 // lib/parallel-merge.ts
 init_autonomy();
@@ -19764,7 +20053,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 path20.join(runtimeDir(root), "logs", "subtasks.log");
 }
 var VERB_RE = /^([a-zA-Z]{3,12})/;
 var CN_VERBS = [
@@ -20069,7 +20358,7 @@ async function writeLog(level, msg, data) {
 `;
   try {
     const logFile = getLogFile();
-    await fs16.mkdir(path19.dirname(logFile), { recursive: true });
+    await fs16.mkdir(path20.dirname(logFile), { recursive: true });
     await fs16.appendFile(logFile, line, "utf8");
   } catch {}
 }
@@ -20587,11 +20876,11 @@ var handler20 = tokenManagerServer;
 
 // plugins/tool-policy.ts
 import { promises as fs17 } from "node:fs";
-import * as path21 from "node:path";
+import * as path22 from "node:path";
 init_autonomy();
 
 // lib/file-regex-acl.ts
-import * as path20 from "node:path";
+import * as path21 from "node:path";
 function compileRule(r) {
   if (r instanceof RegExp)
     return r;
@@ -20657,7 +20946,7 @@ function normalizePath2(p) {
   let s = p.replace(/\\/g, "/");
   if (s.startsWith("./"))
     s = s.slice(2);
-  s = path20.posix.normalize(s);
+  s = path21.posix.normalize(s);
   return s;
 }
 function checkFileAccess(acl, file, op) {
@@ -20767,9 +21056,9 @@ 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 = path22.join(".codeforge", "policy.json");
 async function loadPolicy(root = process.cwd()) {
-  const file = path21.join(root, POLICY_PATH);
+  const file = path22.join(root, POLICY_PATH);
   try {
     const raw = await fs17.readFile(file, "utf8");
     const data = JSON.parse(raw);
@@ -20898,7 +21187,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 dirname11, join as join19 } from "node:path";
 import { fileURLToPath } from "node:url";
 import * as https from "node:https";
 import * as zlib from "node:zlib";
@@ -20906,7 +21195,7 @@ import * as zlib from "node:zlib";
 // lib/version-injected.ts
 function getInjectedVersion() {
   try {
-    const v = "0.5.2";
+    const v = "0.5.4";
     if (typeof v === "string" && /^\d+\.\d+\.\d+/.test(v)) {
       return v;
     }
@@ -20995,7 +21284,7 @@ function readLocalVersion() {
     return injected;
   try {
     const here = fileURLToPath(import.meta.url);
-    const root = dirname10(dirname10(here));
+    const root = dirname11(dirname11(here));
     const pkg = JSON.parse(readFileSync5(join19(root, "package.json"), "utf8"));
     return typeof pkg.version === "string" ? pkg.version : "0.0.0";
   } catch {
@@ -21024,7 +21313,7 @@ function readCache(file) {
 }
 function writeCache(file, entry) {
   try {
-    mkdirSync3(dirname10(file), { recursive: true });
+    mkdirSync3(dirname11(file), { recursive: true });
     writeFileSync2(file, JSON.stringify(entry, null, 2), "utf8");
   } catch {}
 }
@@ -21210,7 +21499,7 @@ function extractTarToDir(tarBuf, destRoot) {
     if (typeFlag === "0" || typeFlag === "" || typeFlag === "\x00") {
       const fileBuf = tarBuf.subarray(offset, offset + size);
       const dest = join19(destRoot, fullName);
-      mkdirSync3(dirname10(dest), { recursive: true });
+      mkdirSync3(dirname11(dest), { recursive: true });
       writeFileSync2(dest, fileBuf);
     } else if (typeFlag === "5") {
       mkdirSync3(join19(destRoot, fullName), { recursive: true });
@@ -21266,7 +21555,7 @@ function atomicReplaceBundle(opts) {
   if (!existsSync4(source)) {
     throw new Error(`atomic_source_missing: ${source}`);
   }
-  mkdirSync3(dirname10(target), { recursive: true });
+  mkdirSync3(dirname11(target), { recursive: true });
   const newPath = `${target}.new`;
   const backupPath = `${target}.bak.${oldVersion}`;
   let strategy = "rename";
@@ -21318,7 +21607,7 @@ function cleanupOldBackups(target, keep) {
   if (keep <= 0)
     return;
   try {
-    const dir = dirname10(target);
+    const dir = dirname11(target);
     const base = target.substring(dir.length + 1);
     const prefix = `${base}.bak.`;
     const all = readdirSync3(dir).filter((f) => f.startsWith(prefix)).map((f) => {
@@ -21369,7 +21658,7 @@ function loadCompatibility(opts) {
 function inferPluginRoot() {
   try {
     const here = fileURLToPath(import.meta.url);
-    return dirname10(dirname10(here));
+    return dirname11(dirname11(here));
   } catch {
     return null;
   }
@@ -21632,11 +21921,11 @@ async function postToast(ctx, message) {
 var handler22 = updateCheckerServer;
 
 // plugins/workflow-engine.ts
-import * as path23 from "node:path";
+import * as path24 from "node:path";
 
 // lib/workflow-loader.ts
 import { promises as fs18 } from "node:fs";
-import * as path22 from "node:path";
+import * as path23 from "node:path";
 import { z as z32 } from "zod";
 var ActionSchema = z32.object({
   tool: z32.string().min(1, "action.tool 不能为空"),
@@ -21749,7 +22038,7 @@ async function loadWorkflowsFromDir(dir) {
       continue;
     if (!/\.ya?ml$/i.test(name))
       continue;
-    const full = path22.join(dir, name);
+    const full = path23.join(dir, name);
     const r = await loadWorkflowFromFile(full);
     if (r.ok)
       loaded.push(r);
@@ -22139,7 +22428,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 = path24.join(directory, "workflows");
   ensureRegistry(workflowsDir).catch((err) => fallbackLog2.warn(`[${PLUGIN_NAME23}] preload workflows failed`, {
     error: err instanceof Error ? err.message : String(err)
   }));
@@ -22183,7 +22472,7 @@ var workflowEngineServer = async (ctx) => {
 var handler23 = workflowEngineServer;
 
 // plugins/session-worktree-guard.ts
-import path24 from "node:path";
+import path25 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 +22501,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 = path25.isAbsolute(value) ? value : path25.resolve(mainRoot, value);
   if (resolved === mainRoot)
     return worktreeRoot;
   const prefix = mainRoot.endsWith("/") ? mainRoot : mainRoot + "/";
@@ -22295,6 +22584,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 });
@@ -22337,8 +22649,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 +22817,31 @@ var worktreeLifecyclePlugin = async (ctx) => {
             });
             return;
           }
+          try {
+            const mainHead = await getCurrentMainHead(mainRoot);
+            const worktreeHead = mainHead ? await getCurrentWorktreeHead(entry.worktreePath) : "";
+            if (worktreeHead && worktreeHead === mainHead) {
+              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 +22991,7 @@ function createCodeforgeServer(opts) {
     const commandExecuteBeforeBucket = [];
     const chatParamsBucket = [];
     const toolExecuteBeforeBucket = [];
+    const toolExecuteAfterBucket = [];
     const chatMessagesTransformBucket = [];
     const chatSystemTransformBucket = [];
     const eventBucket = [];
@@ -22659,6 +23005,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 +23023,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.2",
+  "version": "0.5.4",
   "description": "CodeForge — opencode 的零侵入扩展包",
   "type": "module",
   "private": false,