@andyqiu/codeforge 0.6.7 → 0.6.12

package/dist/index.js

@@ -26,6 +26,8 @@ __export(exports_worktree_ops, {
   mergeCommit: () => mergeCommit,
   mergeAbort: () => mergeAbort,
   listWorktrees: () => listWorktrees,
+  isWorktreeAbsentError: () => isWorktreeAbsentError,
+  isBranchAbsentError: () => isBranchAbsentError,
   getMergeConflicts: () => getMergeConflicts,
   ensureWorktree: () => ensureWorktree,
   deleteBranchIfExists: () => deleteBranchIfExists,
@@ -91,6 +93,10 @@ async function deleteBranchIfExists(opts) {
     throw err;
   }
 }
+function isBranchAbsentError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  return /not found/i.test(msg);
+}
 async function listWorktrees(opts) {
   const out = await runGit(opts.root, ["worktree", "list", "--porcelain"], opts.git_timeout_ms ?? 3000);
   return parseWorktreeList(out);
@@ -366,17 +372,17 @@ var require_visit = __commonJS((exports) => {
   visit.BREAK = BREAK;
   visit.SKIP = SKIP;
   visit.REMOVE = REMOVE;
-  function visit_(key, node, visitor, path20) {
-    const ctrl = callVisitor(key, node, visitor, path20);
+  function visit_(key, node, visitor, path21) {
+    const ctrl = callVisitor(key, node, visitor, path21);
     if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-      replaceNode(key, path20, ctrl);
-      return visit_(key, ctrl, visitor, path20);
+      replaceNode(key, path21, ctrl);
+      return visit_(key, ctrl, visitor, path21);
     }
     if (typeof ctrl !== "symbol") {
       if (identity.isCollection(node)) {
-        path20 = Object.freeze(path20.concat(node));
+        path21 = Object.freeze(path21.concat(node));
         for (let i = 0;i < node.items.length; ++i) {
-          const ci = visit_(i, node.items[i], visitor, path20);
+          const ci = visit_(i, node.items[i], visitor, path21);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -387,13 +393,13 @@ var require_visit = __commonJS((exports) => {
           }
         }
       } else if (identity.isPair(node)) {
-        path20 = Object.freeze(path20.concat(node));
-        const ck = visit_("key", node.key, visitor, path20);
+        path21 = Object.freeze(path21.concat(node));
+        const ck = visit_("key", node.key, visitor, path21);
         if (ck === BREAK)
           return BREAK;
         else if (ck === REMOVE)
           node.key = null;
-        const cv = visit_("value", node.value, visitor, path20);
+        const cv = visit_("value", node.value, visitor, path21);
         if (cv === BREAK)
           return BREAK;
         else if (cv === REMOVE)
@@ -414,17 +420,17 @@ var require_visit = __commonJS((exports) => {
   visitAsync.BREAK = BREAK;
   visitAsync.SKIP = SKIP;
   visitAsync.REMOVE = REMOVE;
-  async function visitAsync_(key, node, visitor, path20) {
-    const ctrl = await callVisitor(key, node, visitor, path20);
+  async function visitAsync_(key, node, visitor, path21) {
+    const ctrl = await callVisitor(key, node, visitor, path21);
     if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-      replaceNode(key, path20, ctrl);
-      return visitAsync_(key, ctrl, visitor, path20);
+      replaceNode(key, path21, ctrl);
+      return visitAsync_(key, ctrl, visitor, path21);
     }
     if (typeof ctrl !== "symbol") {
       if (identity.isCollection(node)) {
-        path20 = Object.freeze(path20.concat(node));
+        path21 = Object.freeze(path21.concat(node));
         for (let i = 0;i < node.items.length; ++i) {
-          const ci = await visitAsync_(i, node.items[i], visitor, path20);
+          const ci = await visitAsync_(i, node.items[i], visitor, path21);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -435,13 +441,13 @@ var require_visit = __commonJS((exports) => {
           }
         }
       } else if (identity.isPair(node)) {
-        path20 = Object.freeze(path20.concat(node));
-        const ck = await visitAsync_("key", node.key, visitor, path20);
+        path21 = Object.freeze(path21.concat(node));
+        const ck = await visitAsync_("key", node.key, visitor, path21);
         if (ck === BREAK)
           return BREAK;
         else if (ck === REMOVE)
           node.key = null;
-        const cv = await visitAsync_("value", node.value, visitor, path20);
+        const cv = await visitAsync_("value", node.value, visitor, path21);
         if (cv === BREAK)
           return BREAK;
         else if (cv === REMOVE)
@@ -468,23 +474,23 @@ var require_visit = __commonJS((exports) => {
     }
     return visitor;
   }
-  function callVisitor(key, node, visitor, path20) {
+  function callVisitor(key, node, visitor, path21) {
     if (typeof visitor === "function")
-      return visitor(key, node, path20);
+      return visitor(key, node, path21);
     if (identity.isMap(node))
-      return visitor.Map?.(key, node, path20);
+      return visitor.Map?.(key, node, path21);
     if (identity.isSeq(node))
-      return visitor.Seq?.(key, node, path20);
+      return visitor.Seq?.(key, node, path21);
     if (identity.isPair(node))
-      return visitor.Pair?.(key, node, path20);
+      return visitor.Pair?.(key, node, path21);
     if (identity.isScalar(node))
-      return visitor.Scalar?.(key, node, path20);
+      return visitor.Scalar?.(key, node, path21);
     if (identity.isAlias(node))
-      return visitor.Alias?.(key, node, path20);
+      return visitor.Alias?.(key, node, path21);
     return;
   }
-  function replaceNode(key, path20, node) {
-    const parent = path20[path20.length - 1];
+  function replaceNode(key, path21, node) {
+    const parent = path21[path21.length - 1];
     if (identity.isCollection(parent)) {
       parent.items[key] = node;
     } else if (identity.isPair(parent)) {
@@ -1043,10 +1049,10 @@ var require_Collection = __commonJS((exports) => {
   var createNode = require_createNode();
   var identity = require_identity();
   var Node = require_Node();
-  function collectionFromPath(schema, path20, value) {
+  function collectionFromPath(schema, path21, value) {
     let v = value;
-    for (let i = path20.length - 1;i >= 0; --i) {
-      const k = path20[i];
+    for (let i = path21.length - 1;i >= 0; --i) {
+      const k = path21[i];
       if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
         const a = [];
         a[k] = v;
@@ -1065,7 +1071,7 @@ var require_Collection = __commonJS((exports) => {
       sourceObjects: new Map
     });
   }
-  var isEmptyPath = (path20) => path20 == null || typeof path20 === "object" && !!path20[Symbol.iterator]().next().done;
+  var isEmptyPath = (path21) => path21 == null || typeof path21 === "object" && !!path21[Symbol.iterator]().next().done;
 
   class Collection extends Node.NodeBase {
     constructor(type, schema) {
@@ -1086,11 +1092,11 @@ var require_Collection = __commonJS((exports) => {
         copy.range = this.range.slice();
       return copy;
     }
-    addIn(path20, value) {
-      if (isEmptyPath(path20))
+    addIn(path21, value) {
+      if (isEmptyPath(path21))
         this.add(value);
       else {
-        const [key, ...rest] = path20;
+        const [key, ...rest] = path21;
         const node = this.get(key, true);
         if (identity.isCollection(node))
           node.addIn(rest, value);
@@ -1100,8 +1106,8 @@ var require_Collection = __commonJS((exports) => {
           throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
       }
     }
-    deleteIn(path20) {
-      const [key, ...rest] = path20;
+    deleteIn(path21) {
+      const [key, ...rest] = path21;
       if (rest.length === 0)
         return this.delete(key);
       const node = this.get(key, true);
@@ -1110,8 +1116,8 @@ var require_Collection = __commonJS((exports) => {
       else
         throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
     }
-    getIn(path20, keepScalar) {
-      const [key, ...rest] = path20;
+    getIn(path21, keepScalar) {
+      const [key, ...rest] = path21;
       const node = this.get(key, true);
       if (rest.length === 0)
         return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -1126,15 +1132,15 @@ var require_Collection = __commonJS((exports) => {
         return n == null || allowScalar && identity.isScalar(n) && n.value == null && !n.commentBefore && !n.comment && !n.tag;
       });
     }
-    hasIn(path20) {
-      const [key, ...rest] = path20;
+    hasIn(path21) {
+      const [key, ...rest] = path21;
       if (rest.length === 0)
         return this.has(key);
       const node = this.get(key, true);
       return identity.isCollection(node) ? node.hasIn(rest) : false;
     }
-    setIn(path20, value) {
-      const [key, ...rest] = path20;
+    setIn(path21, value) {
+      const [key, ...rest] = path21;
       if (rest.length === 0) {
         this.set(key, value);
       } else {
@@ -3527,9 +3533,9 @@ var require_Document = __commonJS((exports) => {
       if (assertCollection(this.contents))
         this.contents.add(value);
     }
-    addIn(path20, value) {
+    addIn(path21, value) {
       if (assertCollection(this.contents))
-        this.contents.addIn(path20, value);
+        this.contents.addIn(path21, value);
     }
     createAlias(node, name) {
       if (!node.anchor) {
@@ -3578,30 +3584,30 @@ var require_Document = __commonJS((exports) => {
     delete(key) {
       return assertCollection(this.contents) ? this.contents.delete(key) : false;
     }
-    deleteIn(path20) {
-      if (Collection.isEmptyPath(path20)) {
+    deleteIn(path21) {
+      if (Collection.isEmptyPath(path21)) {
         if (this.contents == null)
           return false;
         this.contents = null;
         return true;
       }
-      return assertCollection(this.contents) ? this.contents.deleteIn(path20) : false;
+      return assertCollection(this.contents) ? this.contents.deleteIn(path21) : false;
     }
     get(key, keepScalar) {
       return identity.isCollection(this.contents) ? this.contents.get(key, keepScalar) : undefined;
     }
-    getIn(path20, keepScalar) {
-      if (Collection.isEmptyPath(path20))
+    getIn(path21, keepScalar) {
+      if (Collection.isEmptyPath(path21))
         return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-      return identity.isCollection(this.contents) ? this.contents.getIn(path20, keepScalar) : undefined;
+      return identity.isCollection(this.contents) ? this.contents.getIn(path21, keepScalar) : undefined;
     }
     has(key) {
       return identity.isCollection(this.contents) ? this.contents.has(key) : false;
     }
-    hasIn(path20) {
-      if (Collection.isEmptyPath(path20))
+    hasIn(path21) {
+      if (Collection.isEmptyPath(path21))
         return this.contents !== undefined;
-      return identity.isCollection(this.contents) ? this.contents.hasIn(path20) : false;
+      return identity.isCollection(this.contents) ? this.contents.hasIn(path21) : false;
     }
     set(key, value) {
       if (this.contents == null) {
@@ -3610,13 +3616,13 @@ var require_Document = __commonJS((exports) => {
         this.contents.set(key, value);
       }
     }
-    setIn(path20, value) {
-      if (Collection.isEmptyPath(path20)) {
+    setIn(path21, value) {
+      if (Collection.isEmptyPath(path21)) {
         this.contents = value;
       } else if (this.contents == null) {
-        this.contents = Collection.collectionFromPath(this.schema, Array.from(path20), value);
+        this.contents = Collection.collectionFromPath(this.schema, Array.from(path21), value);
       } else if (assertCollection(this.contents)) {
-        this.contents.setIn(path20, value);
+        this.contents.setIn(path21, value);
       }
     }
     setSchema(version, options = {}) {
@@ -5511,9 +5517,9 @@ var require_cst_visit = __commonJS((exports) => {
   visit.BREAK = BREAK;
   visit.SKIP = SKIP;
   visit.REMOVE = REMOVE;
-  visit.itemAtPath = (cst, path20) => {
+  visit.itemAtPath = (cst, path21) => {
     let item = cst;
-    for (const [field, index] of path20) {
+    for (const [field, index] of path21) {
       const tok = item?.[field];
       if (tok && "items" in tok) {
         item = tok.items[index];
@@ -5522,23 +5528,23 @@ var require_cst_visit = __commonJS((exports) => {
     }
     return item;
   };
-  visit.parentCollection = (cst, path20) => {
-    const parent = visit.itemAtPath(cst, path20.slice(0, -1));
-    const field = path20[path20.length - 1][0];
+  visit.parentCollection = (cst, path21) => {
+    const parent = visit.itemAtPath(cst, path21.slice(0, -1));
+    const field = path21[path21.length - 1][0];
     const coll = parent?.[field];
     if (coll && "items" in coll)
       return coll;
     throw new Error("Parent collection not found");
   };
-  function _visit(path20, item, visitor) {
-    let ctrl = visitor(item, path20);
+  function _visit(path21, item, visitor) {
+    let ctrl = visitor(item, path21);
     if (typeof ctrl === "symbol")
       return ctrl;
     for (const field of ["key", "value"]) {
       const token = item[field];
       if (token && "items" in token) {
         for (let i = 0;i < token.items.length; ++i) {
-          const ci = _visit(Object.freeze(path20.concat([[field, i]])), token.items[i], visitor);
+          const ci = _visit(Object.freeze(path21.concat([[field, i]])), token.items[i], visitor);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -5549,10 +5555,10 @@ var require_cst_visit = __commonJS((exports) => {
           }
         }
         if (typeof ctrl === "function" && field === "key")
-          ctrl = ctrl(item, path20);
+          ctrl = ctrl(item, path21);
       }
     }
-    return typeof ctrl === "function" ? ctrl(item, path20) : ctrl;
+    return typeof ctrl === "function" ? ctrl(item, path21) : ctrl;
   }
   exports.visit = visit;
 });
@@ -10677,7 +10683,9 @@ var ArgsSchema4 = z4.object({
   source: z4.enum(["reviewer", "codeforge-fallback"]).optional().describe("写入来源；默认 'reviewer'，codeforge 补写时传 'codeforge-fallback'"),
   reviewerAgent: z4.string().optional().describe("写入 agent name（默认 'reviewer'；fallback 时为 'codeforge'）"),
   sessionId: z4.string().optional().describe("reviewer 子 session id（boomerang 溯源用，可选）"),
-  model: z4.string().optional().describe("审批模型 id（审计用，可选）")
+  model: z4.string().optional().describe("审批模型 id（审计用，可选）"),
+  coveredSha: z4.string().optional().describe("approval 写入时 worktree HEAD sha；reviewer 调此工具时传入（git -C <worktreePath> rev-parse HEAD）。pre-check 强绑定核心字段，缺失则 pre-check 不命中。ADR:merge-approval-pre-check"),
+  reviewTarget: z4.string().optional().describe("本次审阅的 review_target 值（reviewer.md 词表：code / code:typescript / code:python / code:csharp-lua-c / plan_only / adr / docs / decision_only）。pre-check 仅放行 startsWith('code') 的值；缺失或其他值均不命中。ADR:merge-approval-pre-check")
 });
 var _approvalStore = null;
 function getApprovalStore() {
@@ -10711,6 +10719,8 @@ async function execute4(input) {
       decisionLine: args.decisionLine ?? args.verdict,
       notes: args.notes,
       createdAt: now,
+      ...args.coveredSha ? { coveredSha: args.coveredSha } : {},
+      ...args.reviewTarget ? { reviewTarget: args.reviewTarget } : {},
       escapeHatch: null
     };
     const file = await approvals.record(meta);
@@ -12369,13 +12379,23 @@ async function pruneOrphanWorktrees(mainRoot, opts = {}) {
     const r = await pruneDiscardedRegistryEntries(resolved);
     discardedPruned = r.pruned;
   } catch {}
-  return { cleaned, failed, skipped, discardedPruned };
+  let gitAdminPruned = 0;
+  try {
+    const out = await runGit2(resolved, ["worktree", "prune", "--verbose"]);
+    gitAdminPruned = out.split(`
+`).filter((l) => /\bRemoving\b/i.test(l)).length;
+  } catch {}
+  return { cleaned, failed, skipped, discardedPruned, gitAdminPruned };
 }
 
 // lib/merge-gate.ts
 import { promises as fs11 } from "node:fs";
 import * as path14 from "node:path";
-var DEFAULT_MERGE_GATE_CONFIG = { enabled: true };
+var DEFAULT_MERGE_GATE_CONFIG = {
+  enabled: true,
+  approvalPreCheck: true,
+  preCheckTtlSeconds: 3600
+};
 var CONFIG_REL = ".codeforge/merge-gate.json";
 async function loadMergeGate(mainRoot) {
   const file = path14.join(mainRoot, CONFIG_REL);
@@ -12387,29 +12407,40 @@ async function loadMergeGate(mainRoot) {
     if (e.code === "ENOENT")
       return { ...DEFAULT_MERGE_GATE_CONFIG };
     console.warn(`[merge-gate] 读取 ${CONFIG_REL} 失败，fail-safe 退化为 enabled=false: ${e.message}`);
-    return { enabled: false };
+    return { enabled: false, approvalPreCheck: false };
   }
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
     console.warn(`[merge-gate] ${CONFIG_REL} JSON 解析失败，fail-safe 退化为 enabled=false: ${err instanceof Error ? err.message : String(err)}`);
-    return { enabled: false };
+    return { enabled: false, approvalPreCheck: false };
   }
   if (!parsed || typeof parsed !== "object") {
     console.warn(`[merge-gate] ${CONFIG_REL} 顶层非 object，fail-safe 退化为 enabled=false`);
-    return { enabled: false };
+    return { enabled: false, approvalPreCheck: false };
   }
   const obj = parsed;
   const enabled = typeof obj["enabled"] === "boolean" ? obj["enabled"] : DEFAULT_MERGE_GATE_CONFIG.enabled;
-  return { enabled };
+  const approvalPreCheck = typeof obj["approvalPreCheck"] === "boolean" ? obj["approvalPreCheck"] : DEFAULT_MERGE_GATE_CONFIG.approvalPreCheck ?? false;
+  let preCheckTtlSeconds = DEFAULT_MERGE_GATE_CONFIG.preCheckTtlSeconds ?? 3600;
+  const rawTtl = obj["preCheckTtlSeconds"];
+  if (typeof rawTtl === "number" && rawTtl > 0) {
+    if (rawTtl > 86400) {
+      console.warn(`[merge-gate] preCheckTtlSeconds=${rawTtl} 超过 24h 上界，截断为 86400`);
+      preCheckTtlSeconds = 86400;
+    } else {
+      preCheckTtlSeconds = rawTtl;
+    }
+  }
+  return { enabled, approvalPreCheck, preCheckTtlSeconds };
 }
 
 // lib/merge-loop.ts
 var DEFAULT_MERGE_LOOP_CONFIG = {
   maxReviewLoops: 3,
   autoCoder: true,
-  reviewTimeoutMs: 180000,
+  reviewTimeoutMs: 360000,
   coderTimeoutMs: 600000,
   abortDirtyStrategy: "checkpoint"
 };
@@ -12447,6 +12478,43 @@ async function runMergeLoop(opts) {
     });
     return { status: "force_merged", commitSha: sha, loops: 0 };
   }
+  if (mergeGate.enabled && mergeGate.approvalPreCheck) {
+    progress("approval_pre_check", "检查既有 approval 是否可跳过 reviewer");
+    const preStore = opts.__testHooks?.approvalStore ?? ApprovalStore.forProject(opts.mainRoot);
+    const hit = await tryApprovalPreCheck({ opts, entry, mergeGate, store: preStore });
+    if (hit.ok) {
+      await maybeAbort(opts, config, entry);
+      if (typeof preStore.recordEscape === "function") {
+        await preStore.recordEscape({
+          pendingId: `session:${opts.sessionId}`,
+          timestamp: new Date().toISOString(),
+          agent: "codeforge-pre-check",
+          sessionId: opts.sessionId,
+          reason: `approval-pre-check: skipped reviewer (coveredSha=${hit.coveredSha})`,
+          pendingMeta: {
+            target: "worktree",
+            sourceHash: hit.coveredSha,
+            newSize: 0
+          }
+        }).catch((err) => {
+          console.warn(`[merge-loop] pre-check recordEscape 失败 (session=${opts.sessionId}): ${err instanceof Error ? err.message : String(err)}`);
+        });
+      }
+      progress("approval_pre_check", `skip_review | reviewTarget=${hit.reviewTarget} | coveredSha=${hit.coveredSha.slice(0, 12)} | ttlOk`);
+      const { sha } = await mergeSessionBack({
+        sessionId: opts.sessionId,
+        mainRoot: opts.mainRoot
+      });
+      return {
+        status: "skipped_by_approval",
+        commitSha: sha,
+        loops: 0,
+        finalDecision: "APPROVE",
+        lastReviewSummary: `approval-pre-check 命中：coveredSha=${hit.coveredSha}, reviewTarget=${hit.reviewTarget}`
+      };
+    }
+    progress("approval_pre_check", `未命中(${hit.reason})，走 review-loop`);
+  }
   while (true) {
     await maybeAbort(opts, config, entry);
     loops += 1;
@@ -12667,6 +12735,44 @@ async function handleAbortDirty(opts, config, entry) {
     console.warn(`[merge-loop] abort-dirty 处理失败 (session=${opts.sessionId}): ${err instanceof Error ? err.message : String(err)}`);
   }
 }
+async function tryApprovalPreCheck(args) {
+  const { opts, entry, mergeGate, store } = args;
+  const isDirty = opts.__testHooks?.isWorktreeDirty ?? isWorktreeDirty;
+  const headOf = opts.__testHooks?.getCurrentWorktreeHead ?? getCurrentWorktreeHead;
+  let dirty;
+  try {
+    dirty = await isDirty(entry.worktreePath);
+  } catch {
+    return { ok: false, reason: "dirty-check-failed" };
+  }
+  if (dirty)
+    return { ok: false, reason: "dirty" };
+  let approval;
+  try {
+    approval = await store.getLatest(`session:${opts.sessionId}`);
+  } catch (err) {
+    console.warn(`[merge-loop] pre-check getLatest 失败 (session=${opts.sessionId}): ${err instanceof Error ? err.message : String(err)}`);
+    return { ok: false, reason: "no-approval" };
+  }
+  if (!approval)
+    return { ok: false, reason: "no-approval" };
+  if (approval.verdict !== "APPROVE" && approval.verdict !== "APPROVE_WITH_NOTES") {
+    return { ok: false, reason: "verdict" };
+  }
+  if (approval.reviewTarget?.startsWith("code") !== true) {
+    return { ok: false, reason: "target" };
+  }
+  if (!approval.coveredSha)
+    return { ok: false, reason: "no-covered-sha" };
+  const head = await headOf(entry.worktreePath);
+  if (approval.coveredSha !== head)
+    return { ok: false, reason: "sha-mismatch" };
+  const ttlSeconds = Math.min(mergeGate.preCheckTtlSeconds ?? 3600, 86400);
+  const age = Date.now() - Date.parse(approval.createdAt);
+  if (!(age <= ttlSeconds * 1000))
+    return { ok: false, reason: "ttl-expired" };
+  return { ok: true, coveredSha: approval.coveredSha, reviewTarget: approval.reviewTarget };
+}
 function isAbortError(err) {
   return err instanceof Error && err.name === "AbortError";
 }
@@ -13646,6 +13752,159 @@ async function execute15(input) {
     };
   }
 }
+// tools/worktrees-gc.ts
+import { z as z16 } from "zod";
+
+// lib/opencode-session-probe.ts
+import * as path18 from "node:path";
+import * as os5 from "node:os";
+import { createRequire as createRequire2 } from "node:module";
+var requireFromHere = createRequire2(import.meta.url);
+var DEFAULT_LIVENESS_MS = 6 * 60 * 60000;
+var DEFAULT_DB_PATH = path18.join(os5.homedir(), ".local/share/opencode/opencode.db");
+function createSessionProbe(opts = {}) {
+  const dbPath = opts.dbPath ?? DEFAULT_DB_PATH;
+  const httpBaseUrl = opts.httpBaseUrl ?? process.env["OPENCODE_SERVER_URL"];
+  const livenessWindowMs = opts.livenessWindowMs ?? DEFAULT_LIVENESS_MS;
+  const timeoutMs = opts.timeoutMs ?? 1500;
+  let db = null;
+  let dbInitTried = false;
+  let dbStmt = null;
+  async function tryOpenDb() {
+    if (dbInitTried)
+      return db != null;
+    dbInitTried = true;
+    try {
+      const mod = requireFromHere("node:sqlite");
+      try {
+        db = new mod.DatabaseSync(dbPath, { readOnly: true });
+      } catch {
+        db = null;
+        dbStmt = null;
+        return false;
+      }
+      dbStmt = db.prepare("SELECT time_updated, time_archived FROM session WHERE id = ? LIMIT 1");
+      return true;
+    } catch {
+      db = null;
+      dbStmt = null;
+      return false;
+    }
+  }
+  async function probeHttp(sessionId) {
+    if (!httpBaseUrl)
+      return null;
+    try {
+      const ctrl = new AbortController;
+      const t = setTimeout(() => ctrl.abort(), timeoutMs);
+      const res = await fetch(`${httpBaseUrl.replace(/\/$/, "")}/session`, {
+        signal: ctrl.signal
+      }).finally(() => clearTimeout(t));
+      if (!res.ok)
+        return null;
+      const list = await res.json();
+      const hit = Array.isArray(list) && list.some((s) => s.id === sessionId);
+      return { alive: hit, source: "http" };
+    } catch {
+      return null;
+    }
+  }
+  async function probeSqlite(sessionId) {
+    if (!await tryOpenDb() || !dbStmt)
+      return null;
+    try {
+      const row = dbStmt.get(sessionId);
+      if (!row) {
+        return { alive: false, source: "sqlite" };
+      }
+      if (row.time_archived != null) {
+        return {
+          alive: false,
+          source: "sqlite",
+          time_archived: row.time_archived
+        };
+      }
+      const now = Date.now();
+      const tu = Number(row.time_updated) || 0;
+      const alive = now - tu < livenessWindowMs;
+      return { alive, source: "sqlite", time_updated: tu, time_archived: null };
+    } catch {
+      return null;
+    }
+  }
+  return {
+    async isSessionAlive(sessionId) {
+      const http = await probeHttp(sessionId);
+      if (http)
+        return http;
+      const sql = await probeSqlite(sessionId);
+      if (sql)
+        return sql;
+      return { alive: true, source: "unknown" };
+    },
+    close() {
+      try {
+        db?.close?.();
+      } catch {}
+      db = null;
+      dbStmt = null;
+    }
+  };
+}
+
+// tools/worktrees-gc.ts
+var description16 = [
+  "手动触发 worktree 垃圾回收（清理僵尸 / 孤儿 worktree + dangling git 元数据）。",
+  "**何时调用**：",
+  "- 用户发现 worktree 堆积（git worktree list 一大堆 codeforge-session-*）",
+  "- 自动 GC 疑似停跑（lifecycle 因项目无 .codeforge/ skip 过一段时间）",
+  "**模式**：",
+  "- 默认（保守）：沿用自动 GC 的时间护栏（6h/72h），只清确凿僵尸",
+  "- force=true（高风险）：时间护栏归零，连 probe 判 unknown 的也立即清，可能误删活跃 session 的 worktree",
+  "**何时不需要**：自动 30min interval 正常跑时无需手动调。"
+].join(`
+`);
+var ArgsSchema16 = z16.object({
+  force: z16.boolean().optional().describe("高风险：时间护栏归零，连 probe unknown 的 worktree 也立即清，可能误删活跃 session worktree。默认 false（保守）")
+});
+var _ctx3 = {};
+function __setContext3(ctx) {
+  _ctx3 = ctx;
+}
+function getMainRoot2() {
+  return _ctx3.mainRoot ?? process.cwd();
+}
+async function execute16(input) {
+  const parsed = ArgsSchema16.safeParse(input);
+  if (!parsed.success) {
+    return {
+      ok: false,
+      error: parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ")
+    };
+  }
+  const force = parsed.data.force === true;
+  const probe = createSessionProbe();
+  try {
+    const result = await pruneOrphanWorktrees(getMainRoot2(), {
+      isSessionAlive: probe.isSessionAlive,
+      ...force ? { semanticOrphanMinAgeMs: 0, semanticOrphanUnknownTimeoutMs: 0 } : {}
+    });
+    return {
+      ok: true,
+      mode: force ? "force" : "conservative",
+      cleaned: result.cleaned,
+      failed: result.failed,
+      skipped: result.skipped,
+      discardedPruned: result.discardedPruned ?? 0,
+      gitAdminPruned: result.gitAdminPruned ?? 0,
+      cleanedCount: result.cleaned.length
+    };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  } finally {
+    probe.close();
+  }
+}
 // lib/opencode-runner.ts
 function makeOpencodeRunner(opts) {
   const log4 = opts.log ?? (() => {});
@@ -13907,18 +14166,18 @@ init_decision_parser();
 
 // lib/parent-map-store.ts
 import { promises as fs14 } from "node:fs";
-import * as path18 from "node:path";
+import * as path19 from "node:path";
 var PARENT_MAP_VERSION = 1;
 var PARENT_MAP_LOCK_TIMEOUT_MS = 2000;
 var PARENT_MAP_MAX_ENTRIES = 256;
 function parentMapDir(mainRoot) {
-  return path18.join(runtimeDir(path18.resolve(mainRoot), { ensure: false }), "session-worktrees");
+  return path19.join(runtimeDir(path19.resolve(mainRoot), { ensure: false }), "session-worktrees");
 }
 function parentMapPath(mainRoot) {
-  return path18.join(parentMapDir(mainRoot), "parent-map.json");
+  return path19.join(parentMapDir(mainRoot), "parent-map.json");
 }
 function parentMapLockPath(mainRoot) {
-  return path18.join(parentMapDir(mainRoot), "parent-map.lock");
+  return path19.join(parentMapDir(mainRoot), "parent-map.lock");
 }
 async function readParentMapFile(mainRoot) {
   const file = parentMapPath(mainRoot);
@@ -13938,7 +14197,7 @@ async function readParentMapFile(mainRoot) {
 }
 async function writeParentMapFile(mainRoot, payload) {
   const file = parentMapPath(mainRoot);
-  await fs14.mkdir(path18.dirname(file), { recursive: true });
+  await fs14.mkdir(path19.dirname(file), { recursive: true });
   const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
   await fs14.writeFile(tmp, JSON.stringify(payload, null, 2), "utf8");
   await fs14.rename(tmp, file);
@@ -13973,7 +14232,7 @@ async function loadParentMap(mainRoot) {
 }
 async function mutateParentMap(mainRoot, mutator, opts = {}) {
   const lockPath = parentMapLockPath(mainRoot);
-  await fs14.mkdir(path18.dirname(lockPath), { recursive: true });
+  await fs14.mkdir(path19.dirname(lockPath), { recursive: true });
   const lockOpts = {
     timeoutMs: opts.timeoutMs ?? PARENT_MAP_LOCK_TIMEOUT_MS,
     ...opts
@@ -13992,7 +14251,7 @@ async function appendParentEntry(mainRoot, childID, parentID, ts, opts = {}) {
   if (!childID || !parentID)
     return;
   const lockPath = parentMapLockPath(mainRoot);
-  await fs14.mkdir(path18.dirname(lockPath), { recursive: true });
+  await fs14.mkdir(path19.dirname(lockPath), { recursive: true });
   const lockOpts = {
     timeoutMs: opts.timeoutMs ?? PARENT_MAP_LOCK_TIMEOUT_MS,
     ...opts
@@ -14124,7 +14383,7 @@ class ProductionSpawner {
         prompt,
         title: `[merge-review] sess=${args.sessionId.slice(0, 8)} r=${args.round}/${args.maxRounds}`,
         ...args.signal ? { signal: args.signal } : {},
-        timeoutMs: this.opts.reviewerTimeoutMs ?? 180000
+        timeoutMs: this.opts.reviewerTimeoutMs ?? 360000
       }, args.sessionId);
     } catch (err) {
       throw err;
@@ -14326,7 +14585,7 @@ function clip3(s, max) {
 
 // lib/codeforge-runtime.ts
 import { promises as fs15 } from "node:fs";
-import * as path19 from "node:path";
+import * as path20 from "node:path";
 var DEFAULT_RUNTIME = {
   autonomy: {
     downgrade_on_risky: true
@@ -14369,7 +14628,7 @@ function loadRuntimeSync(opts = {}) {
 }
 async function loadRuntime(opts = {}) {
   const root = opts.root ?? process.cwd();
-  const abs = path19.resolve(root, opts.file ?? CONFIG_FILE);
+  const abs = path20.resolve(root, opts.file ?? CONFIG_FILE);
   let raw;
   try {
     raw = await fs15.readFile(abs, "utf8");
@@ -14653,7 +14912,7 @@ var toolHeartbeatServer = async (ctx) => {
 var handler6 = toolHeartbeatServer;
 
 // plugins/codeforge-tools.ts
-var z16 = tool.schema;
+var z17 = tool.schema;
 var PLUGIN_NAME7 = "codeforge-tools";
 logLifecycle(PLUGIN_NAME7, "import");
 function wrap(output, metadata) {
@@ -14700,7 +14959,7 @@ function buildBrowserTools() {
     browser_navigate: tool({
       description: description5,
       args: {
-        url: z16.string().min(1).describe("要打开的 URL；必须是 http(s)")
+        url: z17.string().min(1).describe("要打开的 URL；必须是 http(s)")
       },
       async execute(args) {
         return await runSafe("browser_navigate", async () => {
@@ -14715,7 +14974,7 @@ function buildBrowserTools() {
     browser_click: tool({
       description: description6,
       args: {
-        selector: z16.string().min(1).describe("CSS / Playwright locator，必须能唯一定位")
+        selector: z17.string().min(1).describe("CSS / Playwright locator，必须能唯一定位")
       },
       async execute(args) {
         return await runSafe("browser_click", async () => {
@@ -14730,8 +14989,8 @@ function buildBrowserTools() {
     browser_fill: tool({
       description: description7,
       args: {
-        selector: z16.string().min(1).describe("CSS / Playwright locator"),
-        value: z16.string().describe("要填入的文本；原样写入不转义")
+        selector: z17.string().min(1).describe("CSS / Playwright locator"),
+        value: z17.string().describe("要填入的文本；原样写入不转义")
       },
       async execute(args) {
         return await runSafe("browser_fill", async () => {
@@ -14746,8 +15005,8 @@ function buildBrowserTools() {
     browser_screenshot: tool({
       description: description8,
       args: {
-        fullPage: z16.boolean().optional().describe("是否截全长页面（默认仅可视区）"),
-        selector: z16.string().optional().describe("CSS 选择器；指定时只截该元素")
+        fullPage: z17.boolean().optional().describe("是否截全长页面（默认仅可视区）"),
+        selector: z17.string().optional().describe("CSS 选择器；指定时只截该元素")
       },
       async execute(args) {
         return await runSafe("browser_screenshot", async () => {
@@ -14762,8 +15021,8 @@ function buildBrowserTools() {
     browser_console: tool({
       description: description9,
       args: {
-        level: z16.enum(["log", "info", "warn", "error", "debug"]).optional().describe("过滤级别"),
-        sinceTs: z16.number().optional().describe("timestamp >= sinceTs 的条目")
+        level: z17.enum(["log", "info", "warn", "error", "debug"]).optional().describe("过滤级别"),
+        sinceTs: z17.number().optional().describe("timestamp >= sinceTs 的条目")
       },
       async execute(args) {
         return await runSafe("browser_console", async () => {
@@ -14778,8 +15037,8 @@ function buildBrowserTools() {
     browser_network: tool({
       description: description10,
       args: {
-        method: z16.string().optional().describe("HTTP 方法过滤（GET/POST/...）"),
-        sinceTs: z16.number().optional().describe("start_ts >= sinceTs 的请求")
+        method: z17.string().optional().describe("HTTP 方法过滤（GET/POST/...）"),
+        sinceTs: z17.number().optional().describe("start_ts >= sinceTs 的请求")
       },
       async execute(args) {
         return await runSafe("browser_network", async () => {
@@ -14802,7 +15061,8 @@ var CORE_TOOL_NAMES = [
   "session_merge",
   "plan_write",
   "plan_read",
-  "adr_init"
+  "adr_init",
+  "worktrees_gc"
 ];
 var BROWSER_TOOL_NAMES = [
   "browser_navigate",
@@ -14839,31 +15099,32 @@ var codeforgeToolsServer = async (ctx) => {
     spawner,
     resolveCurrentSessionId: () => process.env["CODEFORGE_SESSION_ID"] ?? ""
   });
+  __setContext3({ mainRoot: ctx.directory ?? process.cwd() });
   const browserTools = browserEnabled ? buildBrowserTools() : {};
   return {
     tool: {
       ast_edit: tool({
         description,
         args: {
-          action: z16.enum([
+          action: z17.enum([
             "replace_anchor",
             "insert_after_anchor",
             "insert_before_anchor",
             "delete_range",
             "rename_symbol"
           ]).describe("编辑类型；不同 action 需要的字段不同"),
-          target: z16.string().min(1).describe("目标文件路径（相对 cwd 或绝对）"),
-          before_hash: z16.string().optional().describe("操作前的 sha256 hex（强烈建议传，新文件传 null/省略）"),
-          auto_stage: z16.boolean().optional().describe("已废弃（保留兼容字段）：Phase 5 后 ast_edit 直接写入 session worktree，无需独立 stage"),
-          description: z16.string().optional().describe("可选变更说明（写入 audit log）"),
-          anchor: z16.string().optional().describe("anchor 类用：anchor 文本或 regex 源"),
-          regex: z16.boolean().optional().describe("anchor 是否按 RegExp 解释，默认 false"),
-          occurrence: z16.number().int().min(1).optional().describe("第几次匹配（1-based），默认 1"),
-          payload: z16.string().optional().describe("anchor 类用：要写入的内容"),
-          start: z16.number().int().min(1).optional().describe("delete_range 用：起始行（1-based）"),
-          end: z16.number().int().min(1).optional().describe("delete_range 用：结束行（1-based）"),
-          old_name: z16.string().optional().describe("rename_symbol 用：旧标识符"),
-          new_name: z16.string().optional().describe("rename_symbol 用：新标识符")
+          target: z17.string().min(1).describe("目标文件路径（相对 cwd 或绝对）"),
+          before_hash: z17.string().optional().describe("操作前的 sha256 hex（强烈建议传，新文件传 null/省略）"),
+          auto_stage: z17.boolean().optional().describe("已废弃（保留兼容字段）：Phase 5 后 ast_edit 直接写入 session worktree，无需独立 stage"),
+          description: z17.string().optional().describe("可选变更说明（写入 audit log）"),
+          anchor: z17.string().optional().describe("anchor 类用：anchor 文本或 regex 源"),
+          regex: z17.boolean().optional().describe("anchor 是否按 RegExp 解释，默认 false"),
+          occurrence: z17.number().int().min(1).optional().describe("第几次匹配（1-based），默认 1"),
+          payload: z17.string().optional().describe("anchor 类用：要写入的内容"),
+          start: z17.number().int().min(1).optional().describe("delete_range 用：起始行（1-based）"),
+          end: z17.number().int().min(1).optional().describe("delete_range 用：结束行（1-based）"),
+          old_name: z17.string().optional().describe("rename_symbol 用：旧标识符"),
+          new_name: z17.string().optional().describe("rename_symbol 用：新标识符")
         },
         async execute(args) {
           return await runSafeTracked("ast_edit", async () => {
@@ -14886,10 +15147,10 @@ var codeforgeToolsServer = async (ctx) => {
       repo_map: tool({
         description: description2,
         args: {
-          root: z16.string().optional().describe("扫描根目录，默认 cwd"),
-          top: z16.number().int().min(1).max(100).optional().describe("展示 top N 文件，默认 20"),
-          focus: z16.string().optional().describe("聚焦文件（POSIX 相对路径）"),
-          max_files: z16.number().int().min(10).max(5000).optional().describe("扫描上限，默认 500")
+          root: z17.string().optional().describe("扫描根目录，默认 cwd"),
+          top: z17.number().int().min(1).max(100).optional().describe("展示 top N 文件，默认 20"),
+          focus: z17.string().optional().describe("聚焦文件（POSIX 相对路径）"),
+          max_files: z17.number().int().min(10).max(5000).optional().describe("扫描上限，默认 500")
         },
         async execute(args) {
           return await runSafeTracked("repo_map", async () => {
@@ -14910,14 +15171,14 @@ var codeforgeToolsServer = async (ctx) => {
       rules_debug: tool({
         description: description3,
         args: {
-          current_agent: z16.string().optional().describe("当前 agent 名"),
-          root: z16.string().optional().describe("项目根目录"),
-          home_dir: z16.string().optional().describe("覆盖个人规则目录"),
-          project_dir: z16.string().optional().describe("覆盖项目规则目录"),
-          skip_personal: z16.boolean().optional(),
-          skip_project: z16.boolean().optional(),
-          skip_agent: z16.boolean().optional(),
-          markdown: z16.boolean().optional().describe("默认 true：渲染 markdown 摘要")
+          current_agent: z17.string().optional().describe("当前 agent 名"),
+          root: z17.string().optional().describe("项目根目录"),
+          home_dir: z17.string().optional().describe("覆盖个人规则目录"),
+          project_dir: z17.string().optional().describe("覆盖项目规则目录"),
+          skip_personal: z17.boolean().optional(),
+          skip_project: z17.boolean().optional(),
+          skip_agent: z17.boolean().optional(),
+          markdown: z17.boolean().optional().describe("默认 true：渲染 markdown 摘要")
         },
         async execute(args) {
           return await runSafe("rules_debug", async () => {
@@ -14932,14 +15193,14 @@ var codeforgeToolsServer = async (ctx) => {
       review_approval: tool({
         description: description4,
         args: {
-          verdict: z16.enum(["APPROVE", "APPROVE_WITH_NOTES"]).describe("审批层裁决（审计字段，与协议层独立）；REQUEST_CHANGES / BLOCK 不应调本工具。⚠️ 不要把本字段值复制到 reviewer 输出的 `## Decision` 节首行 — 那是协议层 3 档。"),
-          pendingIds: z16.array(z16.string().min(1)).min(1).describe("本次 APPROVE 覆盖的 pending change id 列表"),
-          notes: z16.string().min(1).max(2000).describe("审阅意见摘要（建议 ≤ 500 字）"),
-          decisionLine: z16.string().optional().describe("`## Decision` 节首行原文（默认 verdict 字面量，机审证据）"),
-          source: z16.enum(["reviewer", "codeforge-fallback"]).optional().describe("写入来源；默认 'reviewer'，codeforge 补写时传 'codeforge-fallback'"),
-          reviewerAgent: z16.string().optional().describe("写入 agent name（默认 'reviewer'；fallback 时为 'codeforge'）"),
-          sessionId: z16.string().optional().describe("reviewer 子 session id（boomerang 溯源用，可选）"),
-          model: z16.string().optional().describe("审批模型 id（审计用，可选）")
+          verdict: z17.enum(["APPROVE", "APPROVE_WITH_NOTES"]).describe("审批层裁决（审计字段，与协议层独立）；REQUEST_CHANGES / BLOCK 不应调本工具。⚠️ 不要把本字段值复制到 reviewer 输出的 `## Decision` 节首行 — 那是协议层 3 档。"),
+          pendingIds: z17.array(z17.string().min(1)).min(1).describe("本次 APPROVE 覆盖的 pending change id 列表"),
+          notes: z17.string().min(1).max(2000).describe("审阅意见摘要（建议 ≤ 500 字）"),
+          decisionLine: z17.string().optional().describe("`## Decision` 节首行原文（默认 verdict 字面量，机审证据）"),
+          source: z17.enum(["reviewer", "codeforge-fallback"]).optional().describe("写入来源；默认 'reviewer'，codeforge 补写时传 'codeforge-fallback'"),
+          reviewerAgent: z17.string().optional().describe("写入 agent name（默认 'reviewer'；fallback 时为 'codeforge'）"),
+          sessionId: z17.string().optional().describe("reviewer 子 session id（boomerang 溯源用，可选）"),
+          model: z17.string().optional().describe("审批模型 id（审计用，可选）")
         },
         async execute(args) {
           return await runSafe("review_approval", async () => {
@@ -14960,10 +15221,10 @@ var codeforgeToolsServer = async (ctx) => {
       model_chain: tool({
         description: description11,
         args: {
-          agent: z16.string().optional().describe("查指定 agent；不传 → 列出全部"),
-          current: z16.string().optional().describe("当前已用过的模型（<provider>/<id>），用于算下一档"),
-          root: z16.string().optional().describe("项目根目录，默认 cwd"),
-          config_file: z16.string().optional().describe("配置文件名；默认 codeforge.json")
+          agent: z17.string().optional().describe("查指定 agent；不传 → 列出全部"),
+          current: z17.string().optional().describe("当前已用过的模型（<provider>/<id>），用于算下一档"),
+          root: z17.string().optional().describe("项目根目录，默认 cwd"),
+          config_file: z17.string().optional().describe("配置文件名；默认 codeforge.json")
         },
         async execute(args) {
           return await runSafe("model_chain", async () => {
@@ -14984,11 +15245,11 @@ var codeforgeToolsServer = async (ctx) => {
       session_merge: tool({
         description: description12,
         args: {
-          action: z16.enum(["merge", "status", "discard", "diff"]).describe("操作类型：merge=合并到主仓（orchestrator 专用）/ status=查询状态 / discard=放弃 / diff=查看 worktree 改动"),
-          session_id: z16.string().optional().describe("目标 session id；不传则用当前 session"),
-          plan_id: z16.string().optional().describe("关联的 plan_id（reviewer 校验时用），格式 plan-YYYYMMDD-HHmmss-NNN"),
-          force: z16.boolean().optional().describe("action=merge 时跳过 review 直接 squash merge（写审计）"),
-          stat: z16.boolean().optional().describe("action=diff 时：true=只显示文件列表+统计，false=完整 diff（默认 false）")
+          action: z17.enum(["merge", "status", "discard", "diff"]).describe("操作类型：merge=合并到主仓（orchestrator 专用）/ status=查询状态 / discard=放弃 / diff=查看 worktree 改动"),
+          session_id: z17.string().optional().describe("目标 session id；不传则用当前 session"),
+          plan_id: z17.string().optional().describe("关联的 plan_id（reviewer 校验时用），格式 plan-YYYYMMDD-HHmmss-NNN"),
+          force: z17.boolean().optional().describe("action=merge 时跳过 review 直接 squash merge（写审计）"),
+          stat: z17.boolean().optional().describe("action=diff 时：true=只显示文件列表+统计，false=完整 diff（默认 false）")
         },
         async execute(args, input) {
           return await runSafe("session_merge", async () => {
@@ -15024,9 +15285,9 @@ var codeforgeToolsServer = async (ctx) => {
       plan_write: tool({
         description: description13,
         args: {
-          title: z16.string().min(2).max(80).describe('方案简短标题（2-80 字），如 "实现 worktree session 隔离 Phase 1"'),
-          content: z16.string().min(10).describe("方案 markdown 全文，建议 ≥ 50 行"),
-          tags: z16.array(z16.string().min(1)).optional().describe('标签（可选），如 ["phase:1", "arch:worktree"]')
+          title: z17.string().min(2).max(80).describe('方案简短标题（2-80 字），如 "实现 worktree session 隔离 Phase 1"'),
+          content: z17.string().min(10).describe("方案 markdown 全文，建议 ≥ 50 行"),
+          tags: z17.array(z17.string().min(1)).optional().describe('标签（可选），如 ["phase:1", "arch:worktree"]')
         },
         async execute(args) {
           return await runSafeTracked("plan_write", async () => {
@@ -15045,8 +15306,8 @@ var codeforgeToolsServer = async (ctx) => {
       plan_read: tool({
         description: description14,
         args: {
-          plan_id: z16.string().optional().describe("方案 ID（推荐），格式 plan-YYYYMMDD-HHmmss-NNN"),
-          path: z16.string().optional().describe("方案绝对路径（兜底用，没有 plan_id 元数据时退而求其次）")
+          plan_id: z17.string().optional().describe("方案 ID（推荐），格式 plan-YYYYMMDD-HHmmss-NNN"),
+          path: z17.string().optional().describe("方案绝对路径（兜底用，没有 plan_id 元数据时退而求其次）")
         },
         async execute(args) {
           return await runSafe("plan_read", async () => {
@@ -15069,11 +15330,11 @@ var codeforgeToolsServer = async (ctx) => {
       adr_init: tool({
         description: description15,
         args: {
-          cwd: z16.string().optional().describe("目标项目根目录，默认 process.cwd()；通常无需传"),
-          force: z16.boolean().optional().describe("已存在文件覆盖；覆盖前自动 .bak.<ts> 备份"),
-          dryRun: z16.boolean().optional().describe("只输出将要执行的写入计划，不实际写盘"),
-          writePrepare: z16.boolean().optional().describe("（npm 项目）自动合并 git config core.hooksPath 到 package.json scripts.prepare；写前自动 backup"),
-          installPrePush: z16.boolean().optional().describe("是否同时生成 .githooks/pre-push hook，默认 true")
+          cwd: z17.string().optional().describe("目标项目根目录，默认 process.cwd()；通常无需传"),
+          force: z17.boolean().optional().describe("已存在文件覆盖；覆盖前自动 .bak.<ts> 备份"),
+          dryRun: z17.boolean().optional().describe("只输出将要执行的写入计划，不实际写盘"),
+          writePrepare: z17.boolean().optional().describe("（npm 项目）自动合并 git config core.hooksPath 到 package.json scripts.prepare；写前自动 backup"),
+          installPrePush: z17.boolean().optional().describe("是否同时生成 .githooks/pre-push hook，默认 true")
         },
         async execute(args) {
           return await runSafe("adr_init", async () => {
@@ -15085,6 +15346,27 @@ var codeforgeToolsServer = async (ctx) => {
             return wrap(result, { title: "adr_init" });
           });
         }
+      }),
+      worktrees_gc: tool({
+        description: description16,
+        args: {
+          force: z17.boolean().optional().describe("高风险：时间护栏归零，连 probe unknown 的 worktree 也立即清，可能误删活跃 session worktree。默认 false（保守）")
+        },
+        async execute(args) {
+          return await runSafe("worktrees_gc", async () => {
+            const v = projectValidate("worktrees_gc", ArgsSchema16, args);
+            if (!v.ok)
+              return wrap(JSON.parse(v.output));
+            const result = await execute16(v.data);
+            const meta = { title: "worktrees_gc" };
+            const r = result;
+            if (r.ok) {
+              meta["cleaned"] = r.cleanedCount ?? 0;
+              meta["gitAdminPruned"] = r.gitAdminPruned ?? 0;
+            }
+            return wrap(result, meta);
+          });
+        }
       })
     }
   };
@@ -15093,10 +15375,10 @@ var handler7 = codeforgeToolsServer;
 
 // plugins/discover-spec-suggest.ts
 import { readFileSync as readFileSync3, readdirSync, statSync as statSync2 } from "node:fs";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 
 // lib/handoff-schema.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 
 // node_modules/yaml/dist/index.js
 var composer = require_composer();
@@ -15149,92 +15431,92 @@ var MAX_HANDOFF_SIZE = 100 * 1024;
 var SLUG_REGEX = /^[a-z0-9][a-z0-9-]{0,49}$/;
 var SCORE_DIMENSIONS = ["functional", "ux", "technical", "constraints", "edge_cases"];
 var COMBO_VALUES = ["A", "B", "C", "D"];
-var NeedSchema = z17.object({
-  id: z17.string().min(1),
-  type: z17.enum(["must", "should", "nice-to-have"]),
-  statement: z17.string().min(1),
-  rationale: z17.string().optional(),
-  acceptance: z17.array(z17.string()).optional()
+var NeedSchema = z18.object({
+  id: z18.string().min(1),
+  type: z18.enum(["must", "should", "nice-to-have"]),
+  statement: z18.string().min(1),
+  rationale: z18.string().optional(),
+  acceptance: z18.array(z18.string()).optional()
 });
-var BoundarySchema = z17.object({
-  excluded: z17.string().min(1),
-  reason: z17.string().min(1)
+var BoundarySchema = z18.object({
+  excluded: z18.string().min(1),
+  reason: z18.string().min(1)
 });
-var AssumptionSchema = z17.object({
-  statement: z17.string().min(1),
-  confidence: z17.enum(["verified", "speculation", "high-risk-unknown"]),
-  needs_validation_by: z17.enum(["plan", "coder", "runtime"]).optional()
+var AssumptionSchema = z18.object({
+  statement: z18.string().min(1),
+  confidence: z18.enum(["verified", "speculation", "high-risk-unknown"]),
+  needs_validation_by: z18.enum(["plan", "coder", "runtime"]).optional()
 });
-var OpenIssueSchema = z17.union([
-  z17.string().min(1),
-  z17.object({
-    id: z17.string().optional(),
-    question: z17.string().min(1),
-    blocking: z17.boolean().optional()
+var OpenIssueSchema = z18.union([
+  z18.string().min(1),
+  z18.object({
+    id: z18.string().optional(),
+    question: z18.string().min(1),
+    blocking: z18.boolean().optional()
   })
 ]);
-var RedFlagsSchema = z17.object({
-  raised: z17.boolean(),
-  combos: z17.array(z17.enum(COMBO_VALUES)).default([]),
-  reasons: z17.array(z17.string()).default([]),
-  user_persisted_rounds: z17.number().int().nonnegative().default(0),
-  downstream_advisory: z17.string().nullable().optional()
+var RedFlagsSchema = z18.object({
+  raised: z18.boolean(),
+  combos: z18.array(z18.enum(COMBO_VALUES)).default([]),
+  reasons: z18.array(z18.string()).default([]),
+  user_persisted_rounds: z18.number().int().nonnegative().default(0),
+  downstream_advisory: z18.string().nullable().optional()
 }).superRefine((rf, ctx) => {
   if (rf.raised) {
     if (rf.combos.length === 0) {
       ctx.addIssue({
-        code: z17.ZodIssueCode.custom,
+        code: z18.ZodIssueCode.custom,
         message: "red_flags.raised=true 时 combos 必须 >=1",
         path: ["combos"]
       });
     }
     if (rf.reasons.length === 0) {
       ctx.addIssue({
-        code: z17.ZodIssueCode.custom,
+        code: z18.ZodIssueCode.custom,
         message: "red_flags.raised=true 时 reasons 必须 >=1",
         path: ["reasons"]
       });
     }
   }
 });
-var ScoresSchema = z17.object(Object.fromEntries(SCORE_DIMENSIONS.map((d) => [d, z17.number().min(0).max(1)])));
-var PreCodingBlockerSchema = z17.object({
-  id: z17.string().regex(/^PRE-\d+$/, "id 必须形如 PRE-1 / PRE-2"),
-  blocker: z17.string().min(1),
-  source: z17.enum(["assumption", "red_flag", "open_issue"]),
-  must_resolve_by: z17.enum(["user", "codeforge"])
+var ScoresSchema = z18.object(Object.fromEntries(SCORE_DIMENSIONS.map((d) => [d, z18.number().min(0).max(1)])));
+var PreCodingBlockerSchema = z18.object({
+  id: z18.string().regex(/^PRE-\d+$/, "id 必须形如 PRE-1 / PRE-2"),
+  blocker: z18.string().min(1),
+  source: z18.enum(["assumption", "red_flag", "open_issue"]),
+  must_resolve_by: z18.enum(["user", "codeforge"])
 });
-var KhRefSchema = z17.object({
-  kh_id: z17.string(),
-  title: z17.string(),
-  relevance: z17.enum(["positive", "negative", "neutral"]).optional()
+var KhRefSchema = z18.object({
+  kh_id: z18.string(),
+  title: z18.string(),
+  relevance: z18.enum(["positive", "negative", "neutral"]).optional()
 });
-var HandoffSchema = z17.object({
-  schema_version: z17.string().regex(/^\d+\.\d+\.\d+$/, "schema_version 必须形如 1.1.0 / 1.2.0"),
-  slug: z17.string().regex(SLUG_REGEX, "slug 仅允许 [a-z0-9-]，长度 1-50，首字符为字母数字"),
-  title: z17.string().min(1).max(200),
-  created_at: z17.string().optional(),
-  discover_session_id: z17.string().optional(),
-  weighted_score: z17.number().min(0).max(1),
+var HandoffSchema = z18.object({
+  schema_version: z18.string().regex(/^\d+\.\d+\.\d+$/, "schema_version 必须形如 1.1.0 / 1.2.0"),
+  slug: z18.string().regex(SLUG_REGEX, "slug 仅允许 [a-z0-9-]，长度 1-50，首字符为字母数字"),
+  title: z18.string().min(1).max(200),
+  created_at: z18.string().optional(),
+  discover_session_id: z18.string().optional(),
+  weighted_score: z18.number().min(0).max(1),
   scores: ScoresSchema,
-  needs: z17.array(NeedSchema).min(1, "needs 必须 >=1"),
-  boundaries: z17.array(BoundarySchema).min(1, "boundaries 必须 >=1"),
-  assumptions: z17.array(AssumptionSchema),
-  open_issues: z17.array(OpenIssueSchema).default([]),
-  rejected_alternatives: z17.array(z17.object({ option: z17.string(), reason: z17.string() })).default([]),
-  acceptance_criteria: z17.array(z17.object({
-    id: z17.string().regex(/^AC-/, "AC id 必须以 AC- 开头"),
-    description: z17.string().min(1),
-    measurable: z17.boolean().optional(),
-    metric: z17.string().optional()
+  needs: z18.array(NeedSchema).min(1, "needs 必须 >=1"),
+  boundaries: z18.array(BoundarySchema).min(1, "boundaries 必须 >=1"),
+  assumptions: z18.array(AssumptionSchema),
+  open_issues: z18.array(OpenIssueSchema).default([]),
+  rejected_alternatives: z18.array(z18.object({ option: z18.string(), reason: z18.string() })).default([]),
+  acceptance_criteria: z18.array(z18.object({
+    id: z18.string().regex(/^AC-/, "AC id 必须以 AC- 开头"),
+    description: z18.string().min(1),
+    measurable: z18.boolean().optional(),
+    metric: z18.string().optional()
   })).default([]),
   red_flags: RedFlagsSchema,
-  pre_coding_blockers: z17.array(PreCodingBlockerSchema).default([]),
-  kh_references: z17.array(KhRefSchema).default([]),
-  adr_refs: z17.array(z17.string()).default([]),
-  related_artifacts: z17.object({
-    prd: z17.string().optional(),
-    transcript: z17.string().optional()
+  pre_coding_blockers: z18.array(PreCodingBlockerSchema).default([]),
+  kh_references: z18.array(KhRefSchema).default([]),
+  adr_refs: z18.array(z18.string()).default([]),
+  related_artifacts: z18.object({
+    prd: z18.string().optional(),
+    transcript: z18.string().optional()
   }).optional()
 });
 function validateHandoff(rawYaml, fileSize) {
@@ -15260,9 +15542,9 @@ function validateHandoff(rawYaml, fileSize) {
   const result = HandoffSchema.safeParse(parsed);
   if (!result.success) {
     const first = result.error.issues[0];
-    const path20 = first?.path?.join(".") ?? "(root)";
+    const path21 = first?.path?.join(".") ?? "(root)";
     const msg = first?.message ?? "unknown";
-    return { ok: false, reason: `schema 校验失败：${path20}: ${msg}` };
+    return { ok: false, reason: `schema 校验失败：${path21}: ${msg}` };
   }
   return { ok: true, data: result.data, schemaVersion: result.data.schema_version };
 }
@@ -15279,7 +15561,7 @@ var SESSION_TTL_MS2 = 24 * 60 * 60 * 1000;
 var MATCH_THRESHOLD = 0.15;
 var MAX_CANDIDATES = 3;
 var NUDGE_MAX_LEN = 1500;
-var SPECS_REL_DIR = join16("docs", "specs");
+var SPECS_REL_DIR = join17("docs", "specs");
 var sessionMap = new Map;
 function pruneIfOversize2() {
   while (sessionMap.size > SESSION_CAP2) {
@@ -15386,7 +15668,7 @@ function loadSpecs(rootDir, opts = {}) {
   const dirExists = opts.dirExists ?? defaultDirExists;
   const statReader = opts.statReader ?? defaultStatReader;
   const log6 = makePluginLogger(PLUGIN_NAME8);
-  const specsRoot = join16(rootDir, SPECS_REL_DIR);
+  const specsRoot = join17(rootDir, SPECS_REL_DIR);
   const records = [];
   if (!dirExists(specsRoot)) {
     log6.info(`specs 目录不存在，plugin 将 no-op`, { specsRoot });
@@ -15407,7 +15689,7 @@ function loadSpecs(rootDir, opts = {}) {
       log6.info(`跳过非合法 slug 命名的条目`, { entry });
       continue;
     }
-    const specDir = join16(specsRoot, entry);
+    const specDir = join17(specsRoot, entry);
     let dirStat;
     try {
       dirStat = statReader(specDir);
@@ -15420,7 +15702,7 @@ function loadSpecs(rootDir, opts = {}) {
     }
     if (!dirStat.isDirectory)
       continue;
-    const handoffPath = join16(specDir, "handoff.yaml");
+    const handoffPath = join17(specDir, "handoff.yaml");
     let fileStat;
     try {
       fileStat = statReader(handoffPath);
@@ -15593,13 +15875,13 @@ var handler8 = discoverSpecSuggestServer;
 
 // lib/memories.ts
 import { promises as fs16 } from "node:fs";
-import * as path20 from "node:path";
-import * as os5 from "node:os";
+import * as path21 from "node:path";
+import * as os6 from "node:os";
 function resolveConfig(c) {
   return {
     projectRoot: c.projectRoot,
-    homeDir: c.homeDir ?? os5.homedir(),
-    projectName: c.projectName ?? path20.basename(c.projectRoot),
+    homeDir: c.homeDir ?? os6.homedir(),
+    projectName: c.projectName ?? path21.basename(c.projectRoot),
     now: c.now ?? Date.now,
     log: c.log ?? (() => {}),
     maxPerScope: c.maxPerScope ?? 1000
@@ -15607,9 +15889,9 @@ function resolveConfig(c) {
 }
 function fileFor(scope, cfg) {
   if (scope === "project") {
-    return path20.join(cfg.projectRoot, ".codeforge", "memories.json");
+    return path21.join(cfg.projectRoot, ".codeforge", "memories.json");
   }
-  return path20.join(cfg.homeDir, ".codeforge", "memories.json");
+  return path21.join(cfg.homeDir, ".codeforge", "memories.json");
 }
 async function readBank(p) {
   try {
@@ -15623,7 +15905,7 @@ async function readBank(p) {
   }
 }
 async function writeBank(p, items) {
-  await fs16.mkdir(path20.dirname(p), { recursive: true });
+  await fs16.mkdir(path21.dirname(p), { recursive: true });
   const tmp = `${p}.tmp`;
   await fs16.writeFile(tmp, JSON.stringify(items, null, 2), "utf8");
   await fs16.rename(tmp, p);
@@ -16144,7 +16426,7 @@ var handler10 = modelFallbackServer;
 
 // plugins/subtask-heartbeat.ts
 import { promises as fsPromises } from "node:fs";
-import * as path21 from "node:path";
+import * as path22 from "node:path";
 var recordSessionParent2 = recordSessionParent;
 var lookupParentSessionId2 = lookupParentSessionId;
 var deleteSessionParent2 = deleteSessionParent;
@@ -16268,11 +16550,11 @@ function extractTaskArgs(args) {
   const a = args;
   const rawDesc = typeof a["description"] === "string" ? a["description"] : null;
   const rawPrompt = typeof a["prompt"] === "string" ? a["prompt"] : null;
-  const description16 = rawDesc ?? (rawPrompt ? rawPrompt.slice(0, 60) : null);
+  const description17 = rawDesc ?? (rawPrompt ? rawPrompt.slice(0, 60) : null);
   const subagentType = typeof a["subagent_type"] === "string" && a["subagent_type"] || typeof a["agent"] === "string" && a["agent"] || typeof a["agentType"] === "string" && a["agentType"] || typeof a["agent_type"] === "string" && a["agent_type"] || null;
-  if (!description16 && !subagentType)
+  if (!description17 && !subagentType)
     return null;
-  return { description: description16, subagentType };
+  return { description: description17, subagentType };
 }
 function enqueuePendingTask(parentID, entry, now = Date.now()) {
   const ts = entry.ts ?? now;
@@ -16491,7 +16773,7 @@ function buildErrorLogLine(errorReason, elapsedMs, now = Date.now()) {
 }
 async function appendSubagentLog(filePath, line, log7) {
   try {
-    await fsPromises.mkdir(path21.dirname(filePath), { recursive: true });
+    await fsPromises.mkdir(path22.dirname(filePath), { recursive: true });
     await fsPromises.appendFile(filePath, line + `
 `, "utf8");
   } catch (err) {
@@ -16859,8 +17141,8 @@ var handler12 = parallelStatusServer;
 
 // plugins/parallel-tool-nudge.ts
 import { readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync3 } from "node:fs";
-import { join as join18 } from "node:path";
-import { homedir as homedir6 } from "node:os";
+import { join as join19 } from "node:path";
+import { homedir as homedir7 } from "node:os";
 var PLUGIN_NAME13 = "parallel-tool-nudge";
 logLifecycle(PLUGIN_NAME13, "import", {});
 var PARALLEL_SAFE_TOOLS = [
@@ -16912,10 +17194,10 @@ function loadAgentToolsMap(rootDir, opts = {}) {
   const reader = opts.reader ?? defaultReader2;
   const dirReader = opts.dirReader ?? defaultDirReader2;
   const dirExists = opts.dirExists ?? defaultDirExists2;
-  const homeAgentsDir = opts.homeAgentsDir ?? join18(homedir6(), ".config", "opencode", "agents");
+  const homeAgentsDir = opts.homeAgentsDir ?? join19(homedir7(), ".config", "opencode", "agents");
   const candidateDirs = [
-    join18(rootDir, ".codeforge", "agents"),
-    join18(rootDir, "agents"),
+    join19(rootDir, ".codeforge", "agents"),
+    join19(rootDir, "agents"),
     homeAgentsDir
   ];
   const result = new Map;
@@ -16938,20 +17220,20 @@ function loadAgentToolsMap(rootDir, opts = {}) {
     for (const entry of entries) {
       if (!entry.endsWith(".md"))
         continue;
-      const path22 = join18(dir, entry);
+      const path23 = join19(dir, entry);
       let content;
       try {
-        content = reader(path22);
+        content = reader(path23);
       } catch (err) {
         log8.warn(`agent.md 读取失败（已跳过）`, {
-          path: path22,
+          path: path23,
           error: err instanceof Error ? err.message : String(err)
         });
         continue;
       }
       const parsed = parseAgentFrontmatter(content);
       if (!parsed) {
-        log8.warn(`agent frontmatter 解析失败（已跳过）`, { path: path22 });
+        log8.warn(`agent frontmatter 解析失败（已跳过）`, { path: path23 });
         continue;
       }
       if (result.has(parsed.name))
@@ -17111,7 +17393,7 @@ function prependUtf8Prelude(command) {
     return command;
   return PRELUDE + command;
 }
-var handler14 = async (_ctx3) => {
+var handler14 = async (_ctx4) => {
   const enabled = process.platform === "win32" && process.env.CODEFORGE_DISABLE_PWSH_UTF8 !== "1";
   const reason = enabled ? "win32" : process.platform !== "win32" ? "non-win32" : "disabled-by-env";
   logLifecycle(PLUGIN_NAME14, "activate", { enabled, platform: process.platform, reason });
@@ -17143,7 +17425,7 @@ var handler14 = async (_ctx3) => {
 
 // lib/event-stream.ts
 import { promises as fs17 } from "node:fs";
-import * as path22 from "node:path";
+import * as path23 from "node:path";
 async function loadSession(id, opts = {}) {
   const file = resolveSessionFile(id, opts);
   const raw = await fs17.readFile(file, "utf8");
@@ -17163,7 +17445,7 @@ async function listSessions(opts = {}) {
   for (const e of entries) {
     if (!e.isFile() || !e.name.endsWith(".jsonl"))
       continue;
-    const file = path22.join(dir, e.name);
+    const file = path23.join(dir, e.name);
     const id = e.name.replace(/\.jsonl$/, "");
     try {
       const stat = await fs17.stat(file);
@@ -17190,11 +17472,11 @@ async function listSessions(opts = {}) {
   return out;
 }
 function resolveDir(opts = {}) {
-  const root = path22.resolve(opts.root ?? process.cwd());
-  return opts.sessions_dir ? path22.resolve(root, opts.sessions_dir) : path22.join(runtimeDir(root), "sessions");
+  const root = path23.resolve(opts.root ?? process.cwd());
+  return opts.sessions_dir ? path23.resolve(root, opts.sessions_dir) : path23.join(runtimeDir(root), "sessions");
 }
 function resolveSessionFile(id, opts = {}) {
-  return path22.join(resolveDir(opts), `${id}.jsonl`);
+  return path23.join(resolveDir(opts), `${id}.jsonl`);
 }
 function parseJsonl(id, raw) {
   const events = [];
@@ -17458,10 +17740,10 @@ function isRecoveryWorthShowing(plan) {
 
 // lib/block-pending.ts
 import { promises as fs18 } from "node:fs";
-import * as path23 from "node:path";
+import * as path24 from "node:path";
 function blockPendingFilePath(absRoot) {
   const rd = runtimeDir(absRoot, { ensure: false });
-  return path23.join(rd, "sessions", "autonomous-blocks.ndjson");
+  return path24.join(rd, "sessions", "autonomous-blocks.ndjson");
 }
 function consumeLockPath(absRoot) {
   return blockPendingFilePath(absRoot) + ".consume.lock";
@@ -17526,7 +17808,7 @@ async function markBlocksConsumed(absRoot, entries) {
   if (entries.length === 0)
     return;
   const file = blockPendingFilePath(absRoot);
-  await fs18.mkdir(path23.dirname(file), { recursive: true });
+  await fs18.mkdir(path24.dirname(file), { recursive: true });
   const now = new Date().toISOString();
   const lines = entries.map((e) => ({
     type: "consume",
@@ -17676,7 +17958,7 @@ var handler15 = sessionRecoveryServer;
 
 // plugins/subtasks.ts
 import { promises as fs19 } from "node:fs";
-import * as path24 from "node:path";
+import * as path25 from "node:path";
 
 // lib/parallel-merge.ts
 init_worktree_ops();
@@ -18291,7 +18573,7 @@ function buildSystemPrompt(maxSubtasks) {
   ].join(`
 `);
 }
-async function decomposeTask(description16, opts) {
+async function decomposeTask(description17, opts) {
   const log10 = opts.log ?? (() => {});
   if (opts.mockResponse) {
     return validateAndFinalize(opts.mockResponse, undefined, log10, opts.maxSubtasks ?? DEFAULT_MAX_SUBTASKS);
@@ -18301,7 +18583,7 @@ async function decomposeTask(description16, opts) {
   let childSessionId;
   try {
     const created = await opts.client.session.create({
-      body: { title: `decompose:${clip5(description16, 60)}` },
+      body: { title: `decompose:${clip5(description17, 60)}` },
       query: opts.directory ? { directory: opts.directory } : undefined
     });
     if (created.error || !created.data?.id) {
@@ -18318,7 +18600,7 @@ async function decomposeTask(description16, opts) {
       path: { id: childSessionId },
       body: {
         system: systemText,
-        parts: [{ type: "text", text: description16 }]
+        parts: [{ type: "text", text: description17 }]
       },
       query: opts.directory ? { directory: opts.directory } : undefined
     }));
@@ -18500,7 +18782,7 @@ function sleep2(ms) {
 // plugins/subtasks.ts
 var PLUGIN_NAME16 = "subtasks";
 function getLogFile(root = process.cwd()) {
-  return path24.join(runtimeDir(root), "logs", "subtasks.log");
+  return path25.join(runtimeDir(root), "logs", "subtasks.log");
 }
 var VERB_RE = /^([a-zA-Z]{3,12})/;
 var CN_VERBS = [
@@ -18805,7 +19087,7 @@ async function writeLog(level, msg, data) {
 `;
   try {
     const logFile = getLogFile();
-    await fs19.mkdir(path24.dirname(logFile), { recursive: true });
+    await fs19.mkdir(path25.dirname(logFile), { recursive: true });
     await fs19.appendFile(logFile, line, "utf8");
   } catch {}
 }
@@ -18822,8 +19104,8 @@ var subtasksServer = async (ctx) => {
       try {
         if (input?.command !== "parallel")
           return;
-        const description16 = (input.arguments ?? "").trim();
-        if (!description16) {
+        const description17 = (input.arguments ?? "").trim();
+        if (!description17) {
           return;
         }
         let autoMerge = false;
@@ -18862,7 +19144,7 @@ var subtasksServer = async (ctx) => {
         } : undefined;
         const replyLines = [];
         const messageCtx = {
-          content: `/parallel ${description16}`,
+          content: `/parallel ${description17}`,
           reply: (s) => {
             replyLines.push(s);
             return Promise.resolve();
@@ -19438,7 +19720,7 @@ var handler18 = tokenManagerServer;
 
 // plugins/tool-policy.ts
 import { promises as fs20 } from "node:fs";
-import * as path26 from "node:path";
+import * as path27 from "node:path";
 
 // lib/tool-risk.ts
 var RISK_PATTERNS = [
@@ -19592,7 +19874,7 @@ function buildHaystackFor(args, matchOn) {
 }
 
 // lib/file-regex-acl.ts
-import * as path25 from "node:path";
+import * as path26 from "node:path";
 function compileRule(r) {
   if (r instanceof RegExp)
     return r;
@@ -19658,7 +19940,7 @@ function normalizePath2(p) {
   let s = p.replace(/\\/g, "/");
   if (s.startsWith("./"))
     s = s.slice(2);
-  s = path25.posix.normalize(s);
+  s = path26.posix.normalize(s);
   return s;
 }
 function checkFileAccess(acl, file, op) {
@@ -19761,9 +20043,9 @@ function decideToolCall(ctx, cfg = {}, currentAgent) {
   const action = risks.length > 0 || worstAcl === "deny" ? "deny" : "allow";
   return { action, reasons, risks, acl: aclResults };
 }
-var POLICY_PATH = path26.join(".codeforge", "policy.json");
+var POLICY_PATH = path27.join(".codeforge", "policy.json");
 async function loadPolicy(root = process.cwd()) {
-  const file = path26.join(root, POLICY_PATH);
+  const file = path27.join(root, POLICY_PATH);
   try {
     const raw = await fs20.readFile(file, "utf8");
     const data = JSON.parse(raw);
@@ -19862,8 +20144,8 @@ var handler19 = toolPolicyServer;
 
 // plugins/update-checker.ts
 import { existsSync as existsSync6, rmSync } from "node:fs";
-import { homedir as homedir8 } from "node:os";
-import { join as join24 } from "node:path";
+import { homedir as homedir9 } from "node:os";
+import { join as join25 } from "node:path";
 import { spawnSync as spawnSync2 } from "node:child_process";
 
 // lib/update-checker-impl.ts
@@ -19880,8 +20162,8 @@ import {
   unlinkSync,
   writeFileSync as writeFileSync2
 } from "node:fs";
-import { homedir as homedir7, tmpdir } from "node:os";
-import { dirname as dirname14, join as join23 } from "node:path";
+import { homedir as homedir8, tmpdir } from "node:os";
+import { dirname as dirname14, join as join24 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import * as https from "node:https";
 import * as zlib from "node:zlib";
@@ -19889,7 +20171,7 @@ import * as zlib from "node:zlib";
 // lib/version-injected.ts
 function getInjectedVersion() {
   try {
-    const v = "0.6.7";
+    const v = "0.6.12";
     if (typeof v === "string" && /^\d+\.\d+\.\d+/.test(v)) {
       return v;
     }
@@ -19979,17 +20261,17 @@ function readLocalVersion() {
   try {
     const here = fileURLToPath2(import.meta.url);
     const root = dirname14(dirname14(here));
-    const pkg = JSON.parse(readFileSync5(join23(root, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync5(join24(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"] ?? join23(homedir7(), ".cache", "codeforge");
+  return process.env["CODEFORGE_CACHE_DIR"] ?? join24(homedir8(), ".cache", "codeforge");
 }
 function defaultCacheFile() {
-  return join23(defaultCacheDir(), "update-check.json");
+  return join24(defaultCacheDir(), "update-check.json");
 }
 function readCache(file) {
   try {
@@ -20145,14 +20427,14 @@ function defaultHttpFetcher(url2, timeoutMs) {
   });
 }
 async function downloadAndExtractBundle(opts) {
-  const tmpRoot = opts.tmpDir ?? mkdtempSync(join23(tmpdir(), "codeforge-update-"));
+  const tmpRoot = opts.tmpDir ?? mkdtempSync(join24(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 = join23(tmpRoot, "package", "dist", "index.js");
+  const bundlePath = join24(tmpRoot, "package", "dist", "index.js");
   if (!existsSync5(bundlePath)) {
     throw new Error(`bundle_not_found: ${bundlePath}`);
   }
@@ -20192,11 +20474,11 @@ function extractTarToDir(tarBuf, destRoot) {
     offset += 512;
     if (typeFlag === "0" || typeFlag === "" || typeFlag === "\x00") {
       const fileBuf = tarBuf.subarray(offset, offset + size);
-      const dest = join23(destRoot, fullName);
+      const dest = join24(destRoot, fullName);
       mkdirSync3(dirname14(dest), { recursive: true });
       writeFileSync2(dest, fileBuf);
     } else if (typeFlag === "5") {
-      mkdirSync3(join23(destRoot, fullName), { recursive: true });
+      mkdirSync3(join24(destRoot, fullName), { recursive: true });
     }
     offset += Math.ceil(size / 512) * 512;
   }
@@ -20305,7 +20587,7 @@ function cleanupOldBackups(target, keep) {
     const base = target.substring(dir.length + 1);
     const prefix = `${base}.bak.`;
     const all = readdirSync3(dir).filter((f) => f.startsWith(prefix)).map((f) => {
-      const full = join23(dir, f);
+      const full = join24(dir, f);
       let mtimeMs = 0;
       try {
         mtimeMs = statSync4(full).mtimeMs;
@@ -20327,7 +20609,7 @@ function loadCompatibility(opts) {
       const root = opts?.cwd ?? inferPluginRoot();
       if (!root)
         return null;
-      file = join23(root, "compatibility.json");
+      file = join24(root, "compatibility.json");
     }
     if (!existsSync5(file))
       return null;
@@ -20518,11 +20800,11 @@ var updateCheckerServer = async (ctx) => {
           expectedIntegrity: npmResult.integrity
         });
         try {
-          const installMjs = join24(extractDir, "package", "install.mjs");
+          const installMjs = join25(extractDir, "package", "install.mjs");
           if (existsSync6(installMjs)) {
             const nodeBin = resolveNodeBin();
             const r = spawnSync2(nodeBin, [installMjs, "--global", "--skip-build"], {
-              cwd: join24(extractDir, "package"),
+              cwd: join25(extractDir, "package"),
               stdio: "pipe",
               encoding: "utf8"
             });
@@ -20623,14 +20905,14 @@ function detectOpencodeVersion() {
 }
 function getOpencodeBundlePath() {
   const candidates = [];
-  candidates.push(join24(homedir8(), ".config", "opencode", "codeforge", "index.js"));
+  candidates.push(join25(homedir9(), ".config", "opencode", "codeforge", "index.js"));
   if (process.platform === "win32") {
     const appData = process.env["APPDATA"];
     if (appData)
-      candidates.push(join24(appData, "opencode", "codeforge", "index.js"));
+      candidates.push(join25(appData, "opencode", "codeforge", "index.js"));
     const localAppData = process.env["LOCALAPPDATA"];
     if (localAppData)
-      candidates.push(join24(localAppData, "opencode", "codeforge", "index.js"));
+      candidates.push(join25(localAppData, "opencode", "codeforge", "index.js"));
   }
   for (const c of candidates) {
     if (existsSync6(c))
@@ -20691,60 +20973,60 @@ async function postToast(ctx, message) {
 var handler20 = updateCheckerServer;
 
 // plugins/workflow-engine.ts
-import * as path28 from "node:path";
+import * as path29 from "node:path";
 
 // lib/workflow-loader.ts
 import { promises as fs21 } from "node:fs";
-import * as path27 from "node:path";
-import { z as z18 } from "zod";
-var ActionSchema = z18.object({
-  tool: z18.string().min(1, "action.tool 不能为空"),
-  args: z18.record(z18.string(), z18.unknown()).optional().default({}),
-  on_error: z18.enum(["retry", "skip", "abort"]).optional()
+import * as path28 from "node:path";
+import { z as z19 } from "zod";
+var ActionSchema = z19.object({
+  tool: z19.string().min(1, "action.tool 不能为空"),
+  args: z19.record(z19.string(), z19.unknown()).optional().default({}),
+  on_error: z19.enum(["retry", "skip", "abort"]).optional()
 });
-var StepSchema = z18.object({
-  name: z18.string().min(1, "step.name 不能为空"),
-  agent: z18.string().min(1, "step.agent 不能为空").describe("agent 名（与 agents/<name>.md 对应）"),
-  description: z18.string().optional(),
-  inject_context: z18.record(z18.string(), z18.unknown()).optional(),
-  requires_human_approval: z18.boolean().optional().default(false),
-  actions: z18.array(ActionSchema).optional().default([]),
-  on_error: z18.enum(["retry", "skip", "abort"]).optional().default("abort"),
-  max_retries: z18.number().int().min(0).max(10).optional().default(2),
-  timeout: z18.string().regex(/^\d+(?:ms|s|m|h)$/, "timeout 必须是 数字+单位（ms/s/m/h），如 5m").optional(),
-  auto_feedback: z18.object({
-    test_cmd: z18.string().optional().describe("测试命令，如 npm test"),
-    lint_cmd: z18.string().optional().describe("lint 命令，如 npm run lint"),
-    max_retries: z18.number().int().min(1).max(10).optional().default(3),
-    error_excerpt_lines: z18.number().int().min(1).max(50).optional().default(5),
-    escalate_to: z18.string().optional().default("reviewer").describe("超上限后兜底 agent，默认 reviewer")
+var StepSchema = z19.object({
+  name: z19.string().min(1, "step.name 不能为空"),
+  agent: z19.string().min(1, "step.agent 不能为空").describe("agent 名（与 agents/<name>.md 对应）"),
+  description: z19.string().optional(),
+  inject_context: z19.record(z19.string(), z19.unknown()).optional(),
+  requires_human_approval: z19.boolean().optional().default(false),
+  actions: z19.array(ActionSchema).optional().default([]),
+  on_error: z19.enum(["retry", "skip", "abort"]).optional().default("abort"),
+  max_retries: z19.number().int().min(0).max(10).optional().default(2),
+  timeout: z19.string().regex(/^\d+(?:ms|s|m|h)$/, "timeout 必须是 数字+单位（ms/s/m/h），如 5m").optional(),
+  auto_feedback: z19.object({
+    test_cmd: z19.string().optional().describe("测试命令，如 npm test"),
+    lint_cmd: z19.string().optional().describe("lint 命令，如 npm run lint"),
+    max_retries: z19.number().int().min(1).max(10).optional().default(3),
+    error_excerpt_lines: z19.number().int().min(1).max(50).optional().default(5),
+    escalate_to: z19.string().optional().default("reviewer").describe("超上限后兜底 agent，默认 reviewer")
   }).refine((d) => Boolean(d.test_cmd || d.lint_cmd), { message: "auto_feedback 必须至少配置 test_cmd 或 lint_cmd 之一" }).optional(),
-  on_decision: z18.object({
-    APPROVE: z18.union([
-      z18.literal("continue"),
-      z18.literal("abort"),
-      z18.object({ action: z18.literal("goto"), target: z18.string().min(1) })
+  on_decision: z19.object({
+    APPROVE: z19.union([
+      z19.literal("continue"),
+      z19.literal("abort"),
+      z19.object({ action: z19.literal("goto"), target: z19.string().min(1) })
     ]).optional(),
-    REQUEST_CHANGES: z18.union([
-      z18.literal("continue"),
-      z18.literal("abort"),
-      z18.object({ action: z18.literal("goto"), target: z18.string().min(1) })
+    REQUEST_CHANGES: z19.union([
+      z19.literal("continue"),
+      z19.literal("abort"),
+      z19.object({ action: z19.literal("goto"), target: z19.string().min(1) })
     ]).optional(),
-    BLOCK: z18.union([
-      z18.literal("continue"),
-      z18.literal("abort"),
-      z18.object({ action: z18.literal("goto"), target: z18.string().min(1) })
+    BLOCK: z19.union([
+      z19.literal("continue"),
+      z19.literal("abort"),
+      z19.object({ action: z19.literal("goto"), target: z19.string().min(1) })
     ]).optional()
   }).refine((d) => Boolean(d.APPROVE || d.REQUEST_CHANGES || d.BLOCK), { message: "on_decision 必须至少配置 APPROVE / REQUEST_CHANGES / BLOCK 之一" }).optional()
 }).strict();
-var WorkflowSchema = z18.object({
-  name: z18.string().min(1, "workflow.name 不能为空"),
-  description: z18.string().optional().default(""),
-  version: z18.string().optional().default("1.0.0"),
-  trigger: z18.string().min(1).refine((v) => /^\/[a-z][\w-]*$/.test(v) || /^event:[a-z][\w.-]+$/.test(v), "trigger 必须是 /command-name 或 event:xxx 形式"),
-  context_template: z18.string().optional(),
-  max_loops: z18.number().int().min(1).max(10).optional().default(3),
-  steps: z18.array(StepSchema).min(1, "workflow.steps 不能为空")
+var WorkflowSchema = z19.object({
+  name: z19.string().min(1, "workflow.name 不能为空"),
+  description: z19.string().optional().default(""),
+  version: z19.string().optional().default("1.0.0"),
+  trigger: z19.string().min(1).refine((v) => /^\/[a-z][\w-]*$/.test(v) || /^event:[a-z][\w.-]+$/.test(v), "trigger 必须是 /command-name 或 event:xxx 形式"),
+  context_template: z19.string().optional(),
+  max_loops: z19.number().int().min(1).max(10).optional().default(3),
+  steps: z19.array(StepSchema).min(1, "workflow.steps 不能为空")
 }).strict();
 function parseWorkflowYaml(yaml, sourcePath = "<inline>") {
   let raw;
@@ -20808,7 +21090,7 @@ async function loadWorkflowsFromDir(dir) {
       continue;
     if (!/\.ya?ml$/i.test(name))
       continue;
-    const full = path27.join(dir, name);
+    const full = path28.join(dir, name);
     const r = await loadWorkflowFromFile(full);
     if (r.ok)
       loaded.push(r);
@@ -21198,7 +21480,7 @@ async function handleCommandInvoked(raw, workflowsDir = "workflows") {
 }
 var workflowEngineServer = async (ctx) => {
   const directory = ctx.directory ?? process.cwd();
-  const workflowsDir = path28.join(directory, "workflows");
+  const workflowsDir = path29.join(directory, "workflows");
   ensureRegistry(workflowsDir).catch((err) => fallbackLog2.warn(`[${PLUGIN_NAME21}] preload workflows failed`, {
     error: err instanceof Error ? err.message : String(err)
   }));
@@ -21242,7 +21524,7 @@ var workflowEngineServer = async (ctx) => {
 var handler21 = workflowEngineServer;
 
 // plugins/session-worktree-guard.ts
-import path29 from "node:path";
+import path30 from "node:path";
 import { stat } from "node:fs/promises";
 var PLUGIN_NAME22 = "session-worktree-guard";
 logLifecycle(PLUGIN_NAME22, "import", {});
@@ -21278,6 +21560,31 @@ function buildGitVcsWriteRegex(mainRoot) {
 var WRITE_TOOLS = new Set(["write", "edit", "ast_edit"]);
 var TOUCH_THROTTLE_MS = 5 * 60000;
 var _touchCache = new Map;
+var REWRITE_NOTICE_CAP = 200;
+var _rewriteNotices = new Map;
+function recordRewriteNotice(callID, notice) {
+  if (!_rewriteNotices.has(callID) && _rewriteNotices.size >= REWRITE_NOTICE_CAP) {
+    const oldest = _rewriteNotices.keys().next().value;
+    if (oldest !== undefined)
+      _rewriteNotices.delete(oldest);
+  }
+  _rewriteNotices.set(callID, notice);
+}
+function consumeRewriteNotice(callID) {
+  const notice = _rewriteNotices.get(callID);
+  if (!notice)
+    return;
+  _rewriteNotices.delete(callID);
+  return notice;
+}
+function formatRewriteWarning(notice) {
+  const lines = notice.rewrites.map((r) => `  - ${r.field}: ${r.before} → ${r.after}`).join(`
+`);
+  return `⚠️ [codeforge worktree 隔离] 本次 ${notice.tool} 的写入路径已被自动重定向到 session worktree，文件**不在主仓**：
+` + `${lines}
+` + `worktree=${notice.worktreePath}
+` + `如需进主仓，请走 /merge（review-fix-review 闭环）。直接读主仓路径看不到本次改动。`;
+}
 var _sessionIdMissingWarned = false;
 var _bindFailNotified = new Set;
 function formatLazyBindDenyReason(input) {
@@ -21354,23 +21661,23 @@ var MERGE_CALLER_WHITELIST = new Set([
 var FORCE_MERGE_CALLER_WHITELIST = new Set([
   "codeforge"
 ]);
-var CODEFORGE_WORKTREE_DIR_NAME = path29.join(".git", "codeforge-worktrees");
+var CODEFORGE_WORKTREE_DIR_NAME = path30.join(".git", "codeforge-worktrees");
 function worktreesRoot(mainRoot) {
-  return path29.join(mainRoot, CODEFORGE_WORKTREE_DIR_NAME);
+  return path30.join(mainRoot, CODEFORGE_WORKTREE_DIR_NAME);
 }
 function isInsideAnyWorktreeDir(absPath, mainRoot) {
-  if (!path29.isAbsolute(absPath))
+  if (!path30.isAbsolute(absPath))
     return false;
   const root = worktreesRoot(mainRoot);
   if (absPath === root)
     return false;
-  const prefix = root.endsWith(path29.sep) ? root : root + path29.sep;
+  const prefix = root.endsWith(path30.sep) ? root : root + path30.sep;
   return absPath.startsWith(prefix);
 }
 function rewritePath(value, mainRoot, worktreeRoot) {
   if (!value)
     return null;
-  const resolved = path29.isAbsolute(value) ? value : path29.resolve(mainRoot, value);
+  const resolved = path30.isAbsolute(value) ? value : path30.resolve(mainRoot, value);
   const wtPrefix2 = worktreeRoot.endsWith("/") ? worktreeRoot : worktreeRoot + "/";
   if (resolved === worktreeRoot || resolved.startsWith(wtPrefix2)) {
     return null;
@@ -21408,7 +21715,7 @@ function commandContainsMainRootExcludingWorktree(command, mainRoot, worktreePat
     }
   }
   const wtRoot = worktreesRoot(mainRoot);
-  const wtRootPrefix = wtRoot + path29.sep;
+  const wtRootPrefix = wtRoot + path30.sep;
   const escapedWtRootPrefix = escapeRegex(wtRootPrefix);
   const wtPathPattern = escapedWtRootPrefix + `[^\\s'"\\x60)]*`;
   const allWorktreePathsReForEscape = new RegExp(wtPathPattern, "g");
@@ -21463,8 +21770,8 @@ function collectWritePaths(toolName, argsObj, worktreeRoot) {
   const candidate = toolName === "write" || toolName === "edit" ? argsObj["filePath"] : toolName === "ast_edit" ? argsObj["target"] : undefined;
   if (typeof candidate !== "string" || candidate.length === 0)
     return out;
-  const abs = path29.isAbsolute(candidate) ? candidate : path29.resolve(worktreeRoot, candidate);
-  const rel = path29.relative(worktreeRoot, abs).split(path29.sep).join("/");
+  const abs = path30.isAbsolute(candidate) ? candidate : path30.resolve(worktreeRoot, candidate);
+  const rel = path30.relative(worktreeRoot, abs).split(path30.sep).join("/");
   out.push(rel);
   return out;
 }
@@ -21475,7 +21782,7 @@ async function isCodeforgeManagedProject(mainRoot, opts = {}) {
   if (force === "1" || force === "true" || force === "yes")
     return true;
   try {
-    const st = await stat(path29.join(mainRoot, ".codeforge"));
+    const st = await stat(path30.join(mainRoot, ".codeforge"));
     return st.isDirectory();
   } catch {
     return false;
@@ -21489,6 +21796,37 @@ function resolveMainRoot2(rawDir) {
   }
   return rawDir;
 }
+var STALE_MERGE_HEAD_MS = 24 * 60 * 60000;
+var _staleMergeHeadWarned = false;
+var _mergeBypassToastShown = false;
+async function isMainRepoMidMerge(mainRoot, opts = {}) {
+  const gitDir = path30.join(mainRoot, ".git");
+  const markers = [
+    path30.join(gitDir, "MERGE_HEAD"),
+    path30.join(gitDir, "rebase-merge"),
+    path30.join(gitDir, "CHERRY_PICK_HEAD")
+  ];
+  let freshest = -1;
+  for (const m of markers) {
+    try {
+      const st = await stat(m);
+      if (st.mtimeMs > freshest)
+        freshest = st.mtimeMs;
+    } catch {}
+  }
+  if (freshest < 0)
+    return false;
+  const now = opts.now ?? Date.now();
+  const staleMs = opts.staleMs ?? STALE_MERGE_HEAD_MS;
+  if (now - freshest > staleMs) {
+    if (!_staleMergeHeadWarned) {
+      _staleMergeHeadWarned = true;
+      opts.log?.warn(`[guard] 检测到陈旧 merge marker（mtime 超过 ${staleMs / 3600000}h），` + `不启用 merge 冲突 bypass；若确在解冲突请 git merge --continue/--abort 刷新状态`, { mainRoot, freshestMtimeMs: freshest });
+    }
+    return false;
+  }
+  return true;
+}
 var sessionWorktreeGuardPlugin = async (ctx) => {
   const disableEnv = process.env["CODEFORGE_DISABLE_WORKTREE_GUARD"];
   if (disableEnv === "1" || disableEnv === "true" || disableEnv === "yes") {
@@ -21553,6 +21891,29 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
       await safeAsync(PLUGIN_NAME22, "tool.execute.before", async () => {
         const toolName = input.tool;
         const argsObj = output.args ?? {};
+        const midMerge = isWriteOperation(toolName, argsObj, mainRoot) || toolName === "bash" ? await isMainRepoMidMerge(mainRoot, { log: log13 }) : false;
+        const emitMergeBypassNotice = (subClass, detail) => {
+          safeWriteLog(PLUGIN_NAME22, {
+            hook: "tool.execute.before",
+            tool: toolName,
+            sessionID: input.sessionID,
+            action: `merge-conflict-bypass-${subClass}`,
+            ...detail
+          });
+          log13.warn(`[merge-conflict-bypass] ${subClass} 放行主仓直写`, {
+            tool: toolName,
+            ...detail
+          });
+          if (!_mergeBypassToastShown) {
+            _mergeBypassToastShown = true;
+            showToast2(ctx.client, {
+              message: "⚠️ 主仓处于 merge 冲突态，session-worktree-guard 已临时放行主仓直写（解冲突期）",
+              variant: "warning",
+              duration: 8000,
+              title: "CodeForge"
+            }, log13).catch(() => {});
+          }
+        };
         let entry = null;
         try {
           entry = await getSessionWorktree(sessionId, mainRoot);
@@ -21596,6 +21957,12 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
           if (!isWriteOperation(toolName, argsObj, mainRoot)) {
             return;
           }
+          if (midMerge) {
+            emitMergeBypassNotice("lazy-bind", {
+              reason: "mid-merge: skip lazy-bind, passthrough to main repo"
+            });
+            return;
+          }
           try {
             const parentId = lookupParentSessionId2(sessionId);
             if (parentId) {
@@ -21612,6 +21979,18 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
                   parent_branch: parentEntry.branch,
                   parent_worktree: parentEntry.worktreePath
                 });
+              } else if (!parentEntry) {
+                entry = await bindSessionWorktree({ sessionId: parentId, mainRoot });
+                log13.info(`[child-inherit-bind-root] session ${sessionId} 触发父 ${parentId} 的 worktree lazy-bind`, { parentSessionId: parentId, branch: entry.branch, worktreePath: entry.worktreePath });
+                safeWriteLog(PLUGIN_NAME22, {
+                  hook: "tool.execute.before",
+                  tool: toolName,
+                  sessionID: input.sessionID,
+                  action: "child-inherit-bind-root",
+                  parent_session_id: parentId,
+                  branch: entry.branch,
+                  worktreePath: entry.worktreePath
+                });
               }
             }
           } catch (lookupErr) {
@@ -21841,6 +22220,11 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
         if (toolName === "bash") {
           const command = argsObj["command"];
           if (typeof command === "string" && commandContainsMainRootExcludingWorktree(command, mainRoot, worktreePath) && detectBashWriteIntent(command, mainRoot)) {
+            if (midMerge) {
+              const snippet = command.length > 60 ? command.slice(0, 60) + "…" : command;
+              emitMergeBypassNotice("classB", { command: snippet });
+              return;
+            }
             const caller = await resolveAgentForGuard({ sessionID: input.sessionID, agent: input.agent }, ctx.client, log13);
             if (caller !== null && CLASS_B_CALLER_WHITELIST.has(caller)) {
               log13.debug?.(`[class-b-whitelist] allow caller=${caller}`, { sessionId, tool: toolName, command: command.slice(0, 200) });
@@ -21872,182 +22256,85 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
             }
           }
         }
+        const rewritesThisCall = [];
+        const applyRewrite = (field, value) => {
+          const newPath = rewritePath(value, mainRoot, worktreePath);
+          if (newPath === null)
+            return;
+          if (midMerge) {
+            emitMergeBypassNotice("classA", { field, before: value, after: newPath });
+            return;
+          }
+          log13.info(`rewrote ${toolName}.${field}: ${value} → ${newPath}`);
+          safeWriteLog(PLUGIN_NAME22, {
+            hook: "tool.execute.before",
+            tool: toolName,
+            field,
+            before: value,
+            after: newPath,
+            action: "rewrite"
+          });
+          output.args[field] = newPath;
+          rewritesThisCall.push({ field, before: value, after: newPath });
+        };
         if (toolName === "write" || toolName === "edit") {
           const filePath = argsObj["filePath"];
-          if (typeof filePath === "string") {
-            const newPath = rewritePath(filePath, mainRoot, worktreePath);
-            if (newPath !== null) {
-              log13.info(`rewrote ${toolName}.filePath: ${filePath} → ${newPath}`);
-              safeWriteLog(PLUGIN_NAME22, {
-                hook: "tool.execute.before",
-                tool: toolName,
-                field: "filePath",
-                before: filePath,
-                after: newPath,
-                action: "rewrite"
-              });
-              output.args["filePath"] = newPath;
-            }
-          }
+          if (typeof filePath === "string")
+            applyRewrite("filePath", filePath);
         }
         if (toolName === "ast_edit") {
           const target = argsObj["target"];
-          if (typeof target === "string") {
-            const newTarget = rewritePath(target, mainRoot, worktreePath);
-            if (newTarget !== null) {
-              log13.info(`rewrote ast_edit.target: ${target} → ${newTarget}`);
-              safeWriteLog(PLUGIN_NAME22, {
-                hook: "tool.execute.before",
-                tool: toolName,
-                field: "target",
-                before: target,
-                after: newTarget,
-                action: "rewrite"
-              });
-              output.args["target"] = newTarget;
-            }
-          }
+          if (typeof target === "string")
+            applyRewrite("target", target);
           const root = argsObj["root"];
-          if (typeof root === "string") {
-            const newRoot = rewritePath(root, mainRoot, worktreePath);
-            if (newRoot !== null) {
-              log13.info(`rewrote ast_edit.root: ${root} → ${newRoot}`);
-              safeWriteLog(PLUGIN_NAME22, {
-                hook: "tool.execute.before",
-                tool: toolName,
-                field: "root",
-                before: root,
-                after: newRoot,
-                action: "rewrite"
-              });
-              output.args["root"] = newRoot;
-            }
-          }
+          if (typeof root === "string")
+            applyRewrite("root", root);
         }
         if (toolName === "bash") {
           const workdir = argsObj["workdir"];
-          if (typeof workdir === "string") {
-            const newWorkdir = rewritePath(workdir, mainRoot, worktreePath);
-            if (newWorkdir !== null) {
-              log13.info(`rewrote bash.workdir: ${workdir} → ${newWorkdir}`);
-              safeWriteLog(PLUGIN_NAME22, {
-                hook: "tool.execute.before",
-                tool: toolName,
-                field: "workdir",
-                before: workdir,
-                after: newWorkdir,
-                action: "rewrite"
-              });
-              output.args["workdir"] = newWorkdir;
-            }
-          }
+          if (typeof workdir === "string")
+            applyRewrite("workdir", workdir);
+        }
+        const _afterCallID = input.callID;
+        if (_afterCallID && rewritesThisCall.length > 0) {
+          recordRewriteNotice(_afterCallID, {
+            tool: toolName,
+            rewrites: rewritesThisCall,
+            worktreePath
+          });
         }
       });
       if (denied)
         throw denied;
+    },
+    "tool.execute.after": async (input, output) => {
+      await safeAsync(PLUGIN_NAME22, "tool.execute.after", async () => {
+        const callID = input.callID;
+        if (!callID)
+          return;
+        const notice = consumeRewriteNotice(callID);
+        if (!notice)
+          return;
+        const warning = formatRewriteWarning(notice);
+        const prev = typeof output.output === "string" ? output.output : "";
+        output.output = warning + `
+
+` + prev;
+        safeWriteLog(PLUGIN_NAME22, {
+          hook: "tool.execute.after",
+          tool: notice.tool,
+          sessionID: input.sessionID,
+          action: "inject-rewrite-notice",
+          rewrites: notice.rewrites.length
+        });
+      });
     }
   };
 };
 var handler22 = sessionWorktreeGuardPlugin;
 
-// lib/opencode-session-probe.ts
-import * as path30 from "node:path";
-import * as os6 from "node:os";
-import { createRequire as createRequire2 } from "node:module";
-var requireFromHere = createRequire2(import.meta.url);
-var DEFAULT_LIVENESS_MS = 6 * 60 * 60000;
-var DEFAULT_DB_PATH = path30.join(os6.homedir(), ".local/share/opencode/opencode.db");
-function createSessionProbe(opts = {}) {
-  const dbPath = opts.dbPath ?? DEFAULT_DB_PATH;
-  const httpBaseUrl = opts.httpBaseUrl ?? process.env["OPENCODE_SERVER_URL"];
-  const livenessWindowMs = opts.livenessWindowMs ?? DEFAULT_LIVENESS_MS;
-  const timeoutMs = opts.timeoutMs ?? 1500;
-  let db = null;
-  let dbInitTried = false;
-  let dbStmt = null;
-  async function tryOpenDb() {
-    if (dbInitTried)
-      return db != null;
-    dbInitTried = true;
-    try {
-      const mod = requireFromHere("node:sqlite");
-      try {
-        db = new mod.DatabaseSync(dbPath, { readOnly: true });
-      } catch {
-        db = null;
-        dbStmt = null;
-        return false;
-      }
-      dbStmt = db.prepare("SELECT time_updated, time_archived FROM session WHERE id = ? LIMIT 1");
-      return true;
-    } catch {
-      db = null;
-      dbStmt = null;
-      return false;
-    }
-  }
-  async function probeHttp(sessionId) {
-    if (!httpBaseUrl)
-      return null;
-    try {
-      const ctrl = new AbortController;
-      const t = setTimeout(() => ctrl.abort(), timeoutMs);
-      const res = await fetch(`${httpBaseUrl.replace(/\/$/, "")}/session`, {
-        signal: ctrl.signal
-      }).finally(() => clearTimeout(t));
-      if (!res.ok)
-        return null;
-      const list = await res.json();
-      const hit = Array.isArray(list) && list.some((s) => s.id === sessionId);
-      return { alive: hit, source: "http" };
-    } catch {
-      return null;
-    }
-  }
-  async function probeSqlite(sessionId) {
-    if (!await tryOpenDb() || !dbStmt)
-      return null;
-    try {
-      const row = dbStmt.get(sessionId);
-      if (!row) {
-        return { alive: false, source: "sqlite" };
-      }
-      if (row.time_archived != null) {
-        return {
-          alive: false,
-          source: "sqlite",
-          time_archived: row.time_archived
-        };
-      }
-      const now = Date.now();
-      const tu = Number(row.time_updated) || 0;
-      const alive = now - tu < livenessWindowMs;
-      return { alive, source: "sqlite", time_updated: tu, time_archived: null };
-    } catch {
-      return null;
-    }
-  }
-  return {
-    async isSessionAlive(sessionId) {
-      const http = await probeHttp(sessionId);
-      if (http)
-        return http;
-      const sql = await probeSqlite(sessionId);
-      if (sql)
-        return sql;
-      return { alive: true, source: "unknown" };
-    },
-    close() {
-      try {
-        db?.close?.();
-      } catch {}
-      db = null;
-      dbStmt = null;
-    }
-  };
-}
-
 // plugins/worktree-lifecycle.ts
+init_worktree_ops();
 var PLUGIN_NAME23 = "worktree-lifecycle";
 logLifecycle(PLUGIN_NAME23, "import", {});
 var IDLE_TOAST_THROTTLE_MS = 60 * 60000;
@@ -22204,10 +22491,17 @@ var worktreeLifecyclePlugin = async (ctx) => {
               worktreePath: entry.worktreePath
             });
           } catch (err) {
-            log14.warn(`[lifecycle] discardSession failed`, {
-              sessionId: ended.sessionID,
-              error: err instanceof Error ? err.message : String(err)
-            });
+            const errMsg = err instanceof Error ? err.message : String(err);
+            if (isWorktreeAbsentError(err) || isBranchAbsentError(err)) {
+              if (process.env["CODEFORGE_DEBUG"]) {
+                console.debug(`[worktree-lifecycle] discardSession absent-class silenced: ${errMsg}`);
+              }
+            } else {
+              log14.warn(`[lifecycle] discardSession failed`, {
+                sessionId: ended.sessionID,
+                error: errMsg
+              });
+            }
           }
           lastIdleToastAt.delete(ended.sessionID);
           return;