@andyqiu/codeforge 0.3.11 → 0.3.12

package/dist/index.js

@@ -1034,17 +1034,17 @@ var require_visit = __commonJS((exports) => {
   visit.BREAK = BREAK;
   visit.SKIP = SKIP;
   visit.REMOVE = REMOVE;
-  function visit_(key, node, visitor, path16) {
-    const ctrl = callVisitor(key, node, visitor, path16);
+  function visit_(key, node, visitor, path13) {
+    const ctrl = callVisitor(key, node, visitor, path13);
     if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-      replaceNode(key, path16, ctrl);
-      return visit_(key, ctrl, visitor, path16);
+      replaceNode(key, path13, ctrl);
+      return visit_(key, ctrl, visitor, path13);
     }
     if (typeof ctrl !== "symbol") {
       if (identity.isCollection(node)) {
-        path16 = Object.freeze(path16.concat(node));
+        path13 = Object.freeze(path13.concat(node));
         for (let i = 0;i < node.items.length; ++i) {
-          const ci = visit_(i, node.items[i], visitor, path16);
+          const ci = visit_(i, node.items[i], visitor, path13);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -1055,13 +1055,13 @@ var require_visit = __commonJS((exports) => {
           }
         }
       } else if (identity.isPair(node)) {
-        path16 = Object.freeze(path16.concat(node));
-        const ck = visit_("key", node.key, visitor, path16);
+        path13 = Object.freeze(path13.concat(node));
+        const ck = visit_("key", node.key, visitor, path13);
         if (ck === BREAK)
           return BREAK;
         else if (ck === REMOVE)
           node.key = null;
-        const cv = visit_("value", node.value, visitor, path16);
+        const cv = visit_("value", node.value, visitor, path13);
         if (cv === BREAK)
           return BREAK;
         else if (cv === REMOVE)
@@ -1082,17 +1082,17 @@ var require_visit = __commonJS((exports) => {
   visitAsync.BREAK = BREAK;
   visitAsync.SKIP = SKIP;
   visitAsync.REMOVE = REMOVE;
-  async function visitAsync_(key, node, visitor, path16) {
-    const ctrl = await callVisitor(key, node, visitor, path16);
+  async function visitAsync_(key, node, visitor, path13) {
+    const ctrl = await callVisitor(key, node, visitor, path13);
     if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-      replaceNode(key, path16, ctrl);
-      return visitAsync_(key, ctrl, visitor, path16);
+      replaceNode(key, path13, ctrl);
+      return visitAsync_(key, ctrl, visitor, path13);
     }
     if (typeof ctrl !== "symbol") {
       if (identity.isCollection(node)) {
-        path16 = Object.freeze(path16.concat(node));
+        path13 = Object.freeze(path13.concat(node));
         for (let i = 0;i < node.items.length; ++i) {
-          const ci = await visitAsync_(i, node.items[i], visitor, path16);
+          const ci = await visitAsync_(i, node.items[i], visitor, path13);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -1103,13 +1103,13 @@ var require_visit = __commonJS((exports) => {
           }
         }
       } else if (identity.isPair(node)) {
-        path16 = Object.freeze(path16.concat(node));
-        const ck = await visitAsync_("key", node.key, visitor, path16);
+        path13 = Object.freeze(path13.concat(node));
+        const ck = await visitAsync_("key", node.key, visitor, path13);
         if (ck === BREAK)
           return BREAK;
         else if (ck === REMOVE)
           node.key = null;
-        const cv = await visitAsync_("value", node.value, visitor, path16);
+        const cv = await visitAsync_("value", node.value, visitor, path13);
         if (cv === BREAK)
           return BREAK;
         else if (cv === REMOVE)
@@ -1136,23 +1136,23 @@ var require_visit = __commonJS((exports) => {
     }
     return visitor;
   }
-  function callVisitor(key, node, visitor, path16) {
+  function callVisitor(key, node, visitor, path13) {
     if (typeof visitor === "function")
-      return visitor(key, node, path16);
+      return visitor(key, node, path13);
     if (identity.isMap(node))
-      return visitor.Map?.(key, node, path16);
+      return visitor.Map?.(key, node, path13);
     if (identity.isSeq(node))
-      return visitor.Seq?.(key, node, path16);
+      return visitor.Seq?.(key, node, path13);
     if (identity.isPair(node))
-      return visitor.Pair?.(key, node, path16);
+      return visitor.Pair?.(key, node, path13);
     if (identity.isScalar(node))
-      return visitor.Scalar?.(key, node, path16);
+      return visitor.Scalar?.(key, node, path13);
     if (identity.isAlias(node))
-      return visitor.Alias?.(key, node, path16);
+      return visitor.Alias?.(key, node, path13);
     return;
   }
-  function replaceNode(key, path16, node) {
-    const parent = path16[path16.length - 1];
+  function replaceNode(key, path13, node) {
+    const parent = path13[path13.length - 1];
     if (identity.isCollection(parent)) {
       parent.items[key] = node;
     } else if (identity.isPair(parent)) {
@@ -1711,10 +1711,10 @@ var require_Collection = __commonJS((exports) => {
   var createNode = require_createNode();
   var identity = require_identity();
   var Node = require_Node();
-  function collectionFromPath(schema, path16, value) {
+  function collectionFromPath(schema, path13, value) {
     let v = value;
-    for (let i = path16.length - 1;i >= 0; --i) {
-      const k = path16[i];
+    for (let i = path13.length - 1;i >= 0; --i) {
+      const k = path13[i];
       if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
         const a = [];
         a[k] = v;
@@ -1733,7 +1733,7 @@ var require_Collection = __commonJS((exports) => {
       sourceObjects: new Map
     });
   }
-  var isEmptyPath = (path16) => path16 == null || typeof path16 === "object" && !!path16[Symbol.iterator]().next().done;
+  var isEmptyPath = (path13) => path13 == null || typeof path13 === "object" && !!path13[Symbol.iterator]().next().done;
 
   class Collection extends Node.NodeBase {
     constructor(type, schema) {
@@ -1754,11 +1754,11 @@ var require_Collection = __commonJS((exports) => {
         copy.range = this.range.slice();
       return copy;
     }
-    addIn(path16, value) {
-      if (isEmptyPath(path16))
+    addIn(path13, value) {
+      if (isEmptyPath(path13))
         this.add(value);
       else {
-        const [key, ...rest] = path16;
+        const [key, ...rest] = path13;
         const node = this.get(key, true);
         if (identity.isCollection(node))
           node.addIn(rest, value);
@@ -1768,8 +1768,8 @@ var require_Collection = __commonJS((exports) => {
           throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
       }
     }
-    deleteIn(path16) {
-      const [key, ...rest] = path16;
+    deleteIn(path13) {
+      const [key, ...rest] = path13;
       if (rest.length === 0)
         return this.delete(key);
       const node = this.get(key, true);
@@ -1778,8 +1778,8 @@ var require_Collection = __commonJS((exports) => {
       else
         throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
     }
-    getIn(path16, keepScalar) {
-      const [key, ...rest] = path16;
+    getIn(path13, keepScalar) {
+      const [key, ...rest] = path13;
       const node = this.get(key, true);
       if (rest.length === 0)
         return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -1794,15 +1794,15 @@ var require_Collection = __commonJS((exports) => {
         return n == null || allowScalar && identity.isScalar(n) && n.value == null && !n.commentBefore && !n.comment && !n.tag;
       });
     }
-    hasIn(path16) {
-      const [key, ...rest] = path16;
+    hasIn(path13) {
+      const [key, ...rest] = path13;
       if (rest.length === 0)
         return this.has(key);
       const node = this.get(key, true);
       return identity.isCollection(node) ? node.hasIn(rest) : false;
     }
-    setIn(path16, value) {
-      const [key, ...rest] = path16;
+    setIn(path13, value) {
+      const [key, ...rest] = path13;
       if (rest.length === 0) {
         this.set(key, value);
       } else {
@@ -2608,7 +2608,7 @@ var require_merge = __commonJS((exports) => {
 
 // node_modules/yaml/dist/nodes/addPairToJSMap.js
 var require_addPairToJSMap = __commonJS((exports) => {
-  var log12 = require_log();
+  var log8 = require_log();
   var merge = require_merge();
   var stringify = require_stringify();
   var identity = require_identity();
@@ -2657,7 +2657,7 @@ var require_addPairToJSMap = __commonJS((exports) => {
         let jsonStr = JSON.stringify(strKey);
         if (jsonStr.length > 40)
           jsonStr = jsonStr.substring(0, 36) + '..."';
-        log12.warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);
+        log8.warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);
         ctx.mapKeyWarned = true;
       }
       return strKey;
@@ -4195,9 +4195,9 @@ var require_Document = __commonJS((exports) => {
       if (assertCollection(this.contents))
         this.contents.add(value);
     }
-    addIn(path16, value) {
+    addIn(path13, value) {
       if (assertCollection(this.contents))
-        this.contents.addIn(path16, value);
+        this.contents.addIn(path13, value);
     }
     createAlias(node, name) {
       if (!node.anchor) {
@@ -4246,30 +4246,30 @@ var require_Document = __commonJS((exports) => {
     delete(key) {
       return assertCollection(this.contents) ? this.contents.delete(key) : false;
     }
-    deleteIn(path16) {
-      if (Collection.isEmptyPath(path16)) {
+    deleteIn(path13) {
+      if (Collection.isEmptyPath(path13)) {
         if (this.contents == null)
           return false;
         this.contents = null;
         return true;
       }
-      return assertCollection(this.contents) ? this.contents.deleteIn(path16) : false;
+      return assertCollection(this.contents) ? this.contents.deleteIn(path13) : false;
     }
     get(key, keepScalar) {
       return identity.isCollection(this.contents) ? this.contents.get(key, keepScalar) : undefined;
     }
-    getIn(path16, keepScalar) {
-      if (Collection.isEmptyPath(path16))
+    getIn(path13, keepScalar) {
+      if (Collection.isEmptyPath(path13))
         return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-      return identity.isCollection(this.contents) ? this.contents.getIn(path16, keepScalar) : undefined;
+      return identity.isCollection(this.contents) ? this.contents.getIn(path13, keepScalar) : undefined;
     }
     has(key) {
       return identity.isCollection(this.contents) ? this.contents.has(key) : false;
     }
-    hasIn(path16) {
-      if (Collection.isEmptyPath(path16))
+    hasIn(path13) {
+      if (Collection.isEmptyPath(path13))
         return this.contents !== undefined;
-      return identity.isCollection(this.contents) ? this.contents.hasIn(path16) : false;
+      return identity.isCollection(this.contents) ? this.contents.hasIn(path13) : false;
     }
     set(key, value) {
       if (this.contents == null) {
@@ -4278,13 +4278,13 @@ var require_Document = __commonJS((exports) => {
         this.contents.set(key, value);
       }
     }
-    setIn(path16, value) {
-      if (Collection.isEmptyPath(path16)) {
+    setIn(path13, value) {
+      if (Collection.isEmptyPath(path13)) {
         this.contents = value;
       } else if (this.contents == null) {
-        this.contents = Collection.collectionFromPath(this.schema, Array.from(path16), value);
+        this.contents = Collection.collectionFromPath(this.schema, Array.from(path13), value);
       } else if (assertCollection(this.contents)) {
-        this.contents.setIn(path16, value);
+        this.contents.setIn(path13, value);
       }
     }
     setSchema(version, options = {}) {
@@ -6179,9 +6179,9 @@ var require_cst_visit = __commonJS((exports) => {
   visit.BREAK = BREAK;
   visit.SKIP = SKIP;
   visit.REMOVE = REMOVE;
-  visit.itemAtPath = (cst, path16) => {
+  visit.itemAtPath = (cst, path13) => {
     let item = cst;
-    for (const [field, index] of path16) {
+    for (const [field, index] of path13) {
       const tok = item?.[field];
       if (tok && "items" in tok) {
         item = tok.items[index];
@@ -6190,23 +6190,23 @@ var require_cst_visit = __commonJS((exports) => {
     }
     return item;
   };
-  visit.parentCollection = (cst, path16) => {
-    const parent = visit.itemAtPath(cst, path16.slice(0, -1));
-    const field = path16[path16.length - 1][0];
+  visit.parentCollection = (cst, path13) => {
+    const parent = visit.itemAtPath(cst, path13.slice(0, -1));
+    const field = path13[path13.length - 1][0];
     const coll = parent?.[field];
     if (coll && "items" in coll)
       return coll;
     throw new Error("Parent collection not found");
   };
-  function _visit(path16, item, visitor) {
-    let ctrl = visitor(item, path16);
+  function _visit(path13, item, visitor) {
+    let ctrl = visitor(item, path13);
     if (typeof ctrl === "symbol")
       return ctrl;
     for (const field of ["key", "value"]) {
       const token = item[field];
       if (token && "items" in token) {
         for (let i = 0;i < token.items.length; ++i) {
-          const ci = _visit(Object.freeze(path16.concat([[field, i]])), token.items[i], visitor);
+          const ci = _visit(Object.freeze(path13.concat([[field, i]])), token.items[i], visitor);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -6217,10 +6217,10 @@ var require_cst_visit = __commonJS((exports) => {
           }
         }
         if (typeof ctrl === "function" && field === "key")
-          ctrl = ctrl(item, path16);
+          ctrl = ctrl(item, path13);
       }
     }
-    return typeof ctrl === "function" ? ctrl(item, path16) : ctrl;
+    return typeof ctrl === "function" ? ctrl(item, path13) : ctrl;
   }
   exports.visit = visit;
 });
@@ -7489,14 +7489,14 @@ var require_parser = __commonJS((exports) => {
           case "scalar":
           case "single-quoted-scalar":
           case "double-quoted-scalar": {
-            const fs12 = this.flowScalar(this.type);
+            const fs10 = this.flowScalar(this.type);
             if (atNextItem || it.value) {
-              map.items.push({ start, key: fs12, sep: [] });
+              map.items.push({ start, key: fs10, sep: [] });
               this.onKeyLine = true;
             } else if (it.sep) {
-              this.stack.push(fs12);
+              this.stack.push(fs10);
             } else {
-              Object.assign(it, { key: fs12, sep: [] });
+              Object.assign(it, { key: fs10, sep: [] });
               this.onKeyLine = true;
             }
             return;
@@ -7624,13 +7624,13 @@ var require_parser = __commonJS((exports) => {
           case "scalar":
           case "single-quoted-scalar":
           case "double-quoted-scalar": {
-            const fs12 = this.flowScalar(this.type);
+            const fs10 = this.flowScalar(this.type);
             if (!it || it.value)
-              fc.items.push({ start: [], key: fs12, sep: [] });
+              fc.items.push({ start: [], key: fs10, sep: [] });
             else if (it.sep)
-              this.stack.push(fs12);
+              this.stack.push(fs10);
             else
-              Object.assign(it, { key: fs12, sep: [] });
+              Object.assign(it, { key: fs10, sep: [] });
             return;
           }
           case "flow-map-end":
@@ -7794,7 +7794,7 @@ var require_public_api = __commonJS((exports) => {
   var composer = require_composer();
   var Document = require_Document();
   var errors = require_errors();
-  var log12 = require_log();
+  var log8 = require_log();
   var identity = require_identity();
   var lineCounter = require_line_counter();
   var parser = require_parser();
@@ -7846,7 +7846,7 @@ var require_public_api = __commonJS((exports) => {
     const doc = parseDocument(src, options);
     if (!doc)
       return null;
-    doc.warnings.forEach((warning) => log12.warn(doc.options.logLevel, warning));
+    doc.warnings.forEach((warning) => log8.warn(doc.options.logLevel, warning));
     if (doc.errors.length > 0) {
       if (doc.options.logLevel !== "silent")
         throw doc.errors[0];
@@ -8030,11 +8030,11 @@ function shouldStopByStuck(history, cfg) {
 async function withTimeout3(p, timeoutMs) {
   if (timeoutMs <= 0)
     return await p;
-  return await new Promise((resolve11, reject) => {
+  return await new Promise((resolve13, reject) => {
     const timer = setTimeout(() => reject(new Error(`timeout after ${timeoutMs}ms`)), timeoutMs);
     Promise.resolve(p).then((v) => {
       clearTimeout(timer);
-      resolve11(v);
+      resolve13(v);
     }, (err) => {
       clearTimeout(timer);
       reject(err);
@@ -8066,7 +8066,7 @@ async function runAutoFeedback(cfg, ctx) {
   if (cmds.length === 0) {
     throw new Error("auto-feedback: 至少需要 test_cmd 或 lint_cmd 之一");
   }
-  const log12 = ctx.log ?? (() => {});
+  const log13 = ctx.log ?? (() => {});
   const attempt = async () => {
     let last = {
       cmd: "",
@@ -8103,7 +8103,7 @@ ${excerpt}
 
 请基于错误信息修复 pending-changes（用 ast-edit / pending-changes.stage），完成后我会重新跑测试验证。`;
     const result2 = await ctx.dispatchToAgent("coder", prompt);
-    log12("info", `auto-feedback round ${round} dispatch summary: ${result2.summary.slice(0, 200)}`);
+    log13("info", `auto-feedback round ${round} dispatch summary: ${result2.summary.slice(0, 200)}`);
   };
   const debugResult = await runWithAutoDebug({
     attempt,
@@ -8124,7 +8124,7 @@ ${excerpt}
     history: debugResult.history
   };
   if (!debugResult.ok && debugResult.stopReason === "max-rounds") {
-    log12("warn", `auto-feedback 达 max_retries=${cfg.max_retries}，escalate to ${cfg.escalate_to}`);
+    log13("warn", `auto-feedback 达 max_retries=${cfg.max_retries}，escalate to ${cfg.escalate_to}`);
     const lastFail = debugResult.history[debugResult.history.length - 1];
     const excerpt = lastFail?.result ? extractErrorExcerpt(lastFail.result, cfg.error_excerpt_lines) : "(无失败结果)";
     const escalatePrompt = `coder 连续 ${cfg.max_retries} 轮自纠失败，错误片段：
@@ -10729,7 +10729,7 @@ class PendingChangesStore {
           const currentNormHash = crypto3.createHash("sha256").update(normalize3(current)).digest("hex");
           const origNormHash = crypto3.createHash("sha256").update(normalize3(origStored)).digest("hex");
           if (currentNormHash === origNormHash) {
-            console.warn(`[pending-changes] ADR-0044: ${id} 仅 EOL 漂移，已接受 apply ` + `(raw hash mismatch: ${data.meta.source_hash?.slice(0, 8)}… → ${currentHash.slice(0, 8)}…)`);
+            console.warn(`[pending-changes] ADR:pending-changes-eol-tolerant-apply: ${id} 仅 EOL 漂移，已接受 apply ` + `(raw hash mismatch: ${data.meta.source_hash?.slice(0, 8)}… → ${currentHash.slice(0, 8)}…)`);
           } else {
             throw new Error(`apply: 目标文件已被修改（漂移）。原 hash=${data.meta.source_hash?.slice(0, 8)}… → 现 hash=${currentHash.slice(0, 8)}…，` + `请重新 stage 后再 apply`);
           }
@@ -10875,7 +10875,7 @@ var ArgsSchema15 = z16.discriminatedUnion("action", [
     target: z16.string().min(1).describe("相对路径（相对仓库根），如 src/foo.ts"),
     content: z16.string().describe("整文件新内容（UTF-8 文本）"),
     description: z16.string().optional().describe("一句话说明这次改动的意图（建议 ≤ 80 字）"),
-    force_eol: z16.enum(["lf", "crlf", "preserve"]).optional().describe("强制 EOL 转换（ADR-0033）：lf/crlf 显式覆盖，preserve=C-EOL 智能保留（默认行为）。" + "严格期望某 EOL 的场景（脚本 shebang / lint 严格的 markdown 等）建议传 lf；" + "不确定时不传，让默认 C-EOL 处理。docs/adr/*.md 自动判定 lf。")
+    force_eol: z16.enum(["lf", "crlf", "preserve"]).optional().describe("强制 EOL 转换（ADR:pending-changes-force-eol）：lf/crlf 显式覆盖,preserve=C-EOL 智能保留（默认行为）。" + "严格期望某 EOL 的场景（脚本 shebang / lint 严格的 markdown 等）建议传 lf；" + "不确定时不传，让默认 C-EOL 处理。docs/adr/*.md 自动判定 lf。")
   }),
   z16.object({
     action: z16.literal("list"),
@@ -13040,6 +13040,8 @@ function toEntry(r) {
 init_opencode_plugin_helpers();
 
 // lib/codeforge-runtime.ts
+import { promises as fs8 } from "node:fs";
+import * as path11 from "node:path";
 var DEFAULT_RUNTIME = {
   autonomy: {
     default_mode: "semi",
@@ -13081,6 +13083,21 @@ function loadRuntimeSync(opts = {}) {
   }
   return parseRuntime(raw, hit);
 }
+async function loadRuntime(opts = {}) {
+  const root = opts.root ?? process.cwd();
+  const abs = path11.resolve(root, opts.file ?? CONFIG_FILE);
+  let raw;
+  try {
+    raw = await fs8.readFile(abs, "utf8");
+  } catch (e) {
+    const code = e.code;
+    if (code === "ENOENT") {
+      return emptyResult({ reason: `${CONFIG_FILE} not found at ${abs} (using built-in defaults)` });
+    }
+    return emptyResult({ path: abs, reason: `read_failed: ${e.message}` });
+  }
+  return parseRuntime(raw, abs);
+}
 function emptyResult(opts) {
   return {
     ok: false,
@@ -13848,7 +13865,7 @@ var codeforgeToolsServer = async (ctx) => {
           target: z27.string().optional().describe("仅 stage：相对仓库根的目标文件路径"),
           content: z27.string().optional().describe("仅 stage：整文件新内容"),
           description: z27.string().optional().describe("仅 stage：一句话说明改动意图"),
-          force_eol: z27.enum(["lf", "crlf", "preserve"]).optional().describe("仅 stage：强制 EOL 转换（ADR-0033）。lf/crlf 显式覆盖，preserve=C-EOL 智能保留(默认)。不确定时不传"),
+          force_eol: z27.enum(["lf", "crlf", "preserve"]).optional().describe("仅 stage：强制 EOL 转换（ADR:pending-changes-force-eol）。lf/crlf 显式覆盖，preserve=C-EOL 智能保留(默认)。不确定时不传"),
           id: z27.string().optional().describe("show / diff / apply / discard：pending change ID"),
           status: z27.enum(["pending", "applied", "discarded"]).optional().describe("仅 list：按状态过滤")
         },
@@ -14830,14 +14847,14 @@ var khReminderServer = async (ctx) => {
 var handler10 = khReminderServer;
 
 // lib/memories.ts
-import { promises as fs8 } from "node:fs";
-import * as path11 from "node:path";
+import { promises as fs9 } from "node:fs";
+import * as path12 from "node:path";
 import * as os4 from "node:os";
 function resolveConfig(c) {
   return {
     projectRoot: c.projectRoot,
     homeDir: c.homeDir ?? os4.homedir(),
-    projectName: c.projectName ?? path11.basename(c.projectRoot),
+    projectName: c.projectName ?? path12.basename(c.projectRoot),
     kh: c.kh,
     now: c.now ?? Date.now,
     log: c.log ?? (() => {}),
@@ -14846,13 +14863,13 @@ function resolveConfig(c) {
 }
 function fileFor(scope, cfg) {
   if (scope === "project") {
-    return path11.join(cfg.projectRoot, ".codeforge", "memories.json");
+    return path12.join(cfg.projectRoot, ".codeforge", "memories.json");
   }
-  return path11.join(cfg.homeDir, ".codeforge", "memories.json");
+  return path12.join(cfg.homeDir, ".codeforge", "memories.json");
 }
 async function readBank(p) {
   try {
-    const raw = await fs8.readFile(p, "utf8");
+    const raw = await fs9.readFile(p, "utf8");
     const arr = JSON.parse(raw);
     if (!Array.isArray(arr))
       return [];
@@ -14862,10 +14879,10 @@ async function readBank(p) {
   }
 }
 async function writeBank(p, items) {
-  await fs8.mkdir(path11.dirname(p), { recursive: true });
+  await fs9.mkdir(path12.dirname(p), { recursive: true });
   const tmp = `${p}.tmp`;
-  await fs8.writeFile(tmp, JSON.stringify(items, null, 2), "utf8");
-  await fs8.rename(tmp, p);
+  await fs9.writeFile(tmp, JSON.stringify(items, null, 2), "utf8");
+  await fs9.rename(tmp, p);
 }
 function isMemory(x) {
   if (!x || typeof x !== "object")
@@ -15856,10 +15873,301 @@ var parallelStatusServer = async (ctx) => {
 };
 var handler14 = parallelStatusServer;
 
-// plugins/pwsh-utf8.ts
+// plugins/parallel-tool-nudge.ts
+import { readFileSync as readFileSync4, readdirSync, statSync as statSync3 } from "node:fs";
+import { join as join12 } from "node:path";
+import { homedir as homedir6 } from "node:os";
+
+// node_modules/yaml/dist/index.js
+var composer = require_composer();
+var Document = require_Document();
+var Schema = require_Schema();
+var errors = require_errors();
+var Alias = require_Alias();
+var identity = require_identity();
+var Pair = require_Pair();
+var Scalar = require_Scalar();
+var YAMLMap = require_YAMLMap();
+var YAMLSeq = require_YAMLSeq();
+var cst = require_cst();
+var lexer = require_lexer();
+var lineCounter = require_line_counter();
+var parser = require_parser();
+var publicApi = require_public_api();
+var visit = require_visit();
+var $Composer = composer.Composer;
+var $Document = Document.Document;
+var $Schema = Schema.Schema;
+var $YAMLError = errors.YAMLError;
+var $YAMLParseError = errors.YAMLParseError;
+var $YAMLWarning = errors.YAMLWarning;
+var $Alias = Alias.Alias;
+var $isAlias = identity.isAlias;
+var $isCollection = identity.isCollection;
+var $isDocument = identity.isDocument;
+var $isMap = identity.isMap;
+var $isNode = identity.isNode;
+var $isPair = identity.isPair;
+var $isScalar = identity.isScalar;
+var $isSeq = identity.isSeq;
+var $Pair = Pair.Pair;
+var $Scalar = Scalar.Scalar;
+var $YAMLMap = YAMLMap.YAMLMap;
+var $YAMLSeq = YAMLSeq.YAMLSeq;
+var $Lexer = lexer.Lexer;
+var $LineCounter = lineCounter.LineCounter;
+var $Parser = parser.Parser;
+var $parse = publicApi.parse;
+var $parseAllDocuments = publicApi.parseAllDocuments;
+var $parseDocument = publicApi.parseDocument;
+var $stringify = publicApi.stringify;
+var $visit = visit.visit;
+var $visitAsync = visit.visitAsync;
+
+// plugins/parallel-tool-nudge.ts
 init_opencode_plugin_helpers();
-var PLUGIN_NAME15 = "pwsh-utf8";
+var PLUGIN_NAME15 = "parallel-tool-nudge";
 logLifecycle(PLUGIN_NAME15, "import", {});
+var PARALLEL_SAFE_TOOLS = [
+  "read",
+  "smart_search",
+  "repo_map",
+  "webfetch",
+  "list_recent",
+  "get_working_memory"
+];
+var DEFAULT_AGENT_KEY = "__default__";
+var NUDGE_MAX_LEN = 800;
+var agentToolsMap = new Map;
+function defaultReader(p) {
+  return readFileSync4(p, "utf8");
+}
+function defaultDirReader(p) {
+  return readdirSync(p);
+}
+function defaultDirExists(p) {
+  try {
+    return statSync3(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function parseAgentFrontmatter(content) {
+  const fmMatch = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
+  if (!fmMatch || !fmMatch[1])
+    return null;
+  let parsed;
+  try {
+    parsed = $parse(fmMatch[1]);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object")
+    return null;
+  const obj = parsed;
+  const name = typeof obj["name"] === "string" ? obj["name"] : null;
+  const tools = obj["allowed_tools"];
+  if (!name || !Array.isArray(tools))
+    return null;
+  const allowedTools = [];
+  for (const t of tools) {
+    if (typeof t === "string")
+      allowedTools.push(t);
+  }
+  return { name, allowedTools };
+}
+function loadAgentToolsMap(rootDir, opts = {}) {
+  const reader = opts.reader ?? defaultReader;
+  const dirReader = opts.dirReader ?? defaultDirReader;
+  const dirExists = opts.dirExists ?? defaultDirExists;
+  const homeAgentsDir = opts.homeAgentsDir ?? join12(homedir6(), ".config", "opencode", "agents");
+  const candidateDirs = [
+    join12(rootDir, ".codeforge", "agents"),
+    join12(rootDir, "agents"),
+    homeAgentsDir
+  ];
+  const result = new Map;
+  const safeSet = new Set(PARALLEL_SAFE_TOOLS);
+  const unionTools = new Set;
+  const log8 = makePluginLogger(PLUGIN_NAME15);
+  for (const dir of candidateDirs) {
+    if (!dirExists(dir))
+      continue;
+    let entries;
+    try {
+      entries = dirReader(dir);
+    } catch (err) {
+      log8.warn(`agents 目录读取失败（已跳过）`, {
+        dir,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.endsWith(".md"))
+        continue;
+      const path13 = join12(dir, entry);
+      let content;
+      try {
+        content = reader(path13);
+      } catch (err) {
+        log8.warn(`agent.md 读取失败（已跳过）`, {
+          path: path13,
+          error: err instanceof Error ? err.message : String(err)
+        });
+        continue;
+      }
+      const parsed = parseAgentFrontmatter(content);
+      if (!parsed) {
+        log8.warn(`agent frontmatter 解析失败（已跳过）`, { path: path13 });
+        continue;
+      }
+      if (result.has(parsed.name))
+        continue;
+      const intersect = [];
+      const seen = new Set;
+      for (const t of parsed.allowedTools) {
+        if (safeSet.has(t) && !seen.has(t)) {
+          intersect.push(t);
+          seen.add(t);
+          unionTools.add(t);
+        }
+      }
+      result.set(parsed.name, intersect);
+    }
+  }
+  result.set(DEFAULT_AGENT_KEY, Array.from(unionTools));
+  return result;
+}
+var sessionAgentMap = new Map;
+var SESSION_CAP = 200;
+var SESSION_TTL_MS = 24 * 60 * 60 * 1000;
+function pruneIfOversize() {
+  while (sessionAgentMap.size > SESSION_CAP) {
+    const oldestKey = sessionAgentMap.keys().next().value;
+    if (oldestKey === undefined)
+      break;
+    sessionAgentMap.delete(oldestKey);
+  }
+}
+function isExpired(entry, now) {
+  return now - entry.ts > SESSION_TTL_MS;
+}
+function resolveAgent(sessionID, nowFn = Date.now) {
+  if (!sessionID)
+    return "unknown";
+  const entry = sessionAgentMap.get(sessionID);
+  if (!entry)
+    return "unknown";
+  const now = nowFn();
+  if (isExpired(entry, now)) {
+    sessionAgentMap.delete(sessionID);
+    return "unknown";
+  }
+  sessionAgentMap.delete(sessionID);
+  sessionAgentMap.set(sessionID, entry);
+  return entry.agent;
+}
+function renderNudge(agent, tools) {
+  const isUnknown = agent === "unknown";
+  const agentLine = isUnknown ? `You are running as a CodeForge agent (specific agent unknown for this turn).` : `You are the \`${agent}\` agent.`;
+  const toolsBulleted = tools.length > 0 ? tools.map((t) => `    - \`${t}\``).join(`
+`) : `    - (no parallel-safe tools registered for this agent)`;
+  const body = `────────────────────────────────────────
+PARALLEL TOOL CALL DIRECTIVE (auto-injected by parallel-tool-nudge plugin)
+────────────────────────────────────────
+${agentLine} The opencode runtime executes tool calls in your single
+response **truly in parallel** (verified: up to 22 tools in 72ms).
+You MUST batch-emit independent read-only tool calls in one response
+whenever possible.
+
+Parallel-safe tools available to you:
+${toolsBulleted}
+
+Heuristics:
+    - Need to read 3 files? → emit 3 \`read\` calls in ONE response, not 3 sequential turns
+    - Need search + map? → emit \`smart_search\` + \`repo_map\` in ONE response
+    - DO NOT batch write tools (ast_edit / pending_changes.apply / bash)
+    - DO NOT chain reads where each read's path depends on previous read's output
+
+This directive is re-injected every turn — it is not optional advice.
+────────────────────────────────────────`;
+  if (body.length <= NUDGE_MAX_LEN)
+    return body;
+  return body.slice(0, NUDGE_MAX_LEN - 4) + `
+…`;
+}
+var log8 = makePluginLogger(PLUGIN_NAME15);
+var parallelToolNudgeServer = async (ctx) => {
+  try {
+    const loaded = loadAgentToolsMap(ctx.directory ?? process.cwd());
+    agentToolsMap.clear();
+    for (const [k, v] of loaded.entries())
+      agentToolsMap.set(k, v);
+  } catch (err) {
+    log8.warn(`loadAgentToolsMap 失败（plugin 将 no-op）`, {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+  const realAgentCount = Math.max(0, agentToolsMap.size - (agentToolsMap.has(DEFAULT_AGENT_KEY) ? 1 : 0));
+  if (realAgentCount === 0) {
+    agentToolsMap.clear();
+    log8.warn(`0 real agents loaded; plugin will be no-op for this session`, {
+      directory: ctx.directory
+    });
+  }
+  const defaultTools = agentToolsMap.get(DEFAULT_AGENT_KEY) ?? [];
+  logLifecycle(PLUGIN_NAME15, "activate", {
+    directory: ctx.directory,
+    real_agents_loaded: realAgentCount,
+    default_tools_union: defaultTools,
+    parallel_safe_whitelist: PARALLEL_SAFE_TOOLS,
+    session_cap: SESSION_CAP,
+    session_ttl_ms: SESSION_TTL_MS,
+    no_op: agentToolsMap.size === 0
+  });
+  return {
+    "chat.params": async (input, _output) => {
+      await safeAsync(PLUGIN_NAME15, "chat.params", async () => {
+        if (agentToolsMap.size === 0)
+          return;
+        const sid = input?.sessionID;
+        const agent = input?.agent;
+        if (!sid || !agent)
+          return;
+        sessionAgentMap.set(sid, { agent, ts: Date.now() });
+        pruneIfOversize();
+      });
+    },
+    "experimental.chat.system.transform": async (input, output) => {
+      await safeAsync(PLUGIN_NAME15, "experimental.chat.system.transform", async () => {
+        if (agentToolsMap.size === 0)
+          return;
+        if (!output || !Array.isArray(output.system))
+          return;
+        const sid = input?.sessionID;
+        const agent = resolveAgent(sid);
+        const tools = agent !== "unknown" ? agentToolsMap.get(agent) ?? agentToolsMap.get(DEFAULT_AGENT_KEY) ?? [] : agentToolsMap.get(DEFAULT_AGENT_KEY) ?? [];
+        const nudge = renderNudge(agent, tools);
+        output.system.push(nudge);
+        safeWriteLog(PLUGIN_NAME15, {
+          hook: "experimental.chat.system.transform",
+          sessionID: sid,
+          agent,
+          injected_tools: tools,
+          injected_chars: nudge.length,
+          fallback: agent === "unknown"
+        });
+      });
+    }
+  };
+};
+var handler15 = parallelToolNudgeServer;
+
+// plugins/pwsh-utf8.ts
+init_opencode_plugin_helpers();
+var PLUGIN_NAME16 = "pwsh-utf8";
+logLifecycle(PLUGIN_NAME16, "import", {});
 var PRELUDE = "chcp 65001 *> $null; " + "[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new(); " + "$OutputEncoding = [System.Text.UTF8Encoding]::new(); ";
 function prependUtf8Prelude(command) {
   if (typeof command !== "string")
@@ -15872,15 +16180,15 @@ function prependUtf8Prelude(command) {
     return command;
   return PRELUDE + command;
 }
-var handler15 = async (_ctx) => {
+var handler16 = async (_ctx) => {
   const enabled = process.platform === "win32" && process.env.CODEFORGE_DISABLE_PWSH_UTF8 !== "1";
   const reason = enabled ? "win32" : process.platform !== "win32" ? "non-win32" : "disabled-by-env";
-  logLifecycle(PLUGIN_NAME15, "activate", { enabled, platform: process.platform, reason });
+  logLifecycle(PLUGIN_NAME16, "activate", { enabled, platform: process.platform, reason });
   if (!enabled)
     return {};
   return {
     "tool.execute.before": async (input, output) => {
-      await safeAsync(PLUGIN_NAME15, "tool.execute.before", async () => {
+      await safeAsync(PLUGIN_NAME16, "tool.execute.before", async () => {
         if (input.tool !== "bash")
           return;
         const args = output.args ?? {};
@@ -15889,7 +16197,7 @@ var handler15 = async (_ctx) => {
         if (next !== undefined && next !== original) {
           args["command"] = next;
           output.args = args;
-          safeWriteLog(PLUGIN_NAME15, {
+          safeWriteLog(PLUGIN_NAME16, {
             hook: "tool.execute.before",
             tool: input.tool,
             callID: input.callID,
@@ -15906,19 +16214,19 @@ var handler15 = async (_ctx) => {
 init_opencode_plugin_helpers();
 
 // lib/event-stream.ts
-import { promises as fs9 } from "node:fs";
+import { promises as fs10 } from "node:fs";
 init_runtime_paths();
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 async function loadSession(id, opts = {}) {
   const file = resolveSessionFile(id, opts);
-  const raw = await fs9.readFile(file, "utf8");
+  const raw = await fs10.readFile(file, "utf8");
   return parseJsonl(id, raw);
 }
 async function listSessions(opts = {}) {
   const dir = resolveDir(opts);
   let entries;
   try {
-    entries = await fs9.readdir(dir, { withFileTypes: true });
+    entries = await fs10.readdir(dir, { withFileTypes: true });
   } catch (err) {
     if (err.code === "ENOENT")
       return [];
@@ -15928,10 +16236,10 @@ async function listSessions(opts = {}) {
   for (const e of entries) {
     if (!e.isFile() || !e.name.endsWith(".jsonl"))
       continue;
-    const file = path12.join(dir, e.name);
+    const file = path13.join(dir, e.name);
     const id = e.name.replace(/\.jsonl$/, "");
     try {
-      const stat = await fs9.stat(file);
+      const stat = await fs10.stat(file);
       const headerLine = await readFirstLine(file);
       let started_at = stat.birthtimeMs;
       if (headerLine) {
@@ -15955,11 +16263,11 @@ async function listSessions(opts = {}) {
   return out;
 }
 function resolveDir(opts = {}) {
-  const root = path12.resolve(opts.root ?? process.cwd());
-  return opts.sessions_dir ? path12.resolve(root, opts.sessions_dir) : path12.join(runtimeDir(root), "sessions");
+  const root = path13.resolve(opts.root ?? process.cwd());
+  return opts.sessions_dir ? path13.resolve(root, opts.sessions_dir) : path13.join(runtimeDir(root), "sessions");
 }
 function resolveSessionFile(id, opts = {}) {
-  return path12.join(resolveDir(opts), `${id}.jsonl`);
+  return path13.join(resolveDir(opts), `${id}.jsonl`);
 }
 function parseJsonl(id, raw) {
   const events = [];
@@ -15994,7 +16302,7 @@ function isEvent(obj) {
 }
 async function readFirstLine(file) {
   const buf = Buffer.alloc(4096);
-  const fh = await fs9.open(file, "r");
+  const fh = await fs10.open(file, "r");
   try {
     const { bytesRead } = await fh.read(buf, 0, buf.length, 0);
     const s = buf.subarray(0, bytesRead).toString("utf8");
@@ -16222,8 +16530,8 @@ function isRecoveryWorthShowing(plan) {
 }
 
 // plugins/session-recovery.ts
-var PLUGIN_NAME16 = "session-recovery";
-logLifecycle(PLUGIN_NAME16, "import", {});
+var PLUGIN_NAME17 = "session-recovery";
+logLifecycle(PLUGIN_NAME17, "import", {});
 async function processSessionStart(currentSessionId, opts = {}) {
   if (opts.disabled) {
     return { ok: true, injected: false, reason: "disabled" };
@@ -16233,7 +16541,7 @@ async function processSessionStart(currentSessionId, opts = {}) {
     excludeIds.add(currentSessionId);
   const r = await scanLastSession({ ...opts, excludeIds: [...excludeIds] });
   if (!r.ok) {
-    opts.log?.warn?.(`[${PLUGIN_NAME16}] 扫描失败：${r.error}`);
+    opts.log?.warn?.(`[${PLUGIN_NAME17}] 扫描失败：${r.error}`);
     return { ok: false, injected: false, reason: "scan_error", error: r.error };
   }
   const plan = r.plan;
@@ -16247,7 +16555,7 @@ async function processSessionStart(currentSessionId, opts = {}) {
       await opts.injectRecovery(injection);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      opts.log?.warn?.(`[${PLUGIN_NAME16}] injectRecovery 异常：${msg}`);
+      opts.log?.warn?.(`[${PLUGIN_NAME17}] injectRecovery 异常：${msg}`);
       return { ok: false, injected: false, plan, reason: "inject_error", error: msg };
     }
   }
@@ -16276,13 +16584,13 @@ function renderPrompt(plan) {
   return lines.join(`
 `);
 }
-var log8 = makePluginLogger(PLUGIN_NAME16);
+var log9 = makePluginLogger(PLUGIN_NAME17);
 var _lastInjection = null;
 var sessionRecoveryServer = async (ctx) => {
-  logLifecycle(PLUGIN_NAME16, "activate", { directory: ctx.directory });
+  logLifecycle(PLUGIN_NAME17, "activate", { directory: ctx.directory });
   return {
     event: async ({ event }) => {
-      await safeAsync(PLUGIN_NAME16, "event", async () => {
+      await safeAsync(PLUGIN_NAME17, "event", async () => {
         const e = event;
         if (!e || typeof e.type !== "string")
           return;
@@ -16292,12 +16600,12 @@ var sessionRecoveryServer = async (ctx) => {
         const root = typeof e.properties?.["root"] === "string" ? e.properties["root"] : ctx.directory ?? process.cwd();
         const r = await processSessionStart(sid, {
           root,
-          log: log8,
+          log: log9,
           injectRecovery: (inj) => {
             _lastInjection = inj;
           }
         });
-        safeWriteLog(PLUGIN_NAME16, {
+        safeWriteLog(PLUGIN_NAME17, {
           hook: "event",
           type: "session.start",
           ok: r.ok,
@@ -16306,100 +16614,691 @@ var sessionRecoveryServer = async (ctx) => {
           last_session_id: r.plan?.last_session_id
         });
         if (r.injected && r.plan) {
-          log8.info(`[${PLUGIN_NAME16}] 注入恢复提示（last=${r.plan.last_session_id?.slice(0, 8) ?? "?"}, reason=${r.plan.reason}）`);
+          log9.info(`[${PLUGIN_NAME17}] 注入恢复提示（last=${r.plan.last_session_id?.slice(0, 8) ?? "?"}, reason=${r.plan.reason}）`);
         }
       });
     }
   };
 };
-var handler16 = sessionRecoveryServer;
+var handler17 = sessionRecoveryServer;
 
 // plugins/subtasks.ts
-import { promises as fs10 } from "node:fs";
-import * as path13 from "node:path";
+import { promises as fs12 } from "node:fs";
+import * as path15 from "node:path";
 
-// lib/parallel.ts
-async function schedule(opts) {
-  validateSpecs(opts.subtasks);
-  const now = opts.deps.now ?? Date.now;
-  const start = now();
-  const log9 = opts.deps.log ?? (() => {});
-  const concurrency = Math.max(1, opts.maxConcurrency ?? 4);
-  const totalTimeout = opts.totalTimeout_ms ?? 30 * 60000;
-  const limit = Math.max(1, opts.summaryCharLimit ?? 500);
-  const globalCtl = new AbortController;
-  const onParentAbort = () => globalCtl.abort();
-  if (opts.signal) {
-    if (opts.signal.aborted)
-      globalCtl.abort();
-    else
-      opts.signal.addEventListener("abort", onParentAbort, { once: true });
+// lib/autonomy.ts
+import { execFile as execFile2 } from "node:child_process";
+import { promises as fs11 } from "node:fs";
+import * as path14 from "node:path";
+var DEFAULT_POLICIES = {
+  step: {
+    bash: "confirm",
+    edit: "confirm",
+    webfetch: "confirm",
+    read: "confirm",
+    search: "confirm",
+    other: "confirm"
+  },
+  semi: {
+    bash: "confirm",
+    edit: "confirm",
+    webfetch: "confirm",
+    read: "auto",
+    search: "auto",
+    other: "auto"
+  },
+  full: {
+    bash: "auto",
+    edit: "auto",
+    webfetch: "auto",
+    read: "auto",
+    search: "auto",
+    other: "auto"
   }
-  const totalTimer = setTimeout(() => {
-    if (!globalCtl.signal.aborted)
-      globalCtl.abort();
-  }, totalTimeout);
-  const results = new Array(opts.subtasks.length);
-  let nextIdx = 0;
-  const workers = [];
-  const fireFinish = async (i, res) => {
-    if (!opts.onSubtaskFinish)
-      return;
-    try {
-      await opts.onSubtaskFinish(res, i);
-    } catch (err) {
-      log9("warn", `[parallel] onSubtaskFinish 抛错（已隔离）`, {
-        id: res.id,
-        error: describe4(err)
-      });
-    }
-  };
-  const runOne = async (i, spec) => {
-    const subStart = now();
-    let alloc;
-    if (opts.deps.allocateWorktree) {
-      try {
-        alloc = await opts.deps.allocateWorktree(spec.id);
-      } catch (err) {
-        const res2 = {
-          id: spec.id,
-          ok: false,
-          summary: clamp(`worktree 分配失败：${describe4(err)}`, limit),
-          status: "failed",
-          duration_ms: now() - subStart,
-          error: describe4(err)
-        };
-        results[i] = res2;
-        await fireFinish(i, res2);
-        return;
-      }
-    }
-    if (opts.onSubtaskStart) {
-      try {
-        await opts.onSubtaskStart(spec, i);
-      } catch (err) {
-        log9("warn", `[parallel] onSubtaskStart 抛错（已隔离）`, {
-          id: spec.id,
-          error: describe4(err)
-        });
-      }
-    }
-    const ctl = new AbortController;
-    const cascade = () => ctl.abort();
-    if (globalCtl.signal.aborted)
-      ctl.abort();
-    else
-      globalCtl.signal.addEventListener("abort", cascade, { once: true });
-    const perTimer = setTimeout(() => {
-      if (!ctl.signal.aborted)
-        ctl.abort();
-    }, Math.max(1, spec.timeout_ms ?? 5 * 60000));
-    let res;
-    try {
-      const r = await opts.deps.runSubtask(spec, {
-        worktree: alloc?.path,
-        signal: ctl.signal
-      });
+};
+var RISK_PATTERNS = [
+  {
+    tag: "rm_rf_root",
+    kinds: ["bash"],
+    re: /rm\s+-[rRf]+[^|;`\n]*\s+(\/(?:\s|$|[^/\w*.-])|~|\$HOME(?:\b|\/)|\/(?:bin|etc|usr|var|opt|home|root|boot|lib|sbin)\b)/
+  },
+  {
+    tag: "rm_rf_wildcard",
+    kinds: ["bash"],
+    re: /rm\s+-[rRf]+\s+(?:\.\*|\*)/
+  },
+  {
+    tag: "force_push_protected",
+    kinds: ["bash"],
+    re: /git\s+push\s+(?:--force\b|-f\b)[\s\S]*\b(main|master|release(?:\/[\w.-]+)?)\b/
+  },
+  {
+    tag: "git_reset_hard_main",
+    kinds: ["bash"],
+    re: /git\s+reset\s+--hard\s+(origin\/)?(main|master)/
+  },
+  { tag: "sudo", kinds: ["bash"], re: /(?<![\w-])sudo(?![\w-])/ },
+  { tag: "su_root", kinds: ["bash"], re: /(?<![\w-])su\s+(?:-\s+)?root\b/ },
+  { tag: "mkfs", kinds: ["bash"], re: /\bmkfs(\.[\w]+)?\b/ },
+  { tag: "dd_disk", kinds: ["bash"], re: /\bdd\s+if=[^|;\s]+\s+of=\/dev\// },
+  { tag: "chmod_777", kinds: ["bash"], re: /chmod\s+[-+]?[0-7]?777/ },
+  {
+    tag: "curl_pipe_sh",
+    kinds: ["bash"],
+    re: /\b(?:curl|wget)\b[^|]*\|\s*(?:sh|bash|zsh)\b/
+  },
+  {
+    tag: "drop_database",
+    kinds: ["bash", "other"],
+    re: /\b(DROP\s+(DATABASE|TABLE)|TRUNCATE\s+TABLE|DROP\s+SCHEMA)\b/i
+  },
+  { tag: "write_secrets", re: /(\.env(?:\.\w+)?|id_[edr]sa|\.ssh\/id_|\.pem|\.p12|secret\.json)/i },
+  { tag: "write_etc", re: /(?:^|\s|"|')\/etc\// },
+  { tag: "write_usr", re: /(?:^|\s|"|')\/usr\// },
+  { tag: "write_root_home", re: /(?:^|\s|"|')(\/root|\/home\/root)\// },
+  {
+    tag: "internal_url",
+    kinds: ["webfetch"],
+    re: /https?:\/\/(localhost|127\.0\.0\.1|0\.0\.0\.0|169\.254\.|10\.|192\.168\.|172\.(?:1[6-9]|2\d|3[01])\.)/i
+  },
+  {
+    tag: "kubectl_delete",
+    kinds: ["bash"],
+    re: /kubectl\s+(?:delete|destroy)\s+/
+  },
+  {
+    tag: "terraform_destroy",
+    kinds: ["bash"],
+    re: /terraform\s+destroy/
+  }
+];
+function evaluate2(mode, intent, opts = {}) {
+  const ignore = new Set(opts.ignore_risks ?? []);
+  const allRisks = [...RISK_PATTERNS, ...opts.extra_risks ?? []];
+  const haystack = buildHaystack(intent.args);
+  const hits = allRisks.filter((p) => !ignore.has(p.tag)).filter((p) => !p.kinds || p.kinds.includes(intent.kind)).filter((p) => p.re.test(haystack)).map((p) => p.tag);
+  let effective = mode;
+  let downgraded = false;
+  let reason;
+  if (hits.length > 0 && mode === "full") {
+    effective = "semi";
+    downgraded = true;
+    reason = `检测到风险操作 [${hits.join(", ")}]，自动从 full 降级到 semi`;
+  } else if (hits.length > 0 && mode !== "step") {}
+  const policy = mergePolicy(effective, opts.policies);
+  const baseAction = policy[intent.kind] ?? "confirm";
+  const action = hits.length > 0 && effective !== "step" ? "confirm" : baseAction;
+  return {
+    effective_mode: effective,
+    action,
+    downgraded,
+    reason,
+    detected_risks: hits
+  };
+}
+function mergePolicy(mode, override) {
+  const base = DEFAULT_POLICIES[mode];
+  if (!override?.[mode])
+    return base;
+  return { ...base, ...override[mode] };
+}
+function buildHaystack(args) {
+  if (typeof args === "string")
+    return args;
+  try {
+    return JSON.stringify(args);
+  } catch {
+    return String(args);
+  }
+}
+async function ensureWorktree(opts) {
+  const root = path14.resolve(opts.root);
+  const dir = opts.worktrees_dir ?? path14.join(root, ".git", "codeforge-worktrees");
+  await fs11.mkdir(dir, { recursive: true });
+  const wtPath = path14.join(dir, sanitizeBranch(opts.branch));
+  try {
+    const stat = await fs11.stat(wtPath);
+    if (stat.isDirectory()) {
+      return { path: wtPath, branch: opts.branch, created: false };
+    }
+  } catch {}
+  await runGit(root, ["rev-parse", "--is-inside-work-tree"], opts.git_timeout_ms ?? 3000);
+  let branchExists = false;
+  try {
+    await runGit(root, ["rev-parse", "--verify", `refs/heads/${opts.branch}`], opts.git_timeout_ms ?? 3000);
+    branchExists = true;
+  } catch {
+    branchExists = false;
+  }
+  const args = branchExists ? ["worktree", "add", wtPath, opts.branch] : ["worktree", "add", "-b", opts.branch, wtPath, opts.base ?? "HEAD"];
+  await runGit(root, args, opts.git_timeout_ms ?? 1e4);
+  return { path: wtPath, branch: opts.branch, created: true };
+}
+async function removeWorktree(opts) {
+  const args = ["worktree", "remove", opts.worktree_path];
+  if (opts.force)
+    args.push("--force");
+  await runGit(opts.root, args, opts.git_timeout_ms ?? 5000);
+}
+function sanitizeBranch(name) {
+  return name.replace(/[/\\:*?"<>|]/g, "-");
+}
+function runGitAllowFail(cwd, args, timeout) {
+  return new Promise((resolve13, reject) => {
+    execFile2("git", args, { cwd, timeout, windowsHide: true, encoding: "utf8" }, (err, stdout, stderr) => {
+      if (err) {
+        const errCode = err.code;
+        if (typeof errCode === "string") {
+          reject(new Error(`git ${args.join(" ")} 失败: ${stderr || err.message}`));
+          return;
+        }
+        resolve13({
+          code: typeof errCode === "number" ? errCode : 1,
+          stdout: stdout ?? "",
+          stderr: stderr ?? err.message ?? ""
+        });
+        return;
+      }
+      resolve13({ code: 0, stdout, stderr: stderr ?? "" });
+    });
+  });
+}
+function runGit(cwd, args, timeout) {
+  return new Promise((resolve13, reject) => {
+    execFile2("git", args, { cwd, timeout, windowsHide: true, encoding: "utf8" }, (err, stdout, stderr) => {
+      if (err) {
+        reject(new Error(`git ${args.join(" ")} 失败: ${stderr || err.message}`));
+        return;
+      }
+      resolve13(stdout);
+    });
+  });
+}
+async function tryMerge(opts) {
+  const root = path14.resolve(opts.root);
+  const timeout = opts.git_timeout_ms ?? 1e4;
+  const status = await runGitAllowFail(root, ["status", "--porcelain"], 3000);
+  if (status.code !== 0) {
+    return {
+      ok: false,
+      conflicts: [],
+      hadChanges: false,
+      message: `git status 失败: ${status.stderr.trim() || "unknown"}`
+    };
+  }
+  if (status.stdout.trim().length > 0) {
+    return {
+      ok: false,
+      conflicts: [],
+      hadChanges: false,
+      message: "main repo dirty"
+    };
+  }
+  const diff = await runGitAllowFail(root, ["diff", "--name-only", "HEAD", opts.branch], 3000);
+  if (diff.code !== 0) {
+    return {
+      ok: false,
+      conflicts: [],
+      hadChanges: false,
+      message: `git diff HEAD ${opts.branch} 失败: ${diff.stderr.trim() || "unknown"}`
+    };
+  }
+  const hadChanges = diff.stdout.trim().length > 0;
+  if (!hadChanges) {
+    return { ok: true, conflicts: [], hadChanges: false };
+  }
+  const merge = await runGitAllowFail(root, ["merge", "--no-commit", "--no-ff", opts.branch], timeout);
+  if (merge.code === 0) {
+    return { ok: true, conflicts: [], hadChanges: true };
+  }
+  const conflicts = await getMergeConflicts({ root, git_timeout_ms: 3000 });
+  await runGitAllowFail(root, ["merge", "--abort"], 5000);
+  return {
+    ok: false,
+    conflicts,
+    hadChanges: true,
+    message: merge.stderr.trim() || `merge exit code ${merge.code}`
+  };
+}
+async function mergeCommit(opts) {
+  const root = path14.resolve(opts.root);
+  await runGit(root, ["commit", "-m", opts.message], opts.git_timeout_ms ?? 1e4);
+}
+async function mergeAbort(opts) {
+  const root = path14.resolve(opts.root);
+  await runGitAllowFail(root, ["merge", "--abort"], opts.git_timeout_ms ?? 5000);
+}
+async function getMergeConflicts(opts) {
+  const out = await runGitAllowFail(path14.resolve(opts.root), ["diff", "--name-only", "--diff-filter=U"], opts.git_timeout_ms ?? 3000);
+  if (out.code !== 0)
+    return [];
+  return out.stdout.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+}
+async function worktreeHasChanges(opts) {
+  const out = await runGitAllowFail(path14.resolve(opts.worktree_path), ["status", "--porcelain"], opts.git_timeout_ms ?? 3000);
+  if (out.code !== 0)
+    return false;
+  return out.stdout.trim().length > 0;
+}
+async function commitWorktreeIfDirty(opts) {
+  const wt = path14.resolve(opts.worktree_path);
+  const timeout = opts.git_timeout_ms ?? 1e4;
+  const status = await runGitAllowFail(wt, ["status", "--porcelain"], 3000);
+  if (status.code !== 0) {
+    return { committed: false };
+  }
+  if (status.stdout.trim().length === 0) {
+    return { committed: false };
+  }
+  await runGit(wt, ["add", "-A"], timeout);
+  await runGit(wt, ["commit", "-m", opts.message], timeout);
+  return { committed: true };
+}
+
+// lib/parallel-merge.ts
+function resolveMergeFns(deps) {
+  return {
+    commitWorktreeIfDirtyFn: deps.commitWorktreeIfDirty ?? commitWorktreeIfDirty,
+    tryMergeFn: deps.tryMerge ?? tryMerge,
+    mergeCommitFn: deps.mergeCommit ?? mergeCommit,
+    mergeAbortFn: deps.mergeAbort ?? mergeAbort,
+    removeWorktreeFn: deps.removeWorktree ?? removeWorktree,
+    worktreeHasChangesFn: deps.worktreeHasChanges ?? worktreeHasChanges
+  };
+}
+async function mergeOneAttempt(r, opts, mergeFns, log10) {
+  const t0 = Date.now();
+  const root = opts.mergeRoot;
+  const {
+    commitWorktreeIfDirtyFn,
+    tryMergeFn,
+    mergeCommitFn,
+    mergeAbortFn,
+    removeWorktreeFn
+  } = mergeFns;
+  const eligibleStatus = r.status === "success" || r.status === "need_review";
+  if (!eligibleStatus) {
+    return {
+      attempt: {
+        subtaskId: r.id,
+        branch: r.id,
+        worktree: r.worktree ?? null,
+        ok: false,
+        conflicts: [],
+        skippedReason: "subtask_failed",
+        durationMs: 0
+      }
+    };
+  }
+  if (!r.worktree) {
+    return {
+      attempt: {
+        subtaskId: r.id,
+        branch: r.id,
+        worktree: null,
+        ok: false,
+        conflicts: [],
+        skippedReason: "no_worktree",
+        durationMs: 0
+      }
+    };
+  }
+  const wt = r.worktree;
+  const branch = r.id;
+  const attempt = {
+    subtaskId: r.id,
+    branch,
+    worktree: wt,
+    ok: false,
+    conflicts: [],
+    durationMs: 0
+  };
+  try {
+    try {
+      await commitWorktreeIfDirtyFn({
+        worktree_path: wt,
+        message: `parallel: auto-commit ${r.id} before merge`
+      });
+    } catch (commitErr) {
+      attempt.ok = false;
+      attempt.message = `commitWorktreeIfDirty 失败：${describe4(commitErr)}`;
+      attempt.durationMs = Date.now() - t0;
+      return {
+        attempt,
+        pendingItem: { subtaskId: r.id, path: wt, conflicts: [] }
+      };
+    }
+    const merge = await tryMergeFn({ root, branch });
+    if (!merge.ok) {
+      attempt.ok = false;
+      attempt.conflicts = merge.conflicts;
+      attempt.message = merge.message;
+      attempt.durationMs = Date.now() - t0;
+      return {
+        attempt,
+        pendingItem: { subtaskId: r.id, path: wt, conflicts: merge.conflicts }
+      };
+    }
+    if (merge.hadChanges) {
+      try {
+        await mergeCommitFn({ root, message: `parallel: merge ${r.id}` });
+      } catch (commitErr) {
+        let abortFailed = false;
+        try {
+          await mergeAbortFn({ root });
+        } catch (abortErr) {
+          abortFailed = true;
+          log10("error", `[parallel-merge] mergeAbort 失败（仓库可能锁死）`, {
+            id: r.id,
+            error: describe4(abortErr)
+          });
+        }
+        attempt.ok = false;
+        attempt.message = `mergeCommit 失败：${describe4(commitErr)}`;
+        attempt.durationMs = Date.now() - t0;
+        return {
+          attempt,
+          abortFailed,
+          pendingItem: { subtaskId: r.id, path: wt, conflicts: [] }
+        };
+      }
+      attempt.ok = true;
+      attempt.durationMs = Date.now() - t0;
+      await safeRemoveWorktree(removeWorktreeFn, root, wt, log10, r.id);
+      return { attempt };
+    } else {
+      attempt.ok = true;
+      attempt.skippedReason = "no_changes";
+      attempt.durationMs = Date.now() - t0;
+      await safeRemoveWorktree(removeWorktreeFn, root, wt, log10, r.id);
+      return { attempt };
+    }
+  } catch (err) {
+    attempt.ok = false;
+    attempt.message = `mergeWorktrees 异常：${describe4(err)}`;
+    attempt.durationMs = Date.now() - t0;
+    return {
+      attempt,
+      pendingItem: { subtaskId: r.id, path: wt, conflicts: [] }
+    };
+  }
+}
+async function mergeWorktrees(results, opts, deps) {
+  const log10 = deps.log ?? (() => {});
+  const root = opts.mergeRoot;
+  const mergeFns = resolveMergeFns(deps);
+  const report = {
+    attempts: [],
+    merged: 0,
+    skipped: 0,
+    conflicted: 0,
+    pendingWorktrees: []
+  };
+  const mergeable = [];
+  const skipped = [];
+  for (const r of results) {
+    const eligibleStatus = r.status === "success" || r.status === "need_review";
+    if (!eligibleStatus) {
+      skipped.push({ res: r, reason: "subtask_failed" });
+      continue;
+    }
+    if (!r.worktree) {
+      skipped.push({ res: r, reason: "no_worktree" });
+      continue;
+    }
+    mergeable.push(r);
+  }
+  mergeable.sort((a, b) => {
+    const la = a.changedFiles?.length ?? 0;
+    const lb = b.changedFiles?.length ?? 0;
+    return la - lb;
+  });
+  let idx = 0;
+  for (const s of skipped) {
+    const attempt = {
+      subtaskId: s.res.id,
+      branch: s.res.id,
+      worktree: s.res.worktree ?? null,
+      ok: false,
+      conflicts: [],
+      skippedReason: s.reason,
+      durationMs: 0
+    };
+    report.attempts.push(attempt);
+    report.skipped++;
+    await fireMergeAttempt(opts.onMergeAttempt, attempt, idx++, log10);
+  }
+  for (const r of mergeable) {
+    const { attempt, pendingItem } = await mergeOneAttempt(r, { mergeRoot: root }, mergeFns, log10);
+    report.attempts.push(attempt);
+    if (attempt.ok && !attempt.skippedReason)
+      report.merged++;
+    else if (attempt.skippedReason === "no_changes")
+      report.skipped++;
+    else
+      report.conflicted++;
+    if (pendingItem)
+      report.pendingWorktrees.push(pendingItem);
+    await fireMergeAttempt(opts.onMergeAttempt, attempt, idx++, log10);
+  }
+  return report;
+}
+function createMergeQueue(opts, deps = {}) {
+  const log10 = deps.log ?? (() => {});
+  const mergeFns = {
+    commitWorktreeIfDirtyFn: deps.commitWorktreeIfDirtyFn ?? commitWorktreeIfDirty,
+    tryMergeFn: deps.tryMergeFn ?? tryMerge,
+    mergeCommitFn: deps.mergeCommitFn ?? mergeCommit,
+    mergeAbortFn: deps.mergeAbortFn ?? mergeAbort,
+    removeWorktreeFn: deps.removeWorktreeFn ?? removeWorktree,
+    worktreeHasChangesFn: deps.worktreeHasChangesFn ?? worktreeHasChanges
+  };
+  const report = {
+    attempts: [],
+    merged: 0,
+    skipped: 0,
+    conflicted: 0,
+    pendingWorktrees: []
+  };
+  let tail = Promise.resolve();
+  let idx = 0;
+  let queueAborted = false;
+  return {
+    enqueue(result) {
+      tail = tail.then(async () => {
+        if (queueAborted) {
+          const attempt2 = {
+            subtaskId: result.id,
+            branch: result.id,
+            worktree: result.worktree ?? null,
+            ok: false,
+            conflicts: [],
+            skippedReason: "queue_aborted",
+            durationMs: 0
+          };
+          report.attempts.push(attempt2);
+          report.skipped++;
+          if (result.worktree) {
+            report.pendingWorktrees.push({
+              subtaskId: result.id,
+              path: result.worktree,
+              conflicts: []
+            });
+          }
+          await fireMergeAttempt(opts.onMergeAttempt, attempt2, idx++, log10);
+          return;
+        }
+        const { attempt, abortFailed, pendingItem } = await mergeOneAttempt(result, { mergeRoot: opts.mergeRoot, summaryCharLimit: opts.summaryCharLimit }, mergeFns, log10);
+        report.attempts.push(attempt);
+        if (attempt.ok && !attempt.skippedReason)
+          report.merged++;
+        else if (attempt.skippedReason === "no_changes" || attempt.skippedReason === "subtask_failed" || attempt.skippedReason === "no_worktree" || attempt.skippedReason === "autonomy_off")
+          report.skipped++;
+        else
+          report.conflicted++;
+        if (pendingItem)
+          report.pendingWorktrees.push(pendingItem);
+        if (abortFailed) {
+          queueAborted = true;
+          log10("error", `[parallel-merge] queue aborted (mergeAbort failed)`, {
+            id: result.id
+          });
+        }
+        await fireMergeAttempt(opts.onMergeAttempt, attempt, idx++, log10);
+      });
+    },
+    async flushAndReport() {
+      await tail;
+      return report;
+    }
+  };
+}
+async function safeRemoveWorktree(fn, root, wt, log10, subtaskId) {
+  try {
+    await fn({ root, worktree_path: wt, force: true });
+  } catch (err) {
+    log10("warn", `[parallel] removeWorktree 失败 ${subtaskId}`, {
+      error: describe4(err),
+      worktree: wt
+    });
+  }
+}
+async function fireMergeAttempt(cb, attempt, idx, log10) {
+  if (!cb)
+    return;
+  try {
+    await cb(attempt, idx);
+  } catch (err) {
+    log10("warn", `[parallel] onMergeAttempt 抛错（已隔离）`, {
+      id: attempt.subtaskId,
+      error: describe4(err)
+    });
+  }
+}
+function describe4(err) {
+  if (err instanceof Error)
+    return err.message;
+  if (typeof err === "string")
+    return err;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+
+// lib/parallel.ts
+async function schedule(opts) {
+  validateSpecs(opts.subtasks);
+  if (opts.autoMerge && !opts.mergeRoot) {
+    throw new Error("mergeRoot is required when autoMerge=true");
+  }
+  const now = opts.deps.now ?? Date.now;
+  const start = now();
+  const log10 = opts.deps.log ?? (() => {});
+  const concurrency = Math.max(1, opts.maxConcurrency ?? 4);
+  const totalTimeout = opts.totalTimeout_ms ?? 30 * 60000;
+  const limit = Math.max(1, opts.summaryCharLimit ?? 500);
+  const globalCtl = new AbortController;
+  const onParentAbort = () => globalCtl.abort();
+  if (opts.signal) {
+    if (opts.signal.aborted)
+      globalCtl.abort();
+    else
+      opts.signal.addEventListener("abort", onParentAbort, { once: true });
+  }
+  const totalTimer = setTimeout(() => {
+    if (!globalCtl.signal.aborted)
+      globalCtl.abort();
+  }, totalTimeout);
+  const results = new Array(opts.subtasks.length);
+  let nextIdx = 0;
+  const workers = [];
+  const pipelineEnabled = Boolean(opts.autoMerge && opts.pipelineMerge);
+  let queue;
+  if (pipelineEnabled) {
+    queue = createMergeQueue({
+      mergeRoot: opts.mergeRoot,
+      summaryCharLimit: opts.summaryCharLimit,
+      onMergeAttempt: opts.onMergeAttempt
+    }, {
+      commitWorktreeIfDirtyFn: opts.deps.commitWorktreeIfDirty,
+      tryMergeFn: opts.deps.tryMerge,
+      mergeCommitFn: opts.deps.mergeCommit,
+      mergeAbortFn: opts.deps.mergeAbort,
+      removeWorktreeFn: opts.deps.removeWorktree,
+      worktreeHasChangesFn: opts.deps.worktreeHasChanges,
+      log: log10
+    });
+  }
+  const fireFinish = async (i, res) => {
+    if (queue) {
+      try {
+        queue.enqueue(res);
+      } catch (err) {
+        log10("warn", `[parallel] queue.enqueue 抛错（已隔离）`, {
+          id: res.id,
+          error: describe5(err)
+        });
+      }
+    }
+    if (!opts.onSubtaskFinish)
+      return;
+    try {
+      await opts.onSubtaskFinish(res, i);
+    } catch (err) {
+      log10("warn", `[parallel] onSubtaskFinish 抛错（已隔离）`, {
+        id: res.id,
+        error: describe5(err)
+      });
+    }
+  };
+  const runOne = async (i, spec) => {
+    const subStart = now();
+    let alloc;
+    if (opts.deps.allocateWorktree) {
+      try {
+        alloc = await opts.deps.allocateWorktree(spec.id);
+      } catch (err) {
+        const res2 = {
+          id: spec.id,
+          ok: false,
+          summary: clamp(`worktree 分配失败：${describe5(err)}`, limit),
+          status: "failed",
+          duration_ms: now() - subStart,
+          error: describe5(err)
+        };
+        results[i] = res2;
+        await fireFinish(i, res2);
+        return;
+      }
+    }
+    if (opts.onSubtaskStart) {
+      try {
+        await opts.onSubtaskStart(spec, i);
+      } catch (err) {
+        log10("warn", `[parallel] onSubtaskStart 抛错（已隔离）`, {
+          id: spec.id,
+          error: describe5(err)
+        });
+      }
+    }
+    const ctl = new AbortController;
+    const cascade = () => ctl.abort();
+    if (globalCtl.signal.aborted)
+      ctl.abort();
+    else
+      globalCtl.signal.addEventListener("abort", cascade, { once: true });
+    const perTimer = setTimeout(() => {
+      if (!ctl.signal.aborted)
+        ctl.abort();
+    }, Math.max(1, spec.timeout_ms ?? 5 * 60000));
+    let res;
+    try {
+      const r = await opts.deps.runSubtask(spec, {
+        worktree: alloc?.path,
+        signal: ctl.signal
+      });
       const status = pickStatus(r, ctl.signal.aborted, globalCtl.signal.aborted);
       res = {
         id: spec.id,
@@ -16416,21 +17315,21 @@ async function schedule(opts) {
       res = {
         id: spec.id,
         ok: false,
-        summary: clamp(`runSubtask 抛错：${describe4(err)}`, limit),
+        summary: clamp(`runSubtask 抛错：${describe5(err)}`, limit),
         status: isAborted ? globalCtl.signal.aborted ? "cancelled" : "timeout" : "failed",
         duration_ms: now() - subStart,
         worktree: alloc?.path,
-        error: describe4(err)
+        error: describe5(err)
       };
     } finally {
       clearTimeout(perTimer);
       globalCtl.signal.removeEventListener("abort", cascade);
-      if (alloc) {
+      if (alloc && !opts.autoMerge) {
         try {
           await alloc.cleanup();
         } catch (err) {
-          log9("warn", `[parallel] worktree 清理失败 ${spec.id}`, {
-            error: describe4(err)
+          log10("warn", `[parallel] worktree 清理失败 ${spec.id}`, {
+            error: describe5(err)
           });
         }
       }
@@ -16468,12 +17367,21 @@ async function schedule(opts) {
     opts.signal.removeEventListener("abort", onParentAbort);
   const conflicts = detectConflicts(results);
   const digest = buildDigest(results, conflicts);
+  let mergeReport;
+  if (opts.autoMerge) {
+    if (queue) {
+      mergeReport = await queue.flushAndReport();
+    } else {
+      mergeReport = await mergeWorktrees(results, opts, opts.deps);
+    }
+  }
   return {
     parentId: opts.parentId,
     results,
     conflicts,
     digest,
-    duration_ms: now() - start
+    duration_ms: now() - start,
+    mergeReport
   };
 }
 var SUBTASK_ID_RE = /^[a-zA-Z0-9._-]+$/;
@@ -16545,7 +17453,7 @@ function buildDigest(results, conflicts) {
     conflicts
   };
 }
-function describe4(err) {
+function describe5(err) {
   if (err instanceof Error)
     return err.message;
   if (typeof err === "string")
@@ -16580,7 +17488,7 @@ function pickStatus(r, taskAborted, globalAborted) {
 // lib/opencode-runner.ts
 init_opencode_plugin_helpers();
 function makeOpencodeRunner(opts) {
-  const log9 = opts.log ?? (() => {});
+  const log10 = opts.log ?? (() => {});
   return async (spec, runCtx) => {
     const startedAt = Date.now();
     let childSessionId;
@@ -16595,13 +17503,13 @@ function makeOpencodeRunner(opts) {
       if (created.error || !created.data?.id) {
         return {
           ok: false,
-          summary: `session.create 失败：${describe5(created.error) || "no id"}`,
+          summary: `session.create 失败：${describe6(created.error) || "no id"}`,
           status: "failed",
-          error: describe5(created.error) || "session.create 无 id"
+          error: describe6(created.error) || "session.create 无 id"
         };
       }
       childSessionId = created.data.id;
-      log9("info", `[opencode-runner] subtask=${spec.id} session=${childSessionId} created`);
+      log10("info", `[opencode-runner] subtask=${spec.id} session=${childSessionId} created`);
       const promptText = composePromptText(spec);
       const promptPromise = opts.client.session.prompt({
         path: { id: childSessionId },
@@ -16631,9 +17539,9 @@ function makeOpencodeRunner(opts) {
       if (r.error || !r.data) {
         return {
           ok: false,
-          summary: `session.prompt 失败：${describe5(r.error)}`,
+          summary: `session.prompt 失败：${describe6(r.error)}`,
           status: "failed",
-          error: describe5(r.error) || "no data"
+          error: describe6(r.error) || "no data"
         };
       }
       const lastText = pickLastText(r.data.parts ?? []);
@@ -16654,7 +17562,7 @@ function makeOpencodeRunner(opts) {
         });
         changedFiles = pickDiffFiles(diff.data);
       } catch (err) {
-        log9("warn", `[opencode-runner] diff 取失败 ${spec.id}`, { error: describe5(err) });
+        log10("warn", `[opencode-runner] diff 取失败 ${spec.id}`, { error: describe6(err) });
       }
       const elapsed = Date.now() - startedAt;
       const summary = lastText || `subtask ${spec.id} 完成（${elapsed}ms，无文本输出，finish=${finishReason || "unknown"}）`;
@@ -16663,14 +17571,14 @@ function makeOpencodeRunner(opts) {
         summary,
         status,
         changedFiles,
-        error: llmError ? describe5(llmError) : undefined
+        error: llmError ? describe6(llmError) : undefined
       };
     } catch (err) {
       return {
         ok: false,
-        summary: `runner 抛错：${describe5(err)}`,
+        summary: `runner 抛错：${describe6(err)}`,
         status: "failed",
-        error: describe5(err)
+        error: describe6(err)
       };
     } finally {
       if (childSessionId) {
@@ -16680,8 +17588,8 @@ function makeOpencodeRunner(opts) {
             query: opts.directory ? { directory: opts.directory } : undefined
           });
         } catch (err) {
-          log9("warn", `[opencode-runner] session.delete 失败 ${childSessionId}`, {
-            error: describe5(err)
+          log10("warn", `[opencode-runner] session.delete 失败 ${childSessionId}`, {
+            error: describe6(err)
           });
         }
       }
@@ -16735,20 +17643,20 @@ async function withTimeout2(p, ms, signal) {
       throw err;
     }
   }
-  return await new Promise((resolve11, reject) => {
+  return await new Promise((resolve13, reject) => {
     let settled = false;
     const timer = setTimeout(() => {
       if (settled)
         return;
       settled = true;
-      resolve11({ kind: "timeout" });
+      resolve13({ kind: "timeout" });
     }, ms);
     const onAbort = () => {
       if (settled)
         return;
       settled = true;
       clearTimeout(timer);
-      resolve11({ kind: "aborted" });
+      resolve13({ kind: "aborted" });
     };
     signal?.addEventListener("abort", onAbort, { once: true });
     p.then((value) => {
@@ -16757,7 +17665,7 @@ async function withTimeout2(p, ms, signal) {
       settled = true;
       clearTimeout(timer);
       signal?.removeEventListener("abort", onAbort);
-      resolve11({ kind: "ok", value });
+      resolve13({ kind: "ok", value });
     }, (err) => {
       if (settled)
         return;
@@ -16768,7 +17676,7 @@ async function withTimeout2(p, ms, signal) {
     });
   });
 }
-function describe5(err) {
+function describe6(err) {
   if (!err)
     return "";
   if (err instanceof Error)
@@ -16794,14 +17702,14 @@ function clip4(s, max) {
   return s.length <= max ? s : s.slice(0, max - 1) + "…";
 }
 async function sendParentNotice(client, sessionID, text, opts = {}) {
-  const log9 = opts.log ?? (() => {});
+  const log10 = opts.log ?? (() => {});
   if (!client?.session) {
-    log9("warn", "[sendParentNotice] client.session 不可用，noop");
+    log10("warn", "[sendParentNotice] client.session 不可用，noop");
     return false;
   }
   const sessionAny = client.session;
   if (typeof sessionAny.promptAsync !== "function") {
-    log9("warn", "[sendParentNotice] promptAsync 不可用（SDK 太老？），noop");
+    log10("warn", "[sendParentNotice] promptAsync 不可用（SDK 太老？），noop");
     return false;
   }
   try {
@@ -16822,12 +17730,12 @@ async function sendParentNotice(client, sessionID, text, opts = {}) {
       }
     });
     if (res && typeof res === "object" && "error" in res && res.error) {
-      log9("warn", "[sendParentNotice] promptAsync 返回 error", { error: res.error });
+      log10("warn", "[sendParentNotice] promptAsync 返回 error", { error: res.error });
       return false;
     }
     return true;
   } catch (err) {
-    log9("warn", "[sendParentNotice] 抛错（已隔离）", {
+    log10("warn", "[sendParentNotice] 抛错（已隔离）", {
       error: err instanceof Error ? err.message : String(err)
     });
     return false;
@@ -16835,11 +17743,238 @@ async function sendParentNotice(client, sessionID, text, opts = {}) {
 }
 
 // plugins/subtasks.ts
-init_opencode_plugin_helpers();
+init_opencode_plugin_helpers();
+
+// lib/decompose.ts
+var DEFAULT_MAX_SUBTASKS = 8;
+var DEFAULT_TIMEOUT_MS2 = 30000;
+function buildSystemPrompt(maxSubtasks) {
+  return [
+    `你是任务拆分助手。把用户描述拆成 2 到 ${maxSubtasks} 个【可并行执行】的独立子任务。`,
+    `硬约束：`,
+    `(a) 子任务之间不互相依赖（不能"先 A 再 B"的串行关系）`,
+    `(b) 不同子任务尽量改不同文件（hintFiles 填你预测会改的文件路径，用于冲突预检）`,
+    `(c) 每个子任务自包含（单独给一个 agent 执行即可完成）`,
+    `(d) 如果任务不能拆（如"先实现再测试"这种强依赖链），返回 {"single_task": true, "reason": "..."}`,
+    ``,
+    `输出格式（必须是合法 JSON，不要加 markdown 代码围栏之外的内容）：`,
+    `{"subtasks": [{"description": "...", "hintFiles": ["path/to/file.ts"]}]}`,
+    `或`,
+    `{"single_task": true, "reason": "无法并行，因为..."}`
+  ].join(`
+`);
+}
+async function decomposeTask(description26, opts) {
+  const log10 = opts.log ?? (() => {});
+  if (opts.mockResponse) {
+    return validateAndFinalize(opts.mockResponse, undefined, log10, opts.maxSubtasks ?? DEFAULT_MAX_SUBTASKS);
+  }
+  const maxSubtasks = opts.maxSubtasks ?? DEFAULT_MAX_SUBTASKS;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+  let childSessionId;
+  try {
+    const created = await opts.client.session.create({
+      body: { title: `decompose:${clip5(description26, 60)}` },
+      query: opts.directory ? { directory: opts.directory } : undefined
+    });
+    if (created.error || !created.data?.id) {
+      log10("warn", "[decompose] session.create 失败", { error: describe7(created.error) });
+      return {
+        ok: false,
+        subtasks: [],
+        reason: "llm_unavailable"
+      };
+    }
+    childSessionId = created.data.id;
+    const systemText = buildSystemPrompt(maxSubtasks);
+    const promptPromise = Promise.resolve(opts.client.session.prompt({
+      path: { id: childSessionId },
+      body: {
+        system: systemText,
+        parts: [{ type: "text", text: description26 }]
+      },
+      query: opts.directory ? { directory: opts.directory } : undefined
+    }));
+    const raced = await Promise.race([
+      promptPromise.then((v) => ({ kind: "ok", value: v })),
+      sleep(timeoutMs).then(() => ({ kind: "timeout" }))
+    ]);
+    if (raced.kind === "timeout") {
+      log10("warn", "[decompose] LLM 调用超时", { timeoutMs });
+      return { ok: false, subtasks: [], reason: "llm_unavailable" };
+    }
+    const r = raced.value;
+    if (r.error || !r.data) {
+      log10("warn", "[decompose] session.prompt 返回错误", { error: describe7(r.error) });
+      return { ok: false, subtasks: [], reason: "llm_unavailable" };
+    }
+    const rawText = pickLastText2(r.data.parts ?? []);
+    if (!rawText) {
+      log10("warn", "[decompose] LLM 输出为空");
+      return { ok: false, subtasks: [], reason: "parse_failed", raw: "" };
+    }
+    const parsed = extractJson(rawText);
+    if (!parsed) {
+      log10("warn", "[decompose] JSON 解析失败", { raw: clip5(rawText, 200) });
+      return { ok: false, subtasks: [], reason: "parse_failed", raw: rawText };
+    }
+    if (parsed && typeof parsed === "object" && parsed.single_task === true) {
+      return { ok: false, subtasks: [], reason: "single_task", raw: rawText };
+    }
+    const subtasksRaw = parsed.subtasks;
+    if (!Array.isArray(subtasksRaw)) {
+      log10("warn", "[decompose] JSON 缺 subtasks 数组");
+      return { ok: false, subtasks: [], reason: "parse_failed", raw: rawText };
+    }
+    const normalized = [];
+    for (const item of subtasksRaw) {
+      if (!item || typeof item !== "object")
+        continue;
+      const o = item;
+      const desc = typeof o.description === "string" ? o.description.trim() : "";
+      if (!desc) {
+        return { ok: false, subtasks: [], reason: "parse_failed", raw: rawText };
+      }
+      const hintFiles = Array.isArray(o.hintFiles) ? o.hintFiles.filter((x) => typeof x === "string" && x.trim().length > 0) : undefined;
+      normalized.push({ description: desc, hintFiles });
+    }
+    if (normalized.length > maxSubtasks) {
+      log10("warn", "[decompose] LLM 返回子任务超过上限", { count: normalized.length, maxSubtasks });
+      return { ok: false, subtasks: [], reason: "parse_failed", raw: rawText };
+    }
+    return validateAndFinalize(normalized, rawText, log10, maxSubtasks);
+  } catch (err) {
+    log10("warn", "[decompose] 抛错", { error: describe7(err) });
+    return { ok: false, subtasks: [], reason: "llm_unavailable" };
+  } finally {
+    if (childSessionId) {
+      try {
+        await opts.client.session.delete({
+          path: { id: childSessionId },
+          query: opts.directory ? { directory: opts.directory } : undefined
+        });
+      } catch (err) {
+        log10("warn", "[decompose] session.delete 失败", { error: describe7(err) });
+      }
+    }
+  }
+}
+function validateAndFinalize(subtasks, raw, log10, maxSubtasks) {
+  if (subtasks.length < 2) {
+    return { ok: false, subtasks: [], reason: "single_task", raw };
+  }
+  for (const t of subtasks) {
+    if (!t.description || !t.description.trim()) {
+      return { ok: false, subtasks: [], reason: "parse_failed", raw };
+    }
+  }
+  if (subtasks.length > maxSubtasks) {
+    log10("warn", "[decompose] LLM 返回子任务超过上限", { count: subtasks.length, maxSubtasks });
+    return { ok: false, subtasks: [], reason: "parse_failed", raw };
+  }
+  for (let i = 0;i < subtasks.length; i++) {
+    const a = subtasks[i].hintFiles;
+    if (!a || a.length === 0)
+      continue;
+    const setA = new Set(a.map((p) => p.trim()).filter(Boolean));
+    for (let j = i + 1;j < subtasks.length; j++) {
+      const b = subtasks[j].hintFiles;
+      if (!b || b.length === 0)
+        continue;
+      for (const f of b) {
+        if (setA.has(f.trim())) {
+          log10("info", "[decompose] hintFiles 有交集，降级 single_task", {
+            a: subtasks[i].description,
+            b: subtasks[j].description,
+            file: f
+          });
+          return { ok: false, subtasks: [], reason: "single_task", raw };
+        }
+      }
+    }
+  }
+  return { ok: true, subtasks, reason: "ok", raw: undefined };
+}
+function pickLastText2(parts) {
+  for (let i = parts.length - 1;i >= 0; i--) {
+    const p = parts[i];
+    if (p && p.type === "text" && typeof p.text === "string" && !p.synthetic && !p.ignored) {
+      return p.text.trim();
+    }
+  }
+  return "";
+}
+function extractJson(text) {
+  if (!text)
+    return null;
+  const fenceMatch = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/i);
+  if (fenceMatch && fenceMatch[1]) {
+    const inner = fenceMatch[1].trim();
+    const parsed = tryParse(inner);
+    if (parsed !== null)
+      return parsed;
+  }
+  const direct = tryParse(text.trim());
+  if (direct !== null)
+    return direct;
+  for (let end = text.length - 1;end >= 0; end--) {
+    if (text[end] !== "}")
+      continue;
+    let depth = 0;
+    for (let start = end;start >= 0; start--) {
+      const ch = text[start];
+      if (ch === "}")
+        depth++;
+      else if (ch === "{") {
+        depth--;
+        if (depth === 0) {
+          const slice = text.slice(start, end + 1);
+          const parsed = tryParse(slice);
+          if (parsed !== null)
+            return parsed;
+          break;
+        }
+      }
+    }
+  }
+  return null;
+}
+function tryParse(s) {
+  if (!s)
+    return null;
+  try {
+    return JSON.parse(s);
+  } catch {
+    return null;
+  }
+}
+function clip5(s, n) {
+  if (!s)
+    return "";
+  return s.length <= n ? s : s.slice(0, n - 1) + "…";
+}
+function describe7(err) {
+  if (!err)
+    return "";
+  if (err instanceof Error)
+    return err.message;
+  if (typeof err === "string")
+    return err;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve13) => setTimeout(resolve13, ms));
+}
+
+// plugins/subtasks.ts
 init_runtime_paths();
-var PLUGIN_NAME17 = "subtasks";
+var PLUGIN_NAME18 = "subtasks";
 function getLogFile(root = process.cwd()) {
-  return path13.join(runtimeDir(root), "logs", "subtasks.log");
+  return path15.join(runtimeDir(root), "logs", "subtasks.log");
 }
 var VERB_RE = /^([a-zA-Z]{3,12})/;
 var CN_VERBS = [
@@ -16903,9 +18038,10 @@ var mockRunner = async (spec) => {
 };
 async function handleParallelCommand(raw) {
   const ctx = raw ?? {};
-  const log9 = ctx.log;
+  const log10 = ctx.log;
   const args = ctx.args ?? {};
   const parentId = (args.parentId ?? `task-${Date.now().toString(36)}`).replace(/[^a-zA-Z0-9._-]/g, "-");
+  const rawDescription = typeof args.description === "string" ? args.description.trim() : "";
   let specs = [];
   if (Array.isArray(args.subtasks) && args.subtasks.length > 0) {
     specs = args.subtasks.map((s, i) => ({
@@ -16916,16 +18052,80 @@ async function handleParallelCommand(raw) {
     specs = splitDescriptions(args.description, { parentId });
   }
   if (specs.length === 0) {
-    log9?.warn(`[${PLUGIN_NAME17}] /parallel 缺有效子任务`);
+    log10?.warn(`[${PLUGIN_NAME18}] /parallel 缺有效子任务`);
     await safeReply2(ctx, "⚠ /parallel 需要至少 1 个子任务（用 ; 或换行分隔）");
     return { ok: false, reason: "no_subtasks" };
   }
   const maxConcurrency = clampInt(args.maxConcurrency, 1, 16, 4);
   const totalTimeoutMs = clampInt(args.totalTimeout_ms, 1000, 60 * 60000, 30 * 60000);
+  let autoMerge = ctx.autoMerge;
+  if (autoMerge === undefined) {
+    if (ctx.allocateWorktree !== undefined) {
+      autoMerge = false;
+    } else {
+      try {
+        const rt = await loadRuntime({ root: ctx.directory });
+        autoMerge = rt.runtime.runtime.worktree_isolation === true;
+      } catch {
+        autoMerge = false;
+      }
+    }
+  }
+  let downgradedAutoMerge = false;
+  const mergeRoot = autoMerge ? ctx.directory ?? process.cwd() : undefined;
+  if (autoMerge && mergeRoot) {
+    const gitOk = await isGitRepo({ root: mergeRoot }).catch(() => false);
+    if (!gitOk) {
+      autoMerge = false;
+      downgradedAutoMerge = true;
+      log10?.warn("[subtasks] mergeRoot 非 git 仓库，降级 autoMerge=false");
+      const canNoticeEarly = Boolean(ctx.client && ctx.parentSessionID);
+      if (canNoticeEarly) {
+        await sendParentNotice(ctx.client, ctx.parentSessionID, "ℹ 当前目录不是 git 仓库，worktree 隔离已自动关闭，以单目录模式运行", { directory: ctx.directory });
+      }
+    }
+  }
   const canNotice = Boolean(ctx.client && ctx.parentSessionID);
+  if (specs.length === 1 && rawDescription.length >= 30 && ctx.client) {
+    log10?.info(`[${PLUGIN_NAME18}] 触发 AI 拆分（描述长度=${rawDescription.length}）`);
+    const dec = await decomposeTask(rawDescription, {
+      client: ctx.client,
+      directory: ctx.directory,
+      log: (lvl, msg, data) => {
+        if (lvl === "error")
+          log10?.error(msg, data);
+        else if (lvl === "warn")
+          log10?.warn(msg, data);
+        else
+          log10?.info(msg, data);
+      },
+      mockResponse: ctx.decomposeMockResponse
+    });
+    if (dec.ok && dec.subtasks.length >= 2) {
+      specs = dec.subtasks.map((d, i) => ({
+        id: `${parentId}-${i + 1}-${pickVerb(d.description, "task")}`,
+        description: d.description,
+        timeout_ms: undefined,
+        args: d.hintFiles && d.hintFiles.length > 0 ? { hintFiles: d.hintFiles } : undefined
+      }));
+      log10?.info(`[${PLUGIN_NAME18}] AI 拆分成功 → ${specs.length} 个子任务`);
+      if (canNotice) {
+        const lines = [
+          `\uD83E\uDD16 AI 已自动拆为 ${specs.length} 个并行子任务：`,
+          ...specs.map((s, i) => `  ${i + 1}. ${s.description}`)
+        ];
+        await sendParentNotice(ctx.client, ctx.parentSessionID, lines.join(`
+`), {
+          directory: ctx.directory
+        });
+      }
+    } else if (dec.reason === "llm_unavailable" || dec.reason === "parse_failed") {
+      log10?.warn(`[${PLUGIN_NAME18}] AI 拆分失败（${dec.reason}），按单任务执行`);
+    }
+  }
   if (canNotice) {
     const lines = [
-      `\uD83D\uDE80 /parallel 已派出 ${specs.length} 个子任务（并发=${maxConcurrency}）：`,
+      `\uD83D\uDE80 /parallel 已派出 ${specs.length} 个子任务（并发=${maxConcurrency}, worktree 隔离=${autoMerge ? "ON" : "OFF"}）：`,
       ...specs.map((s, i) => `  ${i + 1}. \`${s.id}\` — ${s.description}`),
       "",
       "\uD83D\uDCA1 用 /parallel-status 随时查进度；TUI 按 Ctrl+→ 进子 session 看实时。"
@@ -16935,11 +18135,11 @@ async function handleParallelCommand(raw) {
       directory: ctx.directory,
       log: (lvl, msg, data) => {
         if (lvl === "error")
-          log9?.error(msg, data);
+          log10?.error(msg, data);
         else if (lvl === "warn")
-          log9?.warn(msg, data);
+          log10?.warn(msg, data);
         else
-          log9?.info(msg, data);
+          log10?.info(msg, data);
       }
     });
   }
@@ -16951,6 +18151,9 @@ async function handleParallelCommand(raw) {
       subtasks: specs,
       maxConcurrency,
       totalTimeout_ms: totalTimeoutMs,
+      autoMerge,
+      mergeRoot: autoMerge ? ctx.directory ?? process.cwd() : undefined,
+      pipelineMerge: true,
       onSubtaskStart: canNotice ? async (spec, idx) => {
         await sendParentNotice(ctx.client, ctx.parentSessionID, `▶ 子任务 ${idx + 1}/${specs.length} 启动: \`${spec.id}\` — ${spec.description}`, { directory: ctx.directory });
       } : undefined,
@@ -16959,40 +18162,75 @@ async function handleParallelCommand(raw) {
         const fileCount = res.changedFiles?.length ?? 0;
         await sendParentNotice(ctx.client, ctx.parentSessionID, `${emoji} 子任务 ${idx + 1}/${specs.length} 完成 [${res.status}] \`${res.id}\` (${res.duration_ms}ms, files=${fileCount})`, { directory: ctx.directory });
       } : undefined,
+      onMergeAttempt: canNotice ? async (attempt) => {
+        if (attempt.skippedReason) {
+          if (attempt.skippedReason === "no_changes") {
+            await sendParentNotice(ctx.client, ctx.parentSessionID, `⏭ merge \`${attempt.subtaskId}\`: 无改动，跳过`, { directory: ctx.directory });
+          } else if (attempt.skippedReason === "queue_aborted") {
+            await sendParentNotice(ctx.client, ctx.parentSessionID, `\uD83D\uDED1 merge \`${attempt.subtaskId}\`: 队列已锁死，跳过（worktree 保留）`, { directory: ctx.directory });
+          }
+          return;
+        }
+        if (attempt.ok) {
+          await sendParentNotice(ctx.client, ctx.parentSessionID, `\uD83D\uDD00 merge \`${attempt.subtaskId}\`: ✅ 成功`, { directory: ctx.directory });
+        } else {
+          const n = attempt.conflicts.length;
+          await sendParentNotice(ctx.client, ctx.parentSessionID, `\uD83D\uDD00 merge \`${attempt.subtaskId}\`: ⚠ 冲突 ${n} 个文件`, { directory: ctx.directory });
+        }
+      } : undefined,
       deps: {
         runSubtask: runner,
-        allocateWorktree: ctx.allocateWorktree,
+        allocateWorktree: downgradedAutoMerge ? undefined : ctx.allocateWorktree,
         log: (lvl, msg, data) => {
           if (lvl === "error")
-            log9?.error(msg, data);
+            log10?.error(msg, data);
           else if (lvl === "warn")
-            log9?.warn(msg, data);
+            log10?.warn(msg, data);
           else
-            log9?.info(msg, data);
-        }
+            log10?.info(msg, data);
+        },
+        tryMerge: ctx.tryMerge,
+        mergeCommit: ctx.mergeCommit,
+        mergeAbort: ctx.mergeAbort,
+        worktreeHasChanges: ctx.worktreeHasChanges,
+        removeWorktree: ctx.removeWorktree,
+        commitWorktreeIfDirty: ctx.commitWorktreeIfDirty
       }
     });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    log9?.error(`[${PLUGIN_NAME17}] schedule 抛错`, { error: msg });
+    log10?.error(`[${PLUGIN_NAME18}] schedule 抛错`, { error: msg });
     await safeReply2(ctx, `❌ 并发调度失败：${msg}`);
     return { ok: false, reason: msg };
   }
   const head = `\uD83D\uDCCA 并发完成 ${result.results.length} 个子任务（${result.duration_ms}ms）`;
   const summaryLines = [head, "", "```", result.digest.text, "```"];
+  if (result.mergeReport && result.mergeReport.pendingWorktrees.length > 0) {
+    const repoCwd = mergeRoot ?? ctx.directory ?? process.cwd();
+    summaryLines.push("", `⚠ ${result.mergeReport.pendingWorktrees.length} 个 worktree 有冲突，请手动解决：`);
+    for (const p of result.mergeReport.pendingWorktrees) {
+      const n = p.conflicts.length;
+      const hint = n > 0 ? `(${n} files)` : "";
+      summaryLines.push(`  • ${p.path}  ${hint}  →  cd ${repoCwd} && git merge ${p.subtaskId}`);
+    }
+    summaryLines.push("", `（解决冲突后在主仓库执行上面的 \`git merge\` 命令；冲突 worktree 路径已保留，可 cd 进去查看 status）`);
+  }
   await safeReply2(ctx, summaryLines.join(`
 `));
-  log9?.info(`[${PLUGIN_NAME17}] schedule 完成`, {
+  log10?.info(`[${PLUGIN_NAME18}] schedule 完成`, {
     parentId,
     success: result.digest.success,
     failed: result.digest.failed,
-    conflicts: result.conflicts.hasConflict
+    conflicts: result.conflicts.hasConflict,
+    autoMerge,
+    merged: result.mergeReport?.merged ?? 0,
+    conflicted: result.mergeReport?.conflicted ?? 0
   });
   if (typeof ctx.onCompleted === "function") {
     try {
       await ctx.onCompleted(result);
     } catch (err) {
-      log9?.warn(`[${PLUGIN_NAME17}] onCompleted hook 抛错（已隔离）`, {
+      log10?.warn(`[${PLUGIN_NAME18}] onCompleted hook 抛错（已隔离）`, {
         error: err instanceof Error ? err.message : String(err)
       });
     }
@@ -17026,29 +18264,30 @@ async function maybeHandleMessage(raw) {
     log: ctx.log,
     client: ctx.client,
     parentSessionID: ctx.parentSessionID,
-    directory: ctx.directory
+    directory: ctx.directory,
+    autoMerge: ctx.autoMerge
   });
 }
 async function writeLog(level, msg, data) {
   const line = JSON.stringify({
     ts: new Date().toISOString(),
     level,
-    plugin: PLUGIN_NAME17,
+    plugin: PLUGIN_NAME18,
     msg,
     data
   }) + `
 `;
   try {
     const logFile = getLogFile();
-    await fs10.mkdir(path13.dirname(logFile), { recursive: true });
-    await fs10.appendFile(logFile, line, "utf8");
+    await fs12.mkdir(path15.dirname(logFile), { recursive: true });
+    await fs12.appendFile(logFile, line, "utf8");
   } catch {}
 }
-logLifecycle(PLUGIN_NAME17, "import");
+logLifecycle(PLUGIN_NAME18, "import");
 var subtasksServer = async (ctx) => {
-  const log9 = makePluginLogger(PLUGIN_NAME17);
+  const log10 = makePluginLogger(PLUGIN_NAME18);
   const client = ctx?.client ?? undefined;
-  logLifecycle(PLUGIN_NAME17, "activate", {
+  logLifecycle(PLUGIN_NAME18, "activate", {
     directory: ctx.directory,
     hasClient: Boolean(client)
   });
@@ -17061,6 +18300,40 @@ var subtasksServer = async (ctx) => {
         if (!description26) {
           return;
         }
+        let autoMerge = false;
+        try {
+          const rt = await loadRuntime({ root: ctx.directory });
+          autoMerge = rt.runtime.runtime.worktree_isolation === true;
+        } catch {
+          autoMerge = false;
+        }
+        const repoRoot = ctx.directory ?? process.cwd();
+        if (autoMerge) {
+          const gitOk = await isGitRepo({ root: repoRoot }).catch(() => false);
+          if (!gitOk) {
+            autoMerge = false;
+            log10?.warn("[subtasks] worktree_isolation=true 但非 git 仓库，自动降级 autoMerge=false");
+            const canNotice = Boolean(client);
+            if (canNotice) {
+              await sendParentNotice(client, input.sessionID, "ℹ 当前目录不是 git 仓库，worktree 隔离已自动关闭，以单目录模式运行", { directory: ctx.directory });
+            }
+          }
+        }
+        const allocateWorktree = autoMerge ? async (subtaskId) => {
+          const wt = await ensureWorktree({ root: repoRoot, branch: subtaskId });
+          return {
+            path: wt.path,
+            cleanup: async () => {
+              try {
+                await removeWorktree({
+                  root: repoRoot,
+                  worktree_path: wt.path,
+                  force: true
+                });
+              } catch {}
+            }
+          };
+        } : undefined;
         const replyLines = [];
         const messageCtx = {
           content: `/parallel ${description26}`,
@@ -17068,10 +18341,12 @@ var subtasksServer = async (ctx) => {
             replyLines.push(s);
             return Promise.resolve();
           },
-          log: log9,
+          log: log10,
           client,
           parentSessionID: input.sessionID,
           directory: ctx.directory,
+          allocateWorktree,
+          autoMerge,
           runner: client ? makeOpencodeRunner({
             client,
             parentSessionID: input.sessionID,
@@ -17079,11 +18354,11 @@ var subtasksServer = async (ctx) => {
             perTaskTimeoutMs: 5 * 60000,
             log: (lvl, msg, data) => {
               if (lvl === "error")
-                log9.error(msg, data);
+                log10.error(msg, data);
               else if (lvl === "warn")
-                log9.warn(msg, data);
+                log10.warn(msg, data);
               else
-                log9.info(msg, data);
+                log10.info(msg, data);
             }
           }) : undefined
         };
@@ -17092,7 +18367,8 @@ var subtasksServer = async (ctx) => {
           sessionID: input.sessionID,
           ok: result?.ok,
           subtasks: result?.scheduled?.results?.length ?? 0,
-          usedMockRunner: !client
+          usedMockRunner: !client,
+          autoMerge
         });
         if (replyLines.length > 0 && Array.isArray(output?.parts)) {
           output.parts.length = 0;
@@ -17108,20 +18384,20 @@ var subtasksServer = async (ctx) => {
           });
         }
       } catch (err) {
-        log9.error(`[${PLUGIN_NAME17}] command.execute.before 异常（已隔离）`, {
+        log10.error(`[${PLUGIN_NAME18}] command.execute.before 异常（已隔离）`, {
           error: err instanceof Error ? err.message : String(err)
         });
       }
     }
   };
 };
-var handler17 = subtasksServer;
+var handler18 = subtasksServer;
 
 // plugins/terminal-monitor.ts
 init_opencode_plugin_helpers();
 import * as crypto5 from "node:crypto";
-var PLUGIN_NAME18 = "terminal-monitor";
-logLifecycle(PLUGIN_NAME18, "import", {});
+var PLUGIN_NAME19 = "terminal-monitor";
+logLifecycle(PLUGIN_NAME19, "import", {});
 var DEFAULT_CONFIG7 = {
   minScore: 0.6,
   cooldownMs: 30000,
@@ -17264,7 +18540,7 @@ function parseTerminalOutput(ev, cfg = {}, rules = DEFAULT_RULES) {
 `).length;
     const lineFromStart = text.split(`
 `)[lineIdx - 1] ?? m[0];
-    const excerpt = clip5(lineFromStart.trim(), c.maxExcerpt);
+    const excerpt = clip6(lineFromStart.trim(), c.maxExcerpt);
     if (!out.has(rule.kind)) {
       out.set(rule.kind, {
         severity: rule.severity,
@@ -17286,7 +18562,7 @@ function parseTerminalOutput(ev, cfg = {}, rules = DEFAULT_RULES) {
   }
   return [...out.values()].sort((a, b) => b.score - a.score);
 }
-function clip5(s, max) {
+function clip6(s, max) {
   if (s.length <= max)
     return s;
   return s.slice(0, max - 1) + "…";
@@ -17345,7 +18621,7 @@ function shouldNotify(findings, ev, lru, cfg = {}, now = Date.now()) {
 function buildSummary(ev, findings) {
   const parts = [];
   if (ev.cmd)
-    parts.push(`\`${clip5(ev.cmd, 60)}\``);
+    parts.push(`\`${clip6(ev.cmd, 60)}\``);
   if (ev.type === "terminal.exit" && typeof ev.exit_code === "number") {
     parts.push(`exit=${ev.exit_code}`);
   }
@@ -17357,7 +18633,7 @@ function buildSummary(ev, findings) {
     return parts.join(" · ");
   }
   const top = findings[0];
-  parts.push(`${top.severity}/${top.kind}: ${clip5(top.excerpt, 80)}`);
+  parts.push(`${top.severity}/${top.kind}: ${clip6(top.excerpt, 80)}`);
   if (findings.length > 1)
     parts.push(`(+${findings.length - 1} 条)`);
   return parts.join(" · ");
@@ -17403,17 +18679,17 @@ function describeError(err) {
     return String(err);
   }
 }
-var log9 = makePluginLogger(PLUGIN_NAME18);
+var log10 = makePluginLogger(PLUGIN_NAME19);
 var lru = new FingerprintLRU2;
 var _lastNotification = null;
 var terminalMonitorServer = async (ctx) => {
-  logLifecycle(PLUGIN_NAME18, "activate", {
+  logLifecycle(PLUGIN_NAME19, "activate", {
     directory: ctx.directory,
     triggerEventTypes: ["terminal.output", "terminal.exit"]
   });
   return {
     event: async ({ event }) => {
-      await safeAsync(PLUGIN_NAME18, "event", async () => {
+      await safeAsync(PLUGIN_NAME19, "event", async () => {
         const e = event;
         if (!e || typeof e.type !== "string")
           return;
@@ -17422,12 +18698,12 @@ var terminalMonitorServer = async (ctx) => {
         const ev = { type: e.type, ...e.properties ?? {} };
         const r = await processTerminalEvent(ev, {
           lru,
-          log: log9,
+          log: log10,
           notifyAgent: (msg) => {
             _lastNotification = msg;
           }
         });
-        safeWriteLog(PLUGIN_NAME18, {
+        safeWriteLog(PLUGIN_NAME19, {
           hook: "event",
           type: e.type,
           notified: r.notified,
@@ -17435,19 +18711,19 @@ var terminalMonitorServer = async (ctx) => {
           findings: r.notification?.findings.length ?? 0
         });
         if (r.notified && r.notification) {
-          log9.info(`[${PLUGIN_NAME18}] 反馈 ${r.notification.findings.length} 条 → ${r.notification.summary}`);
+          log10.info(`[${PLUGIN_NAME19}] 反馈 ${r.notification.findings.length} 条 → ${r.notification.summary}`);
         }
       });
     }
   };
 };
-var handler18 = terminalMonitorServer;
+var handler19 = terminalMonitorServer;
 
 // plugins/token-manager.ts
 init_opencode_plugin_helpers();
-var PLUGIN_NAME19 = "token-manager";
-logLifecycle(PLUGIN_NAME19, "import", {});
-async function handleMessageBefore(raw, log10, defaults) {
+var PLUGIN_NAME20 = "token-manager";
+logLifecycle(PLUGIN_NAME20, "import", {});
+async function handleMessageBefore(raw, log11, defaults) {
   const ctx = raw ?? {};
   if (!Array.isArray(ctx.messages) || ctx.messages.length === 0)
     return null;
@@ -17466,21 +18742,21 @@ async function handleMessageBefore(raw, log10, defaults) {
     };
     if (r.compressed) {
       ctx.messages = r.messages;
-      log10?.info(`[${PLUGIN_NAME19}] 压缩 ${r.before.count}→${r.after.count} 条 / ${r.before.tokens}→${r.after.tokens} tokens`);
+      log11?.info(`[${PLUGIN_NAME20}] 压缩 ${r.before.count}→${r.after.count} 条 / ${r.before.tokens}→${r.after.tokens} tokens`);
     }
     return r;
   } catch (err) {
-    log10?.warn(`[${PLUGIN_NAME19}] 压缩异常（已隔离）`, {
+    log11?.warn(`[${PLUGIN_NAME20}] 压缩异常（已隔离）`, {
       error: err instanceof Error ? err.message : String(err)
     });
     return null;
   }
 }
-var log10 = makePluginLogger(PLUGIN_NAME19);
+var log11 = makePluginLogger(PLUGIN_NAME20);
 var tokenManagerServer = async (ctx) => {
   const rt = loadRuntimeSync();
   const threshold = rt.runtime.context.condenser_threshold_ratio;
-  logLifecycle(PLUGIN_NAME19, "activate", {
+  logLifecycle(PLUGIN_NAME20, "activate", {
     directory: ctx.directory,
     threshold,
     target: DEFAULT_CONDENSE.target,
@@ -17489,7 +18765,7 @@ var tokenManagerServer = async (ctx) => {
   });
   return {
     "experimental.chat.messages.transform": async (_input, output) => {
-      await safeAsync(PLUGIN_NAME19, "experimental.chat.messages.transform", async () => {
+      await safeAsync(PLUGIN_NAME20, "experimental.chat.messages.transform", async () => {
         const list = output.messages;
         if (!Array.isArray(list) || list.length === 0)
           return;
@@ -17499,10 +18775,10 @@ var tokenManagerServer = async (ctx) => {
 `);
           return { role, content };
         });
-        const r = await handleMessageBefore({ messages: flat }, log10, { threshold });
+        const r = await handleMessageBefore({ messages: flat }, log11, { threshold });
         if (!r)
           return;
-        safeWriteLog(PLUGIN_NAME19, {
+        safeWriteLog(PLUGIN_NAME20, {
           hook: "experimental.chat.messages.transform",
           mode: "observe-only",
           before_msgs: r.before.count,
@@ -17513,144 +18789,21 @@ var tokenManagerServer = async (ctx) => {
           reason: r.reason
         });
         if (r.compressed) {
-          log10.warn(`[${PLUGIN_NAME19}] advise condense: ${r.before.count}→${r.after.count} msgs / ${r.before.tokens}→${r.after.tokens} tokens (observe-only, no write-back to avoid opencode message schema mismatch)`);
+          log11.warn(`[${PLUGIN_NAME20}] advise condense: ${r.before.count}→${r.after.count} msgs / ${r.before.tokens}→${r.after.tokens} tokens (observe-only, no write-back to avoid opencode message schema mismatch)`);
         }
       });
     }
   };
 };
-var handler19 = tokenManagerServer;
+var handler20 = tokenManagerServer;
 
 // plugins/tool-policy.ts
 init_opencode_plugin_helpers();
-import { promises as fs11 } from "node:fs";
-import * as path15 from "node:path";
-
-// lib/autonomy.ts
-var DEFAULT_POLICIES = {
-  step: {
-    bash: "confirm",
-    edit: "confirm",
-    webfetch: "confirm",
-    read: "confirm",
-    search: "confirm",
-    other: "confirm"
-  },
-  semi: {
-    bash: "confirm",
-    edit: "confirm",
-    webfetch: "confirm",
-    read: "auto",
-    search: "auto",
-    other: "auto"
-  },
-  full: {
-    bash: "auto",
-    edit: "auto",
-    webfetch: "auto",
-    read: "auto",
-    search: "auto",
-    other: "auto"
-  }
-};
-var RISK_PATTERNS = [
-  {
-    tag: "rm_rf_root",
-    kinds: ["bash"],
-    re: /rm\s+-[rRf]+[^|;`\n]*\s+(\/(?:\s|$|[^/\w*.-])|~|\$HOME(?:\b|\/)|\/(?:bin|etc|usr|var|opt|home|root|boot|lib|sbin)\b)/
-  },
-  {
-    tag: "rm_rf_wildcard",
-    kinds: ["bash"],
-    re: /rm\s+-[rRf]+\s+(?:\.\*|\*)/
-  },
-  {
-    tag: "force_push_protected",
-    kinds: ["bash"],
-    re: /git\s+push\s+(?:--force\b|-f\b)[\s\S]*\b(main|master|release(?:\/[\w.-]+)?)\b/
-  },
-  {
-    tag: "git_reset_hard_main",
-    kinds: ["bash"],
-    re: /git\s+reset\s+--hard\s+(origin\/)?(main|master)/
-  },
-  { tag: "sudo", kinds: ["bash"], re: /(?<![\w-])sudo(?![\w-])/ },
-  { tag: "su_root", kinds: ["bash"], re: /(?<![\w-])su\s+(?:-\s+)?root\b/ },
-  { tag: "mkfs", kinds: ["bash"], re: /\bmkfs(\.[\w]+)?\b/ },
-  { tag: "dd_disk", kinds: ["bash"], re: /\bdd\s+if=[^|;\s]+\s+of=\/dev\// },
-  { tag: "chmod_777", kinds: ["bash"], re: /chmod\s+[-+]?[0-7]?777/ },
-  {
-    tag: "curl_pipe_sh",
-    kinds: ["bash"],
-    re: /\b(?:curl|wget)\b[^|]*\|\s*(?:sh|bash|zsh)\b/
-  },
-  {
-    tag: "drop_database",
-    kinds: ["bash", "other"],
-    re: /\b(DROP\s+(DATABASE|TABLE)|TRUNCATE\s+TABLE|DROP\s+SCHEMA)\b/i
-  },
-  { tag: "write_secrets", re: /(\.env(?:\.\w+)?|id_[edr]sa|\.ssh\/id_|\.pem|\.p12|secret\.json)/i },
-  { tag: "write_etc", re: /(?:^|\s|"|')\/etc\// },
-  { tag: "write_usr", re: /(?:^|\s|"|')\/usr\// },
-  { tag: "write_root_home", re: /(?:^|\s|"|')(\/root|\/home\/root)\// },
-  {
-    tag: "internal_url",
-    kinds: ["webfetch"],
-    re: /https?:\/\/(localhost|127\.0\.0\.1|0\.0\.0\.0|169\.254\.|10\.|192\.168\.|172\.(?:1[6-9]|2\d|3[01])\.)/i
-  },
-  {
-    tag: "kubectl_delete",
-    kinds: ["bash"],
-    re: /kubectl\s+(?:delete|destroy)\s+/
-  },
-  {
-    tag: "terraform_destroy",
-    kinds: ["bash"],
-    re: /terraform\s+destroy/
-  }
-];
-function evaluate2(mode, intent, opts = {}) {
-  const ignore = new Set(opts.ignore_risks ?? []);
-  const allRisks = [...RISK_PATTERNS, ...opts.extra_risks ?? []];
-  const haystack = buildHaystack(intent.args);
-  const hits = allRisks.filter((p) => !ignore.has(p.tag)).filter((p) => !p.kinds || p.kinds.includes(intent.kind)).filter((p) => p.re.test(haystack)).map((p) => p.tag);
-  let effective = mode;
-  let downgraded = false;
-  let reason;
-  if (hits.length > 0 && mode === "full") {
-    effective = "semi";
-    downgraded = true;
-    reason = `检测到风险操作 [${hits.join(", ")}]，自动从 full 降级到 semi`;
-  } else if (hits.length > 0 && mode !== "step") {}
-  const policy = mergePolicy(effective, opts.policies);
-  const baseAction = policy[intent.kind] ?? "confirm";
-  const action = hits.length > 0 && effective !== "step" ? "confirm" : baseAction;
-  return {
-    effective_mode: effective,
-    action,
-    downgraded,
-    reason,
-    detected_risks: hits
-  };
-}
-function mergePolicy(mode, override) {
-  const base = DEFAULT_POLICIES[mode];
-  if (!override?.[mode])
-    return base;
-  return { ...base, ...override[mode] };
-}
-function buildHaystack(args) {
-  if (typeof args === "string")
-    return args;
-  try {
-    return JSON.stringify(args);
-  } catch {
-    return String(args);
-  }
-}
+import { promises as fs13 } from "node:fs";
+import * as path17 from "node:path";
 
 // lib/file-regex-acl.ts
-import * as path14 from "node:path";
+import * as path16 from "node:path";
 function compileRule(r) {
   if (r instanceof RegExp)
     return r;
@@ -17716,7 +18869,7 @@ function normalizePath2(p) {
   let s = p.replace(/\\/g, "/");
   if (s.startsWith("./"))
     s = s.slice(2);
-  s = path14.posix.normalize(s);
+  s = path16.posix.normalize(s);
   return s;
 }
 function checkFileAccess(acl, file, op) {
@@ -17762,8 +18915,8 @@ function checkFileAccess(acl, file, op) {
 }
 
 // plugins/tool-policy.ts
-var PLUGIN_NAME20 = "tool-policy";
-logLifecycle(PLUGIN_NAME20, "import", {});
+var PLUGIN_NAME21 = "tool-policy";
+logLifecycle(PLUGIN_NAME21, "import", {});
 var EMPTY_ACL = { whitelistMode: false };
 var SUBAGENT_APPLY_DENY_LIST = new Set([
   "coder",
@@ -17786,7 +18939,7 @@ function decideToolCall(ctx, cfg = {}, currentAgent) {
     return {
       action: "deny",
       reasons: [
-        `[ADR-0061] subagent '${currentAgent}' 禁止调 pending_changes.${action2}` + ` — apply 必须由 codeforge orchestrator 或用户拍板`,
+        `[ADR:prevent-subagent-self-apply] subagent '${currentAgent}' 禁止调 pending_changes.${action2}` + ` — apply 必须由 codeforge orchestrator 或用户拍板`,
         `替代路径：stage 完成后回报 codeforge，由其决定 apply 后通过 task_id 复用启动你跑测试`
       ],
       autonomy: {
@@ -17794,7 +18947,7 @@ function decideToolCall(ctx, cfg = {}, currentAgent) {
         action: "confirm",
         downgraded: false,
         detected_risks: ["subagent_apply_blocked"],
-        reason: `subagent '${currentAgent}' 自 apply 越权 (ADR-0061)`
+        reason: `subagent '${currentAgent}' 自 apply 越权 (ADR:prevent-subagent-self-apply)`
       }
     };
   }
@@ -17826,11 +18979,11 @@ function decideToolCall(ctx, cfg = {}, currentAgent) {
     action = "deny";
   return { action, reasons, autonomy: a, acl: aclResults };
 }
-var POLICY_PATH = path15.join(".codeforge", "policy.json");
+var POLICY_PATH = path17.join(".codeforge", "policy.json");
 async function loadPolicy(root = process.cwd()) {
-  const file = path15.join(root, POLICY_PATH);
+  const file = path17.join(root, POLICY_PATH);
   try {
-    const raw = await fs11.readFile(file, "utf8");
+    const raw = await fs13.readFile(file, "utf8");
     const data = JSON.parse(raw);
     return data;
   } catch {
@@ -17847,18 +19000,18 @@ function classifyToolKind(toolName) {
     return "webfetch";
   return "other";
 }
-async function resolveCurrentAgent(client, sessionID, log11) {
+async function resolveCurrentAgent(client, sessionID, log12) {
   try {
     const sessionApi = client?.session;
     if (!sessionApi || typeof sessionApi.get !== "function") {
-      log11.warn(`client.session.get unavailable`, { sessionID });
+      log12.warn(`client.session.get unavailable`, { sessionID });
       return;
     }
     const res = await sessionApi.get({ path: { id: sessionID } });
     const data = res?.data ?? res;
     const rawAgent = data?.agent;
     if (typeof rawAgent !== "string" || rawAgent === "") {
-      log11.warn(`client.session.get returned no string agent (保守放行)`, {
+      log12.warn(`client.session.get returned no string agent (保守放行)`, {
         sessionID,
         dataKeys: data && typeof data === "object" ? Object.keys(data) : null
       });
@@ -17866,20 +19019,20 @@ async function resolveCurrentAgent(client, sessionID, log11) {
     }
     return rawAgent;
   } catch (err) {
-    log11.warn(`client.session.get failed (保守放行)`, {
+    log12.warn(`client.session.get failed (保守放行)`, {
       sessionID,
       error: err instanceof Error ? err.message : String(err)
     });
     return;
   }
 }
-var log11 = makePluginLogger(PLUGIN_NAME20);
+var log12 = makePluginLogger(PLUGIN_NAME21);
 var toolPolicyServer = async (ctx) => {
   const directory = ctx.directory ?? process.cwd();
   const cfg = await loadPolicy(directory);
   const rt = loadRuntimeSync();
   cfg.defaultMode = rt.runtime.autonomy.default_mode;
-  logLifecycle(PLUGIN_NAME20, "activate", {
+  logLifecycle(PLUGIN_NAME21, "activate", {
     directory,
     acl_loaded: !!cfg.acl,
     default_mode: cfg.defaultMode,
@@ -17888,13 +19041,13 @@ var toolPolicyServer = async (ctx) => {
   return {
     "tool.execute.before": async (input, output) => {
       let denied;
-      await safeAsync(PLUGIN_NAME20, "tool.execute.before", async () => {
+      await safeAsync(PLUGIN_NAME21, "tool.execute.before", async () => {
         const toolName = input.tool;
         const argsObj = output.args ?? {};
         const needsAgentDetection = toolName === "pending_changes" && (argsObj.action === "apply" || argsObj.action === "apply_all");
         let currentAgent = undefined;
         if (needsAgentDetection) {
-          currentAgent = await resolveCurrentAgent(ctx.client, input.sessionID, log11);
+          currentAgent = await resolveCurrentAgent(ctx.client, input.sessionID, log12);
         }
         const files = [];
         const filePath = argsObj["path"] ?? argsObj["filePath"] ?? argsObj["file"];
@@ -17909,7 +19062,7 @@ var toolPolicyServer = async (ctx) => {
           mode: cfg.defaultMode,
           files: files.length ? files : undefined
         }, cfg, currentAgent);
-        safeWriteLog(PLUGIN_NAME20, {
+        safeWriteLog(PLUGIN_NAME21, {
           hook: "tool.execute.before",
           tool: toolName,
           callID: input.callID,
@@ -17919,14 +19072,14 @@ var toolPolicyServer = async (ctx) => {
           currentAgent
         });
         if (decision.action === "deny") {
-          log11.warn(`[${PLUGIN_NAME20}] DENY ${toolName}`, {
+          log12.warn(`[${PLUGIN_NAME21}] DENY ${toolName}`, {
             action: argsObj.action,
             currentAgent,
             reasons: decision.reasons
           });
           denied = new Error(`[tool-policy] DENIED: ${decision.reasons.join(" / ")}`);
         } else if (decision.action === "confirm") {
-          log11.info(`[${PLUGIN_NAME20}] CONFIRM ${toolName}: ${decision.reasons.join("; ")}`);
+          log12.info(`[${PLUGIN_NAME21}] CONFIRM ${toolName}: ${decision.reasons.join("; ")}`);
         }
       });
       if (denied)
@@ -17934,13 +19087,13 @@ var toolPolicyServer = async (ctx) => {
     }
   };
 };
-var handler20 = toolPolicyServer;
+var handler21 = toolPolicyServer;
 
 // plugins/update-checker.ts
 init_opencode_plugin_helpers();
 import { existsSync as existsSync5 } from "node:fs";
-import { homedir as homedir7 } from "node:os";
-import { join as join16 } from "node:path";
+import { homedir as homedir8 } from "node:os";
+import { join as join18 } from "node:path";
 
 // lib/update-checker-impl.ts
 import { createHash as createHash6 } from "node:crypto";
@@ -17949,15 +19102,15 @@ import {
   existsSync as existsSync4,
   mkdirSync as mkdirSync3,
   mkdtempSync,
-  readFileSync as readFileSync4,
-  readdirSync,
+  readFileSync as readFileSync5,
+  readdirSync as readdirSync2,
   renameSync,
-  statSync as statSync3,
+  statSync as statSync4,
   unlinkSync,
   writeFileSync as writeFileSync2
 } from "node:fs";
-import { homedir as homedir6, tmpdir } from "node:os";
-import { dirname as dirname7, join as join15 } from "node:path";
+import { homedir as homedir7, tmpdir } from "node:os";
+import { dirname as dirname7, join as join17 } from "node:path";
 import { fileURLToPath } from "node:url";
 import * as https from "node:https";
 import * as zlib from "node:zlib";
@@ -17965,7 +19118,7 @@ import * as zlib from "node:zlib";
 // lib/version-injected.ts
 function getInjectedVersion() {
   try {
-    const v = "0.3.11";
+    const v = "0.3.12";
     if (typeof v === "string" && /^\d+\.\d+\.\d+/.test(v)) {
       return v;
     }
@@ -18055,23 +19208,23 @@ function readLocalVersion() {
   try {
     const here = fileURLToPath(import.meta.url);
     const root = dirname7(dirname7(here));
-    const pkg = JSON.parse(readFileSync4(join15(root, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync5(join17(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"] ?? join15(homedir6(), ".cache", "codeforge");
+  return process.env["CODEFORGE_CACHE_DIR"] ?? join17(homedir7(), ".cache", "codeforge");
 }
 function defaultCacheFile() {
-  return join15(defaultCacheDir(), "update-check.json");
+  return join17(defaultCacheDir(), "update-check.json");
 }
 function readCache(file) {
   try {
     if (!existsSync4(file))
       return null;
-    const raw = readFileSync4(file, "utf8");
+    const raw = readFileSync5(file, "utf8");
     const obj = JSON.parse(raw);
     if (obj && typeof obj === "object" && typeof obj.checkedAt === "number" && typeof obj.remote === "string" && typeof obj.repo === "string") {
       return obj;
@@ -18102,7 +19255,7 @@ function fetchLatestTagFromGitHub(repo) {
   });
 }
 function getJsonWithRedirect(url, hopsLeft) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve13, reject) => {
     const u = new URL(url);
     const headers = {
       "User-Agent": "codeforge-update-checker",
@@ -18126,12 +19279,12 @@ function getJsonWithRedirect(url, hopsLeft) {
           return;
         }
         const next = new URL(res.headers.location, url).toString();
-        getJsonWithRedirect(next, hopsLeft - 1).then(resolve11, reject);
+        getJsonWithRedirect(next, hopsLeft - 1).then(resolve13, reject);
         return;
       }
       if (status === 404) {
         res.resume();
-        resolve11(null);
+        resolve13(null);
         return;
       }
       if (status >= 400) {
@@ -18142,7 +19295,7 @@ function getJsonWithRedirect(url, hopsLeft) {
       let body = "";
       res.setEncoding("utf8");
       res.on("data", (chunk) => body += chunk);
-      res.on("end", () => resolve11(body));
+      res.on("end", () => resolve13(body));
     });
     req.on("timeout", () => {
       req.destroy();
@@ -18182,7 +19335,7 @@ async function fetchLatestFromNpm(opts) {
   return { version, tarballUrl, integrity };
 }
 function defaultHttpFetcher(url, timeoutMs) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve13, reject) => {
     const u = new URL(url);
     const headers = {
       "User-Agent": "codeforge-update-checker",
@@ -18199,7 +19352,7 @@ function defaultHttpFetcher(url, timeoutMs) {
       const status = res.statusCode ?? 0;
       if (status === 404) {
         res.resume();
-        resolve11(null);
+        resolve13(null);
         return;
       }
       if (status >= 400) {
@@ -18210,7 +19363,7 @@ function defaultHttpFetcher(url, timeoutMs) {
       let body = "";
       res.setEncoding("utf8");
       res.on("data", (chunk) => body += chunk);
-      res.on("end", () => resolve11(body));
+      res.on("end", () => resolve13(body));
     });
     req.on("timeout", () => {
       req.destroy();
@@ -18221,14 +19374,14 @@ function defaultHttpFetcher(url, timeoutMs) {
   });
 }
 async function downloadAndExtractBundle(opts) {
-  const tmpRoot = opts.tmpDir ?? mkdtempSync(join15(tmpdir(), "codeforge-update-"));
+  const tmpRoot = opts.tmpDir ?? mkdtempSync(join17(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 = join15(tmpRoot, "package", "dist", "index.js");
+  const bundlePath = join17(tmpRoot, "package", "dist", "index.js");
   if (!existsSync4(bundlePath)) {
     throw new Error(`bundle_not_found: ${bundlePath}`);
   }
@@ -18268,11 +19421,11 @@ function extractTarToDir(tarBuf, destRoot) {
     offset += 512;
     if (typeFlag === "0" || typeFlag === "" || typeFlag === "\x00") {
       const fileBuf = tarBuf.subarray(offset, offset + size);
-      const dest = join15(destRoot, fullName);
+      const dest = join17(destRoot, fullName);
       mkdirSync3(dirname7(dest), { recursive: true });
       writeFileSync2(dest, fileBuf);
     } else if (typeFlag === "5") {
-      mkdirSync3(join15(destRoot, fullName), { recursive: true });
+      mkdirSync3(join17(destRoot, fullName), { recursive: true });
     }
     offset += Math.ceil(size / 512) * 512;
   }
@@ -18281,7 +19434,7 @@ function defaultBinaryFetcher(url) {
   return downloadBinary(url, 3);
 }
 function downloadBinary(url, hopsLeft) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve13, reject) => {
     const u = new URL(url);
     const req = https.request({
       host: u.hostname,
@@ -18299,7 +19452,7 @@ function downloadBinary(url, hopsLeft) {
           return;
         }
         const next = new URL(res.headers.location, url).toString();
-        downloadBinary(next, hopsLeft - 1).then(resolve11, reject);
+        downloadBinary(next, hopsLeft - 1).then(resolve13, reject);
         return;
       }
       if (status >= 400) {
@@ -18309,7 +19462,7 @@ function downloadBinary(url, hopsLeft) {
       }
       const chunks = [];
       res.on("data", (chunk) => chunks.push(chunk));
-      res.on("end", () => resolve11(Buffer.concat(chunks)));
+      res.on("end", () => resolve13(Buffer.concat(chunks)));
     });
     req.on("timeout", () => {
       req.destroy();
@@ -18380,11 +19533,11 @@ function cleanupOldBackups(target, keep) {
     const dir = dirname7(target);
     const base = target.substring(dir.length + 1);
     const prefix = `${base}.bak.`;
-    const all = readdirSync(dir).filter((f) => f.startsWith(prefix)).map((f) => {
-      const full = join15(dir, f);
+    const all = readdirSync2(dir).filter((f) => f.startsWith(prefix)).map((f) => {
+      const full = join17(dir, f);
       let mtimeMs = 0;
       try {
-        mtimeMs = statSync3(full).mtimeMs;
+        mtimeMs = statSync4(full).mtimeMs;
       } catch {}
       return { full, mtimeMs };
     }).sort((a, b) => b.mtimeMs - a.mtimeMs);
@@ -18403,11 +19556,11 @@ function loadCompatibility(opts) {
       const root = opts?.cwd ?? inferPluginRoot();
       if (!root)
         return null;
-      file = join15(root, "compatibility.json");
+      file = join17(root, "compatibility.json");
     }
     if (!existsSync4(file))
       return null;
-    const raw = readFileSync4(file, "utf8");
+    const raw = readFileSync5(file, "utf8");
     const obj = JSON.parse(raw);
     if (!obj || typeof obj !== "object")
       return null;
@@ -18468,20 +19621,20 @@ function compareOpencodeVersion(opts) {
 }
 
 // plugins/update-checker.ts
-var PLUGIN_NAME21 = "update-checker";
+var PLUGIN_NAME22 = "update-checker";
 var PLUGIN_VERSION = "2.0.0";
-logLifecycle(PLUGIN_NAME21, "import", { version: PLUGIN_VERSION });
+logLifecycle(PLUGIN_NAME22, "import", { version: PLUGIN_VERSION });
 var updateCheckerServer = async (ctx) => {
   const yieldResult = shouldYieldToLocalPlugin({ directory: ctx.directory });
   if (yieldResult.yield) {
-    safeWriteLog(PLUGIN_NAME21, {
+    safeWriteLog(PLUGIN_NAME22, {
       level: "info",
       msg: "dev_mode_yield_skip",
       reason: yieldResult.reason,
       markerPath: yieldResult.markerPath,
       detail: formatYieldLog(yieldResult)
     });
-    logLifecycle(PLUGIN_NAME21, "activate", {
+    logLifecycle(PLUGIN_NAME22, "activate", {
       yield_to_local: true,
       yield_reason: yieldResult.reason,
       skipped: "auto_install + background_check"
@@ -18490,7 +19643,7 @@ var updateCheckerServer = async (ctx) => {
   }
   const rt = loadRuntimeSync();
   const u = rt.runtime.update;
-  logLifecycle(PLUGIN_NAME21, "activate", {
+  logLifecycle(PLUGIN_NAME22, "activate", {
     version: PLUGIN_VERSION,
     auto_check_enabled: u.auto_check_enabled,
     interval_hours: u.interval_hours,
@@ -18502,14 +19655,14 @@ var updateCheckerServer = async (ctx) => {
     repo_fallback: u.repo,
     config_source: "codeforge.json"
   });
-  await safeAsync(PLUGIN_NAME21, "opencode_version_check", async () => {
+  await safeAsync(PLUGIN_NAME22, "opencode_version_check", async () => {
     const compat = loadCompatibility();
     const opencodeVer = detectOpencodeVersion();
     const verdict = compareOpencodeVersion({
       currentOpencodeVer: opencodeVer,
       compat
     });
-    safeWriteLog(PLUGIN_NAME21, {
+    safeWriteLog(PLUGIN_NAME22, {
       level: "info",
       msg: "opencode_version_check",
       opencodeVer,
@@ -18526,14 +19679,14 @@ var updateCheckerServer = async (ctx) => {
     }
   });
   if (!u.auto_check_enabled) {
-    safeWriteLog(PLUGIN_NAME21, {
+    safeWriteLog(PLUGIN_NAME22, {
       level: "info",
       msg: "auto-check disabled (codeforge.json update.auto_check_enabled=false)"
     });
     return {};
   }
   setImmediate(() => {
-    safeAsync(PLUGIN_NAME21, "checkAndMaybeUpdate", async () => {
+    safeAsync(PLUGIN_NAME22, "checkAndMaybeUpdate", async () => {
       const local = readLocalVersion();
       let npmResult = null;
       try {
@@ -18544,7 +19697,7 @@ var updateCheckerServer = async (ctx) => {
           timeoutMs: 5000
         });
       } catch (e) {
-        safeWriteLog(PLUGIN_NAME21, {
+        safeWriteLog(PLUGIN_NAME22, {
           level: "warn",
           msg: "npm_fetch_failed",
           error: e.message
@@ -18553,7 +19706,7 @@ var updateCheckerServer = async (ctx) => {
         return;
       }
       if (!npmResult) {
-        safeWriteLog(PLUGIN_NAME21, {
+        safeWriteLog(PLUGIN_NAME22, {
           level: "info",
           msg: "npm_no_release",
           package: u.package,
@@ -18562,7 +19715,7 @@ var updateCheckerServer = async (ctx) => {
         return;
       }
       const hasUpdate = cmpVersion(local, npmResult.version) < 0;
-      safeWriteLog(PLUGIN_NAME21, {
+      safeWriteLog(PLUGIN_NAME22, {
         level: "info",
         msg: "npm_check_result",
         local,
@@ -18577,10 +19730,10 @@ var updateCheckerServer = async (ctx) => {
    更新命令：npx ${u.package} install --global`);
         return;
       }
-      await safeAsync(PLUGIN_NAME21, "auto_install_bundle", async () => {
+      await safeAsync(PLUGIN_NAME22, "auto_install_bundle", async () => {
         const target = getOpencodeBundlePath();
         if (!target) {
-          safeWriteLog(PLUGIN_NAME21, {
+          safeWriteLog(PLUGIN_NAME22, {
             level: "warn",
             msg: "auto_install_skip",
             reason: "无法定位 opencode bundle 路径"
@@ -18599,7 +19752,7 @@ var updateCheckerServer = async (ctx) => {
           oldVersion: local,
           keepBackups: u.backup_keep
         });
-        safeWriteLog(PLUGIN_NAME21, {
+        safeWriteLog(PLUGIN_NAME22, {
           level: "info",
           msg: "auto_install_success",
           local,
@@ -18623,14 +19776,14 @@ function detectOpencodeVersion() {
 }
 function getOpencodeBundlePath() {
   const candidates = [];
-  candidates.push(join16(homedir7(), ".config", "opencode", "codeforge", "index.js"));
+  candidates.push(join18(homedir8(), ".config", "opencode", "codeforge", "index.js"));
   if (process.platform === "win32") {
     const appData = process.env["APPDATA"];
     if (appData)
-      candidates.push(join16(appData, "opencode", "codeforge", "index.js"));
+      candidates.push(join18(appData, "opencode", "codeforge", "index.js"));
     const localAppData = process.env["LOCALAPPDATA"];
     if (localAppData)
-      candidates.push(join16(localAppData, "opencode", "codeforge", "index.js"));
+      candidates.push(join18(localAppData, "opencode", "codeforge", "index.js"));
   }
   for (const c of candidates) {
     if (existsSync5(c))
@@ -18639,7 +19792,7 @@ function getOpencodeBundlePath() {
   return candidates[0] ?? null;
 }
 async function fallbackToGitHubReleases(ctx, u) {
-  await safeAsync(PLUGIN_NAME21, "github_fallback", async () => {
+  await safeAsync(PLUGIN_NAME22, "github_fallback", async () => {
     const result = await checkUpdateOnce({
       repo: u.repo,
       intervalMs: u.interval_hours * 3600 * 1000
@@ -18649,7 +19802,7 @@ async function fallbackToGitHubReleases(ctx, u) {
 }
 async function reportLegacyResult(ctx, result, repo) {
   if (result.error && !result.fromCache) {
-    safeWriteLog(PLUGIN_NAME21, {
+    safeWriteLog(PLUGIN_NAME22, {
       level: "warn",
       msg: `update check failed: ${result.error}`,
       ...result
@@ -18657,7 +19810,7 @@ async function reportLegacyResult(ctx, result, repo) {
     return;
   }
   if (!result.hasUpdate) {
-    safeWriteLog(PLUGIN_NAME21, {
+    safeWriteLog(PLUGIN_NAME22, {
       level: "info",
       msg: `up-to-date (local=${result.local}, remote=${result.remote}${result.fromCache ? ", from_cache" : ""})`,
       ...result
@@ -18667,7 +19820,7 @@ async function reportLegacyResult(ctx, result, repo) {
   const updateCmd = `bunx --bun github:${repo} install`;
   const toast = `[CodeForge] 有新版本：${result.local} → ${result.remote}
   更新命令：${updateCmd}`;
-  safeWriteLog(PLUGIN_NAME21, {
+  safeWriteLog(PLUGIN_NAME22, {
     level: "info",
     msg: "new_version_available_github_fallback",
     local: result.local,
@@ -18678,74 +19831,26 @@ async function reportLegacyResult(ctx, result, repo) {
   await postToast(ctx, toast);
 }
 async function postToast(ctx, message) {
-  await safeAsync(PLUGIN_NAME21, "client.app.log", async () => {
+  await safeAsync(PLUGIN_NAME22, "client.app.log", async () => {
     await ctx.client.app.log({
       body: {
-        service: PLUGIN_NAME21,
+        service: PLUGIN_NAME22,
         level: "info",
         message
       }
     });
   });
 }
-var handler21 = updateCheckerServer;
+var handler22 = updateCheckerServer;
 
 // plugins/workflow-engine.ts
 init_opencode_plugin_helpers();
-import * as path17 from "node:path";
+import * as path19 from "node:path";
 
 // lib/workflow-loader.ts
-import { promises as fs12 } from "node:fs";
-import * as path16 from "node:path";
+import { promises as fs14 } from "node:fs";
+import * as path18 from "node:path";
 import { z as z28 } from "zod";
-
-// node_modules/yaml/dist/index.js
-var composer = require_composer();
-var Document = require_Document();
-var Schema = require_Schema();
-var errors = require_errors();
-var Alias = require_Alias();
-var identity = require_identity();
-var Pair = require_Pair();
-var Scalar = require_Scalar();
-var YAMLMap = require_YAMLMap();
-var YAMLSeq = require_YAMLSeq();
-var cst = require_cst();
-var lexer = require_lexer();
-var lineCounter = require_line_counter();
-var parser = require_parser();
-var publicApi = require_public_api();
-var visit = require_visit();
-var $Composer = composer.Composer;
-var $Document = Document.Document;
-var $Schema = Schema.Schema;
-var $YAMLError = errors.YAMLError;
-var $YAMLParseError = errors.YAMLParseError;
-var $YAMLWarning = errors.YAMLWarning;
-var $Alias = Alias.Alias;
-var $isAlias = identity.isAlias;
-var $isCollection = identity.isCollection;
-var $isDocument = identity.isDocument;
-var $isMap = identity.isMap;
-var $isNode = identity.isNode;
-var $isPair = identity.isPair;
-var $isScalar = identity.isScalar;
-var $isSeq = identity.isSeq;
-var $Pair = Pair.Pair;
-var $Scalar = Scalar.Scalar;
-var $YAMLMap = YAMLMap.YAMLMap;
-var $YAMLSeq = YAMLSeq.YAMLSeq;
-var $Lexer = lexer.Lexer;
-var $LineCounter = lineCounter.LineCounter;
-var $Parser = parser.Parser;
-var $parse = publicApi.parse;
-var $parseAllDocuments = publicApi.parseAllDocuments;
-var $parseDocument = publicApi.parseDocument;
-var $stringify = publicApi.stringify;
-var $visit = visit.visit;
-var $visitAsync = visit.visitAsync;
-
-// lib/workflow-loader.ts
 var ActionSchema = z28.object({
   tool: z28.string().min(1, "action.tool 不能为空"),
   args: z28.record(z28.string(), z28.unknown()).optional().default({}),
@@ -18830,7 +19935,7 @@ function parseWorkflowYaml(yaml, sourcePath = "<inline>") {
 async function loadWorkflowFromFile(filePath) {
   let txt;
   try {
-    txt = await fs12.readFile(filePath, "utf8");
+    txt = await fs14.readFile(filePath, "utf8");
   } catch (err) {
     return {
       ok: false,
@@ -18845,7 +19950,7 @@ async function loadWorkflowsFromDir(dir) {
   const failed = [];
   let entries;
   try {
-    entries = await fs12.readdir(dir);
+    entries = await fs14.readdir(dir);
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT")
@@ -18857,7 +19962,7 @@ async function loadWorkflowsFromDir(dir) {
       continue;
     if (!/\.ya?ml$/i.test(name))
       continue;
-    const full = path16.join(dir, name);
+    const full = path18.join(dir, name);
     const r = await loadWorkflowFromFile(full);
     if (r.ok)
       loaded.push(r);
@@ -19060,7 +20165,7 @@ async function run(workflow, opts = {}) {
       } else {
         const output = await adapter.getLastAgentOutput();
         if (output === null || output === "") {
-          adapter.log("warn", `[${step.name}] getLastAgentOutput 返回空 → 降级 abort (ADR-0036)`);
+          adapter.log("warn", `[${step.name}] getLastAgentOutput 返回空 → 降级 abort (ADR:on-decision-empty-output-abort)`);
           const last = results[results.length - 1];
           results[results.length - 1] = {
             ...last,
@@ -19192,9 +20297,9 @@ async function runStepAutoFeedback(step, adapter) {
 }
 
 // plugins/workflow-engine.ts
-var PLUGIN_NAME22 = "workflow-engine";
-logLifecycle(PLUGIN_NAME22, "import", {});
-var fallbackLog2 = makePluginLogger(PLUGIN_NAME22);
+var PLUGIN_NAME23 = "workflow-engine";
+logLifecycle(PLUGIN_NAME23, "import", {});
+var fallbackLog2 = makePluginLogger(PLUGIN_NAME23);
 var _registry = null;
 async function loadRegistry(workflowsDir) {
   const { loaded, failed } = await loadWorkflowsFromDir(workflowsDir);
@@ -19211,35 +20316,35 @@ async function ensureRegistry(workflowsDir = "workflows") {
 }
 async function handleCommandInvoked(raw, workflowsDir = "workflows") {
   const ctx = raw ?? {};
-  const log12 = ctx.log ?? fallbackLog2;
+  const log13 = ctx.log ?? fallbackLog2;
   const command = typeof ctx.command === "string" ? ctx.command : null;
   if (!command) {
-    log12.warn(`[${PLUGIN_NAME22}] command.invoked 缺 command 字段`, ctx);
+    log13.warn(`[${PLUGIN_NAME23}] command.invoked 缺 command 字段`, ctx);
     return null;
   }
   const reg = await ensureRegistry(workflowsDir);
   if (reg.errors.length) {
-    log12.warn(`[${PLUGIN_NAME22}] 有 ${reg.errors.length} 个 workflow 加载失败`, reg.errors);
+    log13.warn(`[${PLUGIN_NAME23}] 有 ${reg.errors.length} 个 workflow 加载失败`, reg.errors);
   }
   const wf = reg.workflows.find((w) => matchesTrigger(w, command));
   if (!wf) {
-    log12.info(`[${PLUGIN_NAME22}] no workflow matches "${command}"`);
+    log13.info(`[${PLUGIN_NAME23}] no workflow matches "${command}"`);
     return null;
   }
-  log12.info(`[${PLUGIN_NAME22}] dispatch "${command}" → workflow "${wf.name}"`);
+  log13.info(`[${PLUGIN_NAME23}] dispatch "${command}" → workflow "${wf.name}"`);
   try {
     const result = await run(wf, {
       mode: ctx.adapter ? "real" : "dry_run",
       autonomy: ctx.autonomy ?? "semi",
       adapter: ctx.adapter
     });
-    log12.info(`[${PLUGIN_NAME22}] workflow "${wf.name}" 完成 (${result.plan.mode})`, {
+    log13.info(`[${PLUGIN_NAME23}] workflow "${wf.name}" 完成 (${result.plan.mode})`, {
       steps: result.plan.steps.length,
       results: result.results.length
     });
     return result;
   } catch (err) {
-    log12.error(`[${PLUGIN_NAME22}] workflow "${wf.name}" 执行失败`, {
+    log13.error(`[${PLUGIN_NAME23}] workflow "${wf.name}" 执行失败`, {
       error: err instanceof Error ? err.message : String(err)
     });
     throw err;
@@ -19247,16 +20352,16 @@ async function handleCommandInvoked(raw, workflowsDir = "workflows") {
 }
 var workflowEngineServer = async (ctx) => {
   const directory = ctx.directory ?? process.cwd();
-  const workflowsDir = path17.join(directory, "workflows");
-  ensureRegistry(workflowsDir).catch((err) => fallbackLog2.warn(`[${PLUGIN_NAME22}] preload workflows failed`, {
+  const workflowsDir = path19.join(directory, "workflows");
+  ensureRegistry(workflowsDir).catch((err) => fallbackLog2.warn(`[${PLUGIN_NAME23}] preload workflows failed`, {
     error: err instanceof Error ? err.message : String(err)
   }));
-  logLifecycle(PLUGIN_NAME22, "activate", { directory, workflowsDir });
+  logLifecycle(PLUGIN_NAME23, "activate", { directory, workflowsDir });
   return {
     "command.execute.before": async (input, output) => {
-      await safeAsync(PLUGIN_NAME22, "command.execute.before", async () => {
+      await safeAsync(PLUGIN_NAME23, "command.execute.before", async () => {
         const cmd = input.command.startsWith("/") ? input.command : `/${input.command}`;
-        safeWriteLog(PLUGIN_NAME22, {
+        safeWriteLog(PLUGIN_NAME23, {
           hook: "command.execute.before",
           command: cmd,
           sessionID: input.sessionID
@@ -19271,14 +20376,14 @@ var workflowEngineServer = async (ctx) => {
       });
     },
     "chat.message": async (input, output) => {
-      await safeAsync(PLUGIN_NAME22, "chat.message", async () => {
+      await safeAsync(PLUGIN_NAME23, "chat.message", async () => {
         const text = extractUserText(output).trim();
         if (!text.startsWith("/"))
           return;
         const cmd = text.split(/\s+/)[0];
         if (!cmd)
           return;
-        safeWriteLog(PLUGIN_NAME22, {
+        safeWriteLog(PLUGIN_NAME23, {
           hook: "chat.message",
           command: cmd,
           sessionID: input.sessionID
@@ -19288,11 +20393,11 @@ var workflowEngineServer = async (ctx) => {
     }
   };
 };
-var handler22 = workflowEngineServer;
+var handler23 = workflowEngineServer;
 
 // src/index.ts
 var PLUGIN_ID = "codeforge";
-var log12 = makePluginLogger(PLUGIN_ID);
+var log13 = makePluginLogger(PLUGIN_ID);
 logLifecycle(PLUGIN_ID, "import", { entry: "src/index.ts" });
 var HANDLERS = [
   { name: "agent-router", init: handler },
@@ -19306,17 +20411,18 @@ var HANDLERS = [
   { name: "kh-reminder", init: handler10 },
   { name: "memories-context", init: handler11 },
   { name: "model-fallback", init: handler12 },
-  { name: "pwsh-utf8", init: handler15 },
-  { name: "session-recovery", init: handler16 },
+  { name: "parallel-tool-nudge", init: handler15 },
+  { name: "pwsh-utf8", init: handler16 },
+  { name: "session-recovery", init: handler17 },
   { name: "subtask-heartbeat", init: handler13 },
-  { name: "subtasks", init: handler17 },
+  { name: "subtasks", init: handler18 },
   { name: "parallel-status", init: handler14 },
-  { name: "terminal-monitor", init: handler18 },
-  { name: "token-manager", init: handler19 },
+  { name: "terminal-monitor", init: handler19 },
+  { name: "token-manager", init: handler20 },
   { name: "tool-heartbeat", init: handler7 },
-  { name: "tool-policy", init: handler20 },
-  { name: "update-checker", init: handler21 },
-  { name: "workflow-engine", init: handler22 }
+  { name: "tool-policy", init: handler21 },
+  { name: "update-checker", init: handler22 },
+  { name: "workflow-engine", init: handler23 }
 ];
 function makeSerialHook(hookName, fns) {
   return async (input, output) => {
@@ -19324,7 +20430,7 @@ function makeSerialHook(hookName, fns) {
       try {
         await fn(input, output);
       } catch (err) {
-        log12.warn(`[${PLUGIN_ID}] ${hookName} handler 异常（已隔离）`, {
+        log13.warn(`[${PLUGIN_ID}] ${hookName} handler 异常（已隔离）`, {
           error: err instanceof Error ? err.message : String(err)
         });
       }
@@ -19337,7 +20443,7 @@ function createCodeforgeServer(opts) {
       const yieldResult = shouldYieldToLocalPlugin({ directory: input.directory });
       if (yieldResult.yield) {
         const msg = formatYieldLog(yieldResult);
-        log12.info(msg, { reason: yieldResult.reason, markerPath: yieldResult.markerPath });
+        log13.info(msg, { reason: yieldResult.reason, markerPath: yieldResult.markerPath });
         logLifecycle(PLUGIN_ID, "activate", {
           yield_to_local: true,
           yield_reason: yieldResult.reason,
@@ -19355,7 +20461,7 @@ function createCodeforgeServer(opts) {
       if (r.status === "fulfilled" && r.value && typeof r.value === "object") {
         hooksList.push(r.value);
       } else if (r.status === "rejected") {
-        log12.warn(`[${PLUGIN_ID}] handler ${HANDLERS[i].name} init failed (隔离，其他 handler 继续)`, { error: r.reason instanceof Error ? r.reason.message : String(r.reason) });
+        log13.warn(`[${PLUGIN_ID}] handler ${HANDLERS[i].name} init failed (隔离，其他 handler 继续)`, { error: r.reason instanceof Error ? r.reason.message : String(r.reason) });
       }
     });
     logLifecycle(PLUGIN_ID, "activate", {
@@ -19369,6 +20475,7 @@ function createCodeforgeServer(opts) {
     const chatParamsBucket = [];
     const toolExecuteBeforeBucket = [];
     const chatMessagesTransformBucket = [];
+    const chatSystemTransformBucket = [];
     const eventBucket = [];
     const toolMerged = {};
     for (const h of hooksList) {
@@ -19383,6 +20490,9 @@ function createCodeforgeServer(opts) {
       if (h["experimental.chat.messages.transform"]) {
         chatMessagesTransformBucket.push(h["experimental.chat.messages.transform"]);
       }
+      if (h["experimental.chat.system.transform"]) {
+        chatSystemTransformBucket.push(h["experimental.chat.system.transform"]);
+      }
       if (h.event)
         eventBucket.push(h.event);
       if (h.tool)
@@ -19394,12 +20504,13 @@ function createCodeforgeServer(opts) {
       "chat.params": makeSerialHook("chat.params", chatParamsBucket),
       "tool.execute.before": makeSerialHook("tool.execute.before", toolExecuteBeforeBucket),
       "experimental.chat.messages.transform": makeSerialHook("experimental.chat.messages.transform", chatMessagesTransformBucket),
+      "experimental.chat.system.transform": makeSerialHook("experimental.chat.system.transform", chatSystemTransformBucket),
       event: async (envelope) => {
         await Promise.all(eventBucket.map(async (fn) => {
           try {
             await fn(envelope);
           } catch (err) {
-            log12.warn(`[${PLUGIN_ID}] event handler 异常（已隔离）`, {
+            log13.warn(`[${PLUGIN_ID}] event handler 异常（已隔离）`, {
               error: err instanceof Error ? err.message : String(err)
             });
           }