@andyqiu/codeforge 0.7.10 → 0.8.0

package/dist/index.js

@@ -10585,6 +10585,21 @@ class ApprovalStore {
     all.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
     return all[0];
   }
+  async findAliasApprovals(ownerSessionId) {
+    if (!ownerSessionId)
+      return [];
+    const dirs = await this.safeReaddir(this.base);
+    const out = [];
+    for (const name of dirs) {
+      if (!name.startsWith("session:"))
+        continue;
+      const latest = await this.getLatest(name);
+      if (latest?.aliasOf === ownerSessionId)
+        out.push(latest);
+    }
+    out.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    return out;
+  }
   async recordEscape(meta) {
     const dir = path8.join(this.base, "escapes");
     await fs6.mkdir(dir, { recursive: true });
@@ -10664,8 +10679,8 @@ class ApprovalStore {
 // lib/session-worktree.ts
 init_worktree_ops();
 import { execFile as execFile3 } from "node:child_process";
-import { promises as fs9 } from "node:fs";
-import * as path11 from "node:path";
+import { promises as fs10 } from "node:fs";
+import * as path12 from "node:path";
 
 // lib/file-lock.ts
 import { promises as fs8 } from "node:fs";
@@ -10781,51 +10796,344 @@ function sleep(ms) {
   return new Promise((resolve9) => setTimeout(resolve9, ms));
 }
 
+// lib/parent-map-store.ts
+import { promises as fs9 } from "node:fs";
+import * as path11 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");
+}
+function parentMapPath(mainRoot) {
+  return path11.join(parentMapDir(mainRoot), "parent-map.json");
+}
+function parentMapLockPath(mainRoot) {
+  return path11.join(parentMapDir(mainRoot), "parent-map.lock");
+}
+async function readParentMapFile(mainRoot) {
+  const file = parentMapPath(mainRoot);
+  try {
+    const raw = await fs9.readFile(file, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== PARENT_MAP_VERSION || !Array.isArray(parsed.entries)) {
+      return { version: PARENT_MAP_VERSION, entries: [] };
+    }
+    return parsed;
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT")
+      return { version: PARENT_MAP_VERSION, entries: [] };
+    return { version: PARENT_MAP_VERSION, entries: [] };
+  }
+}
+async function writeParentMapFile(mainRoot, payload) {
+  const file = parentMapPath(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);
+}
+function capEntriesByTsDesc(entries) {
+  if (entries.length <= PARENT_MAP_MAX_ENTRIES)
+    return entries;
+  return [...entries].sort((a, b) => b.ts - a.ts).slice(0, PARENT_MAP_MAX_ENTRIES);
+}
+async function loadParentMap(mainRoot) {
+  const out = new Map;
+  let file;
+  try {
+    file = await readParentMapFile(mainRoot);
+  } catch {
+    return out;
+  }
+  const valid = [];
+  for (const e of file.entries) {
+    if (!e || typeof e.childID !== "string" || typeof e.parentID !== "string")
+      continue;
+    if (!e.childID || !e.parentID)
+      continue;
+    const ts = typeof e.ts === "number" ? e.ts : Date.now();
+    valid.push({ childID: e.childID, parentID: e.parentID, ts });
+  }
+  const capped = capEntriesByTsDesc(valid);
+  for (const e of capped) {
+    out.set(e.childID, { parentID: e.parentID, ts: e.ts });
+  }
+  return out;
+}
+async function mutateParentMap(mainRoot, mutator, opts = {}) {
+  const lockPath = parentMapLockPath(mainRoot);
+  await fs9.mkdir(path11.dirname(lockPath), { recursive: true });
+  const lockOpts = {
+    timeoutMs: opts.timeoutMs ?? PARENT_MAP_LOCK_TIMEOUT_MS,
+    ...opts
+  };
+  await withFileLock(lockPath, async () => {
+    const current = await readParentMapFile(mainRoot);
+    const input = current.entries.slice();
+    const next = await mutator(input);
+    if (!Array.isArray(next))
+      return;
+    const capped = capEntriesByTsDesc(next);
+    await writeParentMapFile(mainRoot, { version: PARENT_MAP_VERSION, entries: capped });
+  }, lockOpts);
+}
+async function appendParentEntry(mainRoot, childID, parentID, ts, opts = {}) {
+  if (!childID || !parentID)
+    return;
+  const lockPath = parentMapLockPath(mainRoot);
+  await fs9.mkdir(path11.dirname(lockPath), { recursive: true });
+  const lockOpts = {
+    timeoutMs: opts.timeoutMs ?? PARENT_MAP_LOCK_TIMEOUT_MS,
+    ...opts
+  };
+  await withFileLock(lockPath, async () => {
+    const current = await readParentMapFile(mainRoot);
+    const idx = current.entries.findIndex((e) => e.childID === childID);
+    if (idx >= 0) {
+      current.entries[idx] = { childID, parentID, ts };
+    } else {
+      current.entries.push({ childID, parentID, ts });
+    }
+    const capped = capEntriesByTsDesc(current.entries);
+    await writeParentMapFile(mainRoot, { version: PARENT_MAP_VERSION, entries: capped });
+  }, lockOpts);
+}
+
+// lib/parent-map-runtime.ts
+var log4 = makePluginLogger("parent-map-runtime");
+var SESSION_PARENT_MAP_TTL_MS = 30 * 60000;
+var SESSION_PARENT_MAP_MAX_SIZE = PARENT_MAP_MAX_ENTRIES;
+var sessionParentMap = new Map;
+var _persistRoot = null;
+function _setPersistRootForTests(root) {
+  _persistRoot = root;
+}
+function _bulkInjectSessionParentMap(entries) {
+  for (const e of entries) {
+    if (!e.childID || !e.parentID)
+      continue;
+    sessionParentMap.set(e.childID, { parentID: e.parentID, ts: e.ts });
+  }
+}
+function _capSessionParentMap() {
+  if (sessionParentMap.size <= SESSION_PARENT_MAP_MAX_SIZE)
+    return 0;
+  const sorted = [...sessionParentMap.entries()].sort((a, b) => b[1].ts - a[1].ts);
+  const keep = new Set(sorted.slice(0, SESSION_PARENT_MAP_MAX_SIZE).map(([k]) => k));
+  let removed = 0;
+  for (const k of [...sessionParentMap.keys()]) {
+    if (!keep.has(k)) {
+      sessionParentMap.delete(k);
+      removed++;
+    }
+  }
+  return removed;
+}
+function recordSessionParent(childID, parentID, now = Date.now()) {
+  if (!childID || !parentID)
+    return;
+  if (sessionParentMap.has(childID)) {
+    sessionParentMap.set(childID, { parentID, ts: now });
+  } else {
+    if (sessionParentMap.size >= SESSION_PARENT_MAP_MAX_SIZE) {
+      let oldestKey = null;
+      let oldestTs = Number.POSITIVE_INFINITY;
+      for (const [k, v] of sessionParentMap.entries()) {
+        if (v.ts < oldestTs) {
+          oldestTs = v.ts;
+          oldestKey = k;
+        }
+      }
+      if (oldestKey !== null)
+        sessionParentMap.delete(oldestKey);
+    }
+    sessionParentMap.set(childID, { parentID, ts: now });
+  }
+  if (_persistRoot) {
+    appendParentEntry(_persistRoot, childID, parentID, now).catch((err) => {
+      log4.warn("appendParentEntry 失败（已隔离）", {
+        error: err instanceof Error ? err.message : String(err),
+        childID
+      });
+    });
+  }
+}
+function lookupParentSessionId(childID, now = Date.now()) {
+  const entry = sessionParentMap.get(childID);
+  if (!entry)
+    return;
+  if (now - entry.ts > SESSION_PARENT_MAP_TTL_MS) {
+    sessionParentMap.delete(childID);
+    return;
+  }
+  return entry.parentID;
+}
+function deleteSessionParent(childID) {
+  sessionParentMap.delete(childID);
+  if (_persistRoot) {
+    mutateParentMap(_persistRoot, (entries) => entries.filter((e) => e.childID !== childID)).catch((err) => {
+      log4.warn("mutateParentMap (delete) 失败（已隔离）", {
+        error: err instanceof Error ? err.message : String(err),
+        childID
+      });
+    });
+  }
+}
+function sweepExpiredSessionParents(now = Date.now()) {
+  let removed = 0;
+  for (const [k, v] of [...sessionParentMap.entries()]) {
+    if (now - v.ts > SESSION_PARENT_MAP_TTL_MS) {
+      sessionParentMap.delete(k);
+      removed++;
+    }
+  }
+  if (_persistRoot) {
+    mutateParentMap(_persistRoot, (entries) => entries.filter((e) => now - e.ts <= SESSION_PARENT_MAP_TTL_MS)).catch((err) => {
+      log4.warn("mutateParentMap (sweep) 失败（已隔离）", {
+        error: err instanceof Error ? err.message : String(err),
+        removed
+      });
+    });
+  }
+  return removed;
+}
+
 // lib/session-worktree.ts
 var REGISTRY_VERSION = 1;
-var DEFAULT_WORKTREE_SUBDIR = path11.join(".git", "codeforge-worktrees");
+var DEFAULT_WORKTREE_SUBDIR = path12.join(".git", "codeforge-worktrees");
 function debugLog(msg) {
   if (process.env["CODEFORGE_DEBUG"]) {
     console.debug(`[session-worktree] ${msg}`);
   }
 }
 function registryDir(mainRoot) {
-  return path11.join(runtimeDir(path11.resolve(mainRoot), { ensure: false }), "session-worktrees");
+  return path12.join(runtimeDir(path12.resolve(mainRoot), { ensure: false }), "session-worktrees");
 }
 function registryPath(mainRoot) {
-  return path11.join(registryDir(mainRoot), "registry.json");
+  return path12.join(registryDir(mainRoot), "registry.json");
 }
 function registryLockPath(mainRoot) {
-  return path11.join(registryDir(mainRoot), "registry.lock");
+  return path12.join(registryDir(mainRoot), "registry.lock");
 }
-async function readRegistry(mainRoot) {
+
+class RegistryCorruptError extends Error {
+  registryPath;
+  backupPath;
+  constructor(reason, registryPath2, backupPath) {
+    super(`session 追踪文件损坏（${reason}）：${registryPath2}。` + `为防止用空表覆盖丢失 worktree 追踪记录，已拒绝写入（fail-closed）。` + (backupPath ? `已备份损坏文件到 ${backupPath}。` : "") + `请检查/备份后删除该文件让系统重建空 registry，或恢复正确内容后重试。`);
+    this.name = "RegistryCorruptError";
+    this.registryPath = registryPath2;
+    if (backupPath)
+      this.backupPath = backupPath;
+  }
+}
+
+class RegistryVersionTooNewError extends Error {
+  registryPath;
+  foundVersion;
+  supportedVersion;
+  constructor(registryPath2, foundVersion, supportedVersion) {
+    super(`session 追踪文件版本（v${foundVersion}）高于当前 CodeForge 支持的版本（v${supportedVersion}）：` + `${registryPath2}。已启用只读保护拒绝写入（fail-closed，绝不降级覆盖有效数据）。` + `请升级 CodeForge 到匹配版本后再操作。`);
+    this.name = "RegistryVersionTooNewError";
+    this.registryPath = registryPath2;
+    this.foundVersion = foundVersion;
+    this.supportedVersion = supportedVersion;
+  }
+}
+async function readRegistryResult(mainRoot) {
   const file = registryPath(mainRoot);
+  let raw;
   try {
-    const raw = await fs9.readFile(file, "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed.version !== REGISTRY_VERSION || !Array.isArray(parsed.entries)) {
-      return { version: REGISTRY_VERSION, entries: [] };
-    }
-    return parsed;
+    raw = await fs10.readFile(file, "utf8");
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT")
-      return { version: REGISTRY_VERSION, entries: [] };
-    return { version: REGISTRY_VERSION, entries: [] };
+      return { kind: "missing" };
+    return { kind: "corrupt", reason: `read_error: ${e.code ?? e.message}`, path: file };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    return { kind: "corrupt", reason: `parse_error: ${err.message}`, path: file };
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return { kind: "corrupt", reason: "structure: 顶层非对象", path: file };
   }
+  const obj = parsed;
+  if (typeof obj.version !== "number" || !Number.isInteger(obj.version) || obj.version < 1) {
+    return {
+      kind: "corrupt",
+      reason: `structure: version 非正整数 (${String(obj.version)})`,
+      path: file
+    };
+  }
+  if (obj.version > REGISTRY_VERSION) {
+    return {
+      kind: "version_too_new",
+      foundVersion: obj.version,
+      supportedVersion: REGISTRY_VERSION,
+      path: file
+    };
+  }
+  if (!Array.isArray(obj.entries)) {
+    return { kind: "corrupt", reason: "structure: entries 非数组", path: file };
+  }
+  return {
+    kind: "ok",
+    registry: { version: REGISTRY_VERSION, entries: obj.entries }
+  };
+}
+async function readRegistry(mainRoot) {
+  const res = await readRegistryResult(mainRoot);
+  if (res.kind === "ok")
+    return res.registry;
+  return { version: REGISTRY_VERSION, entries: [] };
 }
 async function writeRegistry(mainRoot, reg) {
   const file = registryPath(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(reg, null, 2), "utf8");
-  await fs9.rename(tmp, file);
+  await fs10.writeFile(tmp, JSON.stringify(reg, null, 2), "utf8");
+  await fs10.rename(tmp, file);
+}
+async function backupCorruptRegistry(mainRoot) {
+  const file = registryPath(mainRoot);
+  const dir = path12.dirname(file);
+  const base = path12.basename(file);
+  try {
+    const names = await fs10.readdir(dir);
+    const existing = names.find((n) => n.startsWith(`${base}.corrupt.`));
+    if (existing)
+      return path12.join(dir, existing);
+  } catch {}
+  const backup = `${file}.corrupt.${Date.now()}`;
+  try {
+    await fs10.copyFile(file, backup);
+    return backup;
+  } catch {
+    return;
+  }
+}
+async function loadRegistryForMutation(mainRoot) {
+  const res = await readRegistryResult(mainRoot);
+  if (res.kind === "ok")
+    return res.registry;
+  if (res.kind === "missing")
+    return { version: REGISTRY_VERSION, entries: [] };
+  if (res.kind === "version_too_new") {
+    throw new RegistryVersionTooNewError(res.path, res.foundVersion, res.supportedVersion);
+  }
+  const backupPath = await backupCorruptRegistry(mainRoot);
+  throw new RegistryCorruptError(res.reason, res.path, backupPath);
 }
 async function mutateRegistry(mainRoot, fn) {
   const lockPath = registryLockPath(mainRoot);
-  await fs9.mkdir(path11.dirname(lockPath), { recursive: true });
+  await fs10.mkdir(path12.dirname(lockPath), { recursive: true });
   return await withFileLock(lockPath, async () => {
-    const reg = await readRegistry(mainRoot);
+    const reg = await loadRegistryForMutation(mainRoot);
     const result = await fn(reg);
     await writeRegistry(mainRoot, reg);
     return result;
@@ -10835,13 +11143,13 @@ async function bindSessionWorktree(opts) {
   if (!opts.sessionId || opts.sessionId.trim() === "") {
     throw new Error("bindSessionWorktree: sessionId 不能为空");
   }
-  const mainRoot = path11.resolve(opts.mainRoot);
+  const mainRoot = path12.resolve(opts.mainRoot);
   const branch = opts.branchName ?? `codeforge/session-${opts.sessionId}`;
-  const worktreesDir = opts.worktrees_dir ?? path11.join(mainRoot, DEFAULT_WORKTREE_SUBDIR);
+  const worktreesDir = opts.worktrees_dir ?? path12.join(mainRoot, DEFAULT_WORKTREE_SUBDIR);
   const lockPath = registryLockPath(mainRoot);
-  await fs9.mkdir(path11.dirname(lockPath), { recursive: true });
+  await fs10.mkdir(path12.dirname(lockPath), { recursive: true });
   return await withFileLock(lockPath, async () => {
-    const reg = await readRegistry(mainRoot);
+    const reg = await loadRegistryForMutation(mainRoot);
     const existing = reg.entries.find((e) => e.sessionId === opts.sessionId);
     if (existing && existing.status === "active")
       return existing;
@@ -10887,6 +11195,48 @@ async function registryHasEntries(mainRoot) {
     return false;
   }
 }
+var OWNER_RESOLVE_MAX_DEPTH = 16;
+async function resolveWorktreeOwner(opts) {
+  const sid = opts.sessionId;
+  const mainRoot = path12.resolve(opts.mainRoot);
+  const snap = await readRegistryResult(mainRoot);
+  if (snap.kind === "corrupt" || snap.kind === "version_too_new") {
+    return {
+      ok: false,
+      ownerSessionId: sid,
+      entry: null,
+      via: "registry-unreadable",
+      reason: snap.kind === "corrupt" ? `registry corrupt: ${snap.reason}` : `registry version_too_new: v${snap.foundVersion} > 支持 v${snap.supportedVersion}`
+    };
+  }
+  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);
+    if (byPath) {
+      return { ok: true, ownerSessionId: byPath.sessionId, entry: byPath, via: "worktree-path" };
+    }
+  }
+  const selfEntry = activeById(sid);
+  if (selfEntry) {
+    return { ok: true, ownerSessionId: sid, entry: selfEntry, via: "self" };
+  }
+  const visited = new Set([sid]);
+  let cur = sid;
+  for (let depth = 0;depth < OWNER_RESOLVE_MAX_DEPTH; depth++) {
+    const parent = lookupParentSessionId(cur);
+    if (!parent || visited.has(parent))
+      break;
+    visited.add(parent);
+    const parentEntry = activeById(parent);
+    if (parentEntry) {
+      return { ok: true, ownerSessionId: parent, entry: parentEntry, via: "ancestor" };
+    }
+    cur = parent;
+  }
+  return { ok: true, ownerSessionId: sid, entry: null, via: "fallback-self" };
+}
 async function markPlanReadOk(opts) {
   return await mutateRegistry(opts.mainRoot, (reg) => {
     const entry = reg.entries.find((e) => e.sessionId === opts.sessionId);
@@ -10907,7 +11257,7 @@ async function touchEntryUpdatedAt(opts) {
   });
 }
 async function mergeSessionBack(opts) {
-  const mainRoot = path11.resolve(opts.mainRoot);
+  const mainRoot = path12.resolve(opts.mainRoot);
   const entry = await getSessionWorktree(opts.sessionId, mainRoot);
   if (!entry) {
     throw new Error(`mergeSessionBack: session ${opts.sessionId} 没有绑定 worktree`);
@@ -10989,7 +11339,7 @@ async function mergeSessionBack(opts) {
   return { sha: newSha, squashedCommits };
 }
 async function discardSession(opts) {
-  const mainRoot = path11.resolve(opts.mainRoot);
+  const mainRoot = path12.resolve(opts.mainRoot);
   const entry = await getSessionWorktree(opts.sessionId, mainRoot);
   if (!entry) {
     return;
@@ -11041,7 +11391,7 @@ async function markInterruptedDirty(opts) {
 }
 var SALVAGE_BRANCH_PREFIX = "codeforge/salvage/";
 async function listSalvageBranches(mainRoot) {
-  const resolved = path11.resolve(mainRoot);
+  const resolved = path12.resolve(mainRoot);
   try {
     const out = await runGit2(resolved, [
       "for-each-ref",
@@ -11060,14 +11410,27 @@ async function listSalvageBranches(mainRoot) {
   }
 }
 async function reconcileTransitionalEntries(mainRoot) {
-  const resolved = path11.resolve(mainRoot);
+  const resolved = path12.resolve(mainRoot);
   const result = {
     cleanedCreating: [],
     finishedRemoving: [],
     keptConservative: []
   };
-  const snapshot = await readRegistry(resolved);
-  const hasTransitional = snapshot.entries.some((e) => e.status === "creating" || e.status === "removing");
+  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 hasTransitional = entries.some((e) => e.status === "creating" || e.status === "removing");
   if (!hasTransitional)
     return result;
   await mutateRegistry(resolved, async (reg) => {
@@ -11076,7 +11439,7 @@ async function reconcileTransitionalEntries(mainRoot) {
         continue;
       let dirExists = true;
       try {
-        const st = await fs9.stat(entry.worktreePath);
+        const st = await fs10.stat(entry.worktreePath);
         dirExists = st.isDirectory();
       } catch {
         dirExists = false;
@@ -11121,9 +11484,44 @@ async function reconcileTransitionalEntries(mainRoot) {
   });
   return result;
 }
+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 cleanedPrune = prune?.cleaned.length ?? 0;
+  const failedPrune = prune?.failed.length ?? 0;
+  if (totalReconcile === 0 && cleanedPrune === 0 && failedPrune === 0)
+    return "";
+  const parts = [];
+  if (result.cleanedCreating.length > 0) {
+    parts.push(`清理半成品 ${result.cleanedCreating.length}`);
+  }
+  if (result.finishedRemoving.length > 0) {
+    parts.push(`收尾删除 ${result.finishedRemoving.length}`);
+  }
+  if (result.keptConservative.length > 0) {
+    parts.push(`保守保留 ${result.keptConservative.length}`);
+  }
+  if (cleanedPrune > 0)
+    parts.push(`清理僵尸 worktree ${cleanedPrune}`);
+  if (failedPrune > 0)
+    parts.push(`清理失败 ${failedPrune}`);
+  const sample = [
+    ...result.cleanedCreating,
+    ...result.finishedRemoving,
+    ...prune?.cleaned ?? []
+  ];
+  const uniq = [...new Set(sample)].slice(0, maxList);
+  const more = sample.length > uniq.length ? ` 等` : "";
+  const sampleStr = uniq.length > 0 ? `（${uniq.join(", ")}${more}）` : "";
+  return `[codeforge] worktree 收敛：${parts.join("，")}${sampleStr}`;
+}
 async function getCurrentWorktreeHead(worktreePath) {
   try {
-    return (await runGit2(path11.resolve(worktreePath), ["rev-parse", "HEAD"])).trim();
+    return (await runGit2(path12.resolve(worktreePath), ["rev-parse", "HEAD"])).trim();
   } catch {
     return "";
   }
@@ -11142,7 +11540,8 @@ async function checkpointCommit(opts) {
 }
 var CHECKPOINT_MESSAGE_PREFIX = "[codeforge-checkpoint] pre-lane-dispatch";
 async function checkpointSessionWorktree(opts) {
-  const mainRoot = path11.resolve(opts.mainRoot);
+  const mainRoot = path12.resolve(opts.mainRoot);
+  await loadRegistryForMutation(mainRoot);
   const entry = await getSessionWorktree(opts.sessionId, mainRoot);
   if (!entry) {
     throw new Error(`checkpointSessionWorktree: session ${opts.sessionId} 没有绑定 worktree`);
@@ -11164,19 +11563,19 @@ async function checkpointSessionWorktree(opts) {
   return { sessionId: opts.sessionId, worktreePath: wt, committed: true, head };
 }
 function runGit2(cwd, args, timeoutMs = 1e4) {
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve11, 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;
       }
-      resolve10(stdout);
+      resolve11(stdout);
     });
   });
 }
 function runGitWithEnv(cwd, args, envOverrides, timeoutMs = 1e4) {
   const inheritedEnv = process["env"];
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve11, reject) => {
     execFile3("git", args, {
       cwd,
       timeout: timeoutMs,
@@ -11188,7 +11587,7 @@ function runGitWithEnv(cwd, args, envOverrides, timeoutMs = 1e4) {
         reject(new Error(`git ${args.join(" ")} (cwd=${cwd}) 失败: ${stderr?.trim() || err.message}`));
         return;
       }
-      resolve10(stdout);
+      resolve11(stdout);
     });
   });
 }
@@ -11206,7 +11605,7 @@ async function getBuildScript(mainRoot) {
 async function shouldSkipDevOnce(mainRoot, stagedPaths, worktreePath) {
   let distMtimeSec;
   try {
-    const st = await fs9.stat(path11.join(mainRoot, "dist/index.js"));
+    const st = await fs10.stat(path12.join(mainRoot, "dist/index.js"));
     distMtimeSec = Math.floor(st.mtimeMs / 1000);
   } catch {
     return false;
@@ -11226,25 +11625,25 @@ async function shouldSkipDevOnce(mainRoot, stagedPaths, worktreePath) {
 async function statSourceMtime(rel, mainRoot, worktreePath) {
   if (worktreePath) {
     try {
-      const st = await fs9.stat(path11.join(worktreePath, rel));
+      const st = await fs10.stat(path12.join(worktreePath, rel));
       return Math.floor(st.mtimeMs / 1000);
     } catch {}
   }
   try {
-    const st = await fs9.stat(path11.join(mainRoot, rel));
+    const st = await fs10.stat(path12.join(mainRoot, rel));
     return Math.floor(st.mtimeMs / 1000);
   } catch {
     return null;
   }
 }
 function runCmd(cmd, args, cwd, timeoutMs = 300000) {
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve11, 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;
       }
-      resolve10(stdout);
+      resolve11(stdout);
     });
   });
 }
@@ -11269,7 +11668,7 @@ async function pruneDiscardedRegistryEntries(mainRoot, opts = {}) {
   if (keepRecent < 0) {
     throw new Error(`pruneDiscardedRegistryEntries: keepRecent 必须 ≥ 0，收到 ${keepRecent}`);
   }
-  return await mutateRegistry(path11.resolve(mainRoot), (reg) => {
+  return await mutateRegistry(path12.resolve(mainRoot), (reg) => {
     const discarded = [];
     const others = [];
     for (const e of reg.entries) {
@@ -11286,10 +11685,24 @@ async function pruneDiscardedRegistryEntries(mainRoot, opts = {}) {
   });
 }
 async function pruneOrphanWorktrees(mainRoot, opts = {}) {
-  const resolved = path11.resolve(mainRoot);
+  const resolved = path12.resolve(mainRoot);
   const cleaned = [];
   const failed = [];
   let skipped = 0;
+  const health = await readRegistryResult(resolved);
+  if (health.kind === "corrupt" || health.kind === "version_too_new") {
+    debugLog(`pruneOrphanWorktrees 跳过：registry 不可读 (${health.kind})，绝不清理 worktree（fail-closed）`);
+    return {
+      cleaned,
+      failed,
+      skipped,
+      registryUnreadable: {
+        reason: health.kind,
+        detail: health.kind === "corrupt" ? health.reason : `v${health.foundVersion} > 支持 v${health.supportedVersion}`,
+        path: health.path
+      }
+    };
+  }
   let gitWorktrees = [];
   try {
     const mod = await Promise.resolve().then(() => (init_worktree_ops(), exports_worktree_ops));
@@ -11297,7 +11710,7 @@ async function pruneOrphanWorktrees(mainRoot, opts = {}) {
   } catch {
     gitWorktrees = [];
   }
-  const gitWorktreePaths = new Set(gitWorktrees.map((w) => path11.resolve(w.path)));
+  const gitWorktreePaths = new Set(gitWorktrees.map((w) => path12.resolve(w.path)));
   await mutateRegistry(resolved, async (reg2) => {
     const now = Date.now();
     for (const entry of reg2.entries) {
@@ -11307,7 +11720,7 @@ async function pruneOrphanWorktrees(mainRoot, opts = {}) {
       let dirExists = true;
       let dirMtimeMs = 0;
       try {
-        const st = await fs9.stat(wt);
+        const st = await fs10.stat(wt);
         dirExists = st.isDirectory();
         dirMtimeMs = st.mtimeMs;
       } catch {
@@ -11400,12 +11813,12 @@ async function pruneOrphanWorktrees(mainRoot, opts = {}) {
       }
     });
   }
-  const codeforgeWorktreeRoot = path11.resolve(path11.join(resolved, DEFAULT_WORKTREE_SUBDIR));
+  const codeforgeWorktreeRoot = path12.resolve(path12.join(resolved, DEFAULT_WORKTREE_SUBDIR));
   const fsWorktreePaths = [];
   try {
-    const names = await fs9.readdir(codeforgeWorktreeRoot);
+    const names = await fs10.readdir(codeforgeWorktreeRoot);
     for (const name of names) {
-      fsWorktreePaths.push(path11.resolve(path11.join(codeforgeWorktreeRoot, name)));
+      fsWorktreePaths.push(path12.resolve(path12.join(codeforgeWorktreeRoot, name)));
     }
   } catch {}
   const candidatePaths = new Set([
@@ -11413,16 +11826,16 @@ async function pruneOrphanWorktrees(mainRoot, opts = {}) {
     ...fsWorktreePaths
   ]);
   const reg = await readRegistry(resolved);
-  const knownPaths = new Set(reg.entries.map((e) => path11.resolve(e.worktreePath)));
+  const knownPaths = new Set(reg.entries.map((e) => path12.resolve(e.worktreePath)));
   for (const candidate of candidatePaths) {
     if (knownPaths.has(candidate))
       continue;
-    if (candidate !== codeforgeWorktreeRoot && !candidate.startsWith(codeforgeWorktreeRoot + path11.sep)) {
+    if (candidate !== codeforgeWorktreeRoot && !candidate.startsWith(codeforgeWorktreeRoot + path12.sep)) {
       continue;
     }
     let dirExists = true;
     try {
-      const st = await fs9.stat(candidate);
+      const st = await fs10.stat(candidate);
       if (Date.now() - st.mtimeMs < ORPHAN_GRACE_MS) {
         skipped++;
         continue;
@@ -11444,14 +11857,14 @@ async function pruneOrphanWorktrees(mainRoot, opts = {}) {
     }
     if (removed) {
       try {
-        await fs9.stat(candidate);
+        await fs10.stat(candidate);
         removed = false;
         lastError = lastError ?? "git worktree remove 返回成功但目录仍存在（C 类 fs-only orphan）";
       } catch {}
     }
     if (!removed && dirExists) {
       try {
-        await fs9.rm(candidate, { recursive: true, force: true });
+        await fs10.rm(candidate, { recursive: true, force: true });
         removed = true;
       } catch (err) {
         lastError = `git remove 失败: ${lastError}; fs.rm 也失败: ${err instanceof Error ? err.message : String(err)}`;
@@ -11506,7 +11919,8 @@ var ArgsSchema4 = z4.object({
   sessionId: z4.string().optional().describe("reviewer 子 session id（boomerang 溯源用，可选）"),
   model: z4.string().optional().describe("审批模型 id（审计用，可选）"),
   coveredSha: z4.string().optional().describe("approval 写入时 worktree HEAD sha；对 session:<sid> id 工具会自动从 worktree HEAD 捕获（缺失时），显式传入值优先。ADR:review-approval-auto-covered-sha / ADR:merge-approval-pre-check"),
-  reviewTarget: z4.string().optional().describe("本次审阅的 review_target 值（reviewer.md 词表：code / code:typescript / code:python / code:csharp-lua-c / plan_only / adr / docs / decision_only）。对 session:<sid> id 缺失时默认 'code'，显式传入值优先。pre-check 仅放行 startsWith('code') 的值。ADR:review-approval-auto-covered-sha / ADR:merge-approval-pre-check")
+  reviewTarget: z4.string().optional().describe("本次审阅的 review_target 值（reviewer.md 词表：code / code:typescript / code:python / code:csharp-lua-c / plan_only / adr / docs / decision_only）。对 session:<sid> id 缺失时默认 'code'，显式传入值优先。pre-check 仅放行 startsWith('code') 的值。ADR:review-approval-auto-covered-sha / ADR:merge-approval-pre-check"),
+  worktreePath: z4.string().optional().describe("reviewer prompt 的 worktree_path 绝对路径；对 session:<sid> id 用于 owner 归一反查（优先于 parentMap 上溯，不依赖进程内映射）。ADR:worktree-approval-owner-reconciliation")
 });
 var _approvalStore = null;
 function getApprovalStore() {
@@ -11514,7 +11928,7 @@ function getApprovalStore() {
     _approvalStore = ApprovalStore.forProject(process.cwd());
   return _approvalStore;
 }
-var _worktreeResolvers = { getSessionWorktree, getCurrentWorktreeHead };
+var _worktreeResolvers = { getSessionWorktree, getCurrentWorktreeHead, resolveWorktreeOwner };
 async function execute4(input) {
   const parsed = ArgsSchema4.safeParse(input);
   if (!parsed.success) {
@@ -11527,44 +11941,98 @@ async function execute4(input) {
   const approvals = getApprovalStore();
   const now = new Date().toISOString();
   const written = [];
+  const buildMeta = (pendingId, extra) => ({
+    pendingId,
+    verdict: args.verdict,
+    reviewer: {
+      agent: args.reviewerAgent ?? (args.source === "codeforge-fallback" ? "codeforge" : "reviewer"),
+      ...args.sessionId ? { sessionId: args.sessionId } : {},
+      ...args.model ? { model: args.model } : {},
+      source: args.source ?? "reviewer"
+    },
+    targets: [],
+    decisionLine: args.decisionLine ?? args.verdict,
+    notes: args.notes,
+    createdAt: now,
+    ...extra.coveredSha ? { coveredSha: extra.coveredSha } : {},
+    ...extra.reviewTarget ? { reviewTarget: extra.reviewTarget } : {},
+    ...extra.resolvedOwnerSessionId ? { resolvedOwnerSessionId: extra.resolvedOwnerSessionId } : {},
+    ...extra.aliasOf ? { aliasOf: extra.aliasOf } : {},
+    ...extra.ownerResolved !== undefined ? { ownerResolved: extra.ownerResolved } : {},
+    escapeHatch: null
+  });
   for (const id of args.pendingIds) {
-    let coveredSha = args.coveredSha;
-    let reviewTarget = args.reviewTarget;
     const sessionMatch = /^session:(.+)$/.exec(id);
-    if (sessionMatch) {
-      const sid = sessionMatch[1];
-      if (!coveredSha) {
+    if (!sessionMatch) {
+      const meta = buildMeta(id, {
+        coveredSha: args.coveredSha,
+        reviewTarget: args.reviewTarget
+      });
+      const file = await approvals.record(meta);
+      written.push({ pendingId: id, file });
+      continue;
+    }
+    const sid = sessionMatch[1];
+    let owner;
+    try {
+      owner = await _worktreeResolvers.resolveWorktreeOwner({
+        sessionId: sid,
+        mainRoot: process.cwd(),
+        ...args.worktreePath ? { worktreePath: args.worktreePath } : {}
+      });
+    } catch {
+      owner = {
+        ok: false,
+        ownerSessionId: sid,
+        entry: null,
+        via: "registry-unreadable",
+        reason: "resolveWorktreeOwner threw"
+      };
+    }
+    const ownerResolved = owner.ok && owner.entry !== null;
+    let coveredSha = args.coveredSha;
+    const reviewTarget = args.reviewTarget ?? "code";
+    if (!coveredSha) {
+      let wtPath = owner.entry?.worktreePath;
+      if (!wtPath) {
         try {
-          const entry = await _worktreeResolvers.getSessionWorktree(sid, process.cwd());
-          if (entry?.worktreePath) {
-            const head = await _worktreeResolvers.getCurrentWorktreeHead(entry.worktreePath);
-            if (head)
-              coveredSha = head;
-          }
+          const fallbackEntry = await _worktreeResolvers.getSessionWorktree(sid, process.cwd());
+          wtPath = fallbackEntry?.worktreePath;
         } catch {}
       }
-      if (!reviewTarget)
-        reviewTarget = "code";
+      if (wtPath) {
+        const head = await _worktreeResolvers.getCurrentWorktreeHead(wtPath);
+        if (head)
+          coveredSha = head;
+      }
+    }
+    if (ownerResolved && owner.ownerSessionId !== sid) {
+      const ownerKey = `session:${owner.ownerSessionId}`;
+      const ownerMeta = buildMeta(ownerKey, {
+        coveredSha,
+        reviewTarget,
+        resolvedOwnerSessionId: sid,
+        ownerResolved: true
+      });
+      const ownerFile = await approvals.record(ownerMeta);
+      written.push({ pendingId: ownerKey, file: ownerFile });
+      const aliasMeta = buildMeta(id, {
+        coveredSha,
+        reviewTarget,
+        aliasOf: owner.ownerSessionId,
+        ownerResolved: true
+      });
+      const aliasFile = await approvals.record(aliasMeta);
+      written.push({ pendingId: id, file: aliasFile });
+    } else {
+      const meta = buildMeta(id, {
+        coveredSha,
+        reviewTarget,
+        ownerResolved
+      });
+      const file = await approvals.record(meta);
+      written.push({ pendingId: id, file });
     }
-    const meta = {
-      pendingId: id,
-      verdict: args.verdict,
-      reviewer: {
-        agent: args.reviewerAgent ?? (args.source === "codeforge-fallback" ? "codeforge" : "reviewer"),
-        ...args.sessionId ? { sessionId: args.sessionId } : {},
-        ...args.model ? { model: args.model } : {},
-        source: args.source ?? "reviewer"
-      },
-      targets: [],
-      decisionLine: args.decisionLine ?? args.verdict,
-      notes: args.notes,
-      createdAt: now,
-      ...coveredSha ? { coveredSha } : {},
-      ...reviewTarget ? { reviewTarget } : {},
-      escapeHatch: null
-    };
-    const file = await approvals.record(meta);
-    written.push({ pendingId: id, file });
   }
   return { ok: true, written };
 }
@@ -11572,7 +12040,7 @@ async function execute4(input) {
 import { z as z5 } from "zod";
 
 // lib/browser-control.ts
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 var DEFAULT_CONFIG2 = {
   enabled: false,
   headless: true,
@@ -11584,7 +12052,7 @@ var DEFAULT_CONFIG2 = {
   bufferLimit: 500
 };
 function defaultScreenshotDir(root = process.cwd()) {
-  return path12.join(runtimeDir(root), "browser", "screenshots");
+  return path13.join(runtimeDir(root), "browser", "screenshots");
 }
 function checkUrl(url, cfg = DEFAULT_CONFIG2) {
   if (typeof url !== "string" || url.trim() === "") {
@@ -11709,14 +12177,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 path13 = `${dir}/${Date.now()}.png`;
+        const path14 = `${dir}/${Date.now()}.png`;
         if (opts?.selector) {
           const el = await page.locator(opts.selector).first();
-          await el.screenshot({ path: path13 });
+          await el.screenshot({ path: path14 });
         } else {
-          await page.screenshot({ path: path13, fullPage: opts?.fullPage });
+          await page.screenshot({ path: path14, fullPage: opts?.fullPage });
         }
-        return { ok: true, path: path13 };
+        return { ok: true, path: path14 };
       } catch (err) {
         return { ok: false, error: describe3(err) };
       }
@@ -12033,8 +12501,8 @@ async function execute10(input) {
 import { z as z11 } from "zod";
 
 // lib/model-config.ts
-import { promises as fs10 } from "node:fs";
-import * as path13 from "node:path";
+import { promises as fs11 } from "node:fs";
+import * as path14 from "node:path";
 
 // lib/model-tier.ts
 var TIER_ORDER = ["quick", "balanced", "deep", "ultra"];
@@ -12051,12 +12519,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 = path13.resolve(root, opts.file ?? CONFIG_FILE);
+  const abs = path14.resolve(root, opts.file ?? CONFIG_FILE);
   return fsSync.existsSync(abs) ? abs : null;
 }
 function loadModelConfigSync(opts = {}) {
   const root = opts.root ?? process.cwd();
-  const abs = path13.resolve(root, opts.file ?? CONFIG_FILE);
+  const abs = path14.resolve(root, opts.file ?? CONFIG_FILE);
   const fsSync = __require("node:fs");
   if (!fsSync.existsSync(abs)) {
     return { ok: false, warnings: [], error: `config_not_found: ${abs}` };
@@ -12071,10 +12539,10 @@ function loadModelConfigSync(opts = {}) {
 }
 async function loadModelConfig(opts = {}) {
   const root = opts.root ?? process.cwd();
-  const abs = path13.resolve(root, opts.file ?? CONFIG_FILE);
+  const abs = path14.resolve(root, opts.file ?? CONFIG_FILE);
   let raw;
   try {
-    raw = await fs10.readFile(abs, "utf8");
+    raw = await fs11.readFile(abs, "utf8");
   } catch (e) {
     const code = e.code;
     if (code === "ENOENT") {
@@ -12285,6 +12753,18 @@ function normalizeThinking(ctx, raw) {
   if (o.budget_tokens !== undefined && (typeof o.budget_tokens !== "number" || o.budget_tokens < 0)) {
     return { ok: false, error: `${ctx}.thinking.budget_tokens: must be non-negative number` };
   }
+  const REASONING_EFFORT_VALUES = ["low", "medium", "high", "xhigh"];
+  if (o.reasoning_effort !== undefined) {
+    if (typeof o.reasoning_effort !== "string" || !REASONING_EFFORT_VALUES.includes(o.reasoning_effort)) {
+      return { ok: false, error: `${ctx}.thinking.reasoning_effort: must be one of ${REASONING_EFFORT_VALUES.join("/")}` };
+    }
+  }
+  const THINKING_LEVEL_VALUES = ["low", "medium", "high"];
+  if (o.thinking_level !== undefined) {
+    if (typeof o.thinking_level !== "string" || !THINKING_LEVEL_VALUES.includes(o.thinking_level)) {
+      return { ok: false, error: `${ctx}.thinking.thinking_level: must be one of ${THINKING_LEVEL_VALUES.join("/")}` };
+    }
+  }
   return { ok: true, value: { ...o, type: o.type } };
 }
 function normalizeRuntime(raw) {
@@ -12536,8 +13016,8 @@ function toEntry(r) {
 import { z as z12 } from "zod";
 
 // lib/merge-gate.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";
 var DEFAULT_MERGE_GATE_CONFIG = {
   enabled: true,
   approvalPreCheck: true,
@@ -12545,10 +13025,10 @@ var DEFAULT_MERGE_GATE_CONFIG = {
 };
 var CONFIG_REL = ".codeforge/merge-gate.json";
 async function loadMergeGate(mainRoot) {
-  const file = path14.join(mainRoot, CONFIG_REL);
+  const file = path15.join(mainRoot, CONFIG_REL);
   let raw;
   try {
-    raw = await fs11.readFile(file, "utf8");
+    raw = await fs12.readFile(file, "utf8");
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT")
@@ -12715,6 +13195,13 @@ async function runMergeLoop(opts) {
           console.warn(`[merge-loop] approval-store 查询失败 (session=${opts.sessionId}): ${err instanceof Error ? err.message : String(err)}`);
           approval = undefined;
         }
+        if (!approval) {
+          const aliasHit = await tryOwnerAliasBackstop({ opts, entry, store });
+          if (aliasHit) {
+            approval = aliasHit.approval;
+            approvalKey = aliasHit.approvalKey;
+          }
+        }
         const valid = !!approval && (approval.verdict === "APPROVE" || approval.verdict === "APPROVE_WITH_NOTES");
         if (!valid) {
           const blockReason = buildApprovalGateBlockReason({
@@ -12901,6 +13388,11 @@ async function tryApprovalPreCheck(args) {
     console.warn(`[merge-loop] pre-check getLatest 失败 (session=${opts.sessionId}): ${err instanceof Error ? err.message : String(err)}`);
     return { ok: false, reason: "no-approval" };
   }
+  if (!approval) {
+    const aliasHit = await tryOwnerAliasBackstop({ opts, entry, store });
+    if (aliasHit)
+      approval = aliasHit.approval;
+  }
   if (!approval)
     return { ok: false, reason: "no-approval" };
   if (approval.verdict !== "APPROVE" && approval.verdict !== "APPROVE_WITH_NOTES") {
@@ -12920,11 +13412,38 @@ async function tryApprovalPreCheck(args) {
     return { ok: false, reason: "ttl-expired" };
   return { ok: true, coveredSha: approval.coveredSha, reviewTarget: approval.reviewTarget };
 }
+async function tryOwnerAliasBackstop(args) {
+  const { opts, entry, store } = args;
+  const resolveOwner = opts.__testHooks?.resolveWorktreeOwner ?? resolveWorktreeOwner;
+  const validVerdict = (a) => !!a && (a.verdict === "APPROVE" || a.verdict === "APPROVE_WITH_NOTES");
+  try {
+    const owner = await resolveOwner({
+      sessionId: opts.sessionId,
+      mainRoot: opts.mainRoot,
+      worktreePath: entry.worktreePath
+    });
+    if (owner.ok && owner.ownerSessionId !== opts.sessionId) {
+      const key = `session:${owner.ownerSessionId}`;
+      const a = await store.getLatest(key);
+      if (validVerdict(a))
+        return { approval: a, approvalKey: key };
+    }
+  } catch {}
+  if (typeof store.findAliasApprovals === "function") {
+    try {
+      const aliases = await store.findAliasApprovals(opts.sessionId);
+      const hit = aliases.find(validVerdict);
+      if (hit)
+        return { approval: hit, approvalKey: hit.pendingId };
+    } catch {}
+  }
+  return;
+}
 function isAbortError(err) {
   return err instanceof Error && err.name === "AbortError";
 }
 function withTimeout2(p, ms, label, signal, hbOpts) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     const startedAt = Date.now();
     let hbTimer = null;
     let timer;
@@ -12964,7 +13483,7 @@ function withTimeout2(p, ms, label, signal, hbOpts) {
     }
     p.then((v) => {
       cleanup();
-      resolve11(v);
+      resolve12(v);
     }, (e) => {
       cleanup();
       reject(e);
@@ -13087,6 +13606,24 @@ async function isSessionIdValid(sid, mainRoot) {
     return false;
   }
 }
+async function checkRegistryHealth(mainRoot, action) {
+  const health = await readRegistryResult(mainRoot);
+  if (health.kind === "corrupt") {
+    return {
+      ok: false,
+      action,
+      error: `session 追踪文件损坏（${health.reason}），暂时无法读取 worktree 状态` + `——这**不代表**没有 worktree。请检查 ${health.path}` + `（如有 .corrupt.* 备份可对照），确认后删除损坏文件让系统重建，或恢复正确内容。`
+    };
+  }
+  if (health.kind === "version_too_new") {
+    return {
+      ok: false,
+      action,
+      error: `session 追踪文件版本（v${health.foundVersion}）高于当前 CodeForge 支持` + `（v${health.supportedVersion}），已启用只读保护。请升级 CodeForge 后再查看/操作` + `（原文件未被改动）。`
+    };
+  }
+  return null;
+}
 async function execute12(input) {
   const parsed = ArgsSchema12.safeParse(input);
   if (!parsed.success) {
@@ -13102,6 +13639,9 @@ async function execute12(input) {
     const mainRoot = getMainRoot();
     const sessionId = await resolveSessionId(args.session_id);
     if (args.action === "status") {
+      const bad = await checkRegistryHealth(mainRoot, "status");
+      if (bad)
+        return bad;
       const entry = await getSessionWorktree(sessionId, mainRoot);
       if (!entry) {
         return {
@@ -13114,6 +13654,9 @@ async function execute12(input) {
       return { ok: true, action: "status", data: { ...entry, summary } };
     }
     if (args.action === "discard") {
+      const bad = await checkRegistryHealth(mainRoot, "discard");
+      if (bad)
+        return bad;
       await discardSession({ sessionId, mainRoot });
       return {
         ok: true,
@@ -13122,6 +13665,9 @@ async function execute12(input) {
       };
     }
     if (args.action === "diff") {
+      const bad = await checkRegistryHealth(mainRoot, "diff");
+      if (bad)
+        return bad;
       const entry = await getSessionWorktree(sessionId, mainRoot);
       if (!entry) {
         return { ok: false, action: "diff", error: `session ${sessionId} 没有绑定 worktree` };
@@ -13222,8 +13768,8 @@ async function execute12(input) {
 import { z as z13 } from "zod";
 
 // lib/plan-store.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 INDEX_VERSION = 1;
 
 class PlanStore {
@@ -13232,8 +13778,8 @@ class PlanStore {
   now;
   secondCounters = new Map;
   constructor(opts = {}) {
-    this.root = path15.resolve(opts.root ?? process.cwd());
-    this.base = opts.base ? path15.resolve(opts.base) : plansDir(this.root);
+    this.root = path16.resolve(opts.root ?? process.cwd());
+    this.base = opts.base ? path16.resolve(opts.base) : plansDir(this.root);
     this.now = opts.now ?? (() => new Date);
   }
   async write(input) {
@@ -13243,14 +13789,14 @@ class PlanStore {
     if (typeof input.content !== "string" || input.content.length === 0) {
       throw new Error("PlanStore.write: content 不能为空");
     }
-    await fs12.mkdir(this.base, { recursive: true });
+    await fs13.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 = path15.join(this.base, filename);
+      const absFile = path16.join(this.base, filename);
       await this.atomicWriteFile(absFile, input.content);
       const entry = {
         plan_id: planId,
@@ -13274,9 +13820,9 @@ class PlanStore {
     const entry = index.entries.find((e) => e.plan_id === planId);
     if (!entry)
       return null;
-    const abs = path15.join(this.base, entry.path);
+    const abs = path16.join(this.base, entry.path);
     try {
-      const content = await fs12.readFile(abs, "utf8");
+      const content = await fs13.readFile(abs, "utf8");
       return { entry, content };
     } catch (err) {
       const e = err;
@@ -13335,7 +13881,7 @@ class PlanStore {
         else if (e.status === "orphan")
           shouldDelete = true;
         if (shouldDelete) {
-          await fs12.rm(path15.join(this.base, e.path), { force: true }).catch(() => {});
+          await fs13.rm(path16.join(this.base, e.path), { force: true }).catch(() => {});
           removed++;
         } else {
           keep.push(e);
@@ -13357,9 +13903,9 @@ class PlanStore {
         knownPaths.add(e.path);
         if (e.status !== "active")
           continue;
-        const abs = path15.join(this.base, e.path);
+        const abs = path16.join(this.base, e.path);
         try {
-          await fs12.stat(abs);
+          await fs13.stat(abs);
         } catch {
           e.status = "orphan";
           markedOrphan++;
@@ -13369,23 +13915,23 @@ class PlanStore {
         await this.writeIndexLocked(index);
       let unindexedFiles = [];
       try {
-        const all = await fs12.readdir(this.base);
+        const all = await fs13.readdir(this.base);
         unindexedFiles = all.filter((f) => f.endsWith(".md")).filter((f) => !knownPaths.has(f));
       } catch {}
       return { markedOrphan, unindexedFiles };
     });
   }
   indexPath() {
-    return path15.join(this.base, "index.json");
+    return path16.join(this.base, "index.json");
   }
   lockPath() {
-    return path15.join(this.base, "index.lock");
+    return path16.join(this.base, "index.lock");
   }
   async readIndexLocked() {
     const file = this.indexPath();
     let raw;
     try {
-      raw = await fs12.readFile(file, "utf8");
+      raw = await fs13.readFile(file, "utf8");
     } catch (err) {
       const e = err;
       if (e.code === "ENOENT")
@@ -13407,7 +13953,7 @@ class PlanStore {
   async archiveCorruptIndex(file) {
     const ts = this.now().toISOString().replace(/[-:.TZ]/g, "").slice(0, 14);
     const dst = `${file}.corrupt-${ts}`;
-    await fs12.rename(file, dst).catch(() => {});
+    await fs13.rename(file, dst).catch(() => {});
   }
   async readIndex() {
     return this.readIndexLocked();
@@ -13452,15 +13998,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 = path15.basename(sample, ".md");
+    const base = path16.basename(sample, ".md");
     const slug = base.replace(/^\d{8}-\d{6}-?/, "") || "untitled";
     return `${tsPart}-${nnn}-${slug}.md`;
   }
   async atomicWriteFile(file, data) {
-    await fs12.mkdir(path15.dirname(file), { recursive: true });
+    await fs13.mkdir(path16.dirname(file), { recursive: true });
     const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
-    await fs12.writeFile(tmp, data, "utf8");
-    await fs12.rename(tmp, file);
+    await fs13.writeFile(tmp, data, "utf8");
+    await fs13.rename(tmp, file);
   }
 }
 function formatTimestamp(d) {
@@ -13523,8 +14069,8 @@ async function execute13(input) {
   }
 }
 // tools/plan-read.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";
 import { z as z14 } from "zod";
 var description14 = [
   "读取方案文档内容，支持按 plan_id 或绝对路径查询。",
@@ -13630,9 +14176,9 @@ async function execute14(input) {
       };
     }
   }
-  const abs = path16.resolve(args.path);
+  const abs = path17.resolve(args.path);
   try {
-    const content = await fs13.readFile(abs, "utf8");
+    const content = await fs14.readFile(abs, "utf8");
     return {
       ok: true,
       content,
@@ -13657,16 +14203,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 path17 from "node:path";
+import * as path18 from "node:path";
 import * as url from "node:url";
 function resolveAssetsRoot() {
-  const here = path17.dirname(url.fileURLToPath(import.meta.url));
+  const here = path18.dirname(url.fileURLToPath(import.meta.url));
   let dir = here;
   for (let i = 0;i < 6; i++) {
-    if (existsSync4(path17.join(dir, "package.json")) && existsSync4(path17.join(dir, "assets", "adr-init"))) {
-      return path17.join(dir, "assets", "adr-init");
+    if (existsSync4(path18.join(dir, "package.json")) && existsSync4(path18.join(dir, "assets", "adr-init"))) {
+      return path18.join(dir, "assets", "adr-init");
     }
-    const parent = path17.dirname(dir);
+    const parent = path18.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -13674,13 +14220,13 @@ function resolveAssetsRoot() {
   const xdgConfig = process.env["XDG_CONFIG_HOME"];
   const homeDir = process.env["HOME"] ?? process.env["USERPROFILE"] ?? "";
   const fallbackRoots = [
-    xdgConfig ? path17.join(xdgConfig, "opencode") : null,
-    path17.join(homeDir, ".config", "opencode"),
-    process.env["APPDATA"] ? path17.join(process.env["APPDATA"], "opencode") : null,
-    process.env["LOCALAPPDATA"] ? path17.join(process.env["LOCALAPPDATA"], "opencode") : null
+    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
   ].filter(Boolean);
   for (const root of fallbackRoots) {
-    const candidate = path17.join(root, "assets", "adr-init");
+    const candidate = path18.join(root, "assets", "adr-init");
     if (existsSync4(candidate)) {
       return candidate;
     }
@@ -13717,7 +14263,7 @@ function runGitConfigHooksPath(cwd) {
   }
 }
 async function runAdrInit(opts = {}) {
-  const cwd = path17.resolve(opts.cwd ?? process.cwd());
+  const cwd = path18.resolve(opts.cwd ?? process.cwd());
   const force = !!opts.force;
   const dryRun = !!opts.dryRun;
   const writePrepare = !!opts.writePrepare;
@@ -13766,8 +14312,8 @@ async function runAdrInit(opts = {}) {
     });
   }
   for (const item of plan) {
-    const srcAbs = path17.join(assetsRoot, item.src);
-    const dstAbs = path17.join(cwd, item.dst);
+    const srcAbs = path18.join(assetsRoot, item.src);
+    const dstAbs = path18.join(cwd, item.dst);
     if (!existsSync4(srcAbs)) {
       result.warnings.push(`资产缺失：${item.src}（跳过 ${item.dst}）`);
       continue;
@@ -13780,7 +14326,7 @@ async function runAdrInit(opts = {}) {
       const bakRel = `${item.dst}.bak.${ts}`;
       if (!dryRun) {
         try {
-          await fsp.copyFile(dstAbs, path17.join(cwd, bakRel));
+          await fsp.copyFile(dstAbs, path18.join(cwd, bakRel));
         } catch (e) {
           result.ok = false;
           result.reason = "io_error";
@@ -13792,7 +14338,7 @@ async function runAdrInit(opts = {}) {
     }
     if (!dryRun) {
       try {
-        await fsp.mkdir(path17.dirname(dstAbs), { recursive: true });
+        await fsp.mkdir(path18.dirname(dstAbs), { recursive: true });
         await fsp.copyFile(srcAbs, dstAbs);
         if (item.chmod !== undefined) {
           try {
@@ -13822,7 +14368,7 @@ async function runAdrInit(opts = {}) {
   } else {
     result.suggestions.push("[dry-run] 将运行：git config core.hooksPath .githooks");
   }
-  const pkgPath = path17.join(cwd, "package.json");
+  const pkgPath = path18.join(cwd, "package.json");
   const isNpm = existsSync4(pkgPath);
   if (isNpm) {
     if (writePrepare) {
@@ -13837,7 +14383,7 @@ async function runAdrInit(opts = {}) {
           const bakRel = `package.json.bak.${ts}`;
           if (!dryRun) {
             try {
-              await fsp.copyFile(pkgPath, path17.join(cwd, bakRel));
+              await fsp.copyFile(pkgPath, path18.join(cwd, bakRel));
             } catch (e) {
               result.warnings.push(`备份 package.json 失败：${e instanceof Error ? e.message : String(e)}`);
             }
@@ -13960,12 +14506,12 @@ async function execute15(input) {
 import { z as z16 } from "zod";
 
 // lib/opencode-session-probe.ts
-import * as path18 from "node:path";
+import * as path19 from "node:path";
 import * as os5 from "node:os";
 import { createRequire as createRequire2 } from "node:module";
 var requireFromHere = createRequire2(import.meta.url);
 var DEFAULT_LIVENESS_MS = 6 * 60 * 60000;
-var DEFAULT_DB_PATH = path18.join(os5.homedir(), ".local/share/opencode/opencode.db");
+var DEFAULT_DB_PATH = path19.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"];
@@ -14120,14 +14666,14 @@ function pickLastText(parts) {
   return "";
 }
 async function sendParentNotice(client, sessionID, text, opts = {}) {
-  const log4 = opts.log ?? (() => {});
+  const log5 = opts.log ?? (() => {});
   if (!client?.session) {
-    log4("warn", "[sendParentNotice] client.session 不可用，noop");
+    log5("warn", "[sendParentNotice] client.session 不可用，noop");
     return false;
   }
   const sessionAny = client.session;
   if (typeof sessionAny.promptAsync !== "function") {
-    log4("warn", "[sendParentNotice] promptAsync 不可用（SDK 太老？），noop");
+    log5("warn", "[sendParentNotice] promptAsync 不可用（SDK 太老？），noop");
     return false;
   }
   try {
@@ -14148,12 +14694,12 @@ async function sendParentNotice(client, sessionID, text, opts = {}) {
       }
     });
     if (res && typeof res === "object" && "error" in res && res.error) {
-      log4("warn", "[sendParentNotice] promptAsync 返回 error", { error: res.error });
+      log5("warn", "[sendParentNotice] promptAsync 返回 error", { error: res.error });
       return false;
     }
     return true;
   } catch (err) {
-    log4("warn", "[sendParentNotice] 抛错（已隔离）", {
+    log5("warn", "[sendParentNotice] 抛错（已隔离）", {
       error: err instanceof Error ? err.message : String(err)
     });
     return false;
@@ -14162,219 +14708,31 @@ async function sendParentNotice(client, sessionID, text, opts = {}) {
 
 // lib/spawner-production.ts
 init_decision_parser();
-
-// lib/parent-map-store.ts
-import { promises as fs14 } from "node:fs";
-import * as path19 from "node:path";
-var PARENT_MAP_VERSION = 1;
-var PARENT_MAP_LOCK_TIMEOUT_MS = 2000;
-var PARENT_MAP_MAX_ENTRIES = 256;
-function parentMapDir(mainRoot) {
-  return path19.join(runtimeDir(path19.resolve(mainRoot), { ensure: false }), "session-worktrees");
-}
-function parentMapPath(mainRoot) {
-  return path19.join(parentMapDir(mainRoot), "parent-map.json");
-}
-function parentMapLockPath(mainRoot) {
-  return path19.join(parentMapDir(mainRoot), "parent-map.lock");
-}
-async function readParentMapFile(mainRoot) {
-  const file = parentMapPath(mainRoot);
-  try {
-    const raw = await fs14.readFile(file, "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed.version !== PARENT_MAP_VERSION || !Array.isArray(parsed.entries)) {
-      return { version: PARENT_MAP_VERSION, entries: [] };
-    }
-    return parsed;
-  } catch (err) {
-    const e = err;
-    if (e.code === "ENOENT")
-      return { version: PARENT_MAP_VERSION, entries: [] };
-    return { version: PARENT_MAP_VERSION, entries: [] };
-  }
-}
-async function writeParentMapFile(mainRoot, payload) {
-  const file = parentMapPath(mainRoot);
-  await fs14.mkdir(path19.dirname(file), { recursive: true });
-  const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
-  await fs14.writeFile(tmp, JSON.stringify(payload, null, 2), "utf8");
-  await fs14.rename(tmp, file);
-}
-function capEntriesByTsDesc(entries) {
-  if (entries.length <= PARENT_MAP_MAX_ENTRIES)
-    return entries;
-  return [...entries].sort((a, b) => b.ts - a.ts).slice(0, PARENT_MAP_MAX_ENTRIES);
-}
-async function loadParentMap(mainRoot) {
-  const out = new Map;
-  let file;
-  try {
-    file = await readParentMapFile(mainRoot);
-  } catch {
-    return out;
-  }
-  const valid = [];
-  for (const e of file.entries) {
-    if (!e || typeof e.childID !== "string" || typeof e.parentID !== "string")
-      continue;
-    if (!e.childID || !e.parentID)
-      continue;
-    const ts = typeof e.ts === "number" ? e.ts : Date.now();
-    valid.push({ childID: e.childID, parentID: e.parentID, ts });
-  }
-  const capped = capEntriesByTsDesc(valid);
-  for (const e of capped) {
-    out.set(e.childID, { parentID: e.parentID, ts: e.ts });
-  }
-  return out;
-}
-async function mutateParentMap(mainRoot, mutator, opts = {}) {
-  const lockPath = parentMapLockPath(mainRoot);
-  await fs14.mkdir(path19.dirname(lockPath), { recursive: true });
-  const lockOpts = {
-    timeoutMs: opts.timeoutMs ?? PARENT_MAP_LOCK_TIMEOUT_MS,
-    ...opts
-  };
-  await withFileLock(lockPath, async () => {
-    const current = await readParentMapFile(mainRoot);
-    const input = current.entries.slice();
-    const next = await mutator(input);
-    if (!Array.isArray(next))
-      return;
-    const capped = capEntriesByTsDesc(next);
-    await writeParentMapFile(mainRoot, { version: PARENT_MAP_VERSION, entries: capped });
-  }, lockOpts);
-}
-async function appendParentEntry(mainRoot, childID, parentID, ts, opts = {}) {
-  if (!childID || !parentID)
-    return;
-  const lockPath = parentMapLockPath(mainRoot);
-  await fs14.mkdir(path19.dirname(lockPath), { recursive: true });
-  const lockOpts = {
-    timeoutMs: opts.timeoutMs ?? PARENT_MAP_LOCK_TIMEOUT_MS,
-    ...opts
-  };
-  await withFileLock(lockPath, async () => {
-    const current = await readParentMapFile(mainRoot);
-    const idx = current.entries.findIndex((e) => e.childID === childID);
-    if (idx >= 0) {
-      current.entries[idx] = { childID, parentID, ts };
-    } else {
-      current.entries.push({ childID, parentID, ts });
-    }
-    const capped = capEntriesByTsDesc(current.entries);
-    await writeParentMapFile(mainRoot, { version: PARENT_MAP_VERSION, entries: capped });
-  }, lockOpts);
-}
-
-// lib/parent-map-runtime.ts
-var log4 = makePluginLogger("parent-map-runtime");
-var SESSION_PARENT_MAP_TTL_MS = 30 * 60000;
-var SESSION_PARENT_MAP_MAX_SIZE = PARENT_MAP_MAX_ENTRIES;
-var sessionParentMap = new Map;
-var _persistRoot = null;
-function _setPersistRootForTests(root) {
-  _persistRoot = root;
-}
-function _bulkInjectSessionParentMap(entries) {
-  for (const e of entries) {
-    if (!e.childID || !e.parentID)
-      continue;
-    sessionParentMap.set(e.childID, { parentID: e.parentID, ts: e.ts });
-  }
-}
-function _capSessionParentMap() {
-  if (sessionParentMap.size <= SESSION_PARENT_MAP_MAX_SIZE)
-    return 0;
-  const sorted = [...sessionParentMap.entries()].sort((a, b) => b[1].ts - a[1].ts);
-  const keep = new Set(sorted.slice(0, SESSION_PARENT_MAP_MAX_SIZE).map(([k]) => k));
-  let removed = 0;
-  for (const k of [...sessionParentMap.keys()]) {
-    if (!keep.has(k)) {
-      sessionParentMap.delete(k);
-      removed++;
-    }
-  }
-  return removed;
-}
-function recordSessionParent(childID, parentID, now = Date.now()) {
-  if (!childID || !parentID)
-    return;
-  if (sessionParentMap.has(childID)) {
-    sessionParentMap.set(childID, { parentID, ts: now });
-  } else {
-    if (sessionParentMap.size >= SESSION_PARENT_MAP_MAX_SIZE) {
-      let oldestKey = null;
-      let oldestTs = Number.POSITIVE_INFINITY;
-      for (const [k, v] of sessionParentMap.entries()) {
-        if (v.ts < oldestTs) {
-          oldestTs = v.ts;
-          oldestKey = k;
-        }
-      }
-      if (oldestKey !== null)
-        sessionParentMap.delete(oldestKey);
-    }
-    sessionParentMap.set(childID, { parentID, ts: now });
-  }
-  if (_persistRoot) {
-    appendParentEntry(_persistRoot, childID, parentID, now).catch((err) => {
-      log4.warn("appendParentEntry 失败（已隔离）", {
-        error: err instanceof Error ? err.message : String(err),
-        childID
-      });
-    });
-  }
-}
-function lookupParentSessionId(childID, now = Date.now()) {
-  const entry = sessionParentMap.get(childID);
-  if (!entry)
-    return;
-  if (now - entry.ts > SESSION_PARENT_MAP_TTL_MS) {
-    sessionParentMap.delete(childID);
-    return;
-  }
-  return entry.parentID;
-}
-function deleteSessionParent(childID) {
-  sessionParentMap.delete(childID);
-  if (_persistRoot) {
-    mutateParentMap(_persistRoot, (entries) => entries.filter((e) => e.childID !== childID)).catch((err) => {
-      log4.warn("mutateParentMap (delete) 失败（已隔离）", {
-        error: err instanceof Error ? err.message : String(err),
-        childID
-      });
-    });
-  }
-}
-function sweepExpiredSessionParents(now = Date.now()) {
-  let removed = 0;
-  for (const [k, v] of [...sessionParentMap.entries()]) {
-    if (now - v.ts > SESSION_PARENT_MAP_TTL_MS) {
-      sessionParentMap.delete(k);
-      removed++;
-    }
-  }
-  if (_persistRoot) {
-    mutateParentMap(_persistRoot, (entries) => entries.filter((e) => now - e.ts <= SESSION_PARENT_MAP_TTL_MS)).catch((err) => {
-      log4.warn("mutateParentMap (sweep) 失败（已隔离）", {
-        error: err instanceof Error ? err.message : String(err),
-        removed
-      });
-    });
-  }
-  return removed;
-}
-
-// lib/spawner-production.ts
 class ProductionSpawner {
   opts;
   constructor(opts) {
     this.opts = opts;
   }
   async spawnReviewer(args) {
-    const prompt = buildReviewerPrompt(args);
+    let ownerSessionId = args.sessionId;
+    const ownerRoot = this.opts.mainRoot ?? this.opts.directory;
+    if (ownerRoot) {
+      try {
+        const owner = await resolveWorktreeOwner({
+          sessionId: args.sessionId,
+          mainRoot: ownerRoot,
+          ...args.worktreePath ? { worktreePath: args.worktreePath } : {}
+        });
+        if (owner.ok)
+          ownerSessionId = owner.ownerSessionId;
+      } catch (err) {
+        this.opts.log?.("warn", `[spawner] resolveWorktreeOwner 失败，回退原 sessionId`, {
+          err: describe4(err),
+          sessionId: args.sessionId
+        });
+      }
+    }
+    const prompt = buildReviewerPrompt({ ...args, ownerSessionId });
     let r;
     try {
       r = await this.runSubagent({
@@ -14535,16 +14893,17 @@ async function raceAbortTimeout(p, signal, timeoutMs, label) {
   });
 }
 function buildReviewerPrompt(args) {
+  const ownerSessionId = args.ownerSessionId ?? args.sessionId;
   const lines = [
     "[Session Merge Review]",
     "",
-    `session_id: ${args.sessionId}`,
+    `session_id: ${ownerSessionId}`,
     `worktree_path: ${args.worktreePath}`,
     `base_sha: ${args.baseSha}`
   ];
   if (args.planId)
     lines.push(`plan_id: ${args.planId}`);
-  lines.push(`round: ${args.round}/${args.maxRounds}`, "", "请按 reviewer.md 「worktree-session 审阅」模式执行：", "1. 若有 plan_id → 先 plan_read(plan_id=...) 拿方案", "2. 跑 `git -C <worktree_path> diff <base_sha>..HEAD` 看改动", '3. APPROVE 前必须先调 review_approval(verdict=APPROVE, pendingIds=["session:<session_id>"], reviewTarget="code") 写审批', "   （coveredSha 工具会自动从 worktree HEAD 捕获，无需手传）", "4. 输出 ## Decision 节，首行 APPROVE / REQUEST_CHANGES / BLOCK 之一");
+  lines.push(`round: ${args.round}/${args.maxRounds}`, "", "请按 reviewer.md 「worktree-session 审阅」模式执行：", "1. 若有 plan_id → 先 plan_read(plan_id=...) 拿方案", "2. 跑 `git -C <worktree_path> diff <base_sha>..HEAD` 看改动", '3. APPROVE 前必须先调 review_approval(verdict=APPROVE, pendingIds=["session:<session_id>"], reviewTarget="code", worktreePath="<worktree_path>") 写审批', "   （coveredSha 工具会自动从 worktree HEAD 捕获，无需手传）", "4. 输出 ## Decision 节，首行 APPROVE / REQUEST_CHANGES / BLOCK 之一");
   if (args.prevSummary) {
     lines.push("", "## 上一轮 reviewer 意见", "", args.prevSummary, "", "请确认 coder 是否已按意见修复");
   }
@@ -18903,7 +19262,7 @@ import * as https from "node:https";
 // lib/version-injected.ts
 function getInjectedVersion() {
   try {
-    const v = "0.7.10";
+    const v = "0.8.0";
     if (typeof v === "string" && /^\d+\.\d+\.\d+/.test(v)) {
       return v;
     }
@@ -20745,6 +21104,32 @@ var pruneRunning = false;
 var _pruneTimer;
 var _activateGeneration = 0;
 var _probe = null;
+var _registryUnreadableNotified = false;
+async function maybeNotifyRegistryUnreadable(client, rec, prune) {
+  const unreadable = rec.registryUnreadable ?? prune.registryUnreadable;
+  if (!unreadable) {
+    _registryUnreadableNotified = false;
+    return;
+  }
+  safeWriteLog(PLUGIN_NAME22, {
+    hook: "registry-unreadable",
+    reason: unreadable.reason,
+    detail: unreadable.detail,
+    path: unreadable.path,
+    action: "skip-cleanup-fail-closed"
+  });
+  if (_registryUnreadableNotified)
+    return;
+  _registryUnreadableNotified = true;
+  const msg = summarizeReconcileDigest(rec, {
+    cleaned: [],
+    failed: [],
+    ...prune.registryUnreadable ? { registryUnreadable: prune.registryUnreadable } : {}
+  });
+  if (!msg)
+    return;
+  await showToast2(client, { message: msg, variant: "warning", duration: 1e4, title: "CodeForge" }, log14).catch(() => {});
+}
 var log14 = makePluginLogger(PLUGIN_NAME22);
 var worktreeLifecyclePlugin = async (ctx) => {
   const rawDir = ctx.directory ?? process.cwd();
@@ -20790,6 +21175,7 @@ var worktreeLifecyclePlugin = async (ctx) => {
       const result = await pruneOrphanWorktrees(mainRoot, {
         isSessionAlive: _probe.isSessionAlive
       });
+      await maybeNotifyRegistryUnreadable(client, rec, result);
       if (result.cleaned.length > 0 || result.failed.length > 0) {
         log14.info(`[pruneOrphan] cleaned=${result.cleaned.length} failed=${result.failed.length} skipped=${result.skipped}`);
         safeWriteLog(PLUGIN_NAME22, {
@@ -20820,6 +21206,7 @@ var worktreeLifecyclePlugin = async (ctx) => {
         const result = await pruneOrphanWorktrees(mainRoot, {
           isSessionAlive: _probe.isSessionAlive
         });
+        await maybeNotifyRegistryUnreadable(client, rec, result);
         if (result.cleaned.length > 0 || result.failed.length > 0) {
           log14.info(`[pruneOrphan interval] cleaned=${result.cleaned.length} failed=${result.failed.length} skipped=${result.skipped}`);
           safeWriteLog(PLUGIN_NAME22, {