@andyqiu/codeforge 0.8.2 → 0.8.4

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, path20) {
-    const ctrl = callVisitor(key, node, visitor, path20);
+  function visit_(key, node, visitor, path21) {
+    const ctrl = callVisitor(key, node, visitor, path21);
     if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-      replaceNode(key, path20, ctrl);
-      return visit_(key, ctrl, visitor, path20);
+      replaceNode(key, path21, ctrl);
+      return visit_(key, ctrl, visitor, path21);
     }
     if (typeof ctrl !== "symbol") {
       if (identity.isCollection(node)) {
-        path20 = Object.freeze(path20.concat(node));
+        path21 = Object.freeze(path21.concat(node));
         for (let i = 0;i < node.items.length; ++i) {
-          const ci = visit_(i, node.items[i], visitor, path20);
+          const ci = visit_(i, node.items[i], visitor, path21);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -393,13 +393,13 @@ var require_visit = __commonJS((exports) => {
           }
         }
       } else if (identity.isPair(node)) {
-        path20 = Object.freeze(path20.concat(node));
-        const ck = visit_("key", node.key, visitor, path20);
+        path21 = Object.freeze(path21.concat(node));
+        const ck = visit_("key", node.key, visitor, path21);
         if (ck === BREAK)
           return BREAK;
         else if (ck === REMOVE)
           node.key = null;
-        const cv = visit_("value", node.value, visitor, path20);
+        const cv = visit_("value", node.value, visitor, path21);
         if (cv === BREAK)
           return BREAK;
         else if (cv === REMOVE)
@@ -420,17 +420,17 @@ var require_visit = __commonJS((exports) => {
   visitAsync.BREAK = BREAK;
   visitAsync.SKIP = SKIP;
   visitAsync.REMOVE = REMOVE;
-  async function visitAsync_(key, node, visitor, path20) {
-    const ctrl = await callVisitor(key, node, visitor, path20);
+  async function visitAsync_(key, node, visitor, path21) {
+    const ctrl = await callVisitor(key, node, visitor, path21);
     if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-      replaceNode(key, path20, ctrl);
-      return visitAsync_(key, ctrl, visitor, path20);
+      replaceNode(key, path21, ctrl);
+      return visitAsync_(key, ctrl, visitor, path21);
     }
     if (typeof ctrl !== "symbol") {
       if (identity.isCollection(node)) {
-        path20 = Object.freeze(path20.concat(node));
+        path21 = Object.freeze(path21.concat(node));
         for (let i = 0;i < node.items.length; ++i) {
-          const ci = await visitAsync_(i, node.items[i], visitor, path20);
+          const ci = await visitAsync_(i, node.items[i], visitor, path21);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -441,13 +441,13 @@ var require_visit = __commonJS((exports) => {
           }
         }
       } else if (identity.isPair(node)) {
-        path20 = Object.freeze(path20.concat(node));
-        const ck = await visitAsync_("key", node.key, visitor, path20);
+        path21 = Object.freeze(path21.concat(node));
+        const ck = await visitAsync_("key", node.key, visitor, path21);
         if (ck === BREAK)
           return BREAK;
         else if (ck === REMOVE)
           node.key = null;
-        const cv = await visitAsync_("value", node.value, visitor, path20);
+        const cv = await visitAsync_("value", node.value, visitor, path21);
         if (cv === BREAK)
           return BREAK;
         else if (cv === REMOVE)
@@ -474,23 +474,23 @@ var require_visit = __commonJS((exports) => {
     }
     return visitor;
   }
-  function callVisitor(key, node, visitor, path20) {
+  function callVisitor(key, node, visitor, path21) {
     if (typeof visitor === "function")
-      return visitor(key, node, path20);
+      return visitor(key, node, path21);
     if (identity.isMap(node))
-      return visitor.Map?.(key, node, path20);
+      return visitor.Map?.(key, node, path21);
     if (identity.isSeq(node))
-      return visitor.Seq?.(key, node, path20);
+      return visitor.Seq?.(key, node, path21);
     if (identity.isPair(node))
-      return visitor.Pair?.(key, node, path20);
+      return visitor.Pair?.(key, node, path21);
     if (identity.isScalar(node))
-      return visitor.Scalar?.(key, node, path20);
+      return visitor.Scalar?.(key, node, path21);
     if (identity.isAlias(node))
-      return visitor.Alias?.(key, node, path20);
+      return visitor.Alias?.(key, node, path21);
     return;
   }
-  function replaceNode(key, path20, node) {
-    const parent = path20[path20.length - 1];
+  function replaceNode(key, path21, node) {
+    const parent = path21[path21.length - 1];
     if (identity.isCollection(parent)) {
       parent.items[key] = node;
     } else if (identity.isPair(parent)) {
@@ -1049,10 +1049,10 @@ var require_Collection = __commonJS((exports) => {
   var createNode = require_createNode();
   var identity = require_identity();
   var Node = require_Node();
-  function collectionFromPath(schema, path20, value) {
+  function collectionFromPath(schema, path21, value) {
     let v = value;
-    for (let i = path20.length - 1;i >= 0; --i) {
-      const k = path20[i];
+    for (let i = path21.length - 1;i >= 0; --i) {
+      const k = path21[i];
       if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
         const a = [];
         a[k] = v;
@@ -1071,7 +1071,7 @@ var require_Collection = __commonJS((exports) => {
       sourceObjects: new Map
     });
   }
-  var isEmptyPath = (path20) => path20 == null || typeof path20 === "object" && !!path20[Symbol.iterator]().next().done;
+  var isEmptyPath = (path21) => path21 == null || typeof path21 === "object" && !!path21[Symbol.iterator]().next().done;
 
   class Collection extends Node.NodeBase {
     constructor(type, schema) {
@@ -1092,11 +1092,11 @@ var require_Collection = __commonJS((exports) => {
         copy.range = this.range.slice();
       return copy;
     }
-    addIn(path20, value) {
-      if (isEmptyPath(path20))
+    addIn(path21, value) {
+      if (isEmptyPath(path21))
         this.add(value);
       else {
-        const [key, ...rest] = path20;
+        const [key, ...rest] = path21;
         const node = this.get(key, true);
         if (identity.isCollection(node))
           node.addIn(rest, value);
@@ -1106,8 +1106,8 @@ var require_Collection = __commonJS((exports) => {
           throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
       }
     }
-    deleteIn(path20) {
-      const [key, ...rest] = path20;
+    deleteIn(path21) {
+      const [key, ...rest] = path21;
       if (rest.length === 0)
         return this.delete(key);
       const node = this.get(key, true);
@@ -1116,8 +1116,8 @@ var require_Collection = __commonJS((exports) => {
       else
         throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
     }
-    getIn(path20, keepScalar) {
-      const [key, ...rest] = path20;
+    getIn(path21, keepScalar) {
+      const [key, ...rest] = path21;
       const node = this.get(key, true);
       if (rest.length === 0)
         return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -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(path20) {
-      const [key, ...rest] = path20;
+    hasIn(path21) {
+      const [key, ...rest] = path21;
       if (rest.length === 0)
         return this.has(key);
       const node = this.get(key, true);
       return identity.isCollection(node) ? node.hasIn(rest) : false;
     }
-    setIn(path20, value) {
-      const [key, ...rest] = path20;
+    setIn(path21, value) {
+      const [key, ...rest] = path21;
       if (rest.length === 0) {
         this.set(key, value);
       } else {
@@ -3533,9 +3533,9 @@ var require_Document = __commonJS((exports) => {
       if (assertCollection(this.contents))
         this.contents.add(value);
     }
-    addIn(path20, value) {
+    addIn(path21, value) {
       if (assertCollection(this.contents))
-        this.contents.addIn(path20, value);
+        this.contents.addIn(path21, value);
     }
     createAlias(node, name) {
       if (!node.anchor) {
@@ -3584,30 +3584,30 @@ var require_Document = __commonJS((exports) => {
     delete(key) {
       return assertCollection(this.contents) ? this.contents.delete(key) : false;
     }
-    deleteIn(path20) {
-      if (Collection.isEmptyPath(path20)) {
+    deleteIn(path21) {
+      if (Collection.isEmptyPath(path21)) {
         if (this.contents == null)
           return false;
         this.contents = null;
         return true;
       }
-      return assertCollection(this.contents) ? this.contents.deleteIn(path20) : false;
+      return assertCollection(this.contents) ? this.contents.deleteIn(path21) : false;
     }
     get(key, keepScalar) {
       return identity.isCollection(this.contents) ? this.contents.get(key, keepScalar) : undefined;
     }
-    getIn(path20, keepScalar) {
-      if (Collection.isEmptyPath(path20))
+    getIn(path21, keepScalar) {
+      if (Collection.isEmptyPath(path21))
         return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-      return identity.isCollection(this.contents) ? this.contents.getIn(path20, keepScalar) : undefined;
+      return identity.isCollection(this.contents) ? this.contents.getIn(path21, keepScalar) : undefined;
     }
     has(key) {
       return identity.isCollection(this.contents) ? this.contents.has(key) : false;
     }
-    hasIn(path20) {
-      if (Collection.isEmptyPath(path20))
+    hasIn(path21) {
+      if (Collection.isEmptyPath(path21))
         return this.contents !== undefined;
-      return identity.isCollection(this.contents) ? this.contents.hasIn(path20) : false;
+      return identity.isCollection(this.contents) ? this.contents.hasIn(path21) : false;
     }
     set(key, value) {
       if (this.contents == null) {
@@ -3616,13 +3616,13 @@ var require_Document = __commonJS((exports) => {
         this.contents.set(key, value);
       }
     }
-    setIn(path20, value) {
-      if (Collection.isEmptyPath(path20)) {
+    setIn(path21, value) {
+      if (Collection.isEmptyPath(path21)) {
         this.contents = value;
       } else if (this.contents == null) {
-        this.contents = Collection.collectionFromPath(this.schema, Array.from(path20), value);
+        this.contents = Collection.collectionFromPath(this.schema, Array.from(path21), value);
       } else if (assertCollection(this.contents)) {
-        this.contents.setIn(path20, value);
+        this.contents.setIn(path21, value);
       }
     }
     setSchema(version, options = {}) {
@@ -5517,9 +5517,9 @@ var require_cst_visit = __commonJS((exports) => {
   visit.BREAK = BREAK;
   visit.SKIP = SKIP;
   visit.REMOVE = REMOVE;
-  visit.itemAtPath = (cst, path20) => {
+  visit.itemAtPath = (cst, path21) => {
     let item = cst;
-    for (const [field, index] of path20) {
+    for (const [field, index] of path21) {
       const tok = item?.[field];
       if (tok && "items" in tok) {
         item = tok.items[index];
@@ -5528,23 +5528,23 @@ var require_cst_visit = __commonJS((exports) => {
     }
     return item;
   };
-  visit.parentCollection = (cst, path20) => {
-    const parent = visit.itemAtPath(cst, path20.slice(0, -1));
-    const field = path20[path20.length - 1][0];
+  visit.parentCollection = (cst, path21) => {
+    const parent = visit.itemAtPath(cst, path21.slice(0, -1));
+    const field = path21[path21.length - 1][0];
     const coll = parent?.[field];
     if (coll && "items" in coll)
       return coll;
     throw new Error("Parent collection not found");
   };
-  function _visit(path20, item, visitor) {
-    let ctrl = visitor(item, path20);
+  function _visit(path21, item, visitor) {
+    let ctrl = visitor(item, path21);
     if (typeof ctrl === "symbol")
       return ctrl;
     for (const field of ["key", "value"]) {
       const token = item[field];
       if (token && "items" in token) {
         for (let i = 0;i < token.items.length; ++i) {
-          const ci = _visit(Object.freeze(path20.concat([[field, i]])), token.items[i], visitor);
+          const ci = _visit(Object.freeze(path21.concat([[field, i]])), token.items[i], visitor);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -5555,10 +5555,10 @@ var require_cst_visit = __commonJS((exports) => {
           }
         }
         if (typeof ctrl === "function" && field === "key")
-          ctrl = ctrl(item, path20);
+          ctrl = ctrl(item, path21);
       }
     }
-    return typeof ctrl === "function" ? ctrl(item, path20) : ctrl;
+    return typeof ctrl === "function" ? ctrl(item, path21) : ctrl;
   }
   exports.visit = visit;
 });
@@ -6827,14 +6827,14 @@ var require_parser = __commonJS((exports) => {
           case "scalar":
           case "single-quoted-scalar":
           case "double-quoted-scalar": {
-            const fs15 = this.flowScalar(this.type);
+            const fs16 = this.flowScalar(this.type);
             if (atNextItem || it.value) {
-              map.items.push({ start, key: fs15, sep: [] });
+              map.items.push({ start, key: fs16, sep: [] });
               this.onKeyLine = true;
             } else if (it.sep) {
-              this.stack.push(fs15);
+              this.stack.push(fs16);
             } else {
-              Object.assign(it, { key: fs15, sep: [] });
+              Object.assign(it, { key: fs16, 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 fs15 = this.flowScalar(this.type);
+            const fs16 = this.flowScalar(this.type);
             if (!it || it.value)
-              fc.items.push({ start: [], key: fs15, sep: [] });
+              fc.items.push({ start: [], key: fs16, sep: [] });
             else if (it.sep)
-              this.stack.push(fs15);
+              this.stack.push(fs16);
             else
-              Object.assign(it, { key: fs15, sep: [] });
+              Object.assign(it, { key: fs16, sep: [] });
             return;
           }
           case "flow-map-end":
@@ -7314,11 +7314,11 @@ function shouldStopByStuck(history, cfg) {
 async function withTimeout3(p, timeoutMs) {
   if (timeoutMs <= 0)
     return await p;
-  return await new Promise((resolve16, reject) => {
+  return await new Promise((resolve17, reject) => {
     const timer = setTimeout(() => reject(new Error(`timeout after ${timeoutMs}ms`)), timeoutMs);
     Promise.resolve(p).then((v) => {
       clearTimeout(timer);
-      resolve16(v);
+      resolve17(v);
     }, (err) => {
       clearTimeout(timer);
       reject(err);
@@ -10679,8 +10679,8 @@ class ApprovalStore {
 // lib/session-worktree.ts
 init_worktree_ops();
 import { execFile as execFile3 } from "node:child_process";
-import { promises as fs10 } from "node:fs";
-import * as path12 from "node:path";
+import { promises as fs11 } from "node:fs";
+import * as path13 from "node:path";
 
 // lib/file-lock.ts
 import { promises as fs8 } from "node:fs";
@@ -10796,25 +10796,120 @@ function sleep(ms) {
   return new Promise((resolve9) => setTimeout(resolve9, ms));
 }
 
-// lib/parent-map-store.ts
+// lib/merge-journal.ts
 import { promises as fs9 } from "node:fs";
 import * as path11 from "node:path";
+var MERGE_JOURNAL_VERSION = 1;
+var MERGE_PHASE_RANK = {
+  started: 1,
+  committed: 2,
+  cleaned: 3,
+  done: 4,
+  aborted: 0
+};
+function isCommittedOrLater(phase) {
+  return MERGE_PHASE_RANK[phase] >= MERGE_PHASE_RANK.committed;
+}
+function journalDir(mainRoot) {
+  return path11.join(runtimeDir(path11.resolve(mainRoot), { ensure: false }), "session-worktrees");
+}
+function mergeJournalPath(mainRoot) {
+  return path11.join(journalDir(mainRoot), "merge-journal.json");
+}
+function mergeJournalLockPath(mainRoot) {
+  return path11.join(journalDir(mainRoot), "merge-journal.lock");
+}
+async function readJournalFile(mainRoot) {
+  const file = mergeJournalPath(mainRoot);
+  try {
+    const raw = await fs9.readFile(file, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== MERGE_JOURNAL_VERSION || !Array.isArray(parsed.entries)) {
+      return { version: MERGE_JOURNAL_VERSION, entries: [] };
+    }
+    return parsed;
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT")
+      return { version: MERGE_JOURNAL_VERSION, entries: [] };
+    return { version: MERGE_JOURNAL_VERSION, entries: [] };
+  }
+}
+async function writeJournalFile(mainRoot, payload) {
+  const file = mergeJournalPath(mainRoot);
+  await fs9.mkdir(path11.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
+  await fs9.writeFile(tmp, JSON.stringify(payload, null, 2), "utf8");
+  await fs9.rename(tmp, file);
+}
+async function listMergeJournalEntries(mainRoot) {
+  const f = await readJournalFile(mainRoot);
+  return f.entries;
+}
+async function getMergeJournalEntry(mainRoot, sessionId) {
+  const f = await readJournalFile(mainRoot);
+  return f.entries.find((e) => e.sessionId === sessionId) ?? null;
+}
+async function recordMergeJournalPhase(mainRoot, input) {
+  const lockPath = mergeJournalLockPath(mainRoot);
+  await fs9.mkdir(path11.dirname(lockPath), { recursive: true });
+  await withFileLock(lockPath, async () => {
+    const f = await readJournalFile(mainRoot);
+    const now = new Date().toISOString();
+    const idx = f.entries.findIndex((e) => e.sessionId === input.sessionId);
+    if (idx < 0) {
+      const entry = {
+        sessionId: input.sessionId,
+        approvalSha: input.approvalSha,
+        phase: input.phase,
+        updatedAt: now,
+        ...input.mergedCommitSha ? { mergedCommitSha: input.mergedCommitSha } : {}
+      };
+      f.entries.push(entry);
+    } else {
+      const prev = f.entries[idx];
+      if (prev.approvalSha !== input.approvalSha) {
+        f.entries[idx] = {
+          sessionId: input.sessionId,
+          approvalSha: input.approvalSha,
+          phase: input.phase,
+          updatedAt: now,
+          ...input.mergedCommitSha ? { mergedCommitSha: input.mergedCommitSha } : {}
+        };
+      } else {
+        const mergedCommitSha = input.mergedCommitSha ?? prev.mergedCommitSha;
+        f.entries[idx] = {
+          sessionId: input.sessionId,
+          approvalSha: input.approvalSha,
+          phase: input.phase,
+          updatedAt: now,
+          ...mergedCommitSha ? { mergedCommitSha } : {}
+        };
+      }
+    }
+    await writeJournalFile(mainRoot, f);
+  });
+}
+
+// lib/parent-map-store.ts
+import { promises as fs10 } from "node:fs";
+import * as path12 from "node:path";
 var PARENT_MAP_VERSION = 1;
 var PARENT_MAP_LOCK_TIMEOUT_MS = 2000;
 var PARENT_MAP_MAX_ENTRIES = 256;
 function parentMapDir(mainRoot) {
-  return path11.join(runtimeDir(path11.resolve(mainRoot), { ensure: false }), "session-worktrees");
+  return path12.join(runtimeDir(path12.resolve(mainRoot), { ensure: false }), "session-worktrees");
 }
 function parentMapPath(mainRoot) {
-  return path11.join(parentMapDir(mainRoot), "parent-map.json");
+  return path12.join(parentMapDir(mainRoot), "parent-map.json");
 }
 function parentMapLockPath(mainRoot) {
-  return path11.join(parentMapDir(mainRoot), "parent-map.lock");
+  return path12.join(parentMapDir(mainRoot), "parent-map.lock");
 }
 async function readParentMapFile(mainRoot) {
   const file = parentMapPath(mainRoot);
   try {
-    const raw = await fs9.readFile(file, "utf8");
+    const raw = await fs10.readFile(file, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== PARENT_MAP_VERSION || !Array.isArray(parsed.entries)) {
       return { version: PARENT_MAP_VERSION, entries: [] };
@@ -10829,10 +10924,10 @@ async function readParentMapFile(mainRoot) {
 }
 async function writeParentMapFile(mainRoot, payload) {
   const file = parentMapPath(mainRoot);
-  await fs9.mkdir(path11.dirname(file), { recursive: true });
+  await fs10.mkdir(path12.dirname(file), { recursive: true });
   const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
-  await fs9.writeFile(tmp, JSON.stringify(payload, null, 2), "utf8");
-  await fs9.rename(tmp, file);
+  await fs10.writeFile(tmp, JSON.stringify(payload, null, 2), "utf8");
+  await fs10.rename(tmp, file);
 }
 function capEntriesByTsDesc(entries) {
   if (entries.length <= PARENT_MAP_MAX_ENTRIES)
@@ -10864,7 +10959,7 @@ async function loadParentMap(mainRoot) {
 }
 async function mutateParentMap(mainRoot, mutator, opts = {}) {
   const lockPath = parentMapLockPath(mainRoot);
-  await fs9.mkdir(path11.dirname(lockPath), { recursive: true });
+  await fs10.mkdir(path12.dirname(lockPath), { recursive: true });
   const lockOpts = {
     timeoutMs: opts.timeoutMs ?? PARENT_MAP_LOCK_TIMEOUT_MS,
     ...opts
@@ -10883,7 +10978,7 @@ async function appendParentEntry(mainRoot, childID, parentID, ts, opts = {}) {
   if (!childID || !parentID)
     return;
   const lockPath = parentMapLockPath(mainRoot);
-  await fs9.mkdir(path11.dirname(lockPath), { recursive: true });
+  await fs10.mkdir(path12.dirname(lockPath), { recursive: true });
   const lockOpts = {
     timeoutMs: opts.timeoutMs ?? PARENT_MAP_LOCK_TIMEOUT_MS,
     ...opts
@@ -11002,20 +11097,20 @@ function sweepExpiredSessionParents(now = Date.now()) {
 
 // lib/session-worktree.ts
 var REGISTRY_VERSION = 1;
-var DEFAULT_WORKTREE_SUBDIR = path12.join(".git", "codeforge-worktrees");
+var DEFAULT_WORKTREE_SUBDIR = path13.join(".git", "codeforge-worktrees");
 function debugLog(msg) {
   if (process.env["CODEFORGE_DEBUG"]) {
     console.debug(`[session-worktree] ${msg}`);
   }
 }
 function registryDir(mainRoot) {
-  return path12.join(runtimeDir(path12.resolve(mainRoot), { ensure: false }), "session-worktrees");
+  return path13.join(runtimeDir(path13.resolve(mainRoot), { ensure: false }), "session-worktrees");
 }
 function registryPath(mainRoot) {
-  return path12.join(registryDir(mainRoot), "registry.json");
+  return path13.join(registryDir(mainRoot), "registry.json");
 }
 function registryLockPath(mainRoot) {
-  return path12.join(registryDir(mainRoot), "registry.lock");
+  return path13.join(registryDir(mainRoot), "registry.lock");
 }
 
 class RegistryCorruptError extends Error {
@@ -11046,7 +11141,7 @@ async function readRegistryResult(mainRoot) {
   const file = registryPath(mainRoot);
   let raw;
   try {
-    raw = await fs10.readFile(file, "utf8");
+    raw = await fs11.readFile(file, "utf8");
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT")
@@ -11094,24 +11189,24 @@ async function readRegistry(mainRoot) {
 }
 async function writeRegistry(mainRoot, reg) {
   const file = registryPath(mainRoot);
-  await fs10.mkdir(path12.dirname(file), { recursive: true });
+  await fs11.mkdir(path13.dirname(file), { recursive: true });
   const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
-  await fs10.writeFile(tmp, JSON.stringify(reg, null, 2), "utf8");
-  await fs10.rename(tmp, file);
+  await fs11.writeFile(tmp, JSON.stringify(reg, null, 2), "utf8");
+  await fs11.rename(tmp, file);
 }
 async function backupCorruptRegistry(mainRoot) {
   const file = registryPath(mainRoot);
-  const dir = path12.dirname(file);
-  const base = path12.basename(file);
+  const dir = path13.dirname(file);
+  const base = path13.basename(file);
   try {
-    const names = await fs10.readdir(dir);
+    const names = await fs11.readdir(dir);
     const existing = names.find((n) => n.startsWith(`${base}.corrupt.`));
     if (existing)
-      return path12.join(dir, existing);
+      return path13.join(dir, existing);
   } catch {}
   const backup = `${file}.corrupt.${Date.now()}`;
   try {
-    await fs10.copyFile(file, backup);
+    await fs11.copyFile(file, backup);
     return backup;
   } catch {
     return;
@@ -11131,7 +11226,7 @@ async function loadRegistryForMutation(mainRoot) {
 }
 async function mutateRegistry(mainRoot, fn) {
   const lockPath = registryLockPath(mainRoot);
-  await fs10.mkdir(path12.dirname(lockPath), { recursive: true });
+  await fs11.mkdir(path13.dirname(lockPath), { recursive: true });
   return await withFileLock(lockPath, async () => {
     const reg = await loadRegistryForMutation(mainRoot);
     const result = await fn(reg);
@@ -11143,11 +11238,11 @@ async function bindSessionWorktree(opts) {
   if (!opts.sessionId || opts.sessionId.trim() === "") {
     throw new Error("bindSessionWorktree: sessionId 不能为空");
   }
-  const mainRoot = path12.resolve(opts.mainRoot);
+  const mainRoot = path13.resolve(opts.mainRoot);
   const branch = opts.branchName ?? `codeforge/session-${opts.sessionId}`;
-  const worktreesDir = opts.worktrees_dir ?? path12.join(mainRoot, DEFAULT_WORKTREE_SUBDIR);
+  const worktreesDir = opts.worktrees_dir ?? path13.join(mainRoot, DEFAULT_WORKTREE_SUBDIR);
   const lockPath = registryLockPath(mainRoot);
-  await fs10.mkdir(path12.dirname(lockPath), { recursive: true });
+  await fs11.mkdir(path13.dirname(lockPath), { recursive: true });
   return await withFileLock(lockPath, async () => {
     const reg = await loadRegistryForMutation(mainRoot);
     const existing = reg.entries.find((e) => e.sessionId === opts.sessionId);
@@ -11198,7 +11293,7 @@ async function registryHasEntries(mainRoot) {
 var OWNER_RESOLVE_MAX_DEPTH = 16;
 async function resolveWorktreeOwner(opts) {
   const sid = opts.sessionId;
-  const mainRoot = path12.resolve(opts.mainRoot);
+  const mainRoot = path13.resolve(opts.mainRoot);
   const snap = await readRegistryResult(mainRoot);
   if (snap.kind === "corrupt" || snap.kind === "version_too_new") {
     return {
@@ -11212,8 +11307,8 @@ async function resolveWorktreeOwner(opts) {
   const entries = snap.kind === "ok" ? snap.registry.entries : [];
   const activeById = (id) => entries.find((e) => e.sessionId === id && e.status === "active") ?? null;
   if (opts.worktreePath) {
-    const target = path12.resolve(opts.worktreePath);
-    const byPath = entries.find((e) => e.status === "active" && path12.resolve(e.worktreePath) === target);
+    const target = path13.resolve(opts.worktreePath);
+    const byPath = entries.find((e) => e.status === "active" && path13.resolve(e.worktreePath) === target);
     if (byPath) {
       return { ok: true, ownerSessionId: byPath.sessionId, entry: byPath, via: "worktree-path" };
     }
@@ -11257,7 +11352,7 @@ async function touchEntryUpdatedAt(opts) {
   });
 }
 async function mergeSessionBack(opts) {
-  const mainRoot = path12.resolve(opts.mainRoot);
+  const mainRoot = path13.resolve(opts.mainRoot);
   const entry = await getSessionWorktree(opts.sessionId, mainRoot);
   if (!entry) {
     throw new Error(`mergeSessionBack: session ${opts.sessionId} 没有绑定 worktree`);
@@ -11271,6 +11366,38 @@ async function mergeSessionBack(opts) {
   const wt = entry.worktreePath;
   const branch = entry.branch;
   const baseSha = entry.baseSha;
+  const approvalSha = (await runGit2(wt, ["rev-parse", "HEAD"])).trim();
+  {
+    const existing = await getMergeJournalEntry(mainRoot, opts.sessionId).catch(() => null);
+    let recoveredSha;
+    if (existing && existing.approvalSha === approvalSha && isCommittedOrLater(existing.phase) && existing.mergedCommitSha) {
+      recoveredSha = existing.mergedCommitSha;
+    } else {
+      const footerSha = await findMergeCommitBySession(mainRoot, opts.sessionId);
+      if (footerSha)
+        recoveredSha = footerSha;
+    }
+    if (recoveredSha) {
+      await finalizeMergeIdempotent({
+        mainRoot,
+        sessionId: opts.sessionId,
+        worktreePath: wt,
+        branch,
+        approvalSha,
+        mergedCommitSha: recoveredSha,
+        ...opts.planStore ? { planStore: opts.planStore } : {},
+        ...entry.requiredPlanId ? { requiredPlanId: entry.requiredPlanId } : {}
+      });
+      return { sha: recoveredSha, squashedCommits: [] };
+    }
+  }
+  await recordMergeJournalPhase(mainRoot, {
+    sessionId: opts.sessionId,
+    approvalSha,
+    phase: "started"
+  }).catch((err) => {
+    debugLog(`recordMergeJournalPhase(started) 失败 (${opts.sessionId}): ${err.message}`);
+  });
   const wtStatus = (await runGit2(wt, ["status", "--porcelain"])).trim();
   if (wtStatus.length > 0) {
     await runGit2(wt, ["add", "-A"]);
@@ -11310,11 +11437,27 @@ async function mergeSessionBack(opts) {
   } else {}
   const squashedRaw = await runGit2(wt, ["log", "--format=%s", `${baseSha}..HEAD`]);
   const squashedCommits = squashedRaw.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
-  const message = opts.commitMessage ?? buildMergeMessage(opts.sessionId, branch, baseSha, squashedCommits);
+  const message = opts.commitMessage ?? await buildMergeMessage({
+    sessionId: opts.sessionId,
+    branch,
+    baseSha,
+    squashed: squashedCommits,
+    ...opts.planStore ? { planStore: opts.planStore } : {},
+    ...entry.requiredPlanId ? { requiredPlanId: entry.requiredPlanId } : {},
+    ...opts.summary ? { summary: opts.summary } : {}
+  });
   await runGitWithEnv(mainRoot, ["commit", "-m", message], {
     SKIP_DEV_SYNC_CHECK: "1"
   });
   const newSha = (await runGit2(mainRoot, ["rev-parse", "HEAD"])).trim();
+  await recordMergeJournalPhase(mainRoot, {
+    sessionId: opts.sessionId,
+    approvalSha,
+    phase: "committed",
+    mergedCommitSha: newSha
+  }).catch((err) => {
+    debugLog(`recordMergeJournalPhase(committed) 失败 (${opts.sessionId}): ${err.message}`);
+  });
   try {
     await removeWorktree({ root: mainRoot, worktree_path: wt, force: true });
   } catch (err) {
@@ -11324,6 +11467,14 @@ async function mergeSessionBack(opts) {
     debugLog(`deleteBranchIfExists (merge) 非预期失败: ${err.message}`);
     return { deleted: false };
   });
+  await recordMergeJournalPhase(mainRoot, {
+    sessionId: opts.sessionId,
+    approvalSha,
+    phase: "cleaned",
+    mergedCommitSha: newSha
+  }).catch((err) => {
+    debugLog(`recordMergeJournalPhase(cleaned) 失败 (${opts.sessionId}): ${err.message}`);
+  });
   await mutateRegistry(mainRoot, (reg) => {
     const e = reg.entries.find((x) => x.sessionId === opts.sessionId);
     if (e) {
@@ -11331,6 +11482,14 @@ async function mergeSessionBack(opts) {
       e.updatedAt = new Date().toISOString();
     }
   });
+  await recordMergeJournalPhase(mainRoot, {
+    sessionId: opts.sessionId,
+    approvalSha,
+    phase: "done",
+    mergedCommitSha: newSha
+  }).catch((err) => {
+    debugLog(`recordMergeJournalPhase(done) 失败 (${opts.sessionId}): ${err.message}`);
+  });
   if (opts.planStore && entry.requiredPlanId) {
     await opts.planStore.markMerged(entry.requiredPlanId, opts.sessionId).catch((err) => {
       console.warn(`[session-worktree] planStore.markMerged(${entry.requiredPlanId}) 失败: ${err instanceof Error ? err.message : String(err)}`);
@@ -11338,8 +11497,162 @@ async function mergeSessionBack(opts) {
   }
   return { sha: newSha, squashedCommits };
 }
+async function findMergeCommitBySession(mainRoot, sessionId) {
+  try {
+    const out = await runGit2(path13.resolve(mainRoot), [
+      "log",
+      "-F",
+      `--grep=Codeforge-Session: ${sessionId}`,
+      "--format=%H",
+      "-n",
+      "1"
+    ]);
+    return out.trim().split(/\r?\n/)[0]?.trim() ?? "";
+  } catch {
+    return "";
+  }
+}
+async function finalizeMergeIdempotent(opts) {
+  const { mainRoot, sessionId, worktreePath, branch } = opts;
+  try {
+    await removeWorktree({ root: mainRoot, worktree_path: worktreePath, force: true });
+  } catch (err) {
+    debugLog(`finalizeMergeIdempotent removeWorktree 非预期失败 (${sessionId}): ${err.message}`);
+  }
+  await deleteBranchIfExists({ root: mainRoot, branch }).catch(() => ({ deleted: false }));
+  await recordMergeJournalPhase(mainRoot, {
+    sessionId,
+    approvalSha: opts.approvalSha,
+    phase: "cleaned",
+    mergedCommitSha: opts.mergedCommitSha
+  }).catch(() => {});
+  await mutateRegistry(mainRoot, (reg) => {
+    const e = reg.entries.find((x) => x.sessionId === sessionId);
+    if (e && e.status !== "merged") {
+      e.status = "merged";
+      e.updatedAt = new Date().toISOString();
+    }
+  });
+  await recordMergeJournalPhase(mainRoot, {
+    sessionId,
+    approvalSha: opts.approvalSha,
+    phase: "done",
+    mergedCommitSha: opts.mergedCommitSha
+  }).catch(() => {});
+  if (opts.planStore && opts.requiredPlanId) {
+    await opts.planStore.markMerged(opts.requiredPlanId, sessionId).catch((err) => {
+      console.warn(`[session-worktree] finalizeMergeIdempotent planStore.markMerged(${opts.requiredPlanId}) 失败: ${err instanceof Error ? err.message : String(err)}`);
+    });
+  }
+}
+async function reconcileInterruptedMerges(mainRoot, opts = {}) {
+  const resolved = path13.resolve(mainRoot);
+  const result = {
+    recoveredMerged: [],
+    rolledBack: [],
+    conflicts: []
+  };
+  const snap = await readRegistryResult(resolved);
+  if (snap.kind === "corrupt") {
+    result.registryUnreadable = { reason: "corrupt", detail: snap.reason, path: snap.path };
+    return result;
+  }
+  if (snap.kind === "version_too_new") {
+    result.registryUnreadable = {
+      reason: "version_too_new",
+      detail: `v${snap.foundVersion} > 支持 v${snap.supportedVersion}`,
+      path: snap.path
+    };
+    return result;
+  }
+  const entries = snap.kind === "ok" ? snap.registry.entries : [];
+  const journal = await listMergeJournalEntries(resolved).catch(() => []);
+  if (journal.length === 0)
+    return result;
+  const hasStaged = opts.hasStagedOverride ?? (async (root) => {
+    try {
+      await runGit2(root, ["diff", "--cached", "--quiet"]);
+      return false;
+    } catch {
+      return true;
+    }
+  });
+  for (const j of journal) {
+    if (j.phase === "done" || j.phase === "aborted")
+      continue;
+    const regEntry = entries.find((e) => e.sessionId === j.sessionId);
+    const footerSha = await findMergeCommitBySession(resolved, j.sessionId);
+    const footerHit = footerSha.length > 0;
+    const journalCommitted = isCommittedOrLater(j.phase);
+    const conflictA = journalCommitted && !footerHit;
+    const conflictB = !journalCommitted && footerHit;
+    const conflictC = journalCommitted && footerHit && !!j.mergedCommitSha && j.mergedCommitSha !== footerSha;
+    if (conflictA || conflictB || conflictC) {
+      result.conflicts.push({
+        sessionId: j.sessionId,
+        state: "D",
+        action: conflictA ? "journal=committed 但主仓无 merge commit（footer 未命中）→ 保守不动，需人工核查" : conflictB ? "journal=started 但主仓已有 merge commit（footer 命中）→ 保守不动，需人工核查" : "journal.mergedCommitSha 与主仓 footer sha 不一致 → 保守不动，需人工核查"
+      });
+      continue;
+    }
+    if (journalCommitted && footerHit) {
+      if (regEntry && regEntry.status === "merged") {
+        await recordMergeJournalPhase(resolved, {
+          sessionId: j.sessionId,
+          approvalSha: j.approvalSha,
+          phase: "done",
+          mergedCommitSha: footerSha
+        }).catch(() => {});
+        continue;
+      }
+      let worktreeExists = false;
+      if (regEntry?.worktreePath) {
+        try {
+          const st = await fs11.stat(regEntry.worktreePath);
+          worktreeExists = st.isDirectory();
+        } catch {
+          worktreeExists = false;
+        }
+      }
+      await finalizeMergeIdempotent({
+        mainRoot: resolved,
+        sessionId: j.sessionId,
+        worktreePath: regEntry?.worktreePath ?? "",
+        branch: regEntry?.branch ?? `codeforge/session-${j.sessionId}`,
+        approvalSha: j.approvalSha,
+        mergedCommitSha: footerSha
+      });
+      result.recoveredMerged.push({
+        sessionId: j.sessionId,
+        state: worktreeExists ? "A" : "B",
+        action: worktreeExists ? "主仓已有 merge commit，registry 未标 merged → 补标 merged + 清 worktree（绝不重 merge）" : "worktree 已删但 registry 未标 merged + journal committed → 仅补标 merged（绝不重 merge）"
+      });
+      continue;
+    }
+    if (!journalCommitted && !footerHit) {
+      const staged = await hasStaged(resolved);
+      if (staged) {
+        await runGit2(resolved, ["reset", "--hard", "HEAD"]).catch((err) => {
+          debugLog(`reconcileInterruptedMerges 态 C reset 失败 (${j.sessionId}): ${err.message}`);
+        });
+        await recordMergeJournalPhase(resolved, {
+          sessionId: j.sessionId,
+          approvalSha: j.approvalSha,
+          phase: "aborted"
+        }).catch(() => {});
+        result.rolledBack.push({
+          sessionId: j.sessionId,
+          state: "C",
+          action: "崩在 squash commit 之前，主仓有 staged → git reset --hard HEAD 还原（改动仍在 worktree 可重跑）"
+        });
+      }
+      continue;
+    }
+  }
+  return result;
+}
 async function discardSession(opts) {
-  const mainRoot = path12.resolve(opts.mainRoot);
+  const mainRoot = path13.resolve(opts.mainRoot);
   const entry = await getSessionWorktree(opts.sessionId, mainRoot);
   if (!entry) {
     return;
@@ -11390,8 +11703,34 @@ async function markInterruptedDirty(opts) {
   });
 }
 var SALVAGE_BRANCH_PREFIX = "codeforge/salvage/";
+var TRANSITIONAL_STALE_MS = 72 * 60 * 60000;
+async function markAbandoned(opts) {
+  return await mutateRegistry(opts.mainRoot, (reg) => {
+    const e = reg.entries.find((x) => x.sessionId === opts.sessionId);
+    if (!e)
+      return false;
+    if (e.status === "merged" || e.status === "discarded" || e.status === "abandoned") {
+      return false;
+    }
+    e.status = "abandoned";
+    e.updatedAt = new Date().toISOString();
+    return true;
+  });
+}
+async function createSalvageBranch(opts) {
+  const mainRoot = path13.resolve(opts.mainRoot);
+  const ts = new Date().toISOString().replace(/[-:.TZ]/g, "").slice(0, 14);
+  const branch = `${SALVAGE_BRANCH_PREFIX}${opts.sessionId}-${ts}`;
+  try {
+    await runGit2(mainRoot, ["branch", branch, opts.fromRef]);
+    return branch;
+  } catch (err) {
+    debugLog(`createSalvageBranch 失败 (session=${opts.sessionId}): ${err.message}`);
+    return null;
+  }
+}
 async function listSalvageBranches(mainRoot) {
-  const resolved = path12.resolve(mainRoot);
+  const resolved = path13.resolve(mainRoot);
   try {
     const out = await runGit2(resolved, [
       "for-each-ref",
@@ -11409,12 +11748,17 @@ async function listSalvageBranches(mainRoot) {
     return [];
   }
 }
-async function reconcileTransitionalEntries(mainRoot) {
-  const resolved = path12.resolve(mainRoot);
+async function reconcileTransitionalEntries(mainRoot, opts = {}) {
+  const resolved = path13.resolve(mainRoot);
+  const staleMs = opts.transitionalStaleMs ?? TRANSITIONAL_STALE_MS;
+  const now = opts.now ?? Date.now();
   const result = {
     cleanedCreating: [],
     finishedRemoving: [],
-    keptConservative: []
+    keptConservative: [],
+    staleSalvaged: [],
+    staleCleaned: [],
+    staleKept: []
   };
   const snap = await readRegistryResult(resolved);
   if (snap.kind === "corrupt") {
@@ -11433,17 +11777,40 @@ async function reconcileTransitionalEntries(mainRoot) {
   const hasTransitional = entries.some((e) => e.status === "creating" || e.status === "removing");
   if (!hasTransitional)
     return result;
+  const staleSnapshots = [];
   await mutateRegistry(resolved, async (reg) => {
     for (const entry of reg.entries) {
       if (entry.status !== "creating" && entry.status !== "removing")
         continue;
       let dirExists = true;
       try {
-        const st = await fs10.stat(entry.worktreePath);
+        const st = await fs11.stat(entry.worktreePath);
         dirExists = st.isDirectory();
       } catch {
         dirExists = false;
       }
+      const parsedAt = Date.parse(entry.updatedAt);
+      const isStale = Number.isFinite(parsedAt) && now - parsedAt > staleMs;
+      if (isStale && dirExists) {
+        staleSnapshots.push({
+          sessionId: entry.sessionId,
+          branch: entry.branch,
+          worktreePath: entry.worktreePath,
+          baseSha: entry.baseSha,
+          status: entry.status,
+          dirExists
+        });
+        continue;
+      }
+      if (isStale && !dirExists && entry.status === "removing") {
+        await deleteBranchIfExists({ root: resolved, branch: entry.branch }).catch(() => ({
+          deleted: false
+        }));
+        entry.status = "abandoned";
+        entry.updatedAt = new Date().toISOString();
+        result.staleCleaned.push(entry.sessionId);
+        continue;
+      }
       if (entry.status === "creating") {
         if (!dirExists) {
           entry.status = "discarded";
@@ -11482,15 +11849,88 @@ async function reconcileTransitionalEntries(mainRoot) {
       }
     }
   });
+  for (const snap2 of staleSnapshots) {
+    await reconcileOneStaleTransitional(resolved, snap2, result);
+  }
   return result;
 }
+var STALE_SALVAGE_CHECKPOINT_MSG = "[codeforge-checkpoint] stale-transitional-salvage";
+async function reconcileOneStaleTransitional(mainRoot, snap, result) {
+  let hasChanges;
+  if (!snap.baseSha) {
+    hasChanges = true;
+  } else {
+    const dirty = await isWorktreeDirty(snap.worktreePath);
+    if (dirty) {
+      hasChanges = true;
+    } else {
+      const head = await getCurrentWorktreeHead(snap.worktreePath);
+      hasChanges = head.length === 0 || head !== snap.baseSha;
+    }
+  }
+  if (!hasChanges) {
+    await markAbandoned({ sessionId: snap.sessionId, mainRoot });
+    try {
+      await removeWorktree({ root: mainRoot, worktree_path: snap.worktreePath, force: true });
+    } catch (err) {
+      debugLog(`stale 清理 worktree 失败 (${snap.sessionId}): ${err.message}`);
+    }
+    await deleteBranchIfExists({ root: mainRoot, branch: snap.branch }).catch(() => ({
+      deleted: false
+    }));
+    result.staleCleaned.push(snap.sessionId);
+    return;
+  }
+  let salvageOk = true;
+  try {
+    if (await isWorktreeDirty(snap.worktreePath)) {
+      await checkpointCommit({
+        worktreePath: snap.worktreePath,
+        message: STALE_SALVAGE_CHECKPOINT_MSG
+      });
+    }
+  } catch (err) {
+    debugLog(`stale checkpoint commit 失败 (${snap.sessionId}): ${err.message}`);
+    salvageOk = false;
+  }
+  let salvageBranch = null;
+  if (salvageOk) {
+    const head = await getCurrentWorktreeHead(snap.worktreePath);
+    if (head.length === 0) {
+      salvageOk = false;
+    } else {
+      salvageBranch = await createSalvageBranch({
+        mainRoot,
+        sessionId: snap.sessionId,
+        fromRef: head
+      });
+      if (!salvageBranch)
+        salvageOk = false;
+    }
+  }
+  if (!salvageOk) {
+    debugLog(`stale salvage 失败，保留 worktree 待重试 (${snap.sessionId})`);
+    result.staleKept.push(snap.sessionId);
+    return;
+  }
+  await markAbandoned({ sessionId: snap.sessionId, mainRoot });
+  try {
+    await removeWorktree({ root: mainRoot, worktree_path: snap.worktreePath, force: true });
+  } catch (err) {
+    debugLog(`stale salvage 后清理 worktree 失败 (${snap.sessionId}): ${err.message}`);
+  }
+  result.staleSalvaged.push(snap.sessionId);
+}
 function summarizeReconcileDigest(result, prune, maxList = 3) {
   const unreadable = result.registryUnreadable ?? prune?.registryUnreadable;
   if (unreadable) {
     const hint = unreadable.reason === "version_too_new" ? "版本过高，请升级 CodeForge 后再操作" : "文件损坏，已备份留痕，请检查后删除让系统重建";
     return `[codeforge] ⚠️ session 追踪文件不可读（${unreadable.reason}：${unreadable.detail}），本轮已跳过 worktree 清理（fail-closed，未删除任何 worktree）。${hint}。`;
   }
-  const totalReconcile = result.cleanedCreating.length + result.finishedRemoving.length + result.keptConservative.length;
+  const staleSalvaged = result.staleSalvaged?.length ?? 0;
+  const staleCleaned = result.staleCleaned?.length ?? 0;
+  const staleKept = result.staleKept?.length ?? 0;
+  const totalReconcile = result.cleanedCreating.length + result.finishedRemoving.length + result.keptConservative.length + staleSalvaged + staleCleaned + staleKept;
   const cleanedPrune = prune?.cleaned.length ?? 0;
   const failedPrune = prune?.failed.length ?? 0;
   if (totalReconcile === 0 && cleanedPrune === 0 && failedPrune === 0)
@@ -11505,6 +11945,12 @@ function summarizeReconcileDigest(result, prune, maxList = 3) {
   if (result.keptConservative.length > 0) {
     parts.push(`保守保留 ${result.keptConservative.length}`);
   }
+  if (staleSalvaged > 0)
+    parts.push(`超期留痕 ${staleSalvaged}`);
+  if (staleCleaned > 0)
+    parts.push(`超期清理 ${staleCleaned}`);
+  if (staleKept > 0)
+    parts.push(`超期保留 ${staleKept}`);
   if (cleanedPrune > 0)
     parts.push(`清理僵尸 worktree ${cleanedPrune}`);
   if (failedPrune > 0)
@@ -11512,6 +11958,8 @@ function summarizeReconcileDigest(result, prune, maxList = 3) {
   const sample = [
     ...result.cleanedCreating,
     ...result.finishedRemoving,
+    ...result.staleSalvaged ?? [],
+    ...result.staleCleaned ?? [],
     ...prune?.cleaned ?? []
   ];
   const uniq = [...new Set(sample)].slice(0, maxList);
@@ -11519,9 +11967,127 @@ function summarizeReconcileDigest(result, prune, maxList = 3) {
   const sampleStr = uniq.length > 0 ? `（${uniq.join(", ")}${more}）` : "";
   return `[codeforge] worktree 收敛：${parts.join("，")}${sampleStr}`;
 }
+function buildHealthDigest(input) {
+  const signals = [];
+  if (input.registry.kind === "corrupt") {
+    signals.push({
+      kind: "registry_corrupt",
+      count: 1,
+      nextStep: "session 追踪文件损坏，已备份留痕，请检查后删除让系统重建（这不代表 worktree 丢了）。"
+    });
+  } else if (input.registry.kind === "version_too_new") {
+    signals.push({
+      kind: "registry_version_too_new",
+      count: 1,
+      nextStep: "session 追踪文件版本过高，请运行 `bash install.sh --global` 升级 CodeForge 后再操作。"
+    });
+  }
+  const entries = input.registry.kind === "ok" ? input.registry.registry.entries : [];
+  const now = Date.now();
+  const staleCount = entries.filter((e) => {
+    if (e.status !== "creating" && e.status !== "removing")
+      return false;
+    const ts = Date.parse(e.updatedAt);
+    return Number.isFinite(ts) && now - ts > TRANSITIONAL_STALE_MS;
+  }).length;
+  if (staleCount > 0) {
+    signals.push({
+      kind: "transitional_stale",
+      count: staleCount,
+      nextStep: `${staleCount} 个 worktree 超期未收尾，重启 opencode 触发自动收尾，或用 /discard-session 放弃。`
+    });
+  }
+  const salvageCount = input.salvageBranches.length;
+  if (salvageCount > 0) {
+    signals.push({
+      kind: "abandoned_salvage",
+      count: salvageCount,
+      nextStep: `${salvageCount} 个放弃的改动已留痕，可用 \`git cherry-pick <ref>\` 找回，或忽略让系统稍后清理。`
+    });
+  }
+  if (input.pendingReviewCount > 0) {
+    signals.push({
+      kind: "pending_review",
+      count: input.pendingReviewCount,
+      nextStep: `${input.pendingReviewCount} 个 session 待审，先 /review 通过后再 /merge 合入。`
+    });
+  }
+  const laneConflictCount = input.laneConflictCount ?? 0;
+  if (laneConflictCount > 0) {
+    signals.push({
+      kind: "lane_conflict",
+      count: laneConflictCount,
+      nextStep: `${laneConflictCount} 路并行改动有冲突需人工解，用 session_merge action=status 查看详情。`
+    });
+  }
+  const awaitingCount = input.journal.filter((j) => isCommittedOrLater(j.phase) && j.phase !== "done").length;
+  if (awaitingCount > 0) {
+    signals.push({
+      kind: "awaiting_confirm",
+      count: awaitingCount,
+      nextStep: `${awaitingCount} 个合并已提交但未收尾，触发 GC 或重启 opencode 后会自动补完，无需手动干预。`
+    });
+  }
+  const ownerAliasCount = input.ownerAliasCount ?? 0;
+  if (ownerAliasCount > 0) {
+    signals.push({
+      kind: "owner_alias",
+      count: ownerAliasCount,
+      nextStep: `${ownerAliasCount} 个子 session 审批已归一到父 worktree，无需操作（信息性）。`,
+      informational: true
+    });
+  }
+  const rank = (s) => {
+    if (s.kind === "registry_corrupt" || s.kind === "registry_version_too_new")
+      return 0;
+    if (s.informational)
+      return 2;
+    return 1;
+  };
+  signals.sort((a, b) => rank(a) - rank(b));
+  const actionable = signals.filter((s) => !s.informational);
+  const hasIssues = actionable.length > 0;
+  let summary = "";
+  if (hasIssues) {
+    const head = actionable[0];
+    const rest = actionable.length - 1;
+    const restStr = rest > 0 ? ` 另有 ${rest} 类待处理（详见 session_merge status / codeforge doctor --runtime）。` : "";
+    summary = `[codeforge] worktree 健康：${head.nextStep}${restStr}`;
+  }
+  return { hasIssues, signals, summary };
+}
+async function collectHealthDigest(mainRoot) {
+  const resolved = path13.resolve(mainRoot);
+  const [registry, journal, salvageBranches] = await Promise.all([
+    readRegistryResult(resolved).catch(() => ({ kind: "missing" })),
+    listMergeJournalEntries(resolved).catch(() => []),
+    listSalvageBranches(resolved).catch(() => [])
+  ]);
+  const entries = registry.kind === "ok" ? registry.registry.entries : [];
+  const activeEntries = entries.filter((e) => e.status === "active");
+  let pendingReviewCount = 0;
+  if (activeEntries.length > 0) {
+    const store = ApprovalStore.forProject(resolved);
+    const checks = await Promise.all(activeEntries.map(async (e) => {
+      try {
+        const latest = await store.getLatest(`session:${e.sessionId}`);
+        return latest ? 0 : 1;
+      } catch {
+        return 0;
+      }
+    }));
+    pendingReviewCount = checks.reduce((a, b) => a + b, 0);
+  }
+  return buildHealthDigest({
+    registry,
+    journal,
+    salvageBranches,
+    pendingReviewCount
+  });
+}
 async function getCurrentWorktreeHead(worktreePath) {
   try {
-    return (await runGit2(path12.resolve(worktreePath), ["rev-parse", "HEAD"])).trim();
+    return (await runGit2(path13.resolve(worktreePath), ["rev-parse", "HEAD"])).trim();
   } catch {
     return "";
   }
@@ -11540,7 +12106,7 @@ async function checkpointCommit(opts) {
 }
 var CHECKPOINT_MESSAGE_PREFIX = "[codeforge-checkpoint] pre-lane-dispatch";
 async function checkpointSessionWorktree(opts) {
-  const mainRoot = path12.resolve(opts.mainRoot);
+  const mainRoot = path13.resolve(opts.mainRoot);
   await loadRegistryForMutation(mainRoot);
   const entry = await getSessionWorktree(opts.sessionId, mainRoot);
   if (!entry) {
@@ -11563,19 +12129,19 @@ async function checkpointSessionWorktree(opts) {
   return { sessionId: opts.sessionId, worktreePath: wt, committed: true, head };
 }
 function runGit2(cwd, args, timeoutMs = 1e4) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     execFile3("git", args, { cwd, timeout: timeoutMs, windowsHide: true, encoding: "utf8" }, (err, stdout, stderr) => {
       if (err) {
         reject(new Error(`git ${args.join(" ")} (cwd=${cwd}) 失败: ${stderr?.trim() || err.message}`));
         return;
       }
-      resolve11(stdout);
+      resolve12(stdout);
     });
   });
 }
 function runGitWithEnv(cwd, args, envOverrides, timeoutMs = 1e4) {
   const inheritedEnv = process["env"];
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     execFile3("git", args, {
       cwd,
       timeout: timeoutMs,
@@ -11587,7 +12153,7 @@ function runGitWithEnv(cwd, args, envOverrides, timeoutMs = 1e4) {
         reject(new Error(`git ${args.join(" ")} (cwd=${cwd}) 失败: ${stderr?.trim() || err.message}`));
         return;
       }
-      resolve11(stdout);
+      resolve12(stdout);
     });
   });
 }
@@ -11605,7 +12171,7 @@ async function getBuildScript(mainRoot) {
 async function shouldSkipDevOnce(mainRoot, stagedPaths, worktreePath) {
   let distMtimeSec;
   try {
-    const st = await fs10.stat(path12.join(mainRoot, "dist/index.js"));
+    const st = await fs11.stat(path13.join(mainRoot, "dist/index.js"));
     distMtimeSec = Math.floor(st.mtimeMs / 1000);
   } catch {
     return false;
@@ -11625,39 +12191,81 @@ async function shouldSkipDevOnce(mainRoot, stagedPaths, worktreePath) {
 async function statSourceMtime(rel, mainRoot, worktreePath) {
   if (worktreePath) {
     try {
-      const st = await fs10.stat(path12.join(worktreePath, rel));
+      const st = await fs11.stat(path13.join(worktreePath, rel));
       return Math.floor(st.mtimeMs / 1000);
     } catch {}
   }
   try {
-    const st = await fs10.stat(path12.join(mainRoot, rel));
+    const st = await fs11.stat(path13.join(mainRoot, rel));
     return Math.floor(st.mtimeMs / 1000);
   } catch {
     return null;
   }
 }
 function runCmd(cmd, args, cwd, timeoutMs = 300000) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     execFile3(cmd, args, { cwd, timeout: timeoutMs, windowsHide: true, encoding: "utf8" }, (err, stdout, stderr) => {
       if (err) {
         reject(new Error(`${cmd} ${args.join(" ")} (cwd=${cwd}) 失败: ${stderr?.trim() || err.message}`));
         return;
       }
-      resolve11(stdout);
+      resolve12(stdout);
     });
   });
 }
-function buildMergeMessage(sessionId, branch, baseSha, squashed) {
-  const subject = `session(${sessionId}): merge ${branch}`;
-  const body = squashed.length > 0 ? `
+var MERGE_MESSAGE_NOISE_PREFIXES = [
+  "[codeforge-checkpoint]",
+  "[checkpoint]",
+  "auto-commit before merge",
+  "chore(release)",
+  "merge-sync",
+  "sync-to-main",
+  "release sync"
+];
+function filterSquashedCommits(commits, noisePrefixes = MERGE_MESSAGE_NOISE_PREFIXES) {
+  const kept = [];
+  let dropped = 0;
+  for (const c of commits) {
+    const isNoise = noisePrefixes.some((p) => c.includes(p));
+    if (isNoise)
+      dropped++;
+    else
+      kept.push(c);
+  }
+  return { kept, dropped };
+}
+async function buildMergeMessage(args) {
+  const { sessionId, branch, baseSha, squashed } = args;
+  const sid8 = sessionId.slice(0, 8);
+  let subject;
+  if (args.planStore && args.requiredPlanId) {
+    try {
+      const planRead = await args.planStore.read(args.requiredPlanId);
+      const title = planRead?.entry.title?.trim();
+      if (title)
+        subject = `${title} (session ${sid8})`;
+    } catch {}
+  }
+  if (!subject) {
+    const summary = args.summary?.trim();
+    if (summary)
+      subject = `${summary} (session ${sid8})`;
+  }
+  if (!subject)
+    subject = `session(${sessionId}): merge ${branch}`;
+  const { kept, dropped } = filterSquashedCommits(squashed);
+  const body = kept.length > 0 ? `
 
 Squashed commits:
-${squashed.map((s) => `  - ${s}`).join(`
+${kept.map((s) => `  - ${s}`).join(`
 `)}` : "";
-  const footer = `
+  let footer = `
 
 Codeforge-Session: ${sessionId}
 Codeforge-Base: ${baseSha.slice(0, 12)}`;
+  if (dropped > 0)
+    footer += `
+Codeforge-Squash-Dropped: ${dropped}`;
   return subject + body + footer;
 }
 var ORPHAN_GRACE_MS = 60000;
@@ -11668,7 +12276,7 @@ async function pruneDiscardedRegistryEntries(mainRoot, opts = {}) {
   if (keepRecent < 0) {
     throw new Error(`pruneDiscardedRegistryEntries: keepRecent 必须 ≥ 0，收到 ${keepRecent}`);
   }
-  return await mutateRegistry(path12.resolve(mainRoot), (reg) => {
+  return await mutateRegistry(path13.resolve(mainRoot), (reg) => {
     const discarded = [];
     const others = [];
     for (const e of reg.entries) {
@@ -11685,7 +12293,7 @@ async function pruneDiscardedRegistryEntries(mainRoot, opts = {}) {
   });
 }
 async function pruneOrphanWorktrees(mainRoot, opts = {}) {
-  const resolved = path12.resolve(mainRoot);
+  const resolved = path13.resolve(mainRoot);
   const cleaned = [];
   const failed = [];
   let skipped = 0;
@@ -11710,7 +12318,7 @@ async function pruneOrphanWorktrees(mainRoot, opts = {}) {
   } catch {
     gitWorktrees = [];
   }
-  const gitWorktreePaths = new Set(gitWorktrees.map((w) => path12.resolve(w.path)));
+  const gitWorktreePaths = new Set(gitWorktrees.map((w) => path13.resolve(w.path)));
   await mutateRegistry(resolved, async (reg2) => {
     const now = Date.now();
     for (const entry of reg2.entries) {
@@ -11720,7 +12328,7 @@ async function pruneOrphanWorktrees(mainRoot, opts = {}) {
       let dirExists = true;
       let dirMtimeMs = 0;
       try {
-        const st = await fs10.stat(wt);
+        const st = await fs11.stat(wt);
         dirExists = st.isDirectory();
         dirMtimeMs = st.mtimeMs;
       } catch {
@@ -11813,12 +12421,12 @@ async function pruneOrphanWorktrees(mainRoot, opts = {}) {
       }
     });
   }
-  const codeforgeWorktreeRoot = path12.resolve(path12.join(resolved, DEFAULT_WORKTREE_SUBDIR));
+  const codeforgeWorktreeRoot = path13.resolve(path13.join(resolved, DEFAULT_WORKTREE_SUBDIR));
   const fsWorktreePaths = [];
   try {
-    const names = await fs10.readdir(codeforgeWorktreeRoot);
+    const names = await fs11.readdir(codeforgeWorktreeRoot);
     for (const name of names) {
-      fsWorktreePaths.push(path12.resolve(path12.join(codeforgeWorktreeRoot, name)));
+      fsWorktreePaths.push(path13.resolve(path13.join(codeforgeWorktreeRoot, name)));
     }
   } catch {}
   const candidatePaths = new Set([
@@ -11826,16 +12434,16 @@ async function pruneOrphanWorktrees(mainRoot, opts = {}) {
     ...fsWorktreePaths
   ]);
   const reg = await readRegistry(resolved);
-  const knownPaths = new Set(reg.entries.map((e) => path12.resolve(e.worktreePath)));
+  const knownPaths = new Set(reg.entries.map((e) => path13.resolve(e.worktreePath)));
   for (const candidate of candidatePaths) {
     if (knownPaths.has(candidate))
       continue;
-    if (candidate !== codeforgeWorktreeRoot && !candidate.startsWith(codeforgeWorktreeRoot + path12.sep)) {
+    if (candidate !== codeforgeWorktreeRoot && !candidate.startsWith(codeforgeWorktreeRoot + path13.sep)) {
       continue;
     }
     let dirExists = true;
     try {
-      const st = await fs10.stat(candidate);
+      const st = await fs11.stat(candidate);
       if (Date.now() - st.mtimeMs < ORPHAN_GRACE_MS) {
         skipped++;
         continue;
@@ -11857,14 +12465,14 @@ async function pruneOrphanWorktrees(mainRoot, opts = {}) {
     }
     if (removed) {
       try {
-        await fs10.stat(candidate);
+        await fs11.stat(candidate);
         removed = false;
         lastError = lastError ?? "git worktree remove 返回成功但目录仍存在（C 类 fs-only orphan）";
       } catch {}
     }
     if (!removed && dirExists) {
       try {
-        await fs10.rm(candidate, { recursive: true, force: true });
+        await fs11.rm(candidate, { recursive: true, force: true });
         removed = true;
       } catch (err) {
         lastError = `git remove 失败: ${lastError}; fs.rm 也失败: ${err instanceof Error ? err.message : String(err)}`;
@@ -12040,7 +12648,7 @@ async function execute4(input) {
 import { z as z5 } from "zod";
 
 // lib/browser-control.ts
-import * as path13 from "node:path";
+import * as path14 from "node:path";
 var DEFAULT_CONFIG2 = {
   enabled: false,
   headless: true,
@@ -12052,7 +12660,7 @@ var DEFAULT_CONFIG2 = {
   bufferLimit: 500
 };
 function defaultScreenshotDir(root = process.cwd()) {
-  return path13.join(runtimeDir(root), "browser", "screenshots");
+  return path14.join(runtimeDir(root), "browser", "screenshots");
 }
 function checkUrl(url, cfg = DEFAULT_CONFIG2) {
   if (typeof url !== "string" || url.trim() === "") {
@@ -12177,14 +12785,14 @@ async function tryCreatePlaywrightController(cfg = DEFAULT_CONFIG2, resolver = d
     async screenshot(opts) {
       try {
         const dir = cfg.screenshotDir && cfg.screenshotDir.trim().length > 0 ? cfg.screenshotDir : defaultScreenshotDir();
-        const path14 = `${dir}/${Date.now()}.png`;
+        const path15 = `${dir}/${Date.now()}.png`;
         if (opts?.selector) {
           const el = await page.locator(opts.selector).first();
-          await el.screenshot({ path: path14 });
+          await el.screenshot({ path: path15 });
         } else {
-          await page.screenshot({ path: path14, fullPage: opts?.fullPage });
+          await page.screenshot({ path: path15, fullPage: opts?.fullPage });
         }
-        return { ok: true, path: path14 };
+        return { ok: true, path: path15 };
       } catch (err) {
         return { ok: false, error: describe3(err) };
       }
@@ -12501,8 +13109,8 @@ async function execute10(input) {
 import { z as z11 } from "zod";
 
 // lib/model-config.ts
-import { promises as fs11 } from "node:fs";
-import * as path14 from "node:path";
+import { promises as fs12 } from "node:fs";
+import * as path15 from "node:path";
 
 // lib/model-tier.ts
 var TIER_ORDER = ["quick", "balanced", "deep", "ultra"];
@@ -12519,12 +13127,12 @@ var PROVIDER_MODEL_RE = /^[a-z0-9-]+\/[a-zA-Z0-9._-]+$/;
 function findConfigFileSync(opts = {}) {
   const root = opts.root ?? process.cwd();
   const fsSync = __require("node:fs");
-  const abs = path14.resolve(root, opts.file ?? CONFIG_FILE);
+  const abs = path15.resolve(root, opts.file ?? CONFIG_FILE);
   return fsSync.existsSync(abs) ? abs : null;
 }
 function loadModelConfigSync(opts = {}) {
   const root = opts.root ?? process.cwd();
-  const abs = path14.resolve(root, opts.file ?? CONFIG_FILE);
+  const abs = path15.resolve(root, opts.file ?? CONFIG_FILE);
   const fsSync = __require("node:fs");
   if (!fsSync.existsSync(abs)) {
     return { ok: false, warnings: [], error: `config_not_found: ${abs}` };
@@ -12539,10 +13147,10 @@ function loadModelConfigSync(opts = {}) {
 }
 async function loadModelConfig(opts = {}) {
   const root = opts.root ?? process.cwd();
-  const abs = path14.resolve(root, opts.file ?? CONFIG_FILE);
+  const abs = path15.resolve(root, opts.file ?? CONFIG_FILE);
   let raw;
   try {
-    raw = await fs11.readFile(abs, "utf8");
+    raw = await fs12.readFile(abs, "utf8");
   } catch (e) {
     const code = e.code;
     if (code === "ENOENT") {
@@ -13016,8 +13624,8 @@ function toEntry(r) {
 import { z as z12 } from "zod";
 
 // lib/merge-gate.ts
-import { promises as fs12 } from "node:fs";
-import * as path15 from "node:path";
+import { promises as fs13 } from "node:fs";
+import * as path16 from "node:path";
 var DEFAULT_MERGE_GATE_CONFIG = {
   enabled: true,
   approvalPreCheck: true,
@@ -13025,10 +13633,10 @@ var DEFAULT_MERGE_GATE_CONFIG = {
 };
 var CONFIG_REL = ".codeforge/merge-gate.json";
 async function loadMergeGate(mainRoot) {
-  const file = path15.join(mainRoot, CONFIG_REL);
+  const file = path16.join(mainRoot, CONFIG_REL);
   let raw;
   try {
-    raw = await fs12.readFile(file, "utf8");
+    raw = await fs13.readFile(file, "utf8");
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT")
@@ -13130,7 +13738,8 @@ 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
+        mainRoot: opts.mainRoot,
+        ...opts.summary ? { summary: opts.summary } : {}
       });
       return {
         status: "skipped_by_approval",
@@ -13222,7 +13831,8 @@ async function runMergeLoop(opts) {
       }
       const { sha } = await mergeSessionBack({
         sessionId: opts.sessionId,
-        mainRoot: opts.mainRoot
+        mainRoot: opts.mainRoot,
+        ...opts.summary ? { summary: opts.summary } : {}
       });
       return {
         status: "merged",
@@ -13443,7 +14053,7 @@ function isAbortError(err) {
   return err instanceof Error && err.name === "AbortError";
 }
 function withTimeout2(p, ms, label, signal, hbOpts) {
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     const startedAt = Date.now();
     let hbTimer = null;
     let timer;
@@ -13483,7 +14093,7 @@ function withTimeout2(p, ms, label, signal, hbOpts) {
     }
     p.then((v) => {
       cleanup();
-      resolve12(v);
+      resolve13(v);
     }, (e) => {
       cleanup();
       reject(e);
@@ -13512,7 +14122,8 @@ var ArgsSchema12 = z12.discriminatedUnion("action", [
     action: z12.literal("merge"),
     session_id: z12.string().optional().describe("默认当前 session"),
     plan_id: PlanIdSchema,
-    force: z12.boolean().optional().describe("跳过 review 直接 squash merge（写审计）")
+    force: z12.boolean().optional().describe("跳过 review 直接 squash merge（写审计）"),
+    summary: z12.string().optional().describe("merge commit subject 兜底摘要（plan title 缺失时用）")
   }),
   z12.object({
     action: z12.literal("status"),
@@ -13534,9 +14145,10 @@ var ArgsSchema12 = z12.discriminatedUnion("action", [
   })
 ]);
 async function buildStatusSummary(entry, mainRoot) {
-  const [salvageBranches, allEntries] = await Promise.all([
+  const [salvageBranches, allEntries, health] = await Promise.all([
     listSalvageBranches(mainRoot).catch(() => []),
-    listEntries(mainRoot).catch(() => [])
+    listEntries(mainRoot).catch(() => []),
+    collectHealthDigest(mainRoot).catch(() => null)
   ]);
   const abandonedCount = allEntries.filter((e) => e.status === "abandoned").length;
   const pendingCount = allEntries.filter((e) => e.status === "interrupted_dirty" || e.status === "creating" || e.status === "removing").length;
@@ -13564,6 +14176,11 @@ async function buildStatusSummary(entry, mainRoot) {
     default:
       nextStep = "未知状态，保守不处理；如有疑问请人工检查 worktree。";
   }
+  const healthDigest = health && health.hasIssues ? health : null;
+  if (healthDigest && healthDigest.summary) {
+    nextStep = `${nextStep}
+${healthDigest.summary}`;
+  }
   return {
     worktreePath: entry.worktreePath,
     status: entry.status,
@@ -13571,7 +14188,8 @@ async function buildStatusSummary(entry, mainRoot) {
     salvageBranches,
     abandonedCount,
     pendingCount,
-    nextStep
+    nextStep,
+    health: healthDigest
   };
 }
 var _ctx = {};
@@ -13748,6 +14366,7 @@ async function execute12(input) {
       mainRoot,
       ...mergeArgs.plan_id ? { planId: mergeArgs.plan_id } : {},
       ...mergeArgs.force ? { force: true } : {},
+      ...mergeArgs.summary ? { summary: mergeArgs.summary } : {},
       spawner: _ctx.spawner,
       ...sendProgress ? {
         onProgress: (state, detail) => {
@@ -13768,8 +14387,8 @@ async function execute12(input) {
 import { z as z13 } from "zod";
 
 // lib/plan-store.ts
-import { promises as fs13 } from "node:fs";
-import * as path16 from "node:path";
+import { promises as fs14 } from "node:fs";
+import * as path17 from "node:path";
 var INDEX_VERSION = 1;
 
 class PlanStore {
@@ -13778,8 +14397,8 @@ class PlanStore {
   now;
   secondCounters = new Map;
   constructor(opts = {}) {
-    this.root = path16.resolve(opts.root ?? process.cwd());
-    this.base = opts.base ? path16.resolve(opts.base) : plansDir(this.root);
+    this.root = path17.resolve(opts.root ?? process.cwd());
+    this.base = opts.base ? path17.resolve(opts.base) : plansDir(this.root);
     this.now = opts.now ?? (() => new Date);
   }
   async write(input) {
@@ -13789,14 +14408,14 @@ class PlanStore {
     if (typeof input.content !== "string" || input.content.length === 0) {
       throw new Error("PlanStore.write: content 不能为空");
     }
-    await fs13.mkdir(this.base, { recursive: true });
+    await fs14.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 = path16.join(this.base, filename);
+      const absFile = path17.join(this.base, filename);
       await this.atomicWriteFile(absFile, input.content);
       const entry = {
         plan_id: planId,
@@ -13820,9 +14439,9 @@ class PlanStore {
     const entry = index.entries.find((e) => e.plan_id === planId);
     if (!entry)
       return null;
-    const abs = path16.join(this.base, entry.path);
+    const abs = path17.join(this.base, entry.path);
     try {
-      const content = await fs13.readFile(abs, "utf8");
+      const content = await fs14.readFile(abs, "utf8");
       return { entry, content };
     } catch (err) {
       const e = err;
@@ -13881,7 +14500,7 @@ class PlanStore {
         else if (e.status === "orphan")
           shouldDelete = true;
         if (shouldDelete) {
-          await fs13.rm(path16.join(this.base, e.path), { force: true }).catch(() => {});
+          await fs14.rm(path17.join(this.base, e.path), { force: true }).catch(() => {});
           removed++;
         } else {
           keep.push(e);
@@ -13903,9 +14522,9 @@ class PlanStore {
         knownPaths.add(e.path);
         if (e.status !== "active")
           continue;
-        const abs = path16.join(this.base, e.path);
+        const abs = path17.join(this.base, e.path);
         try {
-          await fs13.stat(abs);
+          await fs14.stat(abs);
         } catch {
           e.status = "orphan";
           markedOrphan++;
@@ -13915,23 +14534,23 @@ class PlanStore {
         await this.writeIndexLocked(index);
       let unindexedFiles = [];
       try {
-        const all = await fs13.readdir(this.base);
+        const all = await fs14.readdir(this.base);
         unindexedFiles = all.filter((f) => f.endsWith(".md")).filter((f) => !knownPaths.has(f));
       } catch {}
       return { markedOrphan, unindexedFiles };
     });
   }
   indexPath() {
-    return path16.join(this.base, "index.json");
+    return path17.join(this.base, "index.json");
   }
   lockPath() {
-    return path16.join(this.base, "index.lock");
+    return path17.join(this.base, "index.lock");
   }
   async readIndexLocked() {
     const file = this.indexPath();
     let raw;
     try {
-      raw = await fs13.readFile(file, "utf8");
+      raw = await fs14.readFile(file, "utf8");
     } catch (err) {
       const e = err;
       if (e.code === "ENOENT")
@@ -13953,7 +14572,7 @@ class PlanStore {
   async archiveCorruptIndex(file) {
     const ts = this.now().toISOString().replace(/[-:.TZ]/g, "").slice(0, 14);
     const dst = `${file}.corrupt-${ts}`;
-    await fs13.rename(file, dst).catch(() => {});
+    await fs14.rename(file, dst).catch(() => {});
   }
   async readIndex() {
     return this.readIndexLocked();
@@ -13998,15 +14617,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 = path16.basename(sample, ".md");
+    const base = path17.basename(sample, ".md");
     const slug = base.replace(/^\d{8}-\d{6}-?/, "") || "untitled";
     return `${tsPart}-${nnn}-${slug}.md`;
   }
   async atomicWriteFile(file, data) {
-    await fs13.mkdir(path16.dirname(file), { recursive: true });
+    await fs14.mkdir(path17.dirname(file), { recursive: true });
     const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
-    await fs13.writeFile(tmp, data, "utf8");
-    await fs13.rename(tmp, file);
+    await fs14.writeFile(tmp, data, "utf8");
+    await fs14.rename(tmp, file);
   }
 }
 function formatTimestamp(d) {
@@ -14069,8 +14688,8 @@ async function execute13(input) {
   }
 }
 // tools/plan-read.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";
 import { z as z14 } from "zod";
 var description14 = [
   "读取方案文档内容，支持按 plan_id 或绝对路径查询。",
@@ -14176,9 +14795,9 @@ async function execute14(input) {
       };
     }
   }
-  const abs = path17.resolve(args.path);
+  const abs = path18.resolve(args.path);
   try {
-    const content = await fs14.readFile(abs, "utf8");
+    const content = await fs15.readFile(abs, "utf8");
     return {
       ok: true,
       content,
@@ -14203,16 +14822,16 @@ import { z as z15 } from "zod";
 // lib/adr-init.ts
 import { spawnSync } from "node:child_process";
 import { existsSync as existsSync4, promises as fsp } from "node:fs";
-import * as path18 from "node:path";
+import * as path19 from "node:path";
 import * as url from "node:url";
 function resolveAssetsRoot() {
-  const here = path18.dirname(url.fileURLToPath(import.meta.url));
+  const here = path19.dirname(url.fileURLToPath(import.meta.url));
   let dir = here;
   for (let i = 0;i < 6; i++) {
-    if (existsSync4(path18.join(dir, "package.json")) && existsSync4(path18.join(dir, "assets", "adr-init"))) {
-      return path18.join(dir, "assets", "adr-init");
+    if (existsSync4(path19.join(dir, "package.json")) && existsSync4(path19.join(dir, "assets", "adr-init"))) {
+      return path19.join(dir, "assets", "adr-init");
     }
-    const parent = path18.dirname(dir);
+    const parent = path19.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -14220,13 +14839,13 @@ function resolveAssetsRoot() {
   const xdgConfig = process.env["XDG_CONFIG_HOME"];
   const homeDir = process.env["HOME"] ?? process.env["USERPROFILE"] ?? "";
   const fallbackRoots = [
-    xdgConfig ? path18.join(xdgConfig, "opencode") : null,
-    path18.join(homeDir, ".config", "opencode"),
-    process.env["APPDATA"] ? path18.join(process.env["APPDATA"], "opencode") : null,
-    process.env["LOCALAPPDATA"] ? path18.join(process.env["LOCALAPPDATA"], "opencode") : null
+    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
   ].filter(Boolean);
   for (const root of fallbackRoots) {
-    const candidate = path18.join(root, "assets", "adr-init");
+    const candidate = path19.join(root, "assets", "adr-init");
     if (existsSync4(candidate)) {
       return candidate;
     }
@@ -14263,7 +14882,7 @@ function runGitConfigHooksPath(cwd) {
   }
 }
 async function runAdrInit(opts = {}) {
-  const cwd = path18.resolve(opts.cwd ?? process.cwd());
+  const cwd = path19.resolve(opts.cwd ?? process.cwd());
   const force = !!opts.force;
   const dryRun = !!opts.dryRun;
   const writePrepare = !!opts.writePrepare;
@@ -14312,8 +14931,8 @@ async function runAdrInit(opts = {}) {
     });
   }
   for (const item of plan) {
-    const srcAbs = path18.join(assetsRoot, item.src);
-    const dstAbs = path18.join(cwd, item.dst);
+    const srcAbs = path19.join(assetsRoot, item.src);
+    const dstAbs = path19.join(cwd, item.dst);
     if (!existsSync4(srcAbs)) {
       result.warnings.push(`资产缺失：${item.src}（跳过 ${item.dst}）`);
       continue;
@@ -14326,7 +14945,7 @@ async function runAdrInit(opts = {}) {
       const bakRel = `${item.dst}.bak.${ts}`;
       if (!dryRun) {
         try {
-          await fsp.copyFile(dstAbs, path18.join(cwd, bakRel));
+          await fsp.copyFile(dstAbs, path19.join(cwd, bakRel));
         } catch (e) {
           result.ok = false;
           result.reason = "io_error";
@@ -14338,7 +14957,7 @@ async function runAdrInit(opts = {}) {
     }
     if (!dryRun) {
       try {
-        await fsp.mkdir(path18.dirname(dstAbs), { recursive: true });
+        await fsp.mkdir(path19.dirname(dstAbs), { recursive: true });
         await fsp.copyFile(srcAbs, dstAbs);
         if (item.chmod !== undefined) {
           try {
@@ -14368,7 +14987,7 @@ async function runAdrInit(opts = {}) {
   } else {
     result.suggestions.push("[dry-run] 将运行：git config core.hooksPath .githooks");
   }
-  const pkgPath = path18.join(cwd, "package.json");
+  const pkgPath = path19.join(cwd, "package.json");
   const isNpm = existsSync4(pkgPath);
   if (isNpm) {
     if (writePrepare) {
@@ -14383,7 +15002,7 @@ async function runAdrInit(opts = {}) {
           const bakRel = `package.json.bak.${ts}`;
           if (!dryRun) {
             try {
-              await fsp.copyFile(pkgPath, path18.join(cwd, bakRel));
+              await fsp.copyFile(pkgPath, path19.join(cwd, bakRel));
             } catch (e) {
               result.warnings.push(`备份 package.json 失败：${e instanceof Error ? e.message : String(e)}`);
             }
@@ -14506,12 +15125,12 @@ async function execute15(input) {
 import { z as z16 } from "zod";
 
 // lib/opencode-session-probe.ts
-import * as path19 from "node:path";
+import * as path20 from "node:path";
 import * as os5 from "node:os";
 import { createRequire as createRequire2 } from "node:module";
 var requireFromHere = createRequire2(import.meta.url);
 var DEFAULT_LIVENESS_MS = 6 * 60 * 60000;
-var DEFAULT_DB_PATH = path19.join(os5.homedir(), ".local/share/opencode/opencode.db");
+var DEFAULT_DB_PATH = path20.join(os5.homedir(), ".local/share/opencode/opencode.db");
 function createSessionProbe(opts = {}) {
   const dbPath = opts.dbPath ?? DEFAULT_DB_PATH;
   const httpBaseUrl = opts.httpBaseUrl ?? process.env["OPENCODE_SERVER_URL"];
@@ -14611,11 +15230,13 @@ var description16 = [
   "**模式**：",
   "- 默认（保守）：沿用自动 GC 的时间护栏（6h/72h），只清确凿僵尸",
   "- force=true（高风险）：时间护栏归零，连 probe 判 unknown 的也立即清，可能误删活跃 session 的 worktree",
+  "- dryRun=true：不实际清理，先返回当前 worktree 健康摘要（让用户在执行前看到影响）",
   "**何时不需要**：自动 30min interval 正常跑时无需手动调。"
 ].join(`
 `);
 var ArgsSchema16 = z16.object({
-  force: z16.boolean().optional().describe("高风险：时间护栏归零，连 probe unknown 的 worktree 也立即清，可能误删活跃 session worktree。默认 false（保守）")
+  force: z16.boolean().optional().describe("高风险：时间护栏归零，连 probe unknown 的 worktree 也立即清，可能误删活跃 session worktree。默认 false（保守）"),
+  dryRun: z16.boolean().optional().describe("true=只预览不清理：返回当前 worktree 健康摘要（健康度信号 + 下一步提示），让用户执行 gc 前看到影响")
 });
 var _ctx3 = {};
 function __setContext3(ctx) {
@@ -14633,6 +15254,15 @@ async function execute16(input) {
     };
   }
   const force = parsed.data.force === true;
+  const dryRun = parsed.data.dryRun === true;
+  if (dryRun) {
+    try {
+      const health = await collectHealthDigest(getMainRoot2());
+      return { ok: true, mode: "dry-run", health };
+    } catch (err) {
+      return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
   const probe = createSessionProbe();
   try {
     const result = await pruneOrphanWorktrees(getMainRoot2(), {
@@ -14856,7 +15486,7 @@ async function raceAbortTimeout(p, signal, timeoutMs, label) {
     e.name = "AbortError";
     throw e;
   }
-  return await new Promise((resolve15, reject) => {
+  return await new Promise((resolve16, reject) => {
     let settled = false;
     const timer = setTimeout(() => {
       if (settled)
@@ -14881,7 +15511,7 @@ async function raceAbortTimeout(p, signal, timeoutMs, label) {
       settled = true;
       clearTimeout(timer);
       signal?.removeEventListener("abort", onAbort);
-      resolve15(v);
+      resolve16(v);
     }, (e) => {
       if (settled)
         return;
@@ -15716,7 +16346,7 @@ var handler7 = codeforgeToolsServer;
 
 // plugins/discover-spec-suggest.ts
 import { readFileSync as readFileSync3, readdirSync, statSync as statSync2 } from "node:fs";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 
 // lib/handoff-schema.ts
 import { z as z18 } from "zod";
@@ -15883,9 +16513,9 @@ function validateHandoff(rawYaml, fileSize) {
   const result = HandoffSchema.safeParse(parsed);
   if (!result.success) {
     const first = result.error.issues[0];
-    const path20 = first?.path?.join(".") ?? "(root)";
+    const path21 = first?.path?.join(".") ?? "(root)";
     const msg = first?.message ?? "unknown";
-    return { ok: false, reason: `schema 校验失败：${path20}: ${msg}` };
+    return { ok: false, reason: `schema 校验失败：${path21}: ${msg}` };
   }
   return { ok: true, data: result.data, schemaVersion: result.data.schema_version };
 }
@@ -15902,7 +16532,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 = join17("docs", "specs");
+var SPECS_REL_DIR = join18("docs", "specs");
 var sessionMap = new Map;
 function pruneIfOversize2() {
   while (sessionMap.size > SESSION_CAP2) {
@@ -16009,7 +16639,7 @@ function loadSpecs(rootDir, opts = {}) {
   const dirExists = opts.dirExists ?? defaultDirExists;
   const statReader = opts.statReader ?? defaultStatReader;
   const log6 = makePluginLogger(PLUGIN_NAME8);
-  const specsRoot = join17(rootDir, SPECS_REL_DIR);
+  const specsRoot = join18(rootDir, SPECS_REL_DIR);
   const records = [];
   if (!dirExists(specsRoot)) {
     log6.info(`specs 目录不存在，plugin 将 no-op`, { specsRoot });
@@ -16030,7 +16660,7 @@ function loadSpecs(rootDir, opts = {}) {
       log6.info(`跳过非合法 slug 命名的条目`, { entry });
       continue;
     }
-    const specDir = join17(specsRoot, entry);
+    const specDir = join18(specsRoot, entry);
     let dirStat;
     try {
       dirStat = statReader(specDir);
@@ -16043,7 +16673,7 @@ function loadSpecs(rootDir, opts = {}) {
     }
     if (!dirStat.isDirectory)
       continue;
-    const handoffPath = join17(specDir, "handoff.yaml");
+    const handoffPath = join18(specDir, "handoff.yaml");
     let fileStat;
     try {
       fileStat = statReader(handoffPath);
@@ -16215,14 +16845,14 @@ var discoverSpecSuggestServer = async (ctx) => {
 var handler8 = discoverSpecSuggestServer;
 
 // lib/memories.ts
-import { promises as fs15 } from "node:fs";
-import * as path20 from "node:path";
+import { promises as fs16 } from "node:fs";
+import * as path21 from "node:path";
 import * as os6 from "node:os";
 function resolveConfig(c) {
   return {
     projectRoot: c.projectRoot,
     homeDir: c.homeDir ?? os6.homedir(),
-    projectName: c.projectName ?? path20.basename(c.projectRoot),
+    projectName: c.projectName ?? path21.basename(c.projectRoot),
     now: c.now ?? Date.now,
     log: c.log ?? (() => {}),
     maxPerScope: c.maxPerScope ?? 1000
@@ -16230,13 +16860,13 @@ function resolveConfig(c) {
 }
 function fileFor(scope, cfg) {
   if (scope === "project") {
-    return path20.join(cfg.projectRoot, ".codeforge", "memories.json");
+    return path21.join(cfg.projectRoot, ".codeforge", "memories.json");
   }
-  return path20.join(cfg.homeDir, ".codeforge", "memories.json");
+  return path21.join(cfg.homeDir, ".codeforge", "memories.json");
 }
 async function readBank(p) {
   try {
-    const raw = await fs15.readFile(p, "utf8");
+    const raw = await fs16.readFile(p, "utf8");
     const arr = JSON.parse(raw);
     if (!Array.isArray(arr))
       return [];
@@ -16246,10 +16876,10 @@ async function readBank(p) {
   }
 }
 async function writeBank(p, items) {
-  await fs15.mkdir(path20.dirname(p), { recursive: true });
+  await fs16.mkdir(path21.dirname(p), { recursive: true });
   const tmp = `${p}.tmp`;
-  await fs15.writeFile(tmp, JSON.stringify(items, null, 2), "utf8");
-  await fs15.rename(tmp, p);
+  await fs16.writeFile(tmp, JSON.stringify(items, null, 2), "utf8");
+  await fs16.rename(tmp, p);
 }
 function isMemory(x) {
   if (!x || typeof x !== "object")
@@ -16767,7 +17397,7 @@ var handler10 = modelFallbackServer;
 
 // plugins/parallel-tool-nudge.ts
 import { readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync3 } from "node:fs";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 import { homedir as homedir7 } from "node:os";
 var PLUGIN_NAME11 = "parallel-tool-nudge";
 logLifecycle(PLUGIN_NAME11, "import", {});
@@ -16820,10 +17450,10 @@ function loadAgentToolsMap(rootDir, opts = {}) {
   const reader = opts.reader ?? defaultReader2;
   const dirReader = opts.dirReader ?? defaultDirReader2;
   const dirExists = opts.dirExists ?? defaultDirExists2;
-  const homeAgentsDir = opts.homeAgentsDir ?? join19(homedir7(), ".config", "opencode", "agents");
+  const homeAgentsDir = opts.homeAgentsDir ?? join20(homedir7(), ".config", "opencode", "agents");
   const candidateDirs = [
-    join19(rootDir, ".codeforge", "agents"),
-    join19(rootDir, "agents"),
+    join20(rootDir, ".codeforge", "agents"),
+    join20(rootDir, "agents"),
     homeAgentsDir
   ];
   const result = new Map;
@@ -16846,20 +17476,20 @@ function loadAgentToolsMap(rootDir, opts = {}) {
     for (const entry of entries) {
       if (!entry.endsWith(".md"))
         continue;
-      const path21 = join19(dir, entry);
+      const path22 = join20(dir, entry);
       let content;
       try {
-        content = reader(path21);
+        content = reader(path22);
       } catch (err) {
         log7.warn(`agent.md 读取失败（已跳过）`, {
-          path: path21,
+          path: path22,
           error: err instanceof Error ? err.message : String(err)
         });
         continue;
       }
       const parsed = parseAgentFrontmatter(content);
       if (!parsed) {
-        log7.warn(`agent frontmatter 解析失败（已跳过）`, { path: path21 });
+        log7.warn(`agent frontmatter 解析失败（已跳过）`, { path: path22 });
         continue;
       }
       if (result.has(parsed.name))
@@ -17050,18 +17680,18 @@ var handler12 = async (_ctx4) => {
 };
 
 // lib/event-stream.ts
-import { promises as fs16 } from "node:fs";
-import * as path21 from "node:path";
+import { promises as fs17 } from "node:fs";
+import * as path22 from "node:path";
 async function loadSession(id, opts = {}) {
   const file = resolveSessionFile(id, opts);
-  const raw = await fs16.readFile(file, "utf8");
+  const raw = await fs17.readFile(file, "utf8");
   return parseJsonl(id, raw);
 }
 async function listSessions(opts = {}) {
   const dir = resolveDir(opts);
   let entries;
   try {
-    entries = await fs16.readdir(dir, { withFileTypes: true });
+    entries = await fs17.readdir(dir, { withFileTypes: true });
   } catch (err) {
     if (err.code === "ENOENT")
       return [];
@@ -17071,10 +17701,10 @@ async function listSessions(opts = {}) {
   for (const e of entries) {
     if (!e.isFile() || !e.name.endsWith(".jsonl"))
       continue;
-    const file = path21.join(dir, e.name);
+    const file = path22.join(dir, e.name);
     const id = e.name.replace(/\.jsonl$/, "");
     try {
-      const stat = await fs16.stat(file);
+      const stat = await fs17.stat(file);
       const headerLine = await readFirstLine(file);
       let started_at = stat.birthtimeMs;
       if (headerLine) {
@@ -17098,11 +17728,11 @@ async function listSessions(opts = {}) {
   return out;
 }
 function resolveDir(opts = {}) {
-  const root = path21.resolve(opts.root ?? process.cwd());
-  return opts.sessions_dir ? path21.resolve(root, opts.sessions_dir) : path21.join(runtimeDir(root), "sessions");
+  const root = path22.resolve(opts.root ?? process.cwd());
+  return opts.sessions_dir ? path22.resolve(root, opts.sessions_dir) : path22.join(runtimeDir(root), "sessions");
 }
 function resolveSessionFile(id, opts = {}) {
-  return path21.join(resolveDir(opts), `${id}.jsonl`);
+  return path22.join(resolveDir(opts), `${id}.jsonl`);
 }
 function parseJsonl(id, raw) {
   const events = [];
@@ -17137,7 +17767,7 @@ function isEvent(obj) {
 }
 async function readFirstLine(file) {
   const buf = Buffer.alloc(4096);
-  const fh = await fs16.open(file, "r");
+  const fh = await fs17.open(file, "r");
   try {
     const { bytesRead } = await fh.read(buf, 0, buf.length, 0);
     const s = buf.subarray(0, bytesRead).toString("utf8");
@@ -17365,11 +17995,11 @@ function isRecoveryWorthShowing(plan) {
 }
 
 // lib/block-pending.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";
 function blockPendingFilePath(absRoot) {
   const rd = runtimeDir(absRoot, { ensure: false });
-  return path22.join(rd, "sessions", "autonomous-blocks.ndjson");
+  return path23.join(rd, "sessions", "autonomous-blocks.ndjson");
 }
 function consumeLockPath(absRoot) {
   return blockPendingFilePath(absRoot) + ".consume.lock";
@@ -17378,7 +18008,7 @@ async function scanBlockPending(absRoot, filterSessionId) {
   const file = blockPendingFilePath(absRoot);
   let raw;
   try {
-    raw = await fs17.readFile(file, "utf8");
+    raw = await fs18.readFile(file, "utf8");
   } catch {
     return [];
   }
@@ -17434,7 +18064,7 @@ async function markBlocksConsumed(absRoot, entries) {
   if (entries.length === 0)
     return;
   const file = blockPendingFilePath(absRoot);
-  await fs17.mkdir(path22.dirname(file), { recursive: true });
+  await fs18.mkdir(path23.dirname(file), { recursive: true });
   const now = new Date().toISOString();
   const lines = entries.map((e) => ({
     type: "consume",
@@ -17445,7 +18075,7 @@ async function markBlocksConsumed(absRoot, entries) {
 `) + `
 `;
   await withFileLock(consumeLockPath(absRoot), async () => {
-    await fs17.appendFile(file, lines, "utf8");
+    await fs18.appendFile(file, lines, "utf8");
   });
 }
 
@@ -17584,7 +18214,7 @@ var handler13 = sessionRecoveryServer;
 
 // plugins/subtask-heartbeat.ts
 import { promises as fsPromises } from "node:fs";
-import * as path23 from "node:path";
+import * as path24 from "node:path";
 var recordSessionParent2 = recordSessionParent;
 var lookupParentSessionId2 = lookupParentSessionId;
 var deleteSessionParent2 = deleteSessionParent;
@@ -17925,7 +18555,7 @@ function buildErrorLogLine(errorReason, elapsedMs, now = Date.now()) {
 }
 async function appendSubagentLog(filePath, line, log9) {
   try {
-    await fsPromises.mkdir(path23.dirname(filePath), { recursive: true });
+    await fsPromises.mkdir(path24.dirname(filePath), { recursive: true });
     await fsPromises.appendFile(filePath, line + `
 `, "utf8");
   } catch (err) {
@@ -18227,8 +18857,8 @@ var subtaskHeartbeatServer = async (ctx) => {
 var handler14 = subtaskHeartbeatServer;
 
 // plugins/subtasks.ts
-import { promises as fs18 } from "node:fs";
-import * as path24 from "node:path";
+import { promises as fs19 } from "node:fs";
+import * as path25 from "node:path";
 
 // lib/parallel-merge.ts
 init_worktree_ops();
@@ -18236,7 +18866,7 @@ init_worktree_ops();
 // plugins/subtasks.ts
 var PLUGIN_NAME15 = "subtasks";
 function getLogFile(root = process.cwd()) {
-  return path24.join(runtimeDir(root), "logs", "subtasks.log");
+  return path25.join(runtimeDir(root), "logs", "subtasks.log");
 }
 async function writeLog(level, msg, data) {
   const line = JSON.stringify({
@@ -18249,8 +18879,8 @@ async function writeLog(level, msg, data) {
 `;
   try {
     const logFile = getLogFile();
-    await fs18.mkdir(path24.dirname(logFile), { recursive: true });
-    await fs18.appendFile(logFile, line, "utf8");
+    await fs19.mkdir(path25.dirname(logFile), { recursive: true });
+    await fs19.appendFile(logFile, line, "utf8");
   } catch {}
 }
 logLifecycle(PLUGIN_NAME15, "import");
@@ -18824,8 +19454,8 @@ var tokenManagerServer = async (ctx) => {
 var handler17 = tokenManagerServer;
 
 // plugins/tool-policy.ts
-import { promises as fs19 } from "node:fs";
-import * as path26 from "node:path";
+import { promises as fs20 } from "node:fs";
+import * as path27 from "node:path";
 
 // lib/tool-risk.ts
 var RISK_PATTERNS = [
@@ -18979,7 +19609,7 @@ function buildHaystackFor(args, matchOn) {
 }
 
 // lib/file-regex-acl.ts
-import * as path25 from "node:path";
+import * as path26 from "node:path";
 function compileRule(r) {
   if (r instanceof RegExp)
     return r;
@@ -19045,7 +19675,7 @@ function normalizePath(p) {
   let s = p.replace(/\\/g, "/");
   if (s.startsWith("./"))
     s = s.slice(2);
-  s = path25.posix.normalize(s);
+  s = path26.posix.normalize(s);
   return s;
 }
 function checkFileAccess(acl, file, op) {
@@ -19148,11 +19778,11 @@ function decideToolCall(ctx, cfg = {}, currentAgent) {
   const action = risks.length > 0 || worstAcl === "deny" ? "deny" : "allow";
   return { action, reasons, risks, acl: aclResults };
 }
-var POLICY_PATH = path26.join(".codeforge", "policy.json");
+var POLICY_PATH = path27.join(".codeforge", "policy.json");
 async function loadPolicy(root = process.cwd()) {
-  const file = path26.join(root, POLICY_PATH);
+  const file = path27.join(root, POLICY_PATH);
   try {
-    const raw = await fs19.readFile(file, "utf8");
+    const raw = await fs20.readFile(file, "utf8");
     const data = JSON.parse(raw);
     return data;
   } catch {
@@ -19250,19 +19880,19 @@ var handler18 = toolPolicyServer;
 // plugins/update-checker.ts
 import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync6, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { dirname as dirname15, join as join25 } from "node:path";
+import { dirname as dirname16, join as join26 } from "node:path";
 import { spawn } from "node:child_process";
 
 // lib/update-checker-impl.ts
 import { readFileSync as readFileSync5 } from "node:fs";
-import { dirname as dirname14, join as join24 } from "node:path";
+import { dirname as dirname15, join as join25 } 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.2";
+    const v = "0.8.4";
     if (typeof v === "string" && /^\d+\.\d+\.\d+/.test(v)) {
       return v;
     }
@@ -19309,8 +19939,8 @@ function readLocalVersion() {
     return injected;
   try {
     const here = fileURLToPath2(import.meta.url);
-    const root = dirname14(dirname14(here));
-    const pkg = JSON.parse(readFileSync5(join24(root, "package.json"), "utf8"));
+    const root = dirname15(dirname15(here));
+    const pkg = JSON.parse(readFileSync5(join25(root, "package.json"), "utf8"));
     return typeof pkg.version === "string" ? pkg.version : "0.0.0";
   } catch {
     return "0.0.0";
@@ -19346,7 +19976,7 @@ async function fetchLatestFromNpm(opts) {
   return { version, tarballUrl, integrity };
 }
 function defaultHttpFetcher(url2, timeoutMs) {
-  return new Promise((resolve16, reject) => {
+  return new Promise((resolve17, reject) => {
     const u = new URL(url2);
     const headers = {
       "User-Agent": "codeforge-update-checker",
@@ -19363,7 +19993,7 @@ function defaultHttpFetcher(url2, timeoutMs) {
       const status = res.statusCode ?? 0;
       if (status === 404) {
         res.resume();
-        resolve16(null);
+        resolve17(null);
         return;
       }
       if (status >= 400) {
@@ -19374,7 +20004,7 @@ function defaultHttpFetcher(url2, timeoutMs) {
       let body = "";
       res.setEncoding("utf8");
       res.on("data", (chunk) => body += chunk);
-      res.on("end", () => resolve16(body));
+      res.on("end", () => resolve17(body));
     });
     req.on("timeout", () => {
       req.destroy();
@@ -19390,7 +20020,7 @@ var PLUGIN_NAME19 = "update-checker";
 var PLUGIN_VERSION = "3.0.0";
 var _updateCheckStarted = false;
 function getCacheFile() {
-  return join25(process.env["CODEFORGE_CACHE_DIR"] ?? join25(homedir8(), ".cache", "codeforge"), "update-check.json");
+  return join26(process.env["CODEFORGE_CACHE_DIR"] ?? join26(homedir8(), ".cache", "codeforge"), "update-check.json");
 }
 function readLastInstalledVersion() {
   try {
@@ -19406,12 +20036,12 @@ function readLastInstalledVersion() {
 function writeLastInstalledVersion(v) {
   try {
     const f = getCacheFile();
-    mkdirSync3(dirname15(f), { recursive: true });
+    mkdirSync3(dirname16(f), { recursive: true });
     writeFileSync2(f, JSON.stringify({ installedVersion: v }, null, 2), "utf8");
   } catch {}
 }
 function spawnAsync(cmd, args, opts = {}) {
-  return new Promise((resolve16) => {
+  return new Promise((resolve17) => {
     const chunks = [];
     const errChunks = [];
     const proc = spawn(cmd, args, {
@@ -19425,13 +20055,13 @@ function spawnAsync(cmd, args, opts = {}) {
     if (opts.timeout) {
       timer = setTimeout(() => {
         proc.kill();
-        resolve16({ status: -1, stdout: "", stderr: "timeout" });
+        resolve17({ status: -1, stdout: "", stderr: "timeout" });
       }, opts.timeout);
     }
     proc.on("close", (code) => {
       if (timer)
         clearTimeout(timer);
-      resolve16({
+      resolve17({
         status: code ?? -1,
         stdout: Buffer.concat(chunks).toString("utf8"),
         stderr: Buffer.concat(errChunks).toString("utf8")
@@ -19440,7 +20070,7 @@ function spawnAsync(cmd, args, opts = {}) {
     proc.on("error", () => {
       if (timer)
         clearTimeout(timer);
-      resolve16({ status: -1, stdout: "", stderr: "spawn error" });
+      resolve17({ status: -1, stdout: "", stderr: "spawn error" });
     });
   });
 }
@@ -19571,17 +20201,18 @@ var updateCheckerServer = async (ctx) => {
         }
         safeWriteLog(PLUGIN_NAME19, { level: "info", msg: "npm_install_success", remote });
         try {
-          const opencodeCache = join25(homedir8(), ".cache", "opencode", "packages", "@andyqiu", "codeforge@latest");
+          const cacheRoot = process.env["XDG_CACHE_HOME"] ?? join26(homedir8(), ".cache");
+          const opencodeCache = join26(cacheRoot, "opencode", "packages", "@andyqiu", "codeforge@latest");
           if (existsSync5(opencodeCache)) {
             rmSync(opencodeCache, { recursive: true, force: true });
-            safeWriteLog(PLUGIN_NAME19, { level: "info", msg: "opencode_cache_cleared", path: opencodeCache });
+            safeWriteLog(PLUGIN_NAME19, { level: "info", msg: "opencode_plugin_cache_cleared", path: opencodeCache });
           }
         } catch (e) {
-          safeWriteLog(PLUGIN_NAME19, { level: "warn", msg: "opencode_cache_clear_failed", error: e.message });
+          safeWriteLog(PLUGIN_NAME19, { level: "warn", msg: "opencode_plugin_cache_clear_failed", error: e.message });
         }
         const npmRoot = await getNpmGlobalRoot(npmBin);
-        const pkgRoot = npmRoot ? join25(npmRoot, "@andyqiu", "codeforge") : null;
-        const installMjs = pkgRoot ? join25(pkgRoot, "install.mjs") : null;
+        const pkgRoot = npmRoot ? join26(npmRoot, "@andyqiu", "codeforge") : null;
+        const installMjs = pkgRoot ? join26(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`);
@@ -19598,26 +20229,31 @@ var updateCheckerServer = async (ctx) => {
         }
         writeLastInstalledVersion(remote);
         safeWriteLog(PLUGIN_NAME19, { level: "info", msg: "auto_install_full_success", local, remote, nodeBin, npmBin });
-        await postToast(ctx, `[codeforge] ✅ 已升级 ${local} → ${remote}（重启 opencode 生效）
-   回滚：npm install -g ${u.package}@${local}`);
+        await postToast(ctx, `[Codeforge] 已升级 ${remote}，重启 opencode 生效`);
       });
     });
   });
   return {};
 };
 async function postToast(ctx, message) {
-  await safeAsync(PLUGIN_NAME19, "client.app.log", async () => {
-    await ctx.client.app.log({ body: { service: PLUGIN_NAME19, level: "info", message } });
+  await safeAsync(PLUGIN_NAME19, "tui.showToast", async () => {
+    const tui = ctx.client.tui;
+    if (!tui || typeof tui.showToast !== "function") {
+      safeWriteLog(PLUGIN_NAME19, { level: "info", msg: "tui_show_toast_unavailable_fallback", message });
+      return;
+    }
+    await tui.showToast({ body: { message, variant: "info", duration: 8000 } });
+    safeWriteLog(PLUGIN_NAME19, { level: "info", msg: "tui_show_toast_ok" });
   });
 }
 var handler19 = updateCheckerServer;
 
 // plugins/workflow-engine.ts
-import * as path28 from "node:path";
+import * as path29 from "node:path";
 
 // lib/workflow-loader.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";
 import { z as z19 } from "zod";
 var ActionSchema = z19.object({
   tool: z19.string().min(1, "action.tool 不能为空"),
@@ -19703,7 +20339,7 @@ function parseWorkflowYaml(yaml, sourcePath = "<inline>") {
 async function loadWorkflowFromFile(filePath) {
   let txt;
   try {
-    txt = await fs20.readFile(filePath, "utf8");
+    txt = await fs21.readFile(filePath, "utf8");
   } catch (err) {
     return {
       ok: false,
@@ -19718,7 +20354,7 @@ async function loadWorkflowsFromDir(dir) {
   const failed = [];
   let entries;
   try {
-    entries = await fs20.readdir(dir);
+    entries = await fs21.readdir(dir);
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT")
@@ -19730,7 +20366,7 @@ async function loadWorkflowsFromDir(dir) {
       continue;
     if (!/\.ya?ml$/i.test(name))
       continue;
-    const full = path27.join(dir, name);
+    const full = path28.join(dir, name);
     const r = await loadWorkflowFromFile(full);
     if (r.ok)
       loaded.push(r);
@@ -20120,7 +20756,7 @@ async function handleCommandInvoked(raw, workflowsDir = "workflows") {
 }
 var workflowEngineServer = async (ctx) => {
   const directory = ctx.directory ?? process.cwd();
-  const workflowsDir = path28.join(directory, "workflows");
+  const workflowsDir = path29.join(directory, "workflows");
   ensureRegistry(workflowsDir).catch((err) => fallbackLog2.warn(`[${PLUGIN_NAME20}] preload workflows failed`, {
     error: err instanceof Error ? err.message : String(err)
   }));
@@ -20164,7 +20800,7 @@ var workflowEngineServer = async (ctx) => {
 var handler20 = workflowEngineServer;
 
 // plugins/session-worktree-guard.ts
-import path29 from "node:path";
+import path30 from "node:path";
 import { stat } from "node:fs/promises";
 var PLUGIN_NAME21 = "session-worktree-guard";
 logLifecycle(PLUGIN_NAME21, "import", {});
@@ -20302,28 +20938,28 @@ var MERGE_CALLER_WHITELIST = new Set([
 var FORCE_MERGE_CALLER_WHITELIST = new Set([
   "codeforge"
 ]);
-var CODEFORGE_WORKTREE_DIR_NAME = path29.join(".git", "codeforge-worktrees");
+var CODEFORGE_WORKTREE_DIR_NAME = path30.join(".git", "codeforge-worktrees");
 function worktreesRoot(mainRoot) {
-  return path29.join(mainRoot, CODEFORGE_WORKTREE_DIR_NAME);
+  return path30.join(mainRoot, CODEFORGE_WORKTREE_DIR_NAME);
 }
 function isInsideAnyWorktreeDir(absPath, mainRoot) {
-  if (!path29.isAbsolute(absPath))
+  if (!path30.isAbsolute(absPath))
     return false;
   const root = worktreesRoot(mainRoot);
   if (absPath === root)
     return false;
-  const prefix = root.endsWith(path29.sep) ? root : root + path29.sep;
+  const prefix = root.endsWith(path30.sep) ? root : root + path30.sep;
   return absPath.startsWith(prefix);
 }
 function worktreeRootOf(absPath, mainRoot) {
   const root = worktreesRoot(mainRoot);
-  const prefix = root.endsWith(path29.sep) ? root : root + path29.sep;
+  const prefix = root.endsWith(path30.sep) ? root : root + path30.sep;
   if (!absPath.startsWith(prefix))
     return null;
-  const seg = absPath.slice(prefix.length).split(path29.sep)[0];
+  const seg = absPath.slice(prefix.length).split(path30.sep)[0];
   if (!seg || seg === "..")
     return null;
-  return path29.join(root, seg);
+  return path30.join(root, seg);
 }
 function stripPairedQuotes(raw) {
   if (raw.length >= 2) {
@@ -20354,7 +20990,7 @@ function resolveExplicitWorktreeTarget(argsObj, mainRoot) {
     for (const cand of candidates) {
       if (!cand)
         continue;
-      const abs = path29.resolve(mainRoot, cand);
+      const abs = path30.resolve(mainRoot, cand);
       if (isInsideAnyWorktreeDir(abs, mainRoot)) {
         const wtRoot = worktreeRootOf(abs, mainRoot);
         if (wtRoot)
@@ -20367,14 +21003,14 @@ function resolveExplicitWorktreeTarget(argsObj, mainRoot) {
   }
 }
 function stripSharedGitDirRef(command, mainRoot) {
-  const escGitDir = escapeRegex(path29.join(mainRoot, ".git"));
+  const escGitDir = escapeRegex(path30.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 = path29.isAbsolute(value) ? value : path29.resolve(mainRoot, value);
+  const resolved = path30.isAbsolute(value) ? value : path30.resolve(mainRoot, value);
   const wtPrefix2 = worktreeRoot.endsWith("/") ? worktreeRoot : worktreeRoot + "/";
   if (resolved === worktreeRoot || resolved.startsWith(wtPrefix2)) {
     return null;
@@ -20412,7 +21048,7 @@ function commandContainsMainRootExcludingWorktree(command, mainRoot, worktreePat
     }
   }
   const wtRoot = worktreesRoot(mainRoot);
-  const wtRootPrefix = wtRoot + path29.sep;
+  const wtRootPrefix = wtRoot + path30.sep;
   const escapedWtRootPrefix = escapeRegex(wtRootPrefix);
   const wtPathPattern = escapedWtRootPrefix + `[^\\s'"\\x60)]*`;
   const allWorktreePathsReForEscape = new RegExp(wtPathPattern, "g");
@@ -20467,8 +21103,8 @@ function collectWritePaths(toolName, argsObj, worktreeRoot) {
   const candidate = toolName === "write" || toolName === "edit" ? argsObj["filePath"] : toolName === "ast_edit" ? argsObj["target"] : undefined;
   if (typeof candidate !== "string" || candidate.length === 0)
     return out;
-  const abs = path29.isAbsolute(candidate) ? candidate : path29.resolve(worktreeRoot, candidate);
-  const rel = path29.relative(worktreeRoot, abs).split(path29.sep).join("/");
+  const abs = path30.isAbsolute(candidate) ? candidate : path30.resolve(worktreeRoot, candidate);
+  const rel = path30.relative(worktreeRoot, abs).split(path30.sep).join("/");
   out.push(rel);
   return out;
 }
@@ -20479,7 +21115,7 @@ async function isCodeforgeManagedProject(mainRoot, opts = {}) {
   if (force === "1" || force === "true" || force === "yes")
     return true;
   try {
-    const st = await stat(path29.join(mainRoot, ".codeforge"));
+    const st = await stat(path30.join(mainRoot, ".codeforge"));
     return st.isDirectory();
   } catch {
     return false;
@@ -20509,11 +21145,11 @@ var STALE_MERGE_HEAD_MS = 24 * 60 * 60000;
 var _staleMergeHeadWarned = false;
 var _mergeBypassToastShown = false;
 async function isMainRepoMidMerge(mainRoot, opts = {}) {
-  const gitDir = path29.join(mainRoot, ".git");
+  const gitDir = path30.join(mainRoot, ".git");
   const markers = [
-    path29.join(gitDir, "MERGE_HEAD"),
-    path29.join(gitDir, "rebase-merge"),
-    path29.join(gitDir, "CHERRY_PICK_HEAD")
+    path30.join(gitDir, "MERGE_HEAD"),
+    path30.join(gitDir, "rebase-merge"),
+    path30.join(gitDir, "CHERRY_PICK_HEAD")
   ];
   let freshest = -1;
   for (const m of markers) {
@@ -21172,6 +21808,10 @@ var worktreeLifecyclePlugin = async (ctx) => {
       if (rec.cleanedCreating.length > 0 || rec.finishedRemoving.length > 0 || rec.keptConservative.length > 0) {
         safeWriteLog(PLUGIN_NAME22, { 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 });
+      }
       const result = await pruneOrphanWorktrees(mainRoot, {
         isSessionAlive: _probe.isSessionAlive
       });
@@ -21203,6 +21843,10 @@ var worktreeLifecyclePlugin = async (ctx) => {
         if (rec.cleanedCreating.length > 0 || rec.finishedRemoving.length > 0 || rec.keptConservative.length > 0) {
           safeWriteLog(PLUGIN_NAME22, { 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 });
+        }
         const result = await pruneOrphanWorktrees(mainRoot, {
           isSessionAlive: _probe.isSessionAlive
         });
@@ -21476,6 +22120,7 @@ var src_default = pluginModule;
 export {
   src_default as default,
   createCodeforgeServer,
+  collectHealthDigest,
   codeforgeServer,
   codeforgeDevServer
 };