@andyqiu/codeforge 0.5.5 → 0.5.6

package/dist/index.js

@@ -8205,11 +8205,11 @@ function shouldStopByStuck(history, cfg) {
 async function withTimeout4(p, timeoutMs) {
   if (timeoutMs <= 0)
     return await p;
-  return await new Promise((resolve15, reject) => {
+  return await new Promise((resolve16, reject) => {
     const timer = setTimeout(() => reject(new Error(`timeout after ${timeoutMs}ms`)), timeoutMs);
     Promise.resolve(p).then((v) => {
       clearTimeout(timer);
-      resolve15(v);
+      resolve16(v);
     }, (err) => {
       clearTimeout(timer);
       reject(err);
@@ -14676,8 +14676,8 @@ async function sendParentNotice(client, sessionID, text, opts = {}) {
             id: makePartId(),
             type: "text",
             text,
-            synthetic: false,
-            ignored: false
+            synthetic: true,
+            ignored: true
           }
         ]
       }
@@ -15879,7 +15879,12 @@ var codeforgeToolsServer = async (ctx) => {
               ...sid ? { currentSessionId: sid } : {},
               ...sid ? {
                 sendProgress: async (state, detail) => {
-                  await sendParentNotice(ctx.client, sid, `[merge-loop] ${state}: ${detail}`, ctx.directory ? { directory: ctx.directory } : {});
+                  const client = ctx.client;
+                  if (typeof client?.tui?.showToast === "function") {
+                    await client.tui.showToast({
+                      body: { message: `[merge-loop] ${state}: ${detail}`, variant: "default", duration: 4000, title: "CodeForge" }
+                    });
+                  }
                 }
               } : {}
             });
@@ -17856,9 +17861,103 @@ var handler12 = modelFallbackServer;
 
 // plugins/subtask-heartbeat.ts
 import { promises as fsPromises } from "node:fs";
-import * as path18 from "node:path";
+import * as path19 from "node:path";
 init_runtime_paths();
 init_global_config();
+
+// lib/parent-map-store.ts
+init_runtime_paths();
+import { promises as fs15 } from "node:fs";
+import * as path18 from "node:path";
+var PARENT_MAP_VERSION = 1;
+var PARENT_MAP_LOCK_TIMEOUT_MS = 2000;
+function parentMapDir(mainRoot) {
+  return path18.join(runtimeDir(path18.resolve(mainRoot), { ensure: false }), "session-worktrees");
+}
+function parentMapPath(mainRoot) {
+  return path18.join(parentMapDir(mainRoot), "parent-map.json");
+}
+function parentMapLockPath(mainRoot) {
+  return path18.join(parentMapDir(mainRoot), "parent-map.lock");
+}
+async function readParentMapFile(mainRoot) {
+  const file = parentMapPath(mainRoot);
+  try {
+    const raw = await fs15.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 fs15.mkdir(path18.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
+  await fs15.writeFile(tmp, JSON.stringify(payload, null, 2), "utf8");
+  await fs15.rename(tmp, file);
+}
+async function loadParentMap(mainRoot) {
+  const out = new Map;
+  let file;
+  try {
+    file = await readParentMapFile(mainRoot);
+  } catch {
+    return out;
+  }
+  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();
+    out.set(e.childID, { parentID: e.parentID, ts });
+  }
+  return out;
+}
+async function writeParentMap(mainRoot, snapshot, opts = {}) {
+  const lockPath = parentMapLockPath(mainRoot);
+  await fs15.mkdir(path18.dirname(lockPath), { recursive: true });
+  const lockOpts = {
+    timeoutMs: opts.timeoutMs ?? PARENT_MAP_LOCK_TIMEOUT_MS,
+    ...opts
+  };
+  await withFileLock(lockPath, async () => {
+    const entries = [];
+    for (const [childID, v] of snapshot.entries()) {
+      entries.push({ childID, parentID: v.parentID, ts: v.ts });
+    }
+    await writeParentMapFile(mainRoot, { version: PARENT_MAP_VERSION, entries });
+  }, lockOpts);
+}
+async function appendParentEntry(mainRoot, childID, parentID, ts, opts = {}) {
+  if (!childID || !parentID)
+    return;
+  const lockPath = parentMapLockPath(mainRoot);
+  await fs15.mkdir(path18.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 });
+    }
+    await writeParentMapFile(mainRoot, current);
+  }, lockOpts);
+}
+
+// plugins/subtask-heartbeat.ts
 var PLUGIN_NAME13 = "subtask-heartbeat";
 logLifecycle(PLUGIN_NAME13, "import", {});
 var HEARTBEAT_INTERVAL_MS2 = 30000;
@@ -17876,6 +17975,14 @@ var inflight3 = new Map;
 var pendingTask = new Map;
 var sessionParentMap = new Map;
 var _parentParseFailLogged = 0;
+var _persistRoot = null;
+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 _snapshotInflight() {
   return [...inflight3.values()].map((r) => ({ ...r }));
 }
@@ -17884,21 +17991,29 @@ function recordSessionParent(childID, parentID, now = Date.now()) {
     return;
   if (sessionParentMap.has(childID)) {
     sessionParentMap.set(childID, { parentID, ts: now });
-    return;
-  }
-  if (sessionParentMap.size >= SESSION_PARENT_MAP_MAX_SIZE) {
-    let oldestKey = null;
-    let oldestTs = Number.POSITIVE_INFINITY;
-    for (const [k, v] of sessionParentMap.entries()) {
-      if (v.ts < oldestTs) {
-        oldestTs = v.ts;
-        oldestKey = k;
+  } 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);
     }
-    if (oldestKey !== null)
-      sessionParentMap.delete(oldestKey);
+    sessionParentMap.set(childID, { parentID, ts: now });
+  }
+  if (_persistRoot) {
+    appendParentEntry(_persistRoot, childID, parentID, now).catch((err) => {
+      log7.warn("appendParentEntry 失败（已隔离）", {
+        error: err instanceof Error ? err.message : String(err),
+        childID
+      });
+    });
   }
-  sessionParentMap.set(childID, { parentID, ts: now });
 }
 function lookupParentSessionId(childID, now = Date.now()) {
   const entry = sessionParentMap.get(childID);
@@ -17912,6 +18027,15 @@ function lookupParentSessionId(childID, now = Date.now()) {
 }
 function deleteSessionParent(childID) {
   sessionParentMap.delete(childID);
+  if (_persistRoot) {
+    const snapshot = new Map(sessionParentMap);
+    writeParentMap(_persistRoot, snapshot).catch((err) => {
+      log7.warn("writeParentMap (delete) 失败（已隔离）", {
+        error: err instanceof Error ? err.message : String(err),
+        childID
+      });
+    });
+  }
 }
 function sweepExpiredSessionParents(now = Date.now()) {
   let removed = 0;
@@ -17921,6 +18045,15 @@ function sweepExpiredSessionParents(now = Date.now()) {
       removed++;
     }
   }
+  if (removed > 0 && _persistRoot) {
+    const snapshot = new Map(sessionParentMap);
+    writeParentMap(_persistRoot, snapshot).catch((err) => {
+      log7.warn("writeParentMap (sweep) 失败（已隔离）", {
+        error: err instanceof Error ? err.message : String(err),
+        removed
+      });
+    });
+  }
   return removed;
 }
 function detectUnparsedParentID(event) {
@@ -18218,7 +18351,7 @@ function buildFailureNotice(r, endedType, logPath, worktreePath, now = Date.now(
 }
 async function appendSubagentLog(filePath, line, log7) {
   try {
-    await fsPromises.mkdir(path18.dirname(filePath), { recursive: true });
+    await fsPromises.mkdir(path19.dirname(filePath), { recursive: true });
     await fsPromises.appendFile(filePath, line + `
 `, "utf8");
   } catch (err) {
@@ -18277,6 +18410,27 @@ var subtaskHeartbeatServer = async (ctx) => {
   });
   const client = ctx.client;
   const cwd = ctx.directory;
+  _persistRoot = cwd;
+  try {
+    const restored = await loadParentMap(cwd);
+    if (restored.size > 0) {
+      const entries = [...restored.entries()].map(([childID, v]) => ({
+        childID,
+        parentID: v.parentID,
+        ts: v.ts
+      }));
+      _bulkInjectSessionParentMap(entries);
+      safeWriteLog(PLUGIN_NAME13, {
+        hook: "activate",
+        type: "parent-map.restore",
+        restored: restored.size
+      });
+    }
+  } catch (err) {
+    log7.warn("loadParentMap 失败（已隔离），降级为空表", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
   const interval = setInterval(() => {
     safeAsync(PLUGIN_NAME13, "interval", async () => {
       const swept = sweepExpiredPendingTasks();
@@ -18551,7 +18705,7 @@ var handler14 = parallelStatusServer;
 
 // plugins/parallel-tool-nudge.ts
 import { readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync4 } from "node:fs";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 import { homedir as homedir6 } from "node:os";
 var PLUGIN_NAME15 = "parallel-tool-nudge";
 logLifecycle(PLUGIN_NAME15, "import", {});
@@ -18607,10 +18761,10 @@ function loadAgentToolsMap(rootDir, opts = {}) {
   const reader = opts.reader ?? defaultReader2;
   const dirReader = opts.dirReader ?? defaultDirReader2;
   const dirExists = opts.dirExists ?? defaultDirExists2;
-  const homeAgentsDir = opts.homeAgentsDir ?? join15(homedir6(), ".config", "opencode", "agents");
+  const homeAgentsDir = opts.homeAgentsDir ?? join16(homedir6(), ".config", "opencode", "agents");
   const candidateDirs = [
-    join15(rootDir, ".codeforge", "agents"),
-    join15(rootDir, "agents"),
+    join16(rootDir, ".codeforge", "agents"),
+    join16(rootDir, "agents"),
     homeAgentsDir
   ];
   const result = new Map;
@@ -18633,20 +18787,20 @@ function loadAgentToolsMap(rootDir, opts = {}) {
     for (const entry of entries) {
       if (!entry.endsWith(".md"))
         continue;
-      const path19 = join15(dir, entry);
+      const path20 = join16(dir, entry);
       let content;
       try {
-        content = reader(path19);
+        content = reader(path20);
       } catch (err) {
         log8.warn(`agent.md 读取失败（已跳过）`, {
-          path: path19,
+          path: path20,
           error: err instanceof Error ? err.message : String(err)
         });
         continue;
       }
       const parsed = parseAgentFrontmatter(content);
       if (!parsed) {
-        log8.warn(`agent frontmatter 解析失败（已跳过）`, { path: path19 });
+        log8.warn(`agent frontmatter 解析失败（已跳过）`, { path: path20 });
         continue;
       }
       if (result.has(parsed.name))
@@ -18837,19 +18991,19 @@ var handler16 = async (_ctx3) => {
 };
 
 // lib/event-stream.ts
-import { promises as fs15 } from "node:fs";
+import { promises as fs16 } from "node:fs";
 init_runtime_paths();
-import * as path19 from "node:path";
+import * as path20 from "node:path";
 async function loadSession(id, opts = {}) {
   const file = resolveSessionFile(id, opts);
-  const raw = await fs15.readFile(file, "utf8");
+  const raw = await fs16.readFile(file, "utf8");
   return parseJsonl(id, raw);
 }
 async function listSessions(opts = {}) {
   const dir = resolveDir(opts);
   let entries;
   try {
-    entries = await fs15.readdir(dir, { withFileTypes: true });
+    entries = await fs16.readdir(dir, { withFileTypes: true });
   } catch (err) {
     if (err.code === "ENOENT")
       return [];
@@ -18859,10 +19013,10 @@ async function listSessions(opts = {}) {
   for (const e of entries) {
     if (!e.isFile() || !e.name.endsWith(".jsonl"))
       continue;
-    const file = path19.join(dir, e.name);
+    const file = path20.join(dir, e.name);
     const id = e.name.replace(/\.jsonl$/, "");
     try {
-      const stat = await fs15.stat(file);
+      const stat = await fs16.stat(file);
       const headerLine = await readFirstLine(file);
       let started_at = stat.birthtimeMs;
       if (headerLine) {
@@ -18886,11 +19040,11 @@ async function listSessions(opts = {}) {
   return out;
 }
 function resolveDir(opts = {}) {
-  const root = path19.resolve(opts.root ?? process.cwd());
-  return opts.sessions_dir ? path19.resolve(root, opts.sessions_dir) : path19.join(runtimeDir(root), "sessions");
+  const root = path20.resolve(opts.root ?? process.cwd());
+  return opts.sessions_dir ? path20.resolve(root, opts.sessions_dir) : path20.join(runtimeDir(root), "sessions");
 }
 function resolveSessionFile(id, opts = {}) {
-  return path19.join(resolveDir(opts), `${id}.jsonl`);
+  return path20.join(resolveDir(opts), `${id}.jsonl`);
 }
 function parseJsonl(id, raw) {
   const events = [];
@@ -18925,7 +19079,7 @@ function isEvent(obj) {
 }
 async function readFirstLine(file) {
   const buf = Buffer.alloc(4096);
-  const fh = await fs15.open(file, "r");
+  const fh = await fs16.open(file, "r");
   try {
     const { bytesRead } = await fh.read(buf, 0, buf.length, 0);
     const s = buf.subarray(0, bytesRead).toString("utf8");
@@ -19154,11 +19308,11 @@ function isRecoveryWorthShowing(plan) {
 
 // lib/block-pending.ts
 init_runtime_paths();
-import { promises as fs16 } from "node:fs";
-import * as path20 from "node:path";
+import { promises as fs17 } from "node:fs";
+import * as path21 from "node:path";
 function blockPendingFilePath(absRoot) {
   const rd = runtimeDir(absRoot, { ensure: false });
-  return path20.join(rd, "sessions", "autonomous-blocks.ndjson");
+  return path21.join(rd, "sessions", "autonomous-blocks.ndjson");
 }
 function consumeLockPath(absRoot) {
   return blockPendingFilePath(absRoot) + ".consume.lock";
@@ -19167,7 +19321,7 @@ async function scanBlockPending(absRoot, filterSessionId) {
   const file = blockPendingFilePath(absRoot);
   let raw;
   try {
-    raw = await fs16.readFile(file, "utf8");
+    raw = await fs17.readFile(file, "utf8");
   } catch {
     return [];
   }
@@ -19223,7 +19377,7 @@ async function markBlocksConsumed(absRoot, entries) {
   if (entries.length === 0)
     return;
   const file = blockPendingFilePath(absRoot);
-  await fs16.mkdir(path20.dirname(file), { recursive: true });
+  await fs17.mkdir(path21.dirname(file), { recursive: true });
   const now = new Date().toISOString();
   const lines = entries.map((e) => ({
     type: "consume",
@@ -19234,7 +19388,7 @@ async function markBlocksConsumed(absRoot, entries) {
 `) + `
 `;
   await withFileLock(consumeLockPath(absRoot), async () => {
-    await fs16.appendFile(file, lines, "utf8");
+    await fs17.appendFile(file, lines, "utf8");
   });
 }
 
@@ -19372,8 +19526,8 @@ var sessionRecoveryServer = async (ctx) => {
 var handler17 = sessionRecoveryServer;
 
 // plugins/subtasks.ts
-import { promises as fs17 } from "node:fs";
-import * as path21 from "node:path";
+import { promises as fs18 } from "node:fs";
+import * as path22 from "node:path";
 
 // lib/parallel-merge.ts
 init_autonomy();
@@ -20191,14 +20345,14 @@ function describe8(err) {
   }
 }
 function sleep2(ms) {
-  return new Promise((resolve15) => setTimeout(resolve15, ms));
+  return new Promise((resolve16) => setTimeout(resolve16, ms));
 }
 
 // plugins/subtasks.ts
 init_runtime_paths();
 var PLUGIN_NAME18 = "subtasks";
 function getLogFile(root = process.cwd()) {
-  return path21.join(runtimeDir(root), "logs", "subtasks.log");
+  return path22.join(runtimeDir(root), "logs", "subtasks.log");
 }
 var VERB_RE = /^([a-zA-Z]{3,12})/;
 var CN_VERBS = [
@@ -20503,8 +20657,8 @@ async function writeLog(level, msg, data) {
 `;
   try {
     const logFile = getLogFile();
-    await fs17.mkdir(path21.dirname(logFile), { recursive: true });
-    await fs17.appendFile(logFile, line, "utf8");
+    await fs18.mkdir(path22.dirname(logFile), { recursive: true });
+    await fs18.appendFile(logFile, line, "utf8");
   } catch {}
 }
 logLifecycle(PLUGIN_NAME18, "import");
@@ -21020,12 +21174,12 @@ var tokenManagerServer = async (ctx) => {
 var handler20 = tokenManagerServer;
 
 // plugins/tool-policy.ts
-import { promises as fs18 } from "node:fs";
-import * as path23 from "node:path";
+import { promises as fs19 } from "node:fs";
+import * as path24 from "node:path";
 init_autonomy();
 
 // lib/file-regex-acl.ts
-import * as path22 from "node:path";
+import * as path23 from "node:path";
 function compileRule(r) {
   if (r instanceof RegExp)
     return r;
@@ -21091,7 +21245,7 @@ function normalizePath2(p) {
   let s = p.replace(/\\/g, "/");
   if (s.startsWith("./"))
     s = s.slice(2);
-  s = path22.posix.normalize(s);
+  s = path23.posix.normalize(s);
   return s;
 }
 function checkFileAccess(acl, file, op) {
@@ -21201,11 +21355,11 @@ function decideToolCall(ctx, cfg = {}, currentAgent) {
     action = "deny";
   return { action, reasons, autonomy: a, acl: aclResults };
 }
-var POLICY_PATH = path23.join(".codeforge", "policy.json");
+var POLICY_PATH = path24.join(".codeforge", "policy.json");
 async function loadPolicy(root = process.cwd()) {
-  const file = path23.join(root, POLICY_PATH);
+  const file = path24.join(root, POLICY_PATH);
   try {
-    const raw = await fs18.readFile(file, "utf8");
+    const raw = await fs19.readFile(file, "utf8");
     const data = JSON.parse(raw);
     return data;
   } catch {
@@ -21315,7 +21469,7 @@ var handler21 = toolPolicyServer;
 // plugins/update-checker.ts
 import { existsSync as existsSync5 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 
 // lib/update-checker-impl.ts
 import { createHash as createHash5 } from "node:crypto";
@@ -21332,7 +21486,7 @@ import {
   writeFileSync as writeFileSync2
 } from "node:fs";
 import { homedir as homedir7, tmpdir } from "node:os";
-import { dirname as dirname12, join as join20 } from "node:path";
+import { dirname as dirname13, join as join21 } from "node:path";
 import { fileURLToPath } from "node:url";
 import * as https from "node:https";
 import * as zlib from "node:zlib";
@@ -21340,7 +21494,7 @@ import * as zlib from "node:zlib";
 // lib/version-injected.ts
 function getInjectedVersion() {
   try {
-    const v = "0.5.5";
+    const v = "0.5.6";
     if (typeof v === "string" && /^\d+\.\d+\.\d+/.test(v)) {
       return v;
     }
@@ -21429,18 +21583,18 @@ function readLocalVersion() {
     return injected;
   try {
     const here = fileURLToPath(import.meta.url);
-    const root = dirname12(dirname12(here));
-    const pkg = JSON.parse(readFileSync5(join20(root, "package.json"), "utf8"));
+    const root = dirname13(dirname13(here));
+    const pkg = JSON.parse(readFileSync5(join21(root, "package.json"), "utf8"));
     return typeof pkg.version === "string" ? pkg.version : "0.0.0";
   } catch {
     return "0.0.0";
   }
 }
 function defaultCacheDir() {
-  return process.env["CODEFORGE_CACHE_DIR"] ?? join20(homedir7(), ".cache", "codeforge");
+  return process.env["CODEFORGE_CACHE_DIR"] ?? join21(homedir7(), ".cache", "codeforge");
 }
 function defaultCacheFile() {
-  return join20(defaultCacheDir(), "update-check.json");
+  return join21(defaultCacheDir(), "update-check.json");
 }
 function readCache(file) {
   try {
@@ -21458,7 +21612,7 @@ function readCache(file) {
 }
 function writeCache(file, entry) {
   try {
-    mkdirSync3(dirname12(file), { recursive: true });
+    mkdirSync3(dirname13(file), { recursive: true });
     writeFileSync2(file, JSON.stringify(entry, null, 2), "utf8");
   } catch {}
 }
@@ -21477,7 +21631,7 @@ function fetchLatestTagFromGitHub(repo) {
   });
 }
 function getJsonWithRedirect(url, hopsLeft) {
-  return new Promise((resolve15, reject) => {
+  return new Promise((resolve16, reject) => {
     const u = new URL(url);
     const headers = {
       "User-Agent": "codeforge-update-checker",
@@ -21501,12 +21655,12 @@ function getJsonWithRedirect(url, hopsLeft) {
           return;
         }
         const next = new URL(res.headers.location, url).toString();
-        getJsonWithRedirect(next, hopsLeft - 1).then(resolve15, reject);
+        getJsonWithRedirect(next, hopsLeft - 1).then(resolve16, reject);
         return;
       }
       if (status === 404) {
         res.resume();
-        resolve15(null);
+        resolve16(null);
         return;
       }
       if (status >= 400) {
@@ -21517,7 +21671,7 @@ function getJsonWithRedirect(url, hopsLeft) {
       let body = "";
       res.setEncoding("utf8");
       res.on("data", (chunk) => body += chunk);
-      res.on("end", () => resolve15(body));
+      res.on("end", () => resolve16(body));
     });
     req.on("timeout", () => {
       req.destroy();
@@ -21557,7 +21711,7 @@ async function fetchLatestFromNpm(opts) {
   return { version, tarballUrl, integrity };
 }
 function defaultHttpFetcher(url, timeoutMs) {
-  return new Promise((resolve15, reject) => {
+  return new Promise((resolve16, reject) => {
     const u = new URL(url);
     const headers = {
       "User-Agent": "codeforge-update-checker",
@@ -21574,7 +21728,7 @@ function defaultHttpFetcher(url, timeoutMs) {
       const status = res.statusCode ?? 0;
       if (status === 404) {
         res.resume();
-        resolve15(null);
+        resolve16(null);
         return;
       }
       if (status >= 400) {
@@ -21585,7 +21739,7 @@ function defaultHttpFetcher(url, timeoutMs) {
       let body = "";
       res.setEncoding("utf8");
       res.on("data", (chunk) => body += chunk);
-      res.on("end", () => resolve15(body));
+      res.on("end", () => resolve16(body));
     });
     req.on("timeout", () => {
       req.destroy();
@@ -21596,14 +21750,14 @@ function defaultHttpFetcher(url, timeoutMs) {
   });
 }
 async function downloadAndExtractBundle(opts) {
-  const tmpRoot = opts.tmpDir ?? mkdtempSync(join20(tmpdir(), "codeforge-update-"));
+  const tmpRoot = opts.tmpDir ?? mkdtempSync(join21(tmpdir(), "codeforge-update-"));
   mkdirSync3(tmpRoot, { recursive: true });
   const fetcher = opts.tarballFetcher ?? defaultBinaryFetcher;
   const tarballBuf = await fetcher(opts.tarballUrl);
   verifyIntegrity(tarballBuf, opts.expectedIntegrity);
   const tarBuf = zlib.gunzipSync(tarballBuf);
   extractTarToDir(tarBuf, tmpRoot);
-  const bundlePath = join20(tmpRoot, "package", "dist", "index.js");
+  const bundlePath = join21(tmpRoot, "package", "dist", "index.js");
   if (!existsSync4(bundlePath)) {
     throw new Error(`bundle_not_found: ${bundlePath}`);
   }
@@ -21643,11 +21797,11 @@ function extractTarToDir(tarBuf, destRoot) {
     offset += 512;
     if (typeFlag === "0" || typeFlag === "" || typeFlag === "\x00") {
       const fileBuf = tarBuf.subarray(offset, offset + size);
-      const dest = join20(destRoot, fullName);
-      mkdirSync3(dirname12(dest), { recursive: true });
+      const dest = join21(destRoot, fullName);
+      mkdirSync3(dirname13(dest), { recursive: true });
       writeFileSync2(dest, fileBuf);
     } else if (typeFlag === "5") {
-      mkdirSync3(join20(destRoot, fullName), { recursive: true });
+      mkdirSync3(join21(destRoot, fullName), { recursive: true });
     }
     offset += Math.ceil(size / 512) * 512;
   }
@@ -21656,7 +21810,7 @@ function defaultBinaryFetcher(url) {
   return downloadBinary(url, 3);
 }
 function downloadBinary(url, hopsLeft) {
-  return new Promise((resolve15, reject) => {
+  return new Promise((resolve16, reject) => {
     const u = new URL(url);
     const req = https.request({
       host: u.hostname,
@@ -21674,7 +21828,7 @@ function downloadBinary(url, hopsLeft) {
           return;
         }
         const next = new URL(res.headers.location, url).toString();
-        downloadBinary(next, hopsLeft - 1).then(resolve15, reject);
+        downloadBinary(next, hopsLeft - 1).then(resolve16, reject);
         return;
       }
       if (status >= 400) {
@@ -21684,7 +21838,7 @@ function downloadBinary(url, hopsLeft) {
       }
       const chunks = [];
       res.on("data", (chunk) => chunks.push(chunk));
-      res.on("end", () => resolve15(Buffer.concat(chunks)));
+      res.on("end", () => resolve16(Buffer.concat(chunks)));
     });
     req.on("timeout", () => {
       req.destroy();
@@ -21700,7 +21854,7 @@ function atomicReplaceBundle(opts) {
   if (!existsSync4(source)) {
     throw new Error(`atomic_source_missing: ${source}`);
   }
-  mkdirSync3(dirname12(target), { recursive: true });
+  mkdirSync3(dirname13(target), { recursive: true });
   const newPath = `${target}.new`;
   const backupPath = `${target}.bak.${oldVersion}`;
   let strategy = "rename";
@@ -21752,11 +21906,11 @@ function cleanupOldBackups(target, keep) {
   if (keep <= 0)
     return;
   try {
-    const dir = dirname12(target);
+    const dir = dirname13(target);
     const base = target.substring(dir.length + 1);
     const prefix = `${base}.bak.`;
     const all = readdirSync3(dir).filter((f) => f.startsWith(prefix)).map((f) => {
-      const full = join20(dir, f);
+      const full = join21(dir, f);
       let mtimeMs = 0;
       try {
         mtimeMs = statSync5(full).mtimeMs;
@@ -21778,7 +21932,7 @@ function loadCompatibility(opts) {
       const root = opts?.cwd ?? inferPluginRoot();
       if (!root)
         return null;
-      file = join20(root, "compatibility.json");
+      file = join21(root, "compatibility.json");
     }
     if (!existsSync4(file))
       return null;
@@ -21803,7 +21957,7 @@ function loadCompatibility(opts) {
 function inferPluginRoot() {
   try {
     const here = fileURLToPath(import.meta.url);
-    return dirname12(dirname12(here));
+    return dirname13(dirname13(here));
   } catch {
     return null;
   }
@@ -21998,14 +22152,14 @@ function detectOpencodeVersion() {
 }
 function getOpencodeBundlePath() {
   const candidates = [];
-  candidates.push(join21(homedir8(), ".config", "opencode", "codeforge", "index.js"));
+  candidates.push(join22(homedir8(), ".config", "opencode", "codeforge", "index.js"));
   if (process.platform === "win32") {
     const appData = process.env["APPDATA"];
     if (appData)
-      candidates.push(join21(appData, "opencode", "codeforge", "index.js"));
+      candidates.push(join22(appData, "opencode", "codeforge", "index.js"));
     const localAppData = process.env["LOCALAPPDATA"];
     if (localAppData)
-      candidates.push(join21(localAppData, "opencode", "codeforge", "index.js"));
+      candidates.push(join22(localAppData, "opencode", "codeforge", "index.js"));
   }
   for (const c of candidates) {
     if (existsSync5(c))
@@ -22066,11 +22220,11 @@ async function postToast(ctx, message) {
 var handler22 = updateCheckerServer;
 
 // plugins/workflow-engine.ts
-import * as path25 from "node:path";
+import * as path26 from "node:path";
 
 // lib/workflow-loader.ts
-import { promises as fs19 } from "node:fs";
-import * as path24 from "node:path";
+import { promises as fs20 } from "node:fs";
+import * as path25 from "node:path";
 import { z as z32 } from "zod";
 var ActionSchema = z32.object({
   tool: z32.string().min(1, "action.tool 不能为空"),
@@ -22156,7 +22310,7 @@ function parseWorkflowYaml(yaml, sourcePath = "<inline>") {
 async function loadWorkflowFromFile(filePath) {
   let txt;
   try {
-    txt = await fs19.readFile(filePath, "utf8");
+    txt = await fs20.readFile(filePath, "utf8");
   } catch (err) {
     return {
       ok: false,
@@ -22171,7 +22325,7 @@ async function loadWorkflowsFromDir(dir) {
   const failed = [];
   let entries;
   try {
-    entries = await fs19.readdir(dir);
+    entries = await fs20.readdir(dir);
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT")
@@ -22183,7 +22337,7 @@ async function loadWorkflowsFromDir(dir) {
       continue;
     if (!/\.ya?ml$/i.test(name))
       continue;
-    const full = path24.join(dir, name);
+    const full = path25.join(dir, name);
     const r = await loadWorkflowFromFile(full);
     if (r.ok)
       loaded.push(r);
@@ -22573,7 +22727,7 @@ async function handleCommandInvoked(raw, workflowsDir = "workflows") {
 }
 var workflowEngineServer = async (ctx) => {
   const directory = ctx.directory ?? process.cwd();
-  const workflowsDir = path25.join(directory, "workflows");
+  const workflowsDir = path26.join(directory, "workflows");
   ensureRegistry(workflowsDir).catch((err) => fallbackLog2.warn(`[${PLUGIN_NAME23}] preload workflows failed`, {
     error: err instanceof Error ? err.message : String(err)
   }));
@@ -22617,7 +22771,7 @@ var workflowEngineServer = async (ctx) => {
 var handler23 = workflowEngineServer;
 
 // plugins/session-worktree-guard.ts
-import path26 from "node:path";
+import path27 from "node:path";
 var PLUGIN_NAME24 = "session-worktree-guard";
 logLifecycle(PLUGIN_NAME24, "import", {});
 var WRITE_INTENT_RE = />(?!=)|\btee\b|\brm\b|\bmv\b|\bcp\b|\bmkdir\b|\btouch\b|\bchmod\b|\bchown\b|\bln\b/;
@@ -22646,7 +22800,7 @@ var WRITE_TOOLS = new Set(["write", "edit", "ast_edit"]);
 function rewritePath(value, mainRoot, worktreeRoot) {
   if (!value)
     return null;
-  const resolved = path26.isAbsolute(value) ? value : path26.resolve(mainRoot, value);
+  const resolved = path27.isAbsolute(value) ? value : path27.resolve(mainRoot, value);
   if (resolved === mainRoot)
     return worktreeRoot;
   const prefix = mainRoot.endsWith("/") ? mainRoot : mainRoot + "/";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andyqiu/codeforge",
-  "version": "0.5.5",
+  "version": "0.5.6",
   "description": "CodeForge — opencode 的零侵入扩展包",
   "type": "module",
   "private": false,