@andyqiu/codeforge 0.8.11 → 0.8.12

package/dist/index.js

@@ -372,17 +372,17 @@ var require_visit = __commonJS((exports) => {
   visit.BREAK = BREAK;
   visit.SKIP = SKIP;
   visit.REMOVE = REMOVE;
-  function visit_(key, node, visitor, path21) {
-    const ctrl = callVisitor(key, node, visitor, path21);
+  function visit_(key, node, visitor, path22) {
+    const ctrl = callVisitor(key, node, visitor, path22);
     if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-      replaceNode(key, path21, ctrl);
-      return visit_(key, ctrl, visitor, path21);
+      replaceNode(key, path22, ctrl);
+      return visit_(key, ctrl, visitor, path22);
     }
     if (typeof ctrl !== "symbol") {
       if (identity.isCollection(node)) {
-        path21 = Object.freeze(path21.concat(node));
+        path22 = Object.freeze(path22.concat(node));
         for (let i = 0;i < node.items.length; ++i) {
-          const ci = visit_(i, node.items[i], visitor, path21);
+          const ci = visit_(i, node.items[i], visitor, path22);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -393,13 +393,13 @@ var require_visit = __commonJS((exports) => {
           }
         }
       } else if (identity.isPair(node)) {
-        path21 = Object.freeze(path21.concat(node));
-        const ck = visit_("key", node.key, visitor, path21);
+        path22 = Object.freeze(path22.concat(node));
+        const ck = visit_("key", node.key, visitor, path22);
         if (ck === BREAK)
           return BREAK;
         else if (ck === REMOVE)
           node.key = null;
-        const cv = visit_("value", node.value, visitor, path21);
+        const cv = visit_("value", node.value, visitor, path22);
         if (cv === BREAK)
           return BREAK;
         else if (cv === REMOVE)
@@ -420,17 +420,17 @@ var require_visit = __commonJS((exports) => {
   visitAsync.BREAK = BREAK;
   visitAsync.SKIP = SKIP;
   visitAsync.REMOVE = REMOVE;
-  async function visitAsync_(key, node, visitor, path21) {
-    const ctrl = await callVisitor(key, node, visitor, path21);
+  async function visitAsync_(key, node, visitor, path22) {
+    const ctrl = await callVisitor(key, node, visitor, path22);
     if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-      replaceNode(key, path21, ctrl);
-      return visitAsync_(key, ctrl, visitor, path21);
+      replaceNode(key, path22, ctrl);
+      return visitAsync_(key, ctrl, visitor, path22);
     }
     if (typeof ctrl !== "symbol") {
       if (identity.isCollection(node)) {
-        path21 = Object.freeze(path21.concat(node));
+        path22 = Object.freeze(path22.concat(node));
         for (let i = 0;i < node.items.length; ++i) {
-          const ci = await visitAsync_(i, node.items[i], visitor, path21);
+          const ci = await visitAsync_(i, node.items[i], visitor, path22);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -441,13 +441,13 @@ var require_visit = __commonJS((exports) => {
           }
         }
       } else if (identity.isPair(node)) {
-        path21 = Object.freeze(path21.concat(node));
-        const ck = await visitAsync_("key", node.key, visitor, path21);
+        path22 = Object.freeze(path22.concat(node));
+        const ck = await visitAsync_("key", node.key, visitor, path22);
         if (ck === BREAK)
           return BREAK;
         else if (ck === REMOVE)
           node.key = null;
-        const cv = await visitAsync_("value", node.value, visitor, path21);
+        const cv = await visitAsync_("value", node.value, visitor, path22);
         if (cv === BREAK)
           return BREAK;
         else if (cv === REMOVE)
@@ -474,23 +474,23 @@ var require_visit = __commonJS((exports) => {
     }
     return visitor;
   }
-  function callVisitor(key, node, visitor, path21) {
+  function callVisitor(key, node, visitor, path22) {
     if (typeof visitor === "function")
-      return visitor(key, node, path21);
+      return visitor(key, node, path22);
     if (identity.isMap(node))
-      return visitor.Map?.(key, node, path21);
+      return visitor.Map?.(key, node, path22);
     if (identity.isSeq(node))
-      return visitor.Seq?.(key, node, path21);
+      return visitor.Seq?.(key, node, path22);
     if (identity.isPair(node))
-      return visitor.Pair?.(key, node, path21);
+      return visitor.Pair?.(key, node, path22);
     if (identity.isScalar(node))
-      return visitor.Scalar?.(key, node, path21);
+      return visitor.Scalar?.(key, node, path22);
     if (identity.isAlias(node))
-      return visitor.Alias?.(key, node, path21);
+      return visitor.Alias?.(key, node, path22);
     return;
   }
-  function replaceNode(key, path21, node) {
-    const parent = path21[path21.length - 1];
+  function replaceNode(key, path22, node) {
+    const parent = path22[path22.length - 1];
     if (identity.isCollection(parent)) {
       parent.items[key] = node;
     } else if (identity.isPair(parent)) {
@@ -1049,10 +1049,10 @@ var require_Collection = __commonJS((exports) => {
   var createNode = require_createNode();
   var identity = require_identity();
   var Node = require_Node();
-  function collectionFromPath(schema, path21, value) {
+  function collectionFromPath(schema, path22, value) {
     let v = value;
-    for (let i = path21.length - 1;i >= 0; --i) {
-      const k = path21[i];
+    for (let i = path22.length - 1;i >= 0; --i) {
+      const k = path22[i];
       if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
         const a = [];
         a[k] = v;
@@ -1071,7 +1071,7 @@ var require_Collection = __commonJS((exports) => {
       sourceObjects: new Map
     });
   }
-  var isEmptyPath = (path21) => path21 == null || typeof path21 === "object" && !!path21[Symbol.iterator]().next().done;
+  var isEmptyPath = (path22) => path22 == null || typeof path22 === "object" && !!path22[Symbol.iterator]().next().done;
 
   class Collection extends Node.NodeBase {
     constructor(type, schema) {
@@ -1092,11 +1092,11 @@ var require_Collection = __commonJS((exports) => {
         copy.range = this.range.slice();
       return copy;
     }
-    addIn(path21, value) {
-      if (isEmptyPath(path21))
+    addIn(path22, value) {
+      if (isEmptyPath(path22))
         this.add(value);
       else {
-        const [key, ...rest] = path21;
+        const [key, ...rest] = path22;
         const node = this.get(key, true);
         if (identity.isCollection(node))
           node.addIn(rest, value);
@@ -1106,8 +1106,8 @@ var require_Collection = __commonJS((exports) => {
           throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
       }
     }
-    deleteIn(path21) {
-      const [key, ...rest] = path21;
+    deleteIn(path22) {
+      const [key, ...rest] = path22;
       if (rest.length === 0)
         return this.delete(key);
       const node = this.get(key, true);
@@ -1116,8 +1116,8 @@ var require_Collection = __commonJS((exports) => {
       else
         throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
     }
-    getIn(path21, keepScalar) {
-      const [key, ...rest] = path21;
+    getIn(path22, keepScalar) {
+      const [key, ...rest] = path22;
       const node = this.get(key, true);
       if (rest.length === 0)
         return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -1132,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(path21) {
-      const [key, ...rest] = path21;
+    hasIn(path22) {
+      const [key, ...rest] = path22;
       if (rest.length === 0)
         return this.has(key);
       const node = this.get(key, true);
       return identity.isCollection(node) ? node.hasIn(rest) : false;
     }
-    setIn(path21, value) {
-      const [key, ...rest] = path21;
+    setIn(path22, value) {
+      const [key, ...rest] = path22;
       if (rest.length === 0) {
         this.set(key, value);
       } else {
@@ -3533,9 +3533,9 @@ var require_Document = __commonJS((exports) => {
       if (assertCollection(this.contents))
         this.contents.add(value);
     }
-    addIn(path21, value) {
+    addIn(path22, value) {
       if (assertCollection(this.contents))
-        this.contents.addIn(path21, value);
+        this.contents.addIn(path22, value);
     }
     createAlias(node, name) {
       if (!node.anchor) {
@@ -3584,30 +3584,30 @@ var require_Document = __commonJS((exports) => {
     delete(key) {
       return assertCollection(this.contents) ? this.contents.delete(key) : false;
     }
-    deleteIn(path21) {
-      if (Collection.isEmptyPath(path21)) {
+    deleteIn(path22) {
+      if (Collection.isEmptyPath(path22)) {
         if (this.contents == null)
           return false;
         this.contents = null;
         return true;
       }
-      return assertCollection(this.contents) ? this.contents.deleteIn(path21) : false;
+      return assertCollection(this.contents) ? this.contents.deleteIn(path22) : false;
     }
     get(key, keepScalar) {
       return identity.isCollection(this.contents) ? this.contents.get(key, keepScalar) : undefined;
     }
-    getIn(path21, keepScalar) {
-      if (Collection.isEmptyPath(path21))
+    getIn(path22, keepScalar) {
+      if (Collection.isEmptyPath(path22))
         return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-      return identity.isCollection(this.contents) ? this.contents.getIn(path21, keepScalar) : undefined;
+      return identity.isCollection(this.contents) ? this.contents.getIn(path22, keepScalar) : undefined;
     }
     has(key) {
       return identity.isCollection(this.contents) ? this.contents.has(key) : false;
     }
-    hasIn(path21) {
-      if (Collection.isEmptyPath(path21))
+    hasIn(path22) {
+      if (Collection.isEmptyPath(path22))
         return this.contents !== undefined;
-      return identity.isCollection(this.contents) ? this.contents.hasIn(path21) : false;
+      return identity.isCollection(this.contents) ? this.contents.hasIn(path22) : false;
     }
     set(key, value) {
       if (this.contents == null) {
@@ -3616,13 +3616,13 @@ var require_Document = __commonJS((exports) => {
         this.contents.set(key, value);
       }
     }
-    setIn(path21, value) {
-      if (Collection.isEmptyPath(path21)) {
+    setIn(path22, value) {
+      if (Collection.isEmptyPath(path22)) {
         this.contents = value;
       } else if (this.contents == null) {
-        this.contents = Collection.collectionFromPath(this.schema, Array.from(path21), value);
+        this.contents = Collection.collectionFromPath(this.schema, Array.from(path22), value);
       } else if (assertCollection(this.contents)) {
-        this.contents.setIn(path21, value);
+        this.contents.setIn(path22, value);
       }
     }
     setSchema(version2, options = {}) {
@@ -5517,9 +5517,9 @@ var require_cst_visit = __commonJS((exports) => {
   visit.BREAK = BREAK;
   visit.SKIP = SKIP;
   visit.REMOVE = REMOVE;
-  visit.itemAtPath = (cst, path21) => {
+  visit.itemAtPath = (cst, path22) => {
     let item = cst;
-    for (const [field, index] of path21) {
+    for (const [field, index] of path22) {
       const tok = item?.[field];
       if (tok && "items" in tok) {
         item = tok.items[index];
@@ -5528,23 +5528,23 @@ var require_cst_visit = __commonJS((exports) => {
     }
     return item;
   };
-  visit.parentCollection = (cst, path21) => {
-    const parent = visit.itemAtPath(cst, path21.slice(0, -1));
-    const field = path21[path21.length - 1][0];
+  visit.parentCollection = (cst, path22) => {
+    const parent = visit.itemAtPath(cst, path22.slice(0, -1));
+    const field = path22[path22.length - 1][0];
     const coll = parent?.[field];
     if (coll && "items" in coll)
       return coll;
     throw new Error("Parent collection not found");
   };
-  function _visit(path21, item, visitor) {
-    let ctrl = visitor(item, path21);
+  function _visit(path22, item, visitor) {
+    let ctrl = visitor(item, path22);
     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(path21.concat([[field, i]])), token.items[i], visitor);
+          const ci = _visit(Object.freeze(path22.concat([[field, i]])), token.items[i], visitor);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -5555,10 +5555,10 @@ var require_cst_visit = __commonJS((exports) => {
           }
         }
         if (typeof ctrl === "function" && field === "key")
-          ctrl = ctrl(item, path21);
+          ctrl = ctrl(item, path22);
       }
     }
-    return typeof ctrl === "function" ? ctrl(item, path21) : ctrl;
+    return typeof ctrl === "function" ? ctrl(item, path22) : ctrl;
   }
   exports.visit = visit;
 });
@@ -6827,14 +6827,14 @@ var require_parser = __commonJS((exports) => {
           case "scalar":
           case "single-quoted-scalar":
           case "double-quoted-scalar": {
-            const fs16 = this.flowScalar(this.type);
+            const fs17 = this.flowScalar(this.type);
             if (atNextItem || it.value) {
-              map2.items.push({ start, key: fs16, sep: [] });
+              map2.items.push({ start, key: fs17, sep: [] });
               this.onKeyLine = true;
             } else if (it.sep) {
-              this.stack.push(fs16);
+              this.stack.push(fs17);
             } else {
-              Object.assign(it, { key: fs16, sep: [] });
+              Object.assign(it, { key: fs17, sep: [] });
               this.onKeyLine = true;
             }
             return;
@@ -6962,13 +6962,13 @@ var require_parser = __commonJS((exports) => {
           case "scalar":
           case "single-quoted-scalar":
           case "double-quoted-scalar": {
-            const fs16 = this.flowScalar(this.type);
+            const fs17 = this.flowScalar(this.type);
             if (!it || it.value)
-              fc.items.push({ start: [], key: fs16, sep: [] });
+              fc.items.push({ start: [], key: fs17, sep: [] });
             else if (it.sep)
-              this.stack.push(fs16);
+              this.stack.push(fs17);
             else
-              Object.assign(it, { key: fs16, sep: [] });
+              Object.assign(it, { key: fs17, sep: [] });
             return;
           }
           case "flow-map-end":
@@ -24224,6 +24224,9 @@ async function reconcileOneStaleTransitional(mainRoot, snap, result) {
   } catch (err) {
     debugLog(`stale salvage 后清理 worktree 失败 (${snap.sessionId}): ${err.message}`);
   }
+  await deleteBranchIfExists({ root: mainRoot, branch: snap.branch }).catch((err) => {
+    debugLog(`stale salvage 后删分支失败 (${snap.sessionId}): ${err.message}`);
+  });
   result.staleSalvaged.push(snap.sessionId);
 }
 function summarizeReconcileDigest(result, prune, maxList = 3) {
@@ -24819,7 +24822,11 @@ var description4 = [
   "  reviewTarget 缺失时默认 'code'（[Session Merge Review] 流按合同即 code review）。",
   "  显式传入的值优先，不覆盖。plan:/decision:/pc- id 不补全。",
   "**何时不调**：REQUEST_CHANGES / BLOCK 不调（无 APPROVE = 无审批记录）。",
-  "**fallback**：codeforge 解析 reviewer boomerang 见 APPROVE 但无记录 → 自动以 source='codeforge-fallback' 补写。"
+  "**fallback**：codeforge 解析 reviewer boomerang 见 APPROVE 但无记录 → 自动以 source='codeforge-fallback' 补写。",
+  "**⚠️ 承诺语义（辅助提示，非安全保证）**（ADR:reviewer-approval-decision-consistency）：",
+  "  调此工具 = 你已决定 APPROVE/APPROVE_WITH_NOTES，**不可**再输出 REQUEST_CHANGES/BLOCK。",
+  "  工具层无法强制校验（不能作为关键控制点）；语义防线由 reviewer.md 文案约束承担（Phase 1），",
+  "  Phase 2 将在 review decision collection boundary 层自动作废同轮 stale approval。"
 ].join(`
 `);
 var ArgsSchema4 = exports_external.object({
@@ -25916,50 +25923,218 @@ function toEntry(r) {
 }
 // lib/merge-gate.ts
 import { promises as fs13 } from "node:fs";
+import * as os5 from "node:os";
 import * as path16 from "node:path";
 var DEFAULT_MERGE_GATE_CONFIG = {
   enabled: true,
   approvalPreCheck: true,
-  preCheckTtlSeconds: 3600
+  preCheckTtlSeconds: 3600,
+  requireUserConfirm: true
 };
-var CONFIG_REL = ".codeforge/merge-gate.json";
-async function loadMergeGate(mainRoot) {
-  const file2 = path16.join(mainRoot, CONFIG_REL);
+var PROJECT_CONFIG_REL = ".codeforge/merge-gate.json";
+var GLOBAL_CONFIG_PATH = path16.join(os5.homedir(), ".config", "codeforge", "merge-gate.json");
+async function readOptionalJson(filePath, label) {
   let raw;
   try {
-    raw = await fs13.readFile(file2, "utf8");
+    raw = await fs13.readFile(filePath, "utf8");
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT")
-      return { ...DEFAULT_MERGE_GATE_CONFIG };
-    console.warn(`[merge-gate] 读取 ${CONFIG_REL} 失败，fail-safe 退化为 enabled=false: ${e.message}`);
-    return { enabled: false, approvalPreCheck: false };
+      return null;
+    console.warn(`[merge-gate] 读取 ${label} 失败，跳过该层配置: ${e.message}`);
+    return null;
   }
   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, approvalPreCheck: false };
+    console.warn(`[merge-gate] ${label} JSON 解析失败，跳过该层配置: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
   }
-  if (!parsed || typeof parsed !== "object") {
-    console.warn(`[merge-gate] ${CONFIG_REL} 顶层非 object，fail-safe 退化为 enabled=false`);
-    return { enabled: false, approvalPreCheck: false };
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    console.warn(`[merge-gate] ${label} 顶层非 object，跳过该层配置`);
+    return null;
   }
-  const obj = parsed;
-  const enabled = typeof obj["enabled"] === "boolean" ? obj["enabled"] : DEFAULT_MERGE_GATE_CONFIG.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 parsed;
+}
+async function loadMergeGateWithPaths(mainRoot, globalConfigPath = GLOBAL_CONFIG_PATH) {
+  const projectConfigPath = path16.join(mainRoot, PROJECT_CONFIG_REL);
+  const [globalObj, projectObj] = await Promise.all([
+    readOptionalJson(globalConfigPath, "~/.config/codeforge/merge-gate.json"),
+    readOptionalJson(projectConfigPath, PROJECT_CONFIG_REL)
+  ]);
+  const enabled = (() => {
+    if (projectObj && typeof projectObj["enabled"] === "boolean")
+      return projectObj["enabled"];
+    if (globalObj && typeof globalObj["enabled"] === "boolean")
+      return globalObj["enabled"];
+    return DEFAULT_MERGE_GATE_CONFIG.enabled;
+  })();
+  const approvalPreCheck = (() => {
+    if (projectObj && typeof projectObj["approvalPreCheck"] === "boolean")
+      return projectObj["approvalPreCheck"];
+    if (globalObj && typeof globalObj["approvalPreCheck"] === "boolean")
+      return globalObj["approvalPreCheck"];
+    return DEFAULT_MERGE_GATE_CONFIG.approvalPreCheck ?? true;
+  })();
+  const preCheckTtlSeconds = (() => {
+    const rawTtl = projectObj?.["preCheckTtlSeconds"] ?? globalObj?.["preCheckTtlSeconds"];
+    if (typeof rawTtl === "number" && rawTtl > 0) {
+      if (rawTtl > 86400) {
+        console.warn(`[merge-gate] preCheckTtlSeconds=${rawTtl} 超过 24h 上界，截断为 86400`);
+        return 86400;
+      }
+      return rawTtl;
+    }
+    return DEFAULT_MERGE_GATE_CONFIG.preCheckTtlSeconds ?? 3600;
+  })();
+  const requireUserConfirm = (() => {
+    if (projectObj && projectObj["requireUserConfirm"] === false) {
+      console.warn("[merge-gate] 项目级配置不允许设 requireUserConfirm: false（安全锁定）。" + "若需关闭门 B，请在全局配置 ~/.config/codeforge/merge-gate.json 中设置。" + "项目级 false 被静默忽略，门 B 保持开启。");
+    }
+    if (globalObj?.["requireUserConfirm"] === false)
+      return false;
+    return DEFAULT_MERGE_GATE_CONFIG.requireUserConfirm ?? true;
+  })();
+  return { enabled, approvalPreCheck, preCheckTtlSeconds, requireUserConfirm };
+}
+async function loadMergeGate(mainRoot) {
+  return loadMergeGateWithPaths(mainRoot, GLOBAL_CONFIG_PATH);
+}
+
+// lib/confirm-store.ts
+import { promises as fs14 } from "node:fs";
+import * as path17 from "node:path";
+var CONFIRM_TTL_MS = 30 * 60 * 1000;
+function confirmRoot(mainRoot) {
+  return path17.join(runtimeDir(mainRoot, { ensure: false }), "confirm");
+}
+function pendingFile(mainRoot, sid) {
+  return path17.join(confirmRoot(mainRoot), "pending", `${sid}.json`);
+}
+function consumingFile(mainRoot, sid) {
+  return path17.join(confirmRoot(mainRoot), "consuming", `${sid}.json`);
+}
+function consumedFile(mainRoot, sid) {
+  return path17.join(confirmRoot(mainRoot), "consumed", `${sid}.json`);
+}
+async function ensureConfirmDirs(mainRoot) {
+  const root = confirmRoot(mainRoot);
+  await Promise.all([
+    fs14.mkdir(path17.join(root, "pending"), { recursive: true }),
+    fs14.mkdir(path17.join(root, "consuming"), { recursive: true }),
+    fs14.mkdir(path17.join(root, "consumed"), { recursive: true })
+  ]);
+}
+async function readJsonSafe(file2) {
+  let raw;
+  try {
+    raw = await fs14.readFile(file2, "utf8");
+  } catch (e) {
+    if (e.code === "ENOENT")
+      return null;
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.sessionId !== "string" || typeof parsed.worktreeHeadSha !== "string" || typeof parsed.approvalSha !== "string" || typeof parsed.ts !== "number" || typeof parsed.text !== "string" || parsed.status !== "PENDING" && parsed.status !== "CONSUMING" && parsed.status !== "CONSUMED") {
+      return null;
     }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeJsonAtomic(file2, rec) {
+  const tmp = file2 + ".tmp." + Date.now();
+  try {
+    await fs14.writeFile(tmp, JSON.stringify(rec, null, 2), "utf8");
+    await fs14.rename(tmp, file2);
+  } catch (e) {
+    await fs14.unlink(tmp).catch(() => {});
+    throw e;
+  }
+}
+async function writeConfirmRecord(mainRoot, rec) {
+  await ensureConfirmDirs(mainRoot);
+  const full = { ...rec, status: "PENDING" };
+  await writeJsonAtomic(pendingFile(mainRoot, rec.sessionId), full);
+}
+async function readPendingConfirm(mainRoot, sid) {
+  return readJsonSafe(pendingFile(mainRoot, sid));
+}
+function isHeadDrifted(rec, curHead) {
+  if (!curHead)
+    return true;
+  return rec.worktreeHeadSha !== curHead;
+}
+function isConfirmValid(rec, curHead, approval, now = Date.now()) {
+  if (!rec)
+    return false;
+  if (rec.status !== "PENDING")
+    return false;
+  if (isHeadDrifted(rec, curHead))
+    return false;
+  if (!approval)
+    return false;
+  if (approval.verdict !== "APPROVE" && approval.verdict !== "APPROVE_WITH_NOTES")
+    return false;
+  if (!approval.coveredSha)
+    return false;
+  if (rec.approvalSha !== approval.coveredSha)
+    return false;
+  if (now - rec.ts > CONFIRM_TTL_MS)
+    return false;
+  return true;
+}
+async function claimConfirmIfValid(mainRoot, sid, currentHeadSha, approval, now = Date.now()) {
+  const rec = await readPendingConfirm(mainRoot, sid);
+  if (!rec)
+    return { ok: false, reason: "no_pending_record" };
+  if (!isConfirmValid(rec, currentHeadSha, approval, now)) {
+    return { ok: false, reason: "invalid_or_drifted" };
+  }
+  await ensureConfirmDirs(mainRoot);
+  try {
+    await fs14.rename(pendingFile(mainRoot, sid), consumingFile(mainRoot, sid));
+  } catch (e) {
+    const err = e;
+    if (err.code === "ENOENT") {
+      return { ok: false, reason: "already_claimed" };
+    }
+    throw e;
+  }
+  const claimed = { ...rec, status: "CONSUMING" };
+  await writeJsonAtomic(consumingFile(mainRoot, sid), claimed);
+  return { ok: true, rec: claimed };
+}
+async function finalizeConfirmConsumed(mainRoot, sid) {
+  try {
+    await ensureConfirmDirs(mainRoot);
+    const rec = await readJsonSafe(consumingFile(mainRoot, sid));
+    const consumed = {
+      ...rec ?? { sessionId: sid, worktreeHeadSha: "", approvalSha: "", ts: Date.now(), text: "" },
+      status: "CONSUMED"
+    };
+    await writeJsonAtomic(consumedFile(mainRoot, sid), consumed);
+    await fs14.unlink(consumingFile(mainRoot, sid)).catch(() => {});
+  } catch (err) {
+    console.warn(`[confirm-store] finalizeConfirmConsumed 失败（sid=${sid}），已合入，不阻断：${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function failConfirmConsumed(mainRoot, sid) {
+  try {
+    await ensureConfirmDirs(mainRoot);
+    const rec = await readJsonSafe(consumingFile(mainRoot, sid));
+    const consumed = {
+      ...rec ?? { sessionId: sid, worktreeHeadSha: "", approvalSha: "", ts: Date.now(), text: "" },
+      status: "CONSUMED"
+    };
+    await writeJsonAtomic(consumedFile(mainRoot, sid), consumed);
+    await fs14.unlink(consumingFile(mainRoot, sid)).catch(() => {});
+  } catch (err) {
+    console.warn(`[confirm-store] failConfirmConsumed 失败（sid=${sid}），fail-closed 已记录：${err instanceof Error ? err.message : String(err)}`);
   }
-  return { enabled, approvalPreCheck, preCheckTtlSeconds };
 }
 
 // lib/merge-loop.ts
@@ -26000,7 +26175,8 @@ async function runMergeLoop(opts) {
     const { sha } = await mergeSessionBack({
       sessionId: opts.sessionId,
       mainRoot: opts.mainRoot,
-      commitMessage: message
+      commitMessage: message,
+      ...opts.planStore ? { planStore: opts.planStore } : {}
     });
     return { status: "force_merged", commitSha: sha, loops: 0 };
   }
@@ -26027,14 +26203,50 @@ async function runMergeLoop(opts) {
         });
       }
       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,
-        ...opts.summary ? { summary: opts.summary } : {}
-      });
+      {
+        const preCheckApproval = (() => {
+          return {
+            verdict: "APPROVE",
+            coveredSha: hit.coveredSha,
+            pendingId: `session:${opts.sessionId}`,
+            createdAt: new Date().toISOString()
+          };
+        })();
+        const gate = await claimConfirmGate({
+          mainRoot: opts.mainRoot,
+          sessionId: opts.sessionId,
+          worktreePath: entry.worktreePath,
+          approval: preCheckApproval,
+          mergeGate,
+          getCurrentWorktreeHeadFn: opts.__testHooks?.getCurrentWorktreeHead
+        });
+        if (!gate.ok) {
+          progress("block_pause", "门 B 对话确认未通过（pre-check 路径）");
+          return {
+            status: "blocked",
+            loops: 0,
+            finalDecision: "APPROVE",
+            blockReason: gate.blockReason,
+            lastReviewSummary: `approval-pre-check 命中但门 B 阻断：${gate.blockReason}`
+          };
+        }
+      }
+      let preCheckSha;
+      try {
+        ({ sha: preCheckSha } = await mergeSessionBack({
+          sessionId: opts.sessionId,
+          mainRoot: opts.mainRoot,
+          ...opts.summary ? { summary: opts.summary } : {},
+          ...opts.planStore ? { planStore: opts.planStore } : {}
+        }));
+      } catch (mergeErr) {
+        await failConfirmConsumed(opts.mainRoot, opts.sessionId);
+        throw mergeErr;
+      }
+      await finalizeConfirmConsumed(opts.mainRoot, opts.sessionId);
       return {
         status: "skipped_by_approval",
-        commitSha: sha,
+        commitSha: preCheckSha,
         loops: 0,
         finalDecision: "APPROVE",
         lastReviewSummary: `approval-pre-check 命中：coveredSha=${hit.coveredSha}, reviewTarget=${hit.reviewTarget}`
@@ -26119,15 +26331,43 @@ async function runMergeLoop(opts) {
             ...lastReviewSummary ? { lastReviewSummary } : {}
           };
         }
+        {
+          const gate = await claimConfirmGate({
+            mainRoot: opts.mainRoot,
+            sessionId: opts.sessionId,
+            worktreePath: entry.worktreePath,
+            approval: approval ?? undefined,
+            mergeGate,
+            getCurrentWorktreeHeadFn: opts.__testHooks?.getCurrentWorktreeHead
+          });
+          if (!gate.ok) {
+            progress("block_pause", "门 B 对话确认未通过（S6 路径）");
+            return {
+              status: "blocked",
+              loops,
+              finalDecision: "APPROVE",
+              blockReason: gate.blockReason,
+              ...lastReviewSummary ? { lastReviewSummary } : {}
+            };
+          }
+        }
       }
-      const { sha } = await mergeSessionBack({
-        sessionId: opts.sessionId,
-        mainRoot: opts.mainRoot,
-        ...opts.summary ? { summary: opts.summary } : {}
-      });
+      let s6Sha;
+      try {
+        ({ sha: s6Sha } = await mergeSessionBack({
+          sessionId: opts.sessionId,
+          mainRoot: opts.mainRoot,
+          ...opts.summary ? { summary: opts.summary } : {},
+          ...opts.planStore ? { planStore: opts.planStore } : {}
+        }));
+      } catch (mergeErr) {
+        await failConfirmConsumed(opts.mainRoot, opts.sessionId);
+        throw mergeErr;
+      }
+      await finalizeConfirmConsumed(opts.mainRoot, opts.sessionId);
       return {
         status: "merged",
-        commitSha: sha,
+        commitSha: s6Sha,
         loops,
         finalDecision: "APPROVE",
         lastReviewSummary
@@ -26203,6 +26443,26 @@ async function runMergeLoop(opts) {
     }
   }
 }
+async function claimConfirmGate(args) {
+  const { mainRoot, sessionId, worktreePath, approval, mergeGate } = args;
+  if (!mergeGate.requireUserConfirm) {
+    return { ok: true, skip: true };
+  }
+  const headOf = args.getCurrentWorktreeHeadFn ?? getCurrentWorktreeHead;
+  const curHead = await headOf(worktreePath).catch(() => "");
+  const approvalArg = approval ? { verdict: approval.verdict, coveredSha: approval.coveredSha ?? "" } : null;
+  const claim = await claimConfirmIfValid(mainRoot, sessionId, curHead, approvalArg).catch((e) => ({
+    ok: false,
+    reason: `io_error:${e instanceof Error ? e.message : String(e)}`
+  }));
+  if (!claim.ok) {
+    return {
+      ok: false,
+      blockReason: `对话确认门（门 B）未通过（${claim.reason}）：请重新说「确认合入」。`
+    };
+  }
+  return { ok: true, claimed: true };
+}
 function buildForceMergeMessage(sessionId, entry) {
   return `session(${sessionId}): merge ${entry.branch} [force-merge: skipped review]
 
@@ -26658,12 +26918,14 @@ async function execute12(input) {
       ...mergeArgs.plan_id ? { planId: mergeArgs.plan_id } : {},
       ...mergeArgs.force ? { force: true } : {},
       ...mergeArgs.summary ? { summary: mergeArgs.summary } : {},
+      ..._ctx.planStore ? { planStore: _ctx.planStore } : {},
       spawner: _ctx.spawner,
       ...sendProgress ? {
         onProgress: (state, detail) => {
           Promise.resolve(sendProgress(state, detail)).catch(() => {});
         }
-      } : {}
+      } : {},
+      ..._ctx.__testHooks ? { __testHooks: _ctx.__testHooks } : {}
     });
     return { ok: true, action: "merge", data: result };
   } catch (err) {
@@ -26675,8 +26937,8 @@ async function execute12(input) {
   }
 }
 // lib/plan-store.ts
-import { promises as fs14 } from "node:fs";
-import * as path17 from "node:path";
+import { promises as fs15 } from "node:fs";
+import * as path18 from "node:path";
 var INDEX_VERSION = 1;
 
 class PlanStore {
@@ -26685,8 +26947,8 @@ class PlanStore {
   now;
   secondCounters = new Map;
   constructor(opts = {}) {
-    this.root = path17.resolve(opts.root ?? process.cwd());
-    this.base = opts.base ? path17.resolve(opts.base) : plansDir(this.root);
+    this.root = path18.resolve(opts.root ?? process.cwd());
+    this.base = opts.base ? path18.resolve(opts.base) : plansDir(this.root);
     this.now = opts.now ?? (() => new Date);
   }
   async write(input) {
@@ -26696,14 +26958,14 @@ class PlanStore {
     if (typeof input.content !== "string" || input.content.length === 0) {
       throw new Error("PlanStore.write: content 不能为空");
     }
-    await fs14.mkdir(this.base, { recursive: true });
+    await fs15.mkdir(this.base, { recursive: true });
     const lockPath = this.lockPath();
     return await withFileLock(lockPath, async () => {
       const index = await this.readIndexLocked();
       const now = this.now();
       const planId = this.allocPlanId(now, index);
       const filename = this.composeFilename(planId, input.title);
-      const absFile = path17.join(this.base, filename);
+      const absFile = path18.join(this.base, filename);
       await this.atomicWriteFile(absFile, input.content);
       const entry = {
         plan_id: planId,
@@ -26727,9 +26989,9 @@ class PlanStore {
     const entry = index.entries.find((e) => e.plan_id === planId);
     if (!entry)
       return null;
-    const abs = path17.join(this.base, entry.path);
+    const abs = path18.join(this.base, entry.path);
     try {
-      const content = await fs14.readFile(abs, "utf8");
+      const content = await fs15.readFile(abs, "utf8");
       return { entry, content };
     } catch (err) {
       const e = err;
@@ -26788,7 +27050,7 @@ class PlanStore {
         else if (e.status === "orphan")
           shouldDelete = true;
         if (shouldDelete) {
-          await fs14.rm(path17.join(this.base, e.path), { force: true }).catch(() => {});
+          await fs15.rm(path18.join(this.base, e.path), { force: true }).catch(() => {});
           removed++;
         } else {
           keep.push(e);
@@ -26810,9 +27072,9 @@ class PlanStore {
         knownPaths.add(e.path);
         if (e.status !== "active")
           continue;
-        const abs = path17.join(this.base, e.path);
+        const abs = path18.join(this.base, e.path);
         try {
-          await fs14.stat(abs);
+          await fs15.stat(abs);
         } catch {
           e.status = "orphan";
           markedOrphan++;
@@ -26822,23 +27084,23 @@ class PlanStore {
         await this.writeIndexLocked(index);
       let unindexedFiles = [];
       try {
-        const all = await fs14.readdir(this.base);
+        const all = await fs15.readdir(this.base);
         unindexedFiles = all.filter((f) => f.endsWith(".md")).filter((f) => !knownPaths.has(f));
       } catch {}
       return { markedOrphan, unindexedFiles };
     });
   }
   indexPath() {
-    return path17.join(this.base, "index.json");
+    return path18.join(this.base, "index.json");
   }
   lockPath() {
-    return path17.join(this.base, "index.lock");
+    return path18.join(this.base, "index.lock");
   }
   async readIndexLocked() {
     const file2 = this.indexPath();
     let raw;
     try {
-      raw = await fs14.readFile(file2, "utf8");
+      raw = await fs15.readFile(file2, "utf8");
     } catch (err) {
       const e = err;
       if (e.code === "ENOENT")
@@ -26860,7 +27122,7 @@ class PlanStore {
   async archiveCorruptIndex(file2) {
     const ts = this.now().toISOString().replace(/[-:.TZ]/g, "").slice(0, 14);
     const dst = `${file2}.corrupt-${ts}`;
-    await fs14.rename(file2, dst).catch(() => {});
+    await fs15.rename(file2, dst).catch(() => {});
   }
   async readIndex() {
     return this.readIndexLocked();
@@ -26905,15 +27167,15 @@ class PlanStore {
     const tsPart = m ? `${m[1]}-${m[2]}` : planId;
     const nnn = m ? m[3] : "000";
     const sample = planFilePath(this.root, title);
-    const base = path17.basename(sample, ".md");
+    const base = path18.basename(sample, ".md");
     const slug = base.replace(/^\d{8}-\d{6}-?/, "") || "untitled";
     return `${tsPart}-${nnn}-${slug}.md`;
   }
   async atomicWriteFile(file2, data) {
-    await fs14.mkdir(path17.dirname(file2), { recursive: true });
+    await fs15.mkdir(path18.dirname(file2), { recursive: true });
     const tmp = `${file2}.tmp-${process.pid}-${Date.now()}`;
-    await fs14.writeFile(tmp, data, "utf8");
-    await fs14.rename(tmp, file2);
+    await fs15.writeFile(tmp, data, "utf8");
+    await fs15.rename(tmp, file2);
   }
 }
 function formatTimestamp(d) {
@@ -26976,8 +27238,8 @@ async function execute13(input) {
   }
 }
 // tools/plan-read.ts
-import { promises as fs15 } from "node:fs";
-import * as path18 from "node:path";
+import { promises as fs16 } from "node:fs";
+import * as path19 from "node:path";
 var description14 = [
   "读取方案文档内容，支持按 plan_id 或绝对路径查询。",
   "**何时调用**：",
@@ -27082,9 +27344,9 @@ async function execute14(input) {
       };
     }
   }
-  const abs = path18.resolve(args.path);
+  const abs = path19.resolve(args.path);
   try {
-    const content = await fs15.readFile(abs, "utf8");
+    const content = await fs16.readFile(abs, "utf8");
     return {
       ok: true,
       content,
@@ -27106,16 +27368,16 @@ async function execute14(input) {
 // lib/adr-init.ts
 import { spawnSync } from "node:child_process";
 import { existsSync as existsSync4, promises as fsp } from "node:fs";
-import * as path19 from "node:path";
+import * as path20 from "node:path";
 import * as url2 from "node:url";
 function resolveAssetsRoot() {
-  const here = path19.dirname(url2.fileURLToPath(import.meta.url));
+  const here = path20.dirname(url2.fileURLToPath(import.meta.url));
   let dir = here;
   for (let i = 0;i < 6; i++) {
-    if (existsSync4(path19.join(dir, "package.json")) && existsSync4(path19.join(dir, "assets", "adr-init"))) {
-      return path19.join(dir, "assets", "adr-init");
+    if (existsSync4(path20.join(dir, "package.json")) && existsSync4(path20.join(dir, "assets", "adr-init"))) {
+      return path20.join(dir, "assets", "adr-init");
     }
-    const parent = path19.dirname(dir);
+    const parent = path20.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -27123,13 +27385,13 @@ function resolveAssetsRoot() {
   const xdgConfig = process.env["XDG_CONFIG_HOME"];
   const homeDir = process.env["HOME"] ?? process.env["USERPROFILE"] ?? "";
   const fallbackRoots = [
-    xdgConfig ? path19.join(xdgConfig, "opencode") : null,
-    path19.join(homeDir, ".config", "opencode"),
-    process.env["APPDATA"] ? path19.join(process.env["APPDATA"], "opencode") : null,
-    process.env["LOCALAPPDATA"] ? path19.join(process.env["LOCALAPPDATA"], "opencode") : null
+    xdgConfig ? path20.join(xdgConfig, "opencode") : null,
+    path20.join(homeDir, ".config", "opencode"),
+    process.env["APPDATA"] ? path20.join(process.env["APPDATA"], "opencode") : null,
+    process.env["LOCALAPPDATA"] ? path20.join(process.env["LOCALAPPDATA"], "opencode") : null
   ].filter(Boolean);
   for (const root of fallbackRoots) {
-    const candidate = path19.join(root, "assets", "adr-init");
+    const candidate = path20.join(root, "assets", "adr-init");
     if (existsSync4(candidate)) {
       return candidate;
     }
@@ -27166,7 +27428,7 @@ function runGitConfigHooksPath(cwd) {
   }
 }
 async function runAdrInit(opts = {}) {
-  const cwd = path19.resolve(opts.cwd ?? process.cwd());
+  const cwd = path20.resolve(opts.cwd ?? process.cwd());
   const force = !!opts.force;
   const dryRun = !!opts.dryRun;
   const writePrepare = !!opts.writePrepare;
@@ -27215,8 +27477,8 @@ async function runAdrInit(opts = {}) {
     });
   }
   for (const item of plan) {
-    const srcAbs = path19.join(assetsRoot, item.src);
-    const dstAbs = path19.join(cwd, item.dst);
+    const srcAbs = path20.join(assetsRoot, item.src);
+    const dstAbs = path20.join(cwd, item.dst);
     if (!existsSync4(srcAbs)) {
       result.warnings.push(`资产缺失：${item.src}（跳过 ${item.dst}）`);
       continue;
@@ -27229,7 +27491,7 @@ async function runAdrInit(opts = {}) {
       const bakRel = `${item.dst}.bak.${ts}`;
       if (!dryRun) {
         try {
-          await fsp.copyFile(dstAbs, path19.join(cwd, bakRel));
+          await fsp.copyFile(dstAbs, path20.join(cwd, bakRel));
         } catch (e) {
           result.ok = false;
           result.reason = "io_error";
@@ -27241,7 +27503,7 @@ async function runAdrInit(opts = {}) {
     }
     if (!dryRun) {
       try {
-        await fsp.mkdir(path19.dirname(dstAbs), { recursive: true });
+        await fsp.mkdir(path20.dirname(dstAbs), { recursive: true });
         await fsp.copyFile(srcAbs, dstAbs);
         if (item.chmod !== undefined) {
           try {
@@ -27271,7 +27533,7 @@ async function runAdrInit(opts = {}) {
   } else {
     result.suggestions.push("[dry-run] 将运行：git config core.hooksPath .githooks");
   }
-  const pkgPath = path19.join(cwd, "package.json");
+  const pkgPath = path20.join(cwd, "package.json");
   const isNpm = existsSync4(pkgPath);
   if (isNpm) {
     if (writePrepare) {
@@ -27286,7 +27548,7 @@ async function runAdrInit(opts = {}) {
           const bakRel = `package.json.bak.${ts}`;
           if (!dryRun) {
             try {
-              await fsp.copyFile(pkgPath, path19.join(cwd, bakRel));
+              await fsp.copyFile(pkgPath, path20.join(cwd, bakRel));
             } catch (e) {
               result.warnings.push(`备份 package.json 失败：${e instanceof Error ? e.message : String(e)}`);
             }
@@ -27406,12 +27668,12 @@ async function execute15(input) {
   }
 }
 // lib/opencode-session-probe.ts
-import * as path20 from "node:path";
-import * as os5 from "node:os";
+import * as path21 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 = path20.join(os5.homedir(), ".local/share/opencode/opencode.db");
+var DEFAULT_DB_PATH = path21.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"];
@@ -27566,6 +27828,241 @@ async function execute16(input) {
     probe.close();
   }
 }
+// lib/llm-retry.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 2,
+  baseDelayMs: 1000,
+  maxDelayMs: 8000,
+  jitterRatio: 0.25,
+  minAttemptWindowMs: 30000
+};
+function classifyError(err) {
+  const e = err;
+  if (e instanceof Error && e.name === "AbortError" || e && e.name === "AbortError" || e && e.name === "MessageAbortedError") {
+    return "fatal";
+  }
+  if (e && e.__cfTimeout === true) {
+    return "fatal";
+  }
+  const errName = e ? e.name : undefined;
+  if (errName === "MessageOutputLengthError")
+    return "fatal";
+  const msg = getMsg(err);
+  if (/finish[=\s]+length/i.test(msg))
+    return "fatal";
+  if (errName === "APIError") {
+    const data = e.data ?? {};
+    const isRetryable = data.isRetryable;
+    const statusCode = data.statusCode;
+    if (typeof isRetryable === "boolean") {
+      return isRetryable ? "retryable" : "fatal";
+    }
+    if (typeof statusCode === "number") {
+      if (statusCode === 429 || statusCode === 529 || statusCode >= 500 && statusCode < 600) {
+        return "retryable";
+      }
+      if (statusCode >= 400 && statusCode < 500)
+        return "fatal";
+    }
+    return "retryable";
+  }
+  const NETWORK_KEYWORDS = [
+    "http2",
+    "client connection lost",
+    "econnreset",
+    "econnrefused",
+    "etimedout",
+    "epipe",
+    "socket hang up",
+    "fetch failed",
+    "network"
+  ];
+  const msgLower = msg.toLowerCase();
+  if (NETWORK_KEYWORDS.some((kw) => msgLower.includes(kw))) {
+    return "retryable";
+  }
+  if (/\b(5\d{2}|529|429)\b/.test(msg))
+    return "retryable";
+  if (errName === "ProviderAuthError" || errName === "ContextOverflowError")
+    return "fatal";
+  if (/\b4[0-9]{2}\b/.test(msg) && !/\b429\b/.test(msg))
+    return "fatal";
+  return "fatal";
+}
+function extractRetryAfterMs(err) {
+  const headers = getResponseHeaders(err) ?? getResponseHeaders(err?.cause);
+  if (!headers)
+    return;
+  const headerValue = findHeader(headers, "retry-after");
+  if (!headerValue)
+    return;
+  return parseRetryAfterHeader(headerValue);
+}
+function getResponseHeaders(src) {
+  if (!src || typeof src !== "object")
+    return;
+  const e = src;
+  const data = e["data"];
+  if (data && typeof data === "object") {
+    const rh = data["responseHeaders"];
+    if (rh && typeof rh === "object" && !Array.isArray(rh)) {
+      return rh;
+    }
+  }
+  return;
+}
+function findHeader(headers, name) {
+  const lower = name.toLowerCase();
+  for (const [k, v] of Object.entries(headers)) {
+    if (k.toLowerCase() === lower)
+      return v;
+  }
+  return;
+}
+function parseRetryAfterHeader(value) {
+  const trimmed = value.trim();
+  const seconds = parseFloat(trimmed);
+  if (!isNaN(seconds) && seconds >= 0) {
+    return Math.ceil(seconds * 1000);
+  }
+  const d = new Date(trimmed);
+  if (!isNaN(d.getTime())) {
+    const ms = d.getTime() - Date.now();
+    return ms > 0 ? ms : 0;
+  }
+  return;
+}
+async function withLlmRetry(fn, opts = {}) {
+  const maxRetries = opts.maxRetries ?? DEFAULT_RETRY_CONFIG.maxRetries;
+  const baseDelayMs = opts.baseDelayMs ?? DEFAULT_RETRY_CONFIG.baseDelayMs;
+  const maxDelayMs = opts.maxDelayMs ?? DEFAULT_RETRY_CONFIG.maxDelayMs;
+  const jitterRatio = opts.jitterRatio ?? DEFAULT_RETRY_CONFIG.jitterRatio;
+  const minAttemptWindowMs = opts.minAttemptWindowMs ?? DEFAULT_RETRY_CONFIG.minAttemptWindowMs;
+  const maxTotalRetryMs = opts.maxTotalRetryMs;
+  const maxAttempts = maxRetries + 1;
+  const startedAt = Date.now();
+  let lastError;
+  let attempt = 0;
+  while (attempt < maxAttempts) {
+    if (attempt > 0 && opts.signal?.aborted) {
+      const e = new Error("withLlmRetry: aborted by signal");
+      e.name = "AbortError";
+      throw e;
+    }
+    if (attempt > 0 && maxTotalRetryMs != null) {
+      const elapsed = Date.now() - startedAt;
+      const remaining = maxTotalRetryMs - elapsed;
+      const backoff = calcBackoff(attempt, baseDelayMs, maxDelayMs, jitterRatio);
+      const gate = Math.max(backoff, minAttemptWindowMs);
+      if (remaining < gate) {
+        opts.log?.("warn", `[llm-retry] budget gate: remaining=${remaining}ms < gate=${gate}ms, stopping after attempt ${attempt}`);
+        throw lastError ?? new Error("withLlmRetry: budget exhausted");
+      }
+    }
+    attempt++;
+    try {
+      const result = await fn();
+      if (opts.isRetryableResult) {
+        const failErr = opts.isRetryableResult(result);
+        if (failErr) {
+          const cls = classifyError(failErr);
+          if (cls === "retryable" && attempt < maxAttempts) {
+            lastError = failErr;
+            const delayMs = await handleRetryDelay(failErr, attempt, maxAttempts, baseDelayMs, maxDelayMs, jitterRatio, opts);
+            if (delayMs < 0)
+              throw lastError;
+            continue;
+          }
+          throw failErr;
+        }
+      }
+      return result;
+    } catch (err) {
+      if (err.name === "AbortError")
+        throw err;
+      const cls = classifyError(err);
+      if (cls === "fatal" || attempt >= maxAttempts) {
+        throw err;
+      }
+      lastError = err;
+      const delayMs = await handleRetryDelay(err, attempt, maxAttempts, baseDelayMs, maxDelayMs, jitterRatio, opts);
+      if (delayMs < 0) {
+        const e = new Error("withLlmRetry: aborted during retry sleep");
+        e.name = "AbortError";
+        throw e;
+      }
+    }
+  }
+  throw lastError ?? new Error("withLlmRetry: unexpected loop exit");
+}
+async function handleRetryDelay(err, attempt, maxAttempts, baseDelayMs, maxDelayMs, jitterRatio, opts) {
+  const getRetryAfterMs = opts.getRetryAfterMs ?? extractRetryAfterMs;
+  const backoff = calcBackoff(attempt, baseDelayMs, maxDelayMs, jitterRatio);
+  const retryAfterMs = getRetryAfterMs(err);
+  let delayMs;
+  if (retryAfterMs != null) {
+    delayMs = retryAfterMs;
+  } else {
+    if (isLikelyRateLimitError(err)) {
+      opts.log?.("warn", `[llm-retry] 429/rate-limit 但拿不到 Retry-After, 使用默认 backoff=${backoff}ms`, {
+        err: getMsg(err)
+      });
+    }
+    delayMs = backoff;
+  }
+  opts.onRetry?.(attempt, maxAttempts, err, delayMs);
+  opts.log?.("warn", `[llm-retry] attempt ${attempt}/${maxAttempts} failed: ${getMsg(err)}, retry in ${delayMs}ms`, { err: getMsg(err), delayMs });
+  return sleep2(delayMs, opts.signal);
+}
+function calcBackoff(attempt, baseMs, maxMs, jitterRatio) {
+  const expo = Math.min(baseMs * Math.pow(2, attempt - 1), maxMs);
+  const jitter = expo * jitterRatio * (Math.random() * 2 - 1);
+  return Math.max(0, Math.round(expo + jitter));
+}
+function sleep2(ms, signal) {
+  if (signal?.aborted)
+    return Promise.resolve(-1);
+  if (ms <= 0)
+    return Promise.resolve(0);
+  return new Promise((resolve16) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled)
+        return;
+      settled = true;
+      signal?.removeEventListener("abort", onAbort);
+      resolve16(ms);
+    }, ms);
+    const onAbort = () => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve16(-1);
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function isLikelyRateLimitError(err) {
+  if (!err)
+    return false;
+  const msg = getMsg(err).toLowerCase();
+  return msg.includes("429") || msg.includes("rate limit") || msg.includes("too many requests");
+}
+function getMsg(err) {
+  if (!err)
+    return "";
+  if (err instanceof Error)
+    return err.message;
+  if (typeof err === "string")
+    return err;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+
 // lib/opencode-runner.ts
 function pickLastText(parts) {
   for (let i = parts.length - 1;i >= 0; i--) {
@@ -27699,66 +28196,85 @@ ${r.text.slice(0, 800)}`
     return { ok: true, summary: r.text || "(coder 无文本输出)" };
   }
   async runSubagent(opts, parentSessionIdOverride) {
-    let childId;
-    try {
-      const created = await this.opts.client.session.create({
-        body: { title: clip2(opts.title, 80) },
-        query: this.opts.directory ? { directory: this.opts.directory } : undefined
-      });
-      if (created.error || !created.data?.id) {
-        throw new Error(`session.create 失败: ${describe4(created.error) || "no id"}`);
+    const retryCfg = this.opts.retry;
+    const retryOpts = {
+      maxRetries: retryCfg?.maxRetries ?? DEFAULT_RETRY_CONFIG.maxRetries,
+      baseDelayMs: retryCfg?.baseDelayMs ?? DEFAULT_RETRY_CONFIG.baseDelayMs,
+      maxDelayMs: retryCfg?.maxDelayMs ?? DEFAULT_RETRY_CONFIG.maxDelayMs,
+      jitterRatio: retryCfg?.jitterRatio ?? DEFAULT_RETRY_CONFIG.jitterRatio,
+      minAttemptWindowMs: retryCfg?.minAttemptWindowMs ?? DEFAULT_RETRY_CONFIG.minAttemptWindowMs,
+      maxTotalRetryMs: retryCfg?.maxTotalRetryMs ?? opts.timeoutMs,
+      signal: opts.signal,
+      log: this.opts.log,
+      isRetryableResult: (result) => {
+        if (result.llmError == null)
+          return;
+        const cls = classifyError(result.llmError);
+        return cls === "retryable" ? new Error(describe4(result.llmError)) : undefined;
       }
-      childId = created.data.id;
-      const parentSessionId = parentSessionIdOverride ?? this.opts.parentSessionId ?? "";
-      if (parentSessionId) {
-        try {
-          recordSessionParent(childId, parentSessionId);
-        } catch (err) {
-          this.opts.log?.("warn", `[spawner] recordSessionParent 失败 child=${childId}`, {
-            err: describe4(err),
-            parentSessionId
-          });
+    };
+    return withLlmRetry(async () => {
+      let childId;
+      try {
+        const created = await this.opts.client.session.create({
+          body: { title: clip2(opts.title, 80) },
+          query: this.opts.directory ? { directory: this.opts.directory } : undefined
+        });
+        if (created.error || !created.data?.id) {
+          throw new Error(`session.create 失败: ${describe4(created.error) || "no id"}`);
         }
-      }
-      const promptPromise = Promise.resolve(this.opts.client.session.prompt({
-        path: { id: childId },
-        body: {
-          agent: opts.agentName,
-          parts: [{ type: "text", text: opts.prompt }]
-        },
-        query: this.opts.directory ? { directory: this.opts.directory } : undefined
-      }));
-      const res = await raceAbortTimeout(promptPromise, opts.signal, opts.timeoutMs, opts.title);
-      if (res.error || !res.data) {
-        throw new Error(`session.prompt 失败: ${describe4(res.error) || "no data"}`);
-      }
-      const text = pickLastText(res.data.parts ?? []);
-      const finishReason = (res.data.info?.finish ?? "").toLowerCase();
-      const llmError = res.data.info?.error;
-      return llmError !== undefined ? { text, finishReason, llmError } : { text, finishReason };
-    } finally {
-      if (childId) {
-        try {
-          await this.opts.client.session.delete({
-            path: { id: childId },
-            query: this.opts.directory ? { directory: this.opts.directory } : undefined
-          });
-        } catch (err) {
-          this.opts.log?.("warn", `[spawner] session.delete 失败 ${childId}`, {
-            err: describe4(err)
-          });
+        childId = created.data.id;
+        const parentSessionId = parentSessionIdOverride ?? this.opts.parentSessionId ?? "";
+        if (parentSessionId) {
+          try {
+            recordSessionParent(childId, parentSessionId);
+          } catch (err) {
+            this.opts.log?.("warn", `[spawner] recordSessionParent 失败 child=${childId}`, {
+              err: describe4(err),
+              parentSessionId
+            });
+          }
         }
-        const mainRoot = this.opts.mainRoot ?? this.opts.directory;
-        if (mainRoot) {
-          const cid = childId;
-          discardSession({ sessionId: cid, mainRoot }).catch((err) => {
-            this.opts.log?.("warn", `[spawner] auto-discard 失败 ${cid}`, {
+        const promptPromise = Promise.resolve(this.opts.client.session.prompt({
+          path: { id: childId },
+          body: {
+            agent: opts.agentName,
+            parts: [{ type: "text", text: opts.prompt }]
+          },
+          query: this.opts.directory ? { directory: this.opts.directory } : undefined
+        }));
+        const res = await raceAbortTimeout(promptPromise, opts.signal, opts.timeoutMs, opts.title);
+        if (res.error || !res.data) {
+          throw new Error(`session.prompt 失败: ${describe4(res.error) || "no data"}`);
+        }
+        const text = pickLastText(res.data.parts ?? []);
+        const finishReason = (res.data.info?.finish ?? "").toLowerCase();
+        const llmError = res.data.info?.error;
+        return llmError !== undefined ? { text, finishReason, llmError } : { text, finishReason };
+      } finally {
+        if (childId) {
+          try {
+            await this.opts.client.session.delete({
+              path: { id: childId },
+              query: this.opts.directory ? { directory: this.opts.directory } : undefined
+            });
+          } catch (err) {
+            this.opts.log?.("warn", `[spawner] session.delete 失败 ${childId}`, {
               err: describe4(err)
             });
-          });
+          }
+          const mainRoot = this.opts.mainRoot ?? this.opts.directory;
+          if (mainRoot) {
+            const cid = childId;
+            discardSession({ sessionId: cid, mainRoot }).catch((err) => {
+              this.opts.log?.("warn", `[spawner] auto-discard 失败 ${cid}`, {
+                err: describe4(err)
+              });
+            });
+          }
         }
       }
-    }
+    }, retryOpts);
   }
 }
 async function raceAbortTimeout(p, signal, timeoutMs, label) {
@@ -27774,7 +28290,9 @@ async function raceAbortTimeout(p, signal, timeoutMs, label) {
         return;
       settled = true;
       signal?.removeEventListener("abort", onAbort);
-      reject(new Error(`${label} 超时 (${timeoutMs}ms)`));
+      const timeoutErr = new Error(`${label} 超时 (${timeoutMs}ms)`);
+      timeoutErr["__cfTimeout"] = true;
+      reject(timeoutErr);
     }, timeoutMs);
     const onAbort = () => {
       if (settled)
@@ -28335,10 +28853,11 @@ var codeforgeToolsServer = async (ctx) => {
     browser_enabled: browserEnabled,
     config_source: rt.ok ? "codeforge.json" : "built-in"
   });
+  const planStore = new PlanStore({ root: ctx.directory ?? process.cwd() });
   __setContext2({
     resolveCurrentSessionId: () => process.env["CODEFORGE_SESSION_ID"],
     resolveMainRoot: () => ctx.directory ?? process.cwd(),
-    store: new PlanStore({ root: ctx.directory ?? process.cwd() })
+    store: planStore
   });
   const spawner = new ProductionSpawner({
     client: ctx.client,
@@ -28349,7 +28868,8 @@ var codeforgeToolsServer = async (ctx) => {
   __setContext({
     mainRoot: ctx.directory ?? process.cwd(),
     spawner,
-    resolveCurrentSessionId: () => process.env["CODEFORGE_SESSION_ID"] ?? ""
+    resolveCurrentSessionId: () => process.env["CODEFORGE_SESSION_ID"] ?? "",
+    planStore
   });
   __setContext3({ mainRoot: ctx.directory ?? process.cwd() });
   const browserTools = browserEnabled ? buildBrowserTools() : {};
@@ -28627,7 +29147,7 @@ var handler7 = codeforgeToolsServer;
 
 // plugins/discover-spec-suggest.ts
 import { readFileSync as readFileSync3, readdirSync, statSync as statSync2 } from "node:fs";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 
 // node_modules/yaml/dist/index.js
 var composer = require_composer();
@@ -28791,9 +29311,9 @@ function validateHandoff(rawYaml, fileSize) {
   const result = HandoffSchema.safeParse(parsed);
   if (!result.success) {
     const first = result.error.issues[0];
-    const path21 = first?.path?.join(".") ?? "(root)";
+    const path22 = first?.path?.join(".") ?? "(root)";
     const msg = first?.message ?? "unknown";
-    return { ok: false, reason: `schema 校验失败：${path21}: ${msg}` };
+    return { ok: false, reason: `schema 校验失败：${path22}: ${msg}` };
   }
   return { ok: true, data: result.data, schemaVersion: result.data.schema_version };
 }
@@ -28810,7 +29330,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 = join18("docs", "specs");
+var SPECS_REL_DIR = join19("docs", "specs");
 var sessionMap = new Map;
 function pruneIfOversize2() {
   while (sessionMap.size > SESSION_CAP2) {
@@ -28917,7 +29437,7 @@ function loadSpecs(rootDir, opts = {}) {
   const dirExists = opts.dirExists ?? defaultDirExists;
   const statReader = opts.statReader ?? defaultStatReader;
   const log6 = makePluginLogger(PLUGIN_NAME8);
-  const specsRoot = join18(rootDir, SPECS_REL_DIR);
+  const specsRoot = join19(rootDir, SPECS_REL_DIR);
   const records = [];
   if (!dirExists(specsRoot)) {
     log6.info(`specs 目录不存在，plugin 将 no-op`, { specsRoot });
@@ -28938,7 +29458,7 @@ function loadSpecs(rootDir, opts = {}) {
       log6.info(`跳过非合法 slug 命名的条目`, { entry });
       continue;
     }
-    const specDir = join18(specsRoot, entry);
+    const specDir = join19(specsRoot, entry);
     let dirStat;
     try {
       dirStat = statReader(specDir);
@@ -28951,7 +29471,7 @@ function loadSpecs(rootDir, opts = {}) {
     }
     if (!dirStat.isDirectory)
       continue;
-    const handoffPath = join18(specDir, "handoff.yaml");
+    const handoffPath = join19(specDir, "handoff.yaml");
     let fileStat;
     try {
       fileStat = statReader(handoffPath);
@@ -29123,14 +29643,14 @@ var discoverSpecSuggestServer = async (ctx) => {
 var handler8 = discoverSpecSuggestServer;
 
 // lib/memories.ts
-import { promises as fs16 } from "node:fs";
-import * as path21 from "node:path";
-import * as os6 from "node:os";
+import { promises as fs17 } from "node:fs";
+import * as path22 from "node:path";
+import * as os7 from "node:os";
 function resolveConfig(c) {
   return {
     projectRoot: c.projectRoot,
-    homeDir: c.homeDir ?? os6.homedir(),
-    projectName: c.projectName ?? path21.basename(c.projectRoot),
+    homeDir: c.homeDir ?? os7.homedir(),
+    projectName: c.projectName ?? path22.basename(c.projectRoot),
     now: c.now ?? Date.now,
     log: c.log ?? (() => {}),
     maxPerScope: c.maxPerScope ?? 1000
@@ -29138,13 +29658,13 @@ function resolveConfig(c) {
 }
 function fileFor(scope, cfg) {
   if (scope === "project") {
-    return path21.join(cfg.projectRoot, ".codeforge", "memories.json");
+    return path22.join(cfg.projectRoot, ".codeforge", "memories.json");
   }
-  return path21.join(cfg.homeDir, ".codeforge", "memories.json");
+  return path22.join(cfg.homeDir, ".codeforge", "memories.json");
 }
 async function readBank(p) {
   try {
-    const raw = await fs16.readFile(p, "utf8");
+    const raw = await fs17.readFile(p, "utf8");
     const arr = JSON.parse(raw);
     if (!Array.isArray(arr))
       return [];
@@ -29154,10 +29674,10 @@ async function readBank(p) {
   }
 }
 async function writeBank(p, items) {
-  await fs16.mkdir(path21.dirname(p), { recursive: true });
+  await fs17.mkdir(path22.dirname(p), { recursive: true });
   const tmp = `${p}.tmp`;
-  await fs16.writeFile(tmp, JSON.stringify(items, null, 2), "utf8");
-  await fs16.rename(tmp, p);
+  await fs17.writeFile(tmp, JSON.stringify(items, null, 2), "utf8");
+  await fs17.rename(tmp, p);
 }
 function isMemory(x) {
   if (!x || typeof x !== "object")
@@ -29675,8 +30195,8 @@ var handler10 = modelFallbackServer;
 
 // plugins/parallel-tool-nudge.ts
 import { readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync3 } from "node:fs";
-import { join as join20 } from "node:path";
-import { homedir as homedir7 } from "node:os";
+import { join as join21 } from "node:path";
+import { homedir as homedir8 } from "node:os";
 var PLUGIN_NAME11 = "parallel-tool-nudge";
 logLifecycle(PLUGIN_NAME11, "import", {});
 var PARALLEL_SAFE_TOOLS = [
@@ -29728,10 +30248,10 @@ function loadAgentToolsMap(rootDir, opts = {}) {
   const reader = opts.reader ?? defaultReader2;
   const dirReader = opts.dirReader ?? defaultDirReader2;
   const dirExists = opts.dirExists ?? defaultDirExists2;
-  const homeAgentsDir = opts.homeAgentsDir ?? join20(homedir7(), ".config", "opencode", "agents");
+  const homeAgentsDir = opts.homeAgentsDir ?? join21(homedir8(), ".config", "opencode", "agents");
   const candidateDirs = [
-    join20(rootDir, ".codeforge", "agents"),
-    join20(rootDir, "agents"),
+    join21(rootDir, ".codeforge", "agents"),
+    join21(rootDir, "agents"),
     homeAgentsDir
   ];
   const result = new Map;
@@ -29754,20 +30274,20 @@ function loadAgentToolsMap(rootDir, opts = {}) {
     for (const entry of entries) {
       if (!entry.endsWith(".md"))
         continue;
-      const path22 = join20(dir, entry);
+      const path23 = join21(dir, entry);
       let content;
       try {
-        content = reader(path22);
+        content = reader(path23);
       } catch (err) {
         log7.warn(`agent.md 读取失败（已跳过）`, {
-          path: path22,
+          path: path23,
           error: err instanceof Error ? err.message : String(err)
         });
         continue;
       }
       const parsed = parseAgentFrontmatter(content);
       if (!parsed) {
-        log7.warn(`agent frontmatter 解析失败（已跳过）`, { path: path22 });
+        log7.warn(`agent frontmatter 解析失败（已跳过）`, { path: path23 });
         continue;
       }
       if (result.has(parsed.name))
@@ -29958,18 +30478,18 @@ var handler12 = async (_ctx4) => {
 };
 
 // lib/event-stream.ts
-import { promises as fs17 } from "node:fs";
-import * as path22 from "node:path";
+import { promises as fs18 } from "node:fs";
+import * as path23 from "node:path";
 async function loadSession(id, opts = {}) {
   const file2 = resolveSessionFile(id, opts);
-  const raw = await fs17.readFile(file2, "utf8");
+  const raw = await fs18.readFile(file2, "utf8");
   return parseJsonl(id, raw);
 }
 async function listSessions(opts = {}) {
   const dir = resolveDir(opts);
   let entries;
   try {
-    entries = await fs17.readdir(dir, { withFileTypes: true });
+    entries = await fs18.readdir(dir, { withFileTypes: true });
   } catch (err) {
     if (err.code === "ENOENT")
       return [];
@@ -29979,10 +30499,10 @@ async function listSessions(opts = {}) {
   for (const e of entries) {
     if (!e.isFile() || !e.name.endsWith(".jsonl"))
       continue;
-    const file2 = path22.join(dir, e.name);
+    const file2 = path23.join(dir, e.name);
     const id = e.name.replace(/\.jsonl$/, "");
     try {
-      const stat = await fs17.stat(file2);
+      const stat = await fs18.stat(file2);
       const headerLine = await readFirstLine(file2);
       let started_at = stat.birthtimeMs;
       if (headerLine) {
@@ -30006,11 +30526,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 = [];
@@ -30045,7 +30565,7 @@ function isEvent(obj) {
 }
 async function readFirstLine(file2) {
   const buf = Buffer.alloc(4096);
-  const fh = await fs17.open(file2, "r");
+  const fh = await fs18.open(file2, "r");
   try {
     const { bytesRead } = await fh.read(buf, 0, buf.length, 0);
     const s = buf.subarray(0, bytesRead).toString("utf8");
@@ -30273,11 +30793,11 @@ function isRecoveryWorthShowing(plan) {
 }
 
 // lib/block-pending.ts
-import { promises as fs18 } from "node:fs";
-import * as path23 from "node:path";
+import { promises as fs19 } from "node:fs";
+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";
@@ -30286,7 +30806,7 @@ async function scanBlockPending(absRoot, filterSessionId) {
   const file2 = blockPendingFilePath(absRoot);
   let raw;
   try {
-    raw = await fs18.readFile(file2, "utf8");
+    raw = await fs19.readFile(file2, "utf8");
   } catch {
     return [];
   }
@@ -30342,7 +30862,7 @@ async function markBlocksConsumed(absRoot, entries) {
   if (entries.length === 0)
     return;
   const file2 = blockPendingFilePath(absRoot);
-  await fs18.mkdir(path23.dirname(file2), { recursive: true });
+  await fs19.mkdir(path24.dirname(file2), { recursive: true });
   const now = new Date().toISOString();
   const lines = entries.map((e) => ({
     type: "consume",
@@ -30353,7 +30873,7 @@ async function markBlocksConsumed(absRoot, entries) {
 `) + `
 `;
   await withFileLock(consumeLockPath(absRoot), async () => {
-    await fs18.appendFile(file2, lines, "utf8");
+    await fs19.appendFile(file2, lines, "utf8");
   });
 }
 
@@ -30492,7 +31012,7 @@ var handler13 = sessionRecoveryServer;
 
 // plugins/subtask-heartbeat.ts
 import { promises as fsPromises } from "node:fs";
-import * as path24 from "node:path";
+import * as path25 from "node:path";
 var recordSessionParent2 = recordSessionParent;
 var lookupParentSessionId2 = lookupParentSessionId;
 var deleteSessionParent2 = deleteSessionParent;
@@ -30833,7 +31353,7 @@ function buildErrorLogLine(errorReason, elapsedMs, now = Date.now()) {
 }
 async function appendSubagentLog(filePath, line, log9) {
   try {
-    await fsPromises.mkdir(path24.dirname(filePath), { recursive: true });
+    await fsPromises.mkdir(path25.dirname(filePath), { recursive: true });
     await fsPromises.appendFile(filePath, line + `
 `, "utf8");
   } catch (err) {
@@ -31135,8 +31655,8 @@ var subtaskHeartbeatServer = async (ctx) => {
 var handler14 = subtaskHeartbeatServer;
 
 // plugins/subtasks.ts
-import { promises as fs19 } from "node:fs";
-import * as path25 from "node:path";
+import { promises as fs20 } from "node:fs";
+import * as path26 from "node:path";
 
 // lib/parallel-merge.ts
 init_worktree_ops();
@@ -31144,7 +31664,7 @@ init_worktree_ops();
 // plugins/subtasks.ts
 var PLUGIN_NAME15 = "subtasks";
 function getLogFile(root = process.cwd()) {
-  return path25.join(runtimeDir(root), "logs", "subtasks.log");
+  return path26.join(runtimeDir(root), "logs", "subtasks.log");
 }
 async function writeLog(level, msg, data) {
   const line = JSON.stringify({
@@ -31157,8 +31677,8 @@ async function writeLog(level, msg, data) {
 `;
   try {
     const logFile = getLogFile();
-    await fs19.mkdir(path25.dirname(logFile), { recursive: true });
-    await fs19.appendFile(logFile, line, "utf8");
+    await fs20.mkdir(path26.dirname(logFile), { recursive: true });
+    await fs20.appendFile(logFile, line, "utf8");
   } catch {}
 }
 logLifecycle(PLUGIN_NAME15, "import");
@@ -31732,8 +32252,8 @@ var tokenManagerServer = async (ctx) => {
 var handler17 = tokenManagerServer;
 
 // plugins/tool-policy.ts
-import { promises as fs20 } from "node:fs";
-import * as path27 from "node:path";
+import { promises as fs21 } from "node:fs";
+import * as path28 from "node:path";
 
 // lib/tool-risk.ts
 var RISK_PATTERNS = [
@@ -31887,7 +32407,7 @@ function buildHaystackFor(args, matchOn) {
 }
 
 // lib/file-regex-acl.ts
-import * as path26 from "node:path";
+import * as path27 from "node:path";
 function compileRule(r) {
   if (r instanceof RegExp)
     return r;
@@ -31953,7 +32473,7 @@ function normalizePath(p) {
   let s = p.replace(/\\/g, "/");
   if (s.startsWith("./"))
     s = s.slice(2);
-  s = path26.posix.normalize(s);
+  s = path27.posix.normalize(s);
   return s;
 }
 function checkFileAccess(acl, file2, op) {
@@ -32056,11 +32576,11 @@ function decideToolCall(ctx, cfg = {}, currentAgent) {
   const action = risks.length > 0 || worstAcl === "deny" ? "deny" : "allow";
   return { action, reasons, risks, acl: aclResults };
 }
-var POLICY_PATH = path27.join(".codeforge", "policy.json");
+var POLICY_PATH = path28.join(".codeforge", "policy.json");
 async function loadPolicy(root = process.cwd()) {
-  const file2 = path27.join(root, POLICY_PATH);
+  const file2 = path28.join(root, POLICY_PATH);
   try {
-    const raw = await fs20.readFile(file2, "utf8");
+    const raw = await fs21.readFile(file2, "utf8");
     const data = JSON.parse(raw);
     return data;
   } catch {
@@ -32157,20 +32677,20 @@ var handler18 = toolPolicyServer;
 
 // plugins/update-checker.ts
 import { closeSync, existsSync as existsSync5, mkdirSync as mkdirSync3, openSync, readFileSync as readFileSync6, rmSync, statSync as statSync4, writeFileSync as writeFileSync2, writeSync } from "node:fs";
-import { homedir as homedir8 } from "node:os";
-import { dirname as dirname16, join as join26 } from "node:path";
+import { homedir as homedir9 } from "node:os";
+import { dirname as dirname16, join as join27 } from "node:path";
 import { spawn } from "node:child_process";
 
 // lib/update-checker-impl.ts
 import { readFileSync as readFileSync5 } from "node:fs";
-import { dirname as dirname15, join as join25 } from "node:path";
+import { dirname as dirname15, join as join26 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import * as https from "node:https";
 
 // lib/version-injected.ts
 function getInjectedVersion() {
   try {
-    const v = "0.8.11";
+    const v = "0.8.12";
     if (typeof v === "string" && /^\d+\.\d+\.\d+/.test(v)) {
       return v;
     }
@@ -32218,7 +32738,7 @@ function readLocalVersion() {
   try {
     const here = fileURLToPath2(import.meta.url);
     const root = dirname15(dirname15(here));
-    const pkg = JSON.parse(readFileSync5(join25(root, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync5(join26(root, "package.json"), "utf8"));
     return typeof pkg.version === "string" ? pkg.version : "0.0.0";
   } catch {
     return "0.0.0";
@@ -32298,7 +32818,7 @@ var PLUGIN_NAME19 = "update-checker";
 var PLUGIN_VERSION = "3.0.0";
 var _updateCheckStarted = false;
 function getCacheFile() {
-  return join26(process.env["CODEFORGE_CACHE_DIR"] ?? join26(homedir8(), ".cache", "codeforge"), "update-check.json");
+  return join27(process.env["CODEFORGE_CACHE_DIR"] ?? join27(homedir9(), ".cache", "codeforge"), "update-check.json");
 }
 function readLastInstalledVersion() {
   try {
@@ -32319,7 +32839,7 @@ function writeLastInstalledVersion(v) {
   } catch {}
 }
 function getLockFile() {
-  return join26(process.env["CODEFORGE_CACHE_DIR"] ?? join26(homedir8(), ".cache", "codeforge"), "install.lock");
+  return join27(process.env["CODEFORGE_CACHE_DIR"] ?? join27(homedir9(), ".cache", "codeforge"), "install.lock");
 }
 function tryAcquireInstallLock() {
   try {
@@ -32512,7 +33032,7 @@ var updateCheckerServer = async (ctx) => {
             try {
               const npmRoot2 = await getNpmGlobalRoot(npmBin);
               if (npmRoot2) {
-                const oldPkgDir = join26(npmRoot2, ...u.package.split("/"));
+                const oldPkgDir = join27(npmRoot2, ...u.package.split("/"));
                 if (existsSync5(oldPkgDir)) {
                   rmSync(oldPkgDir, { recursive: true, force: true });
                   safeWriteLog(PLUGIN_NAME19, { level: "info", msg: "npm_install_old_dir_removed", path: oldPkgDir });
@@ -32530,8 +33050,8 @@ var updateCheckerServer = async (ctx) => {
           }
           safeWriteLog(PLUGIN_NAME19, { level: "info", msg: "npm_install_success", remote });
           try {
-            const cacheRoot = process.env["XDG_CACHE_HOME"] ?? join26(homedir8(), ".cache");
-            const opencodeCache = join26(cacheRoot, "opencode", "packages", "@andyqiu", "codeforge@latest");
+            const cacheRoot = process.env["XDG_CACHE_HOME"] ?? join27(homedir9(), ".cache");
+            const opencodeCache = join27(cacheRoot, "opencode", "packages", "@andyqiu", "codeforge@latest");
             if (existsSync5(opencodeCache)) {
               rmSync(opencodeCache, { recursive: true, force: true });
               safeWriteLog(PLUGIN_NAME19, { level: "info", msg: "opencode_plugin_cache_cleared", path: opencodeCache });
@@ -32540,8 +33060,8 @@ var updateCheckerServer = async (ctx) => {
             safeWriteLog(PLUGIN_NAME19, { level: "warn", msg: "opencode_plugin_cache_clear_failed", error: e.message });
           }
           const npmRoot = await getNpmGlobalRoot(npmBin);
-          const pkgRoot = npmRoot ? join26(npmRoot, "@andyqiu", "codeforge") : null;
-          const installMjs = pkgRoot ? join26(pkgRoot, "install.mjs") : null;
+          const pkgRoot = npmRoot ? join27(npmRoot, "@andyqiu", "codeforge") : null;
+          const installMjs = pkgRoot ? join27(pkgRoot, "install.mjs") : null;
           if (!installMjs || !existsSync5(installMjs)) {
             safeWriteLog(PLUGIN_NAME19, { level: "warn", msg: "install_mjs_not_found", path: installMjs ?? "null" });
             await postToast(ctx, `[codeforge] ⚠ npm 包已升级 ${local} → ${remote}，但资产部署未完成。下次启动将重试，或手动运行：codeforge upgrade`);
@@ -32580,12 +33100,195 @@ async function postToast(ctx, message) {
 }
 var handler19 = updateCheckerServer;
 
-// plugins/workflow-engine.ts
+// plugins/user-merge-confirm.ts
+import { execFile as execFile4 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+
+// lib/merge-confirm-semantics.ts
+import { promises as fs22 } from "node:fs";
 import * as path29 from "node:path";
+var RULES_REL_PATH = "workflows/_merge-confirm-semantics.yaml";
+async function loadMergeConfirmSemantics(repoRoot) {
+  const file2 = path29.join(repoRoot, RULES_REL_PATH);
+  const txt = await fs22.readFile(file2, "utf8");
+  return $parse(txt);
+}
+function includesAny(haystack, needles) {
+  const lower = haystack.toLowerCase();
+  return needles.some((n) => lower.includes(n.toLowerCase()));
+}
+function stripAffirmatives(text, affirmatives) {
+  let lower = text.toLowerCase();
+  let matched = false;
+  const sorted = [...affirmatives].sort((a, b) => b.length - a.length);
+  for (const phrase of sorted) {
+    const p = phrase.toLowerCase();
+    if (lower.includes(p)) {
+      matched = true;
+      lower = lower.split(p).join(" ");
+    }
+  }
+  return { matched, remainder: lower };
+}
+function classifyMergeConfirm(text, rules) {
+  if (!text || !text.trim())
+    return "NOT_CONFIRMED";
+  const { matched, remainder } = stripAffirmatives(text, rules.affirmative);
+  if (!matched)
+    return "NOT_CONFIRMED";
+  if (includesAny(remainder, rules.ambiguous_or_negative))
+    return "NOT_CONFIRMED";
+  if (rules.confirm_plus_new_request_is_not_confirmed && includesAny(remainder, rules.new_request_signals)) {
+    return "NOT_CONFIRMED";
+  }
+  return "CONFIRMED";
+}
+
+// plugins/user-merge-confirm.ts
+var PLUGIN_NAME20 = "user-merge-confirm";
+var execFileAsync = promisify2(execFile4);
+logLifecycle(PLUGIN_NAME20, "import", {});
+async function getWorktreeHead(worktreePath) {
+  if (!worktreePath)
+    return "";
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-parse", "HEAD"], {
+      cwd: worktreePath,
+      timeout: 5000
+    });
+    return stdout.trim();
+  } catch {
+    return "";
+  }
+}
+var userMergeConfirmPlugin = async (ctx) => {
+  const mainRoot = ctx.directory;
+  logLifecycle(PLUGIN_NAME20, "activate", { directory: mainRoot });
+  return {
+    "chat.message": async (input, _output) => {
+      await safeAsync(PLUGIN_NAME20, "chat.message", async () => {
+        if (input?.role !== "user")
+          return;
+        const sid = input?.sessionID;
+        if (typeof sid !== "string" || !sid)
+          return;
+        const owner = await resolveWorktreeOwner({
+          sessionId: sid,
+          mainRoot
+        }).catch(() => null);
+        if (!owner || !owner.ok) {
+          safeWriteLog(PLUGIN_NAME20, {
+            hook: "chat.message",
+            sid,
+            action: "skip_registry_unreadable",
+            via: owner?.via
+          });
+          return;
+        }
+        const targetRootSessionId = owner.ownerSessionId;
+        if (sid !== targetRootSessionId) {
+          safeWriteLog(PLUGIN_NAME20, {
+            hook: "chat.message",
+            sid,
+            action: "skip_child_session",
+            ownerSessionId: targetRootSessionId
+          });
+          return;
+        }
+        const text = extractUserText(input);
+        if (!text?.trim())
+          return;
+        const entry = owner.entry;
+        if (!entry || entry.status !== "active") {
+          return;
+        }
+        if (entry.kind === "parallel-lane" || entry.kind === "merge-fix")
+          return;
+        let approval;
+        try {
+          const store = ApprovalStore.forProject(mainRoot);
+          approval = await store.getLatest(`session:${targetRootSessionId}`);
+        } catch {
+          return;
+        }
+        if (!approval)
+          return;
+        if (approval.verdict !== "APPROVE" && approval.verdict !== "APPROVE_WITH_NOTES")
+          return;
+        if (!approval.coveredSha) {
+          safeWriteLog(PLUGIN_NAME20, {
+            hook: "chat.message",
+            sid: targetRootSessionId,
+            action: "no_covered_sha_early_exit"
+          });
+          return;
+        }
+        let mergeConfirmRules;
+        try {
+          const semantics = await loadMergeConfirmSemantics(mainRoot);
+          mergeConfirmRules = semantics.merge_confirm;
+        } catch {
+          safeWriteLog(PLUGIN_NAME20, {
+            hook: "chat.message",
+            sid: targetRootSessionId,
+            action: "skip_rules_load_failed"
+          });
+          return;
+        }
+        const verdict = classifyMergeConfirm(text, mergeConfirmRules);
+        if (verdict !== "CONFIRMED") {
+          safeWriteLog(PLUGIN_NAME20, {
+            hook: "chat.message",
+            sid: targetRootSessionId,
+            action: "not_confirmed",
+            text_preview: text.slice(0, 50)
+          });
+          return;
+        }
+        const currentHead = await getWorktreeHead(entry.worktreePath);
+        if (!currentHead) {
+          safeWriteLog(PLUGIN_NAME20, {
+            hook: "chat.message",
+            sid: targetRootSessionId,
+            action: "skip_head_unavailable",
+            worktreePath: entry.worktreePath
+          });
+          return;
+        }
+        await writeConfirmRecord(mainRoot, {
+          sessionId: targetRootSessionId,
+          worktreeHeadSha: currentHead,
+          approvalSha: approval.coveredSha,
+          ts: Date.now(),
+          text,
+          status: "PENDING"
+        });
+        safeWriteLog(PLUGIN_NAME20, {
+          hook: "chat.message",
+          sid: targetRootSessionId,
+          action: "confirm_recorded",
+          head: currentHead.slice(0, 8),
+          approvalSha: approval.coveredSha.slice(0, 8)
+        });
+        safeWriteLog(PLUGIN_NAME20, {
+          hook: "chat.message",
+          sid: targetRootSessionId,
+          action: "anchor_notice",
+          anchor: `[CODEFORGE_CONFIRM_PENDING sid=${targetRootSessionId}]`
+        });
+        console.log(`[CODEFORGE_CONFIRM_PENDING sid=${targetRootSessionId}] ` + `已记录合入确认，codeforge 将执行合入。`);
+      });
+    }
+  };
+};
+var handler20 = userMergeConfirmPlugin;
+
+// plugins/workflow-engine.ts
+import * as path31 from "node:path";
 
 // lib/workflow-loader.ts
-import { promises as fs21 } from "node:fs";
-import * as path28 from "node:path";
+import { promises as fs23 } from "node:fs";
+import * as path30 from "node:path";
 var ActionSchema = exports_external.object({
   tool: exports_external.string().min(1, "action.tool 不能为空"),
   args: exports_external.record(exports_external.string(), exports_external.unknown()).optional().default({}),
@@ -32670,7 +33373,7 @@ function parseWorkflowYaml(yaml, sourcePath = "<inline>") {
 async function loadWorkflowFromFile(filePath) {
   let txt;
   try {
-    txt = await fs21.readFile(filePath, "utf8");
+    txt = await fs23.readFile(filePath, "utf8");
   } catch (err) {
     return {
       ok: false,
@@ -32685,7 +33388,7 @@ async function loadWorkflowsFromDir(dir) {
   const failed = [];
   let entries;
   try {
-    entries = await fs21.readdir(dir);
+    entries = await fs23.readdir(dir);
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT")
@@ -32697,7 +33400,7 @@ async function loadWorkflowsFromDir(dir) {
       continue;
     if (!/\.ya?ml$/i.test(name))
       continue;
-    const full = path28.join(dir, name);
+    const full = path30.join(dir, name);
     const r = await loadWorkflowFromFile(full);
     if (r.ok)
       loaded.push(r);
@@ -33032,9 +33735,9 @@ async function runStepAutoFeedback(step, adapter) {
 }
 
 // plugins/workflow-engine.ts
-var PLUGIN_NAME20 = "workflow-engine";
-logLifecycle(PLUGIN_NAME20, "import", {});
-var fallbackLog2 = makePluginLogger(PLUGIN_NAME20);
+var PLUGIN_NAME21 = "workflow-engine";
+logLifecycle(PLUGIN_NAME21, "import", {});
+var fallbackLog2 = makePluginLogger(PLUGIN_NAME21);
 var _registry = null;
 async function loadRegistry(workflowsDir) {
   const { loaded, failed } = await loadWorkflowsFromDir(workflowsDir);
@@ -33054,32 +33757,32 @@ async function handleCommandInvoked(raw, workflowsDir = "workflows") {
   const log13 = ctx.log ?? fallbackLog2;
   const command = typeof ctx.command === "string" ? ctx.command : null;
   if (!command) {
-    log13.warn(`[${PLUGIN_NAME20}] command.invoked 缺 command 字段`, ctx);
+    log13.warn(`[${PLUGIN_NAME21}] command.invoked 缺 command 字段`, ctx);
     return null;
   }
   const reg = await ensureRegistry(workflowsDir);
   if (reg.errors.length) {
-    log13.warn(`[${PLUGIN_NAME20}] 有 ${reg.errors.length} 个 workflow 加载失败`, reg.errors);
+    log13.warn(`[${PLUGIN_NAME21}] 有 ${reg.errors.length} 个 workflow 加载失败`, reg.errors);
   }
   const wf = reg.workflows.find((w) => matchesTrigger(w, command));
   if (!wf) {
-    log13.info(`[${PLUGIN_NAME20}] no workflow matches "${command}"`);
+    log13.info(`[${PLUGIN_NAME21}] no workflow matches "${command}"`);
     return null;
   }
-  log13.info(`[${PLUGIN_NAME20}] dispatch "${command}" → workflow "${wf.name}"`);
+  log13.info(`[${PLUGIN_NAME21}] dispatch "${command}" → workflow "${wf.name}"`);
   try {
     const result = await run(wf, {
       mode: ctx.adapter ? "real" : "dry_run",
       autonomy: ctx.autonomy ?? "semi",
       adapter: ctx.adapter
     });
-    log13.info(`[${PLUGIN_NAME20}] workflow "${wf.name}" 完成 (${result.plan.mode})`, {
+    log13.info(`[${PLUGIN_NAME21}] workflow "${wf.name}" 完成 (${result.plan.mode})`, {
       steps: result.plan.steps.length,
       results: result.results.length
     });
     return result;
   } catch (err) {
-    log13.error(`[${PLUGIN_NAME20}] workflow "${wf.name}" 执行失败`, {
+    log13.error(`[${PLUGIN_NAME21}] workflow "${wf.name}" 执行失败`, {
       error: err instanceof Error ? err.message : String(err)
     });
     throw err;
@@ -33087,16 +33790,16 @@ async function handleCommandInvoked(raw, workflowsDir = "workflows") {
 }
 var workflowEngineServer = async (ctx) => {
   const directory = ctx.directory ?? process.cwd();
-  const workflowsDir = path29.join(directory, "workflows");
-  ensureRegistry(workflowsDir).catch((err) => fallbackLog2.warn(`[${PLUGIN_NAME20}] preload workflows failed`, {
+  const workflowsDir = path31.join(directory, "workflows");
+  ensureRegistry(workflowsDir).catch((err) => fallbackLog2.warn(`[${PLUGIN_NAME21}] preload workflows failed`, {
     error: err instanceof Error ? err.message : String(err)
   }));
-  logLifecycle(PLUGIN_NAME20, "activate", { directory, workflowsDir });
+  logLifecycle(PLUGIN_NAME21, "activate", { directory, workflowsDir });
   return {
     "command.execute.before": async (input, output) => {
-      await safeAsync(PLUGIN_NAME20, "command.execute.before", async () => {
+      await safeAsync(PLUGIN_NAME21, "command.execute.before", async () => {
         const cmd = input.command.startsWith("/") ? input.command : `/${input.command}`;
-        safeWriteLog(PLUGIN_NAME20, {
+        safeWriteLog(PLUGIN_NAME21, {
           hook: "command.execute.before",
           command: cmd,
           sessionID: input.sessionID
@@ -33111,14 +33814,14 @@ var workflowEngineServer = async (ctx) => {
       });
     },
     "chat.message": async (input, output) => {
-      await safeAsync(PLUGIN_NAME20, "chat.message", async () => {
+      await safeAsync(PLUGIN_NAME21, "chat.message", async () => {
         const text = extractUserText(output).trim();
         if (!text.startsWith("/"))
           return;
         const cmd = text.split(/\s+/)[0];
         if (!cmd)
           return;
-        safeWriteLog(PLUGIN_NAME20, {
+        safeWriteLog(PLUGIN_NAME21, {
           hook: "chat.message",
           command: cmd,
           sessionID: input.sessionID
@@ -33128,13 +33831,13 @@ var workflowEngineServer = async (ctx) => {
     }
   };
 };
-var handler20 = workflowEngineServer;
+var handler21 = workflowEngineServer;
 
 // plugins/session-worktree-guard.ts
-import path30 from "node:path";
+import path32 from "node:path";
 import { stat } from "node:fs/promises";
-var PLUGIN_NAME21 = "session-worktree-guard";
-logLifecycle(PLUGIN_NAME21, "import", {});
+var PLUGIN_NAME22 = "session-worktree-guard";
+logLifecycle(PLUGIN_NAME22, "import", {});
 var WRITE_INTENT_RE = />(?![=&])(?!\s*\/dev\/(?:null|stdout|stderr|fd\/\d+)\b)|\btee\b|\brm\b|\bmv\b|\bcp\b|\bmkdir\b|\btouch\b|\bchmod\b|\bchown\b|\bln\b/;
 var READ_ONLY_COMMANDS = /^\s*(?:ls|cat|head|tail|grep|rg|find|fd|wc|stat|file|which|whereis|echo|pwd|cd|pushd|popd|env|printenv|type|less|more|sort|uniq|awk|tr|cut|jq|date|whoami|id|uname|node|npx|tsc|diff|python3?|git(?:\s+-C\s+\S+)?\s+(?:log|show|diff|status|branch|tag|remote|config\s+--get|rev-parse|rev-list|ls-files|ls-tree|cat-file|describe|reflog|blame|shortlog|name-rev|symbolic-ref|merge-base|worktree\s+list|stash\s+list|stash\s+show))\b/;
 var SIDE_EFFECT_TOKEN_RE = />(?![=&])(?!\s*\/dev\/(?:null|stdout|stderr|fd\/\d+)\b)|\|\s*tee\b|\btee\b/;
@@ -33269,28 +33972,28 @@ var MERGE_CALLER_WHITELIST = new Set([
 var FORCE_MERGE_CALLER_WHITELIST = new Set([
   "codeforge"
 ]);
-var CODEFORGE_WORKTREE_DIR_NAME = path30.join(".git", "codeforge-worktrees");
+var CODEFORGE_WORKTREE_DIR_NAME = path32.join(".git", "codeforge-worktrees");
 function worktreesRoot(mainRoot) {
-  return path30.join(mainRoot, CODEFORGE_WORKTREE_DIR_NAME);
+  return path32.join(mainRoot, CODEFORGE_WORKTREE_DIR_NAME);
 }
 function isInsideAnyWorktreeDir(absPath, mainRoot) {
-  if (!path30.isAbsolute(absPath))
+  if (!path32.isAbsolute(absPath))
     return false;
   const root = worktreesRoot(mainRoot);
   if (absPath === root)
     return false;
-  const prefix = root.endsWith(path30.sep) ? root : root + path30.sep;
+  const prefix = root.endsWith(path32.sep) ? root : root + path32.sep;
   return absPath.startsWith(prefix);
 }
 function worktreeRootOf(absPath, mainRoot) {
   const root = worktreesRoot(mainRoot);
-  const prefix = root.endsWith(path30.sep) ? root : root + path30.sep;
+  const prefix = root.endsWith(path32.sep) ? root : root + path32.sep;
   if (!absPath.startsWith(prefix))
     return null;
-  const seg = absPath.slice(prefix.length).split(path30.sep)[0];
+  const seg = absPath.slice(prefix.length).split(path32.sep)[0];
   if (!seg || seg === "..")
     return null;
-  return path30.join(root, seg);
+  return path32.join(root, seg);
 }
 function stripPairedQuotes(raw) {
   if (raw.length >= 2) {
@@ -33321,7 +34024,7 @@ function resolveExplicitWorktreeTarget(argsObj, mainRoot) {
     for (const cand of candidates) {
       if (!cand)
         continue;
-      const abs = path30.resolve(mainRoot, cand);
+      const abs = path32.resolve(mainRoot, cand);
       if (isInsideAnyWorktreeDir(abs, mainRoot)) {
         const wtRoot = worktreeRootOf(abs, mainRoot);
         if (wtRoot)
@@ -33334,14 +34037,14 @@ function resolveExplicitWorktreeTarget(argsObj, mainRoot) {
   }
 }
 function stripSharedGitDirRef(command, mainRoot) {
-  const escGitDir = escapeRegex2(path30.join(mainRoot, ".git"));
+  const escGitDir = escapeRegex2(path32.join(mainRoot, ".git"));
   const re = new RegExp(`--git-dir(?:=|\\s+)['"]?${escGitDir}(?:/[^\\s'"\\x60)]*)?['"]?`, "g");
   return command.replace(re, " ");
 }
 function rewritePath(value, mainRoot, worktreeRoot) {
   if (!value)
     return null;
-  const resolved = path30.isAbsolute(value) ? value : path30.resolve(mainRoot, value);
+  const resolved = path32.isAbsolute(value) ? value : path32.resolve(mainRoot, value);
   const wtPrefix2 = worktreeRoot.endsWith("/") ? worktreeRoot : worktreeRoot + "/";
   if (resolved === worktreeRoot || resolved.startsWith(wtPrefix2)) {
     return null;
@@ -33379,7 +34082,7 @@ function commandContainsMainRootExcludingWorktree(command, mainRoot, worktreePat
     }
   }
   const wtRoot = worktreesRoot(mainRoot);
-  const wtRootPrefix = wtRoot + path30.sep;
+  const wtRootPrefix = wtRoot + path32.sep;
   const escapedWtRootPrefix = escapeRegex2(wtRootPrefix);
   const wtPathPattern = escapedWtRootPrefix + `[^\\s'"\\x60)]*`;
   const allWorktreePathsReForEscape = new RegExp(wtPathPattern, "g");
@@ -33434,19 +34137,19 @@ 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 = path30.isAbsolute(candidate) ? candidate : path30.resolve(worktreeRoot, candidate);
-  const rel = path30.relative(worktreeRoot, abs).split(path30.sep).join("/");
+  const abs = path32.isAbsolute(candidate) ? candidate : path32.resolve(worktreeRoot, candidate);
+  const rel = path32.relative(worktreeRoot, abs).split(path32.sep).join("/");
   out.push(rel);
   return out;
 }
-var log13 = makePluginLogger(PLUGIN_NAME21);
+var log13 = makePluginLogger(PLUGIN_NAME22);
 async function isCodeforgeManagedProject(mainRoot, opts = {}) {
   const env = opts.env ?? process.env;
   const force = env["CODEFORGE_FORCE_WORKTREE_GUARD"];
   if (force === "1" || force === "true" || force === "yes")
     return true;
   try {
-    const st = await stat(path30.join(mainRoot, ".codeforge"));
+    const st = await stat(path32.join(mainRoot, ".codeforge"));
     return st.isDirectory();
   } catch {
     return false;
@@ -33476,11 +34179,11 @@ 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 gitDir = path32.join(mainRoot, ".git");
   const markers = [
-    path30.join(gitDir, "MERGE_HEAD"),
-    path30.join(gitDir, "rebase-merge"),
-    path30.join(gitDir, "CHERRY_PICK_HEAD")
+    path32.join(gitDir, "MERGE_HEAD"),
+    path32.join(gitDir, "rebase-merge"),
+    path32.join(gitDir, "CHERRY_PICK_HEAD")
   ];
   let freshest = -1;
   for (const m of markers) {
@@ -33507,25 +34210,25 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
   const disableEnv = process.env["CODEFORGE_DISABLE_WORKTREE_GUARD"];
   if (disableEnv === "1" || disableEnv === "true" || disableEnv === "yes") {
     log13.warn("[guard] CODEFORGE_DISABLE_WORKTREE_GUARD 已启用，session-worktree-guard 全部 hook 跳过；" + "本次 opencode 会话所有写操作将直接落到主工作区（失去隔离保护）", { env: disableEnv });
-    safeWriteLog(PLUGIN_NAME21, {
+    safeWriteLog(PLUGIN_NAME22, {
       hook: "activate",
       action: "skip",
       source: "disable-env",
       env_value: disableEnv
     });
-    logLifecycle(PLUGIN_NAME21, "activate", { disabled_by_env: true });
+    logLifecycle(PLUGIN_NAME22, "activate", { disabled_by_env: true });
     return {};
   }
   const mainRoot = resolveMainRoot2(ctx.directory ?? process.cwd());
   if (!await isCodeforgeManagedProject(mainRoot)) {
     log13.info("[guard] 当前项目无 .codeforge/ 目录，session-worktree-guard 不启用；" + "如需在此项目启用 worktree 隔离：mkdir .codeforge", { mainRoot });
-    safeWriteLog(PLUGIN_NAME21, {
+    safeWriteLog(PLUGIN_NAME22, {
       hook: "activate",
       action: "skip",
       source: "non-codeforge-project",
       mainRoot
     });
-    logLifecycle(PLUGIN_NAME21, "activate", { skipped: "non-codeforge-project", mainRoot });
+    logLifecycle(PLUGIN_NAME22, "activate", { skipped: "non-codeforge-project", mainRoot });
     return {};
   }
   let policyCfg = {};
@@ -33538,7 +34241,7 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
     });
   }
   const perAgentEnabled = !!policyCfg.per_agent && Object.keys(policyCfg.per_agent).length > 0;
-  logLifecycle(PLUGIN_NAME21, "activate", {
+  logLifecycle(PLUGIN_NAME22, "activate", {
     mainRoot,
     CODEFORGE_SESSION_ID: process.env["CODEFORGE_SESSION_ID"] ?? "(not set)"
   });
@@ -33554,7 +34257,7 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
             opencode_version_hint: "需 opencode >= 0.x 才会在 tool.execute.before 注入 input.sessionID"
           });
         }
-        safeWriteLog(PLUGIN_NAME21, {
+        safeWriteLog(PLUGIN_NAME22, {
           hook: "tool.execute.before",
           tool: input.tool,
           action: "skip",
@@ -33564,12 +34267,12 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
         return;
       }
       let denied;
-      await safeAsync(PLUGIN_NAME21, "tool.execute.before", async () => {
+      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_NAME21, {
+          safeWriteLog(PLUGIN_NAME22, {
             hook: "tool.execute.before",
             tool: toolName,
             sessionID: input.sessionID,
@@ -33602,7 +34305,7 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
               tool: toolName,
               error: errMsg
             });
-            safeWriteLog(PLUGIN_NAME21, {
+            safeWriteLog(PLUGIN_NAME22, {
               hook: "tool.execute.before",
               tool: toolName,
               sessionID: input.sessionID,
@@ -33619,7 +34322,7 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
             tool: toolName,
             error: errMsg
           });
-          safeWriteLog(PLUGIN_NAME21, {
+          safeWriteLog(PLUGIN_NAME22, {
             hook: "tool.execute.before",
             tool: toolName,
             sessionID: input.sessionID,
@@ -33646,7 +34349,7 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
               if (parentEntry && parentEntry.status === "active") {
                 entry = parentEntry;
                 log13.debug?.(`[child-inherit] session ${sessionId} 继承父 ${parentId} 的 worktree`, { parentSessionId: parentId, worktreePath: parentEntry.worktreePath });
-                safeWriteLog(PLUGIN_NAME21, {
+                safeWriteLog(PLUGIN_NAME22, {
                   hook: "tool.execute.before",
                   tool: toolName,
                   sessionID: input.sessionID,
@@ -33658,7 +34361,7 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
               } 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_NAME21, {
+                safeWriteLog(PLUGIN_NAME22, {
                   hook: "tool.execute.before",
                   tool: toolName,
                   sessionID: input.sessionID,
@@ -33677,7 +34380,7 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
           try {
             entry = await bindSessionWorktree({ sessionId, mainRoot });
             log13.info(`[lazy-bind] auto-created worktree for session ${sessionId}`, { branch: entry.branch, path: entry.worktreePath });
-            safeWriteLog(PLUGIN_NAME21, {
+            safeWriteLog(PLUGIN_NAME22, {
               hook: "tool.execute.before",
               tool: toolName,
               sessionID: input.sessionID,
@@ -33702,7 +34405,7 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
               error: errMsg,
               throttled: alreadyNotified
             });
-            safeWriteLog(PLUGIN_NAME21, {
+            safeWriteLog(PLUGIN_NAME22, {
               hook: "tool.execute.before",
               tool: toolName,
               sessionID: input.sessionID,
@@ -33746,7 +34449,7 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
                 caller: null,
                 force: true
               });
-              safeWriteLog(PLUGIN_NAME21, {
+              safeWriteLog(PLUGIN_NAME22, {
                 hook: "tool.execute.before",
                 tool: toolName,
                 sessionID: input.sessionID,
@@ -33767,7 +34470,7 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
                 action,
                 caller
               });
-              safeWriteLog(PLUGIN_NAME21, {
+              safeWriteLog(PLUGIN_NAME22, {
                 hook: "tool.execute.before",
                 tool: toolName,
                 sessionID: input.sessionID,
@@ -33788,7 +34491,7 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
                 caller,
                 force: true
               });
-              safeWriteLog(PLUGIN_NAME21, {
+              safeWriteLog(PLUGIN_NAME22, {
                 hook: "tool.execute.before",
                 tool: toolName,
                 sessionID: input.sessionID,
@@ -33812,7 +34515,7 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
               tool: toolName,
               source: "per-agent-acl-fail-closed"
             });
-            safeWriteLog(PLUGIN_NAME21, {
+            safeWriteLog(PLUGIN_NAME22, {
               hook: "tool.execute.before",
               tool: toolName,
               sessionID: input.sessionID,
@@ -33837,7 +34540,7 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
                   path: relPath,
                   acl_decision: dec
                 });
-                safeWriteLog(PLUGIN_NAME21, {
+                safeWriteLog(PLUGIN_NAME22, {
                   hook: "tool.execute.before",
                   tool: toolName,
                   sessionID: input.sessionID,
@@ -33881,7 +34584,7 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
               requiredPlanId: entry.requiredPlanId,
               inheritedFromParent: inherited ? entry.sessionId : undefined
             });
-            safeWriteLog(PLUGIN_NAME21, {
+            safeWriteLog(PLUGIN_NAME22, {
               hook: "tool.execute.before",
               tool: toolName,
               sessionID: input.sessionID,
@@ -33903,7 +34606,7 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
             if (!stillHit) {
               hitMainRoot = false;
               if (detectBashWriteIntent(command, mainRoot)) {
-                safeWriteLog(PLUGIN_NAME21, {
+                safeWriteLog(PLUGIN_NAME22, {
                   hook: "tool.execute.before",
                   tool: toolName,
                   sessionID: input.sessionID,
@@ -33924,7 +34627,7 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
             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) });
-              safeWriteLog(PLUGIN_NAME21, {
+              safeWriteLog(PLUGIN_NAME22, {
                 hook: "tool.execute.before",
                 tool: toolName,
                 sessionID: input.sessionID,
@@ -33938,7 +34641,7 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
               const snippet = command.length > 60 ? command.slice(0, 60) + "…" : command;
               const reason = `[session-worktree-guard] DENIED: bash.command 含主仓绝对路径写操作 (${snippet}) [caller=${callerTag}]，请在当前 session worktree (${worktreePath}) 内操作`;
               log13.warn(reason, { sessionId, caller: callerTag, command: command.slice(0, 200) });
-              safeWriteLog(PLUGIN_NAME21, {
+              safeWriteLog(PLUGIN_NAME22, {
                 hook: "tool.execute.before",
                 tool: toolName,
                 sessionID: input.sessionID,
@@ -33962,7 +34665,7 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
             return;
           }
           log13.info(`rewrote ${toolName}.${field}: ${value} → ${newPath}`);
-          safeWriteLog(PLUGIN_NAME21, {
+          safeWriteLog(PLUGIN_NAME22, {
             hook: "tool.execute.before",
             tool: toolName,
             field,
@@ -33993,7 +34696,7 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
           } else if (!midMerge && entry.status === "active") {
             output.args["workdir"] = worktreePath;
             log13.info(`injected default bash.workdir → ${worktreePath}`);
-            safeWriteLog(PLUGIN_NAME21, {
+            safeWriteLog(PLUGIN_NAME22, {
               hook: "tool.execute.before",
               tool: toolName,
               field: "workdir",
@@ -34009,7 +34712,7 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
             const newReadPath = rewritePath(filePath, mainRoot, worktreePath);
             if (newReadPath !== null) {
               output.args["filePath"] = newReadPath;
-              safeWriteLog(PLUGIN_NAME21, {
+              safeWriteLog(PLUGIN_NAME22, {
                 hook: "tool.execute.before",
                 tool: toolName,
                 field: "filePath",
@@ -34033,7 +34736,7 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
         throw denied;
     },
     "tool.execute.after": async (input, output) => {
-      await safeAsync(PLUGIN_NAME21, "tool.execute.after", async () => {
+      await safeAsync(PLUGIN_NAME22, "tool.execute.after", async () => {
         const callID = input.callID;
         if (!callID)
           return;
@@ -34045,7 +34748,7 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
         output.output = warning + `
 
 ` + prev;
-        safeWriteLog(PLUGIN_NAME21, {
+        safeWriteLog(PLUGIN_NAME22, {
           hook: "tool.execute.after",
           tool: notice.tool,
           sessionID: input.sessionID,
@@ -34056,12 +34759,12 @@ var sessionWorktreeGuardPlugin = async (ctx) => {
     }
   };
 };
-var handler21 = sessionWorktreeGuardPlugin;
+var handler22 = sessionWorktreeGuardPlugin;
 
 // plugins/worktree-lifecycle.ts
 init_worktree_ops();
-var PLUGIN_NAME22 = "worktree-lifecycle";
-logLifecycle(PLUGIN_NAME22, "import", {});
+var PLUGIN_NAME23 = "worktree-lifecycle";
+logLifecycle(PLUGIN_NAME23, "import", {});
 var IDLE_TOAST_THROTTLE_MS = 60 * 60000;
 var IDLE_TOAST_DURATION_MS = 8000;
 var IDLE_TOAST_REMINDER_INTERVAL_MS = 30 * 60000;
@@ -34078,7 +34781,7 @@ async function maybeNotifyRegistryUnreadable(client, rec, prune) {
     _registryUnreadableNotified = false;
     return;
   }
-  safeWriteLog(PLUGIN_NAME22, {
+  safeWriteLog(PLUGIN_NAME23, {
     hook: "registry-unreadable",
     reason: unreadable.reason,
     detail: unreadable.detail,
@@ -34097,11 +34800,11 @@ async function maybeNotifyRegistryUnreadable(client, rec, prune) {
     return;
   await showToast2(client, { message: msg, variant: "warning", duration: 1e4, title: "CodeForge" }, log14).catch(() => {});
 }
-var log14 = makePluginLogger(PLUGIN_NAME22);
+var log14 = makePluginLogger(PLUGIN_NAME23);
 var worktreeLifecyclePlugin = async (ctx) => {
   const rawDir = ctx.directory ?? process.cwd();
   const mainRoot = resolveMainRoot2(rawDir);
-  logLifecycle(PLUGIN_NAME22, "activate", {
+  logLifecycle(PLUGIN_NAME23, "activate", {
     mainRoot: mainRoot ?? "(not set)",
     idle_threshold_ms: IDLE_TOAST_THROTTLE_MS
   });
@@ -34115,13 +34818,13 @@ var worktreeLifecyclePlugin = async (ctx) => {
   }
   if (!await shouldRunWorktreeGc(mainRoot)) {
     log14.info("[lifecycle] 当前项目无 .codeforge/ 目录且 registry 无条目，worktree-lifecycle 不启用", { mainRoot });
-    safeWriteLog(PLUGIN_NAME22, {
+    safeWriteLog(PLUGIN_NAME23, {
       hook: "activate",
       action: "skip",
       source: "non-codeforge-project",
       mainRoot
     });
-    logLifecycle(PLUGIN_NAME22, "activate", { skipped: "non-codeforge-project", mainRoot });
+    logLifecycle(PLUGIN_NAME23, "activate", { skipped: "non-codeforge-project", mainRoot });
     return {};
   }
   if (myGeneration !== _activateGeneration)
@@ -34134,14 +34837,14 @@ var worktreeLifecyclePlugin = async (ctx) => {
   }
   _probe = createSessionProbe();
   setImmediate(() => {
-    safeAsync(PLUGIN_NAME22, "activate.pruneOrphan", async () => {
+    safeAsync(PLUGIN_NAME23, "activate.pruneOrphan", async () => {
       const rec = await reconcileTransitionalEntries(mainRoot);
       if (rec.cleanedCreating.length > 0 || rec.finishedRemoving.length > 0 || rec.keptConservative.length > 0) {
-        safeWriteLog(PLUGIN_NAME22, { hook: "activate.reconcile", ...rec });
+        safeWriteLog(PLUGIN_NAME23, { hook: "activate.reconcile", ...rec });
       }
       const merc = await reconcileInterruptedMerges(mainRoot);
       if (merc.recoveredMerged.length > 0 || merc.rolledBack.length > 0 || merc.conflicts.length > 0 || merc.registryUnreadable) {
-        safeWriteLog(PLUGIN_NAME22, { hook: "activate.reconcileMerge", ...merc });
+        safeWriteLog(PLUGIN_NAME23, { hook: "activate.reconcileMerge", ...merc });
       }
       const result = await pruneOrphanWorktrees(mainRoot, {
         isSessionAlive: _probe.isSessionAlive
@@ -34149,7 +34852,7 @@ var worktreeLifecyclePlugin = async (ctx) => {
       await maybeNotifyRegistryUnreadable(client, rec, result);
       if (result.cleaned.length > 0 || result.failed.length > 0) {
         log14.info(`[pruneOrphan] cleaned=${result.cleaned.length} failed=${result.failed.length} skipped=${result.skipped}`);
-        safeWriteLog(PLUGIN_NAME22, {
+        safeWriteLog(PLUGIN_NAME23, {
           hook: "activate.pruneOrphan",
           cleaned: result.cleaned,
           failed: result.failed,
@@ -34160,7 +34863,7 @@ var worktreeLifecyclePlugin = async (ctx) => {
   });
   _pruneTimer = setInterval(() => {
     if (pruneRunning) {
-      safeWriteLog(PLUGIN_NAME22, {
+      safeWriteLog(PLUGIN_NAME23, {
         hook: "interval.pruneOrphan",
         action: "skip",
         reason: "previous prune still running"
@@ -34168,15 +34871,15 @@ var worktreeLifecyclePlugin = async (ctx) => {
       return;
     }
     pruneRunning = true;
-    safeAsync(PLUGIN_NAME22, "interval.pruneOrphan", async () => {
+    safeAsync(PLUGIN_NAME23, "interval.pruneOrphan", async () => {
       try {
         const rec = await reconcileTransitionalEntries(mainRoot);
         if (rec.cleanedCreating.length > 0 || rec.finishedRemoving.length > 0 || rec.keptConservative.length > 0) {
-          safeWriteLog(PLUGIN_NAME22, { hook: "interval.reconcile", ...rec });
+          safeWriteLog(PLUGIN_NAME23, { hook: "interval.reconcile", ...rec });
         }
         const merc = await reconcileInterruptedMerges(mainRoot);
         if (merc.recoveredMerged.length > 0 || merc.rolledBack.length > 0 || merc.conflicts.length > 0 || merc.registryUnreadable) {
-          safeWriteLog(PLUGIN_NAME22, { hook: "interval.reconcileMerge", ...merc });
+          safeWriteLog(PLUGIN_NAME23, { hook: "interval.reconcileMerge", ...merc });
         }
         const result = await pruneOrphanWorktrees(mainRoot, {
           isSessionAlive: _probe.isSessionAlive
@@ -34184,7 +34887,7 @@ var worktreeLifecyclePlugin = async (ctx) => {
         await maybeNotifyRegistryUnreadable(client, rec, result);
         if (result.cleaned.length > 0 || result.failed.length > 0) {
           log14.info(`[pruneOrphan interval] cleaned=${result.cleaned.length} failed=${result.failed.length} skipped=${result.skipped}`);
-          safeWriteLog(PLUGIN_NAME22, {
+          safeWriteLog(PLUGIN_NAME23, {
             hook: "interval.pruneOrphan",
             cleaned: result.cleaned,
             failed: result.failed,
@@ -34199,14 +34902,14 @@ var worktreeLifecyclePlugin = async (ctx) => {
   _pruneTimer.unref();
   return {
     event: async ({ event }) => {
-      await safeAsync(PLUGIN_NAME22, "event", async () => {
+      await safeAsync(PLUGIN_NAME23, "event", async () => {
         const ended = extractEndedSessionID(event);
         if (!ended)
           return;
         if (ended.type === "session.deleted") {
           const entry = await getSessionWorktree(ended.sessionID, mainRoot);
           if (!entry || entry.status !== "active") {
-            safeWriteLog(PLUGIN_NAME22, {
+            safeWriteLog(PLUGIN_NAME23, {
               hook: "event",
               type: ended.type,
               sessionID: ended.sessionID,
@@ -34221,7 +34924,7 @@ var worktreeLifecyclePlugin = async (ctx) => {
               const fastDirty = await isWorktreeDirty(entry.worktreePath);
               if (!fastDirty) {
                 await discardSession({ sessionId: ended.sessionID, mainRoot });
-                safeWriteLog(PLUGIN_NAME22, {
+                safeWriteLog(PLUGIN_NAME23, {
                   hook: "event",
                   type: ended.type,
                   sessionID: ended.sessionID,
@@ -34256,7 +34959,7 @@ var worktreeLifecyclePlugin = async (ctx) => {
           }
           try {
             await discardSession({ sessionId: ended.sessionID, mainRoot });
-            safeWriteLog(PLUGIN_NAME22, {
+            safeWriteLog(PLUGIN_NAME23, {
               hook: "event",
               type: ended.type,
               sessionID: ended.sessionID,
@@ -34297,7 +35000,7 @@ var worktreeLifecyclePlugin = async (ctx) => {
           const idleMin = Math.round(idleMs / 60000);
           const msg = `\uD83D\uDCA4 Session ${ended.sessionID.slice(0, 8)} worktree 已空闲 ${idleMin}min，` + `用 /merge 收尾或 /discard-session 放弃`;
           const sent = await showToast2(client, { message: msg, variant: "default", duration: IDLE_TOAST_DURATION_MS, title: "CodeForge" }, log14);
-          safeWriteLog(PLUGIN_NAME22, {
+          safeWriteLog(PLUGIN_NAME23, {
             hook: "event",
             type: ended.type,
             sessionID: ended.sessionID,
@@ -34310,7 +35013,7 @@ var worktreeLifecyclePlugin = async (ctx) => {
     }
   };
 };
-var handler22 = worktreeLifecyclePlugin;
+var handler23 = worktreeLifecyclePlugin;
 
 // src/index.ts
 var PLUGIN_ID = "codeforge";
@@ -34336,9 +35039,10 @@ var HANDLERS = [
   { name: "tool-heartbeat", init: handler6 },
   { name: "tool-policy", init: handler18 },
   { name: "update-checker", init: handler19 },
-  { name: "workflow-engine", init: handler20 },
-  { name: "session-worktree-guard", init: handler21 },
-  { name: "worktree-lifecycle", init: handler22 }
+  { name: "user-merge-confirm", init: handler20 },
+  { name: "workflow-engine", init: handler21 },
+  { name: "session-worktree-guard", init: handler22 },
+  { name: "worktree-lifecycle", init: handler23 }
 ];
 function makeSerialHook(hookName, fns) {
   return async (input, output) => {