@andyqiu/codeforge 0.3.13 → 0.3.14

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, path13) {
-    const ctrl = callVisitor(key, node, visitor, path13);
+  function visit_(key, node, visitor, path12) {
+    const ctrl = callVisitor(key, node, visitor, path12);
     if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-      replaceNode(key, path13, ctrl);
-      return visit_(key, ctrl, visitor, path13);
+      replaceNode(key, path12, ctrl);
+      return visit_(key, ctrl, visitor, path12);
     }
     if (typeof ctrl !== "symbol") {
       if (identity.isCollection(node)) {
-        path13 = Object.freeze(path13.concat(node));
+        path12 = Object.freeze(path12.concat(node));
         for (let i = 0;i < node.items.length; ++i) {
-          const ci = visit_(i, node.items[i], visitor, path13);
+          const ci = visit_(i, node.items[i], visitor, path12);
           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)) {
-        path13 = Object.freeze(path13.concat(node));
-        const ck = visit_("key", node.key, visitor, path13);
+        path12 = Object.freeze(path12.concat(node));
+        const ck = visit_("key", node.key, visitor, path12);
         if (ck === BREAK)
           return BREAK;
         else if (ck === REMOVE)
           node.key = null;
-        const cv = visit_("value", node.value, visitor, path13);
+        const cv = visit_("value", node.value, visitor, path12);
         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, path13) {
-    const ctrl = await callVisitor(key, node, visitor, path13);
+  async function visitAsync_(key, node, visitor, path12) {
+    const ctrl = await callVisitor(key, node, visitor, path12);
     if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-      replaceNode(key, path13, ctrl);
-      return visitAsync_(key, ctrl, visitor, path13);
+      replaceNode(key, path12, ctrl);
+      return visitAsync_(key, ctrl, visitor, path12);
     }
     if (typeof ctrl !== "symbol") {
       if (identity.isCollection(node)) {
-        path13 = Object.freeze(path13.concat(node));
+        path12 = Object.freeze(path12.concat(node));
         for (let i = 0;i < node.items.length; ++i) {
-          const ci = await visitAsync_(i, node.items[i], visitor, path13);
+          const ci = await visitAsync_(i, node.items[i], visitor, path12);
           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)) {
-        path13 = Object.freeze(path13.concat(node));
-        const ck = await visitAsync_("key", node.key, visitor, path13);
+        path12 = Object.freeze(path12.concat(node));
+        const ck = await visitAsync_("key", node.key, visitor, path12);
         if (ck === BREAK)
           return BREAK;
         else if (ck === REMOVE)
           node.key = null;
-        const cv = await visitAsync_("value", node.value, visitor, path13);
+        const cv = await visitAsync_("value", node.value, visitor, path12);
         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, path13) {
+  function callVisitor(key, node, visitor, path12) {
     if (typeof visitor === "function")
-      return visitor(key, node, path13);
+      return visitor(key, node, path12);
     if (identity.isMap(node))
-      return visitor.Map?.(key, node, path13);
+      return visitor.Map?.(key, node, path12);
     if (identity.isSeq(node))
-      return visitor.Seq?.(key, node, path13);
+      return visitor.Seq?.(key, node, path12);
     if (identity.isPair(node))
-      return visitor.Pair?.(key, node, path13);
+      return visitor.Pair?.(key, node, path12);
     if (identity.isScalar(node))
-      return visitor.Scalar?.(key, node, path13);
+      return visitor.Scalar?.(key, node, path12);
     if (identity.isAlias(node))
-      return visitor.Alias?.(key, node, path13);
+      return visitor.Alias?.(key, node, path12);
     return;
   }
-  function replaceNode(key, path13, node) {
-    const parent = path13[path13.length - 1];
+  function replaceNode(key, path12, node) {
+    const parent = path12[path12.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, path13, value) {
+  function collectionFromPath(schema, path12, value) {
     let v = value;
-    for (let i = path13.length - 1;i >= 0; --i) {
-      const k = path13[i];
+    for (let i = path12.length - 1;i >= 0; --i) {
+      const k = path12[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 = (path13) => path13 == null || typeof path13 === "object" && !!path13[Symbol.iterator]().next().done;
+  var isEmptyPath = (path12) => path12 == null || typeof path12 === "object" && !!path12[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(path13, value) {
-      if (isEmptyPath(path13))
+    addIn(path12, value) {
+      if (isEmptyPath(path12))
         this.add(value);
       else {
-        const [key, ...rest] = path13;
+        const [key, ...rest] = path12;
         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(path13) {
-      const [key, ...rest] = path13;
+    deleteIn(path12) {
+      const [key, ...rest] = path12;
       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(path13, keepScalar) {
-      const [key, ...rest] = path13;
+    getIn(path12, keepScalar) {
+      const [key, ...rest] = path12;
       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(path13) {
-      const [key, ...rest] = path13;
+    hasIn(path12) {
+      const [key, ...rest] = path12;
       if (rest.length === 0)
         return this.has(key);
       const node = this.get(key, true);
       return identity.isCollection(node) ? node.hasIn(rest) : false;
     }
-    setIn(path13, value) {
-      const [key, ...rest] = path13;
+    setIn(path12, value) {
+      const [key, ...rest] = path12;
       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 log8 = require_log();
+  var log6 = 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) + '..."';
-        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.`);
+        log6.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(path13, value) {
+    addIn(path12, value) {
       if (assertCollection(this.contents))
-        this.contents.addIn(path13, value);
+        this.contents.addIn(path12, 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(path13) {
-      if (Collection.isEmptyPath(path13)) {
+    deleteIn(path12) {
+      if (Collection.isEmptyPath(path12)) {
         if (this.contents == null)
           return false;
         this.contents = null;
         return true;
       }
-      return assertCollection(this.contents) ? this.contents.deleteIn(path13) : false;
+      return assertCollection(this.contents) ? this.contents.deleteIn(path12) : false;
     }
     get(key, keepScalar) {
       return identity.isCollection(this.contents) ? this.contents.get(key, keepScalar) : undefined;
     }
-    getIn(path13, keepScalar) {
-      if (Collection.isEmptyPath(path13))
+    getIn(path12, keepScalar) {
+      if (Collection.isEmptyPath(path12))
         return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-      return identity.isCollection(this.contents) ? this.contents.getIn(path13, keepScalar) : undefined;
+      return identity.isCollection(this.contents) ? this.contents.getIn(path12, keepScalar) : undefined;
     }
     has(key) {
       return identity.isCollection(this.contents) ? this.contents.has(key) : false;
     }
-    hasIn(path13) {
-      if (Collection.isEmptyPath(path13))
+    hasIn(path12) {
+      if (Collection.isEmptyPath(path12))
         return this.contents !== undefined;
-      return identity.isCollection(this.contents) ? this.contents.hasIn(path13) : false;
+      return identity.isCollection(this.contents) ? this.contents.hasIn(path12) : false;
     }
     set(key, value) {
       if (this.contents == null) {
@@ -4278,13 +4278,13 @@ var require_Document = __commonJS((exports) => {
         this.contents.set(key, value);
       }
     }
-    setIn(path13, value) {
-      if (Collection.isEmptyPath(path13)) {
+    setIn(path12, value) {
+      if (Collection.isEmptyPath(path12)) {
         this.contents = value;
       } else if (this.contents == null) {
-        this.contents = Collection.collectionFromPath(this.schema, Array.from(path13), value);
+        this.contents = Collection.collectionFromPath(this.schema, Array.from(path12), value);
       } else if (assertCollection(this.contents)) {
-        this.contents.setIn(path13, value);
+        this.contents.setIn(path12, 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, path13) => {
+  visit.itemAtPath = (cst, path12) => {
     let item = cst;
-    for (const [field, index] of path13) {
+    for (const [field, index] of path12) {
       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, path13) => {
-    const parent = visit.itemAtPath(cst, path13.slice(0, -1));
-    const field = path13[path13.length - 1][0];
+  visit.parentCollection = (cst, path12) => {
+    const parent = visit.itemAtPath(cst, path12.slice(0, -1));
+    const field = path12[path12.length - 1][0];
     const coll = parent?.[field];
     if (coll && "items" in coll)
       return coll;
     throw new Error("Parent collection not found");
   };
-  function _visit(path13, item, visitor) {
-    let ctrl = visitor(item, path13);
+  function _visit(path12, item, visitor) {
+    let ctrl = visitor(item, path12);
     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(path13.concat([[field, i]])), token.items[i], visitor);
+          const ci = _visit(Object.freeze(path12.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, path13);
+          ctrl = ctrl(item, path12);
       }
     }
-    return typeof ctrl === "function" ? ctrl(item, path13) : ctrl;
+    return typeof ctrl === "function" ? ctrl(item, path12) : ctrl;
   }
   exports.visit = visit;
 });
@@ -6429,11 +6429,11 @@ var require_lexer = __commonJS((exports) => {
     hasChars(n) {
       return this.pos + n <= this.buffer.length;
     }
-    setNext(state3) {
+    setNext(state2) {
       this.buffer = this.buffer.substring(this.pos);
       this.pos = 0;
       this.lineEndPos = null;
-      this.next = state3;
+      this.next = state2;
       return null;
     }
     peek(n) {
@@ -7489,14 +7489,14 @@ var require_parser = __commonJS((exports) => {
           case "scalar":
           case "single-quoted-scalar":
           case "double-quoted-scalar": {
-            const fs10 = this.flowScalar(this.type);
+            const fs9 = this.flowScalar(this.type);
             if (atNextItem || it.value) {
-              map.items.push({ start, key: fs10, sep: [] });
+              map.items.push({ start, key: fs9, sep: [] });
               this.onKeyLine = true;
             } else if (it.sep) {
-              this.stack.push(fs10);
+              this.stack.push(fs9);
             } else {
-              Object.assign(it, { key: fs10, sep: [] });
+              Object.assign(it, { key: fs9, 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 fs10 = this.flowScalar(this.type);
+            const fs9 = this.flowScalar(this.type);
             if (!it || it.value)
-              fc.items.push({ start: [], key: fs10, sep: [] });
+              fc.items.push({ start: [], key: fs9, sep: [] });
             else if (it.sep)
-              this.stack.push(fs10);
+              this.stack.push(fs9);
             else
-              Object.assign(it, { key: fs10, sep: [] });
+              Object.assign(it, { key: fs9, 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 log8 = require_log();
+  var log6 = 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) => log8.warn(doc.options.logLevel, warning));
+    doc.warnings.forEach((warning) => log6.warn(doc.options.logLevel, warning));
     if (doc.errors.length > 0) {
       if (doc.options.logLevel !== "silent")
         throw doc.errors[0];
@@ -8066,7 +8066,7 @@ async function runAutoFeedback(cfg, ctx) {
   if (cmds.length === 0) {
     throw new Error("auto-feedback: 至少需要 test_cmd 或 lint_cmd 之一");
   }
-  const log13 = ctx.log ?? (() => {});
+  const log14 = 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);
-    log13("info", `auto-feedback round ${round} dispatch summary: ${result2.summary.slice(0, 200)}`);
+    log14("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") {
-    log13("warn", `auto-feedback 达 max_retries=${cfg.max_retries}，escalate to ${cfg.escalate_to}`);
+    log14("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} 轮自纠失败，错误片段：
@@ -14008,6 +14008,507 @@ var codeforgeToolsServer = async (ctx) => {
 };
 var handler8 = codeforgeToolsServer;
 
+// plugins/discover-spec-suggest.ts
+init_opencode_plugin_helpers();
+import { readFileSync as readFileSync4, readdirSync, statSync as statSync3 } from "node:fs";
+import { join as join11 } from "node:path";
+
+// lib/handoff-schema.ts
+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/handoff-schema.ts
+var MAX_HANDOFF_SIZE = 100 * 1024;
+var SLUG_REGEX = /^[a-z0-9][a-z0-9-]{0,49}$/;
+var SCORE_DIMENSIONS = ["functional", "ux", "technical", "constraints", "edge_cases"];
+var COMBO_VALUES = ["A", "B", "C", "D"];
+var NeedSchema = z28.object({
+  id: z28.string().min(1),
+  type: z28.enum(["must", "should", "nice-to-have"]),
+  statement: z28.string().min(1),
+  rationale: z28.string().optional(),
+  acceptance: z28.array(z28.string()).optional()
+});
+var BoundarySchema = z28.object({
+  excluded: z28.string().min(1),
+  reason: z28.string().min(1)
+});
+var AssumptionSchema = z28.object({
+  statement: z28.string().min(1),
+  confidence: z28.enum(["verified", "speculation", "high-risk-unknown"]),
+  needs_validation_by: z28.enum(["plan", "coder", "runtime"]).optional()
+});
+var OpenIssueSchema = z28.union([
+  z28.string().min(1),
+  z28.object({
+    id: z28.string().optional(),
+    question: z28.string().min(1),
+    blocking: z28.boolean().optional()
+  })
+]);
+var RedFlagsSchema = z28.object({
+  raised: z28.boolean(),
+  combos: z28.array(z28.enum(COMBO_VALUES)).default([]),
+  reasons: z28.array(z28.string()).default([]),
+  user_persisted_rounds: z28.number().int().nonnegative().default(0),
+  downstream_advisory: z28.string().nullable().optional()
+}).superRefine((rf, ctx) => {
+  if (rf.raised) {
+    if (rf.combos.length === 0) {
+      ctx.addIssue({
+        code: z28.ZodIssueCode.custom,
+        message: "red_flags.raised=true 时 combos 必须 >=1",
+        path: ["combos"]
+      });
+    }
+    if (rf.reasons.length === 0) {
+      ctx.addIssue({
+        code: z28.ZodIssueCode.custom,
+        message: "red_flags.raised=true 时 reasons 必须 >=1",
+        path: ["reasons"]
+      });
+    }
+  }
+});
+var ScoresSchema = z28.object(Object.fromEntries(SCORE_DIMENSIONS.map((d) => [d, z28.number().min(0).max(1)])));
+var PreCodingBlockerSchema = z28.object({
+  id: z28.string().regex(/^PRE-\d+$/, "id 必须形如 PRE-1 / PRE-2"),
+  blocker: z28.string().min(1),
+  source: z28.enum(["assumption", "red_flag", "open_issue"]),
+  must_resolve_by: z28.enum(["user", "codeforge"])
+});
+var KhRefSchema = z28.object({
+  kh_id: z28.string(),
+  title: z28.string(),
+  relevance: z28.enum(["positive", "negative", "neutral"]).optional()
+});
+var HandoffSchema = z28.object({
+  schema_version: z28.string().regex(/^\d+\.\d+\.\d+$/, "schema_version 必须形如 1.1.0 / 1.2.0"),
+  slug: z28.string().regex(SLUG_REGEX, "slug 仅允许 [a-z0-9-]，长度 1-50，首字符为字母数字"),
+  title: z28.string().min(1).max(200),
+  created_at: z28.string().optional(),
+  discover_session_id: z28.string().optional(),
+  weighted_score: z28.number().min(0).max(1),
+  scores: ScoresSchema,
+  needs: z28.array(NeedSchema).min(1, "needs 必须 >=1"),
+  boundaries: z28.array(BoundarySchema).min(1, "boundaries 必须 >=1"),
+  assumptions: z28.array(AssumptionSchema),
+  open_issues: z28.array(OpenIssueSchema).default([]),
+  rejected_alternatives: z28.array(z28.object({ option: z28.string(), reason: z28.string() })).default([]),
+  acceptance_criteria: z28.array(z28.object({
+    id: z28.string().regex(/^AC-/, "AC id 必须以 AC- 开头"),
+    description: z28.string().min(1),
+    measurable: z28.boolean().optional(),
+    metric: z28.string().optional()
+  })).default([]),
+  red_flags: RedFlagsSchema,
+  pre_coding_blockers: z28.array(PreCodingBlockerSchema).default([]),
+  kh_references: z28.array(KhRefSchema).default([]),
+  adr_refs: z28.array(z28.string()).default([]),
+  related_artifacts: z28.object({
+    prd: z28.string().optional(),
+    transcript: z28.string().optional()
+  }).optional()
+});
+function validateHandoff(rawYaml, fileSize) {
+  if (fileSize > MAX_HANDOFF_SIZE) {
+    return {
+      ok: false,
+      reason: `handoff.yaml 超过 ${MAX_HANDOFF_SIZE} 字节上限（实际 ${fileSize} 字节）`
+    };
+  }
+  if (typeof rawYaml !== "string" || rawYaml.length === 0) {
+    return { ok: false, reason: "handoff.yaml 内容为空" };
+  }
+  let parsed;
+  try {
+    parsed = $parse(rawYaml);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, reason: `YAML 解析失败：${msg}` };
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { ok: false, reason: "handoff.yaml 顶层必须是 object" };
+  }
+  const result = HandoffSchema.safeParse(parsed);
+  if (!result.success) {
+    const first = result.error.issues[0];
+    const path12 = first?.path?.join(".") ?? "(root)";
+    const msg = first?.message ?? "unknown";
+    return { ok: false, reason: `schema 校验失败：${path12}: ${msg}` };
+  }
+  return { ok: true, data: result.data, schemaVersion: result.data.schema_version };
+}
+function isValidSlug(slug) {
+  return typeof slug === "string" && SLUG_REGEX.test(slug);
+}
+
+// plugins/discover-spec-suggest.ts
+var PLUGIN_NAME9 = "discover-spec-suggest";
+logLifecycle(PLUGIN_NAME9, "import", {});
+var TARGET_AGENT = "codeforge";
+var SESSION_CAP = 200;
+var SESSION_TTL_MS = 24 * 60 * 60 * 1000;
+var MATCH_THRESHOLD = 0.15;
+var MAX_CANDIDATES = 3;
+var NUDGE_MAX_LEN = 1500;
+var SPECS_REL_DIR = join11(".codeforge", "specs");
+var sessionMap = new Map;
+function pruneIfOversize() {
+  while (sessionMap.size > SESSION_CAP) {
+    const oldestKey = sessionMap.keys().next().value;
+    if (oldestKey === undefined)
+      break;
+    sessionMap.delete(oldestKey);
+  }
+}
+function isExpired(entry, now = Date.now()) {
+  return now - entry.ts > SESSION_TTL_MS;
+}
+var specIndex = [];
+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 defaultStatReader(p) {
+  const st = statSync3(p);
+  return { size: st.size, mtimeMs: st.mtimeMs, isDirectory: st.isDirectory() };
+}
+function tokenize(s) {
+  if (typeof s !== "string" || s.length === 0)
+    return [];
+  const lower = s.toLowerCase();
+  const parts = lower.split(/[^a-z0-9\u4e00-\u9fff]+/u).filter(Boolean);
+  return parts.filter((t) => /[\u4e00-\u9fff]/u.test(t) || t.length >= 2);
+}
+function jaccard(a, b) {
+  if (a.size === 0 || b.size === 0)
+    return 0;
+  let inter = 0;
+  for (const t of a)
+    if (b.has(t))
+      inter++;
+  const union = a.size + b.size - inter;
+  if (union === 0)
+    return 0;
+  return inter / union;
+}
+function escapeRegExp2(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isEnglishToken(t) {
+  return /^[a-zA-Z0-9_-]+$/.test(t);
+}
+function titleHit(queryTokens, titleLower) {
+  if (typeof titleLower !== "string" || titleLower.length === 0)
+    return 0;
+  let hits = 0;
+  for (const t of queryTokens) {
+    if (typeof t !== "string" || t.length === 0)
+      continue;
+    const tLower = t.toLowerCase();
+    if (isEnglishToken(tLower)) {
+      const re = new RegExp(`\\b${escapeRegExp2(tLower)}\\b`);
+      if (re.test(titleLower))
+        hits++;
+    } else {
+      if (tLower.length >= 2 && titleLower.includes(tLower))
+        hits++;
+    }
+  }
+  return hits;
+}
+function matchSpecs(query, index) {
+  const qTokens = new Set(tokenize(query));
+  if (qTokens.size === 0)
+    return [];
+  const scored = [];
+  for (const rec of index) {
+    const j = jaccard(qTokens, rec.tokens);
+    const t = titleHit(qTokens, rec.titleLower);
+    const score = j * 0.6 + Math.min(t, 1) * 0.4;
+    if (score >= MATCH_THRESHOLD) {
+      scored.push({
+        slug: rec.slug,
+        title: rec.title,
+        score,
+        schemaVersion: rec.schemaVersion,
+        mtime: rec.mtime
+      });
+    }
+  }
+  scored.sort((a, b) => {
+    if (b.score !== a.score)
+      return b.score - a.score;
+    return b.mtime - a.mtime;
+  });
+  return scored.slice(0, MAX_CANDIDATES);
+}
+function loadSpecs(rootDir, opts = {}) {
+  const reader = opts.reader ?? defaultReader;
+  const dirReader = opts.dirReader ?? defaultDirReader;
+  const dirExists = opts.dirExists ?? defaultDirExists;
+  const statReader = opts.statReader ?? defaultStatReader;
+  const log6 = makePluginLogger(PLUGIN_NAME9);
+  const specsRoot = join11(rootDir, SPECS_REL_DIR);
+  const records = [];
+  if (!dirExists(specsRoot)) {
+    log6.info(`specs 目录不存在，plugin 将 no-op`, { specsRoot });
+    return records;
+  }
+  let entries;
+  try {
+    entries = dirReader(specsRoot);
+  } catch (err) {
+    log6.warn(`specs 目录读取失败`, {
+      specsRoot,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return records;
+  }
+  for (const entry of entries) {
+    if (!isValidSlug(entry)) {
+      log6.info(`跳过非合法 slug 命名的条目`, { entry });
+      continue;
+    }
+    const specDir = join11(specsRoot, entry);
+    let dirStat;
+    try {
+      dirStat = statReader(specDir);
+    } catch (err) {
+      log6.warn(`spec 目录 stat 失败`, {
+        specDir,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      continue;
+    }
+    if (!dirStat.isDirectory)
+      continue;
+    const handoffPath = join11(specDir, "handoff.yaml");
+    let fileStat;
+    try {
+      fileStat = statReader(handoffPath);
+    } catch {
+      continue;
+    }
+    if (fileStat.isDirectory)
+      continue;
+    if (fileStat.size > MAX_HANDOFF_SIZE) {
+      log6.warn(`handoff.yaml 超过 ${MAX_HANDOFF_SIZE} 字节上限，已跳过`, {
+        handoffPath,
+        size: fileStat.size
+      });
+      continue;
+    }
+    let rawYaml;
+    try {
+      rawYaml = reader(handoffPath);
+    } catch (err) {
+      log6.warn(`handoff.yaml 读取失败`, {
+        handoffPath,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      continue;
+    }
+    const result = validateHandoff(rawYaml, fileStat.size);
+    if (!result.ok) {
+      log6.warn(`handoff.yaml 校验失败，已跳过`, {
+        handoffPath,
+        reason: result.reason
+      });
+      continue;
+    }
+    const handoff = result.data;
+    if (handoff.slug !== entry) {
+      log6.warn(`handoff.slug 与目录名不一致，以目录名为准`, {
+        dir: entry,
+        handoffSlug: handoff.slug
+      });
+    }
+    const corpus = [handoff.title];
+    for (const need of handoff.needs ?? []) {
+      if (need.statement)
+        corpus.push(need.statement);
+      if (need.rationale)
+        corpus.push(need.rationale);
+    }
+    const tokens = new Set(tokenize(corpus.join(" ")));
+    records.push({
+      slug: entry,
+      title: handoff.title,
+      schemaVersion: result.schemaVersion,
+      tokens,
+      titleLower: handoff.title.toLowerCase(),
+      mtime: fileStat.mtimeMs,
+      handoff
+    });
+  }
+  log6.info(`specs 加载完成`, {
+    specsRoot,
+    loaded: records.length,
+    total_entries: entries.length
+  });
+  return records;
+}
+function renderCandidatesNudge(matched) {
+  if (matched.length === 0)
+    return "";
+  const lines = [];
+  lines.push("────────────────────────────────────────");
+  lines.push("DISCOVER SPEC CANDIDATES (auto-injected by discover-spec-suggest plugin)");
+  lines.push("────────────────────────────────────────");
+  lines.push("以下 spec 与用户当前需求**可能**相关（jaccard + title 加权匹配）。");
+  lines.push("**必须明文跟用户确认**是否走该 spec 路径；用户否认 → 忽略本提示继续原计划。");
+  lines.push("");
+  for (const m of matched) {
+    const scorePct = (m.score * 100).toFixed(0);
+    lines.push(`  - \`${m.slug}\` (${m.schemaVersion}, score ${scorePct}%): ${m.title}`);
+  }
+  lines.push("");
+  lines.push("若用户确认走 spec：");
+  lines.push("  1. 先 `read .codeforge/specs/<slug>/PRD.md` + `read .codeforge/specs/<slug>/handoff.yaml`");
+  lines.push("  2. 派 planner / coder 时 prompt 必须含 `spec=<slug>`");
+  lines.push("  3. 若 handoff 含 pre_coding_blockers[]，派 coder 时需附 `pre_ack=<PRE-id>`");
+  lines.push("────────────────────────────────────────");
+  const body = lines.join(`
+`);
+  if (body.length <= NUDGE_MAX_LEN)
+    return body;
+  return body.slice(0, NUDGE_MAX_LEN - 4) + `
+…`;
+}
+var log6 = makePluginLogger(PLUGIN_NAME9);
+var discoverSpecSuggestServer = async (ctx) => {
+  try {
+    const loaded = loadSpecs(ctx.directory ?? process.cwd());
+    specIndex.length = 0;
+    specIndex.push(...loaded);
+  } catch (err) {
+    log6.warn(`loadSpecs 失败（plugin 将 no-op）`, {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+  logLifecycle(PLUGIN_NAME9, "activate", {
+    directory: ctx.directory,
+    specs_loaded: specIndex.length,
+    target_agent: TARGET_AGENT,
+    match_threshold: MATCH_THRESHOLD,
+    max_candidates: MAX_CANDIDATES,
+    session_cap: SESSION_CAP,
+    session_ttl_ms: SESSION_TTL_MS,
+    no_op: specIndex.length === 0
+  });
+  return {
+    "chat.message": async (input, output) => {
+      await safeAsync(PLUGIN_NAME9, "chat.message", async () => {
+        if (specIndex.length === 0)
+          return;
+        const text = extractUserText(output);
+        if (!text)
+          return;
+        const agent = input?.agent ?? "unknown";
+        const sid = input?.sessionID;
+        if (!sid)
+          return;
+        sessionMap.set(sid, { text, agent, ts: Date.now() });
+        pruneIfOversize();
+      });
+    },
+    "experimental.chat.system.transform": async (input, output) => {
+      await safeAsync(PLUGIN_NAME9, "experimental.chat.system.transform", async () => {
+        if (specIndex.length === 0)
+          return;
+        if (!output || !Array.isArray(output.system))
+          return;
+        const sid = input?.sessionID;
+        if (!sid)
+          return;
+        const entry = sessionMap.get(sid);
+        if (!entry)
+          return;
+        if (isExpired(entry)) {
+          sessionMap.delete(sid);
+          return;
+        }
+        if (entry.agent !== TARGET_AGENT)
+          return;
+        if (!entry.text)
+          return;
+        const matched = matchSpecs(entry.text, specIndex);
+        if (matched.length === 0)
+          return;
+        const nudge = renderCandidatesNudge(matched);
+        if (!nudge)
+          return;
+        output.system.push(nudge);
+        safeWriteLog(PLUGIN_NAME9, {
+          hook: "experimental.chat.system.transform",
+          sessionID: sid,
+          agent: entry.agent,
+          matched_slugs: matched.map((m) => m.slug),
+          matched_count: matched.length,
+          injected_chars: nudge.length
+        });
+      });
+    }
+  };
+};
+var handler9 = discoverSpecSuggestServer;
+
 // plugins/kh-auto-context.ts
 init_kh_client();
 
@@ -14031,16 +14532,16 @@ class SessionScopedCache {
     const { client, sessionId, query, limit, timeoutMs } = args;
     const queryHash = this.hashQuery(sessionId, query);
     const inflightKey = `${sessionId}::${queryHash}`;
-    const sessionMap = this.cache.get(sessionId);
-    if (sessionMap) {
-      const entry = sessionMap.get(queryHash);
+    const sessionMap2 = this.cache.get(sessionId);
+    if (sessionMap2) {
+      const entry = sessionMap2.get(queryHash);
       if (entry && this.now() - entry.cachedAt < this.ttlMs) {
-        sessionMap.delete(queryHash);
-        sessionMap.set(queryHash, entry);
+        sessionMap2.delete(queryHash);
+        sessionMap2.set(queryHash, entry);
         return entry.result;
       }
       if (entry)
-        sessionMap.delete(queryHash);
+        sessionMap2.delete(queryHash);
     }
     const pending = this.inflight.get(inflightKey);
     if (pending)
@@ -14128,18 +14629,18 @@ class SessionScopedCache {
     }
   }
   writeCache(sessionId, queryHash, query, result) {
-    let sessionMap = this.cache.get(sessionId);
-    if (!sessionMap) {
-      sessionMap = new Map;
-      this.cache.set(sessionId, sessionMap);
-    }
-    sessionMap.delete(queryHash);
-    sessionMap.set(queryHash, { query, result, cachedAt: this.now() });
-    while (sessionMap.size > this.maxPerSession) {
-      const oldest = sessionMap.keys().next().value;
+    let sessionMap2 = this.cache.get(sessionId);
+    if (!sessionMap2) {
+      sessionMap2 = new Map;
+      this.cache.set(sessionId, sessionMap2);
+    }
+    sessionMap2.delete(queryHash);
+    sessionMap2.set(queryHash, { query, result, cachedAt: this.now() });
+    while (sessionMap2.size > this.maxPerSession) {
+      const oldest = sessionMap2.keys().next().value;
       if (oldest === undefined)
         break;
-      sessionMap.delete(oldest);
+      sessionMap2.delete(oldest);
     }
   }
 }
@@ -14147,7 +14648,7 @@ var sharedKhCache = new SessionScopedCache;
 
 // plugins/kh-auto-context.ts
 init_opencode_plugin_helpers();
-var PLUGIN_NAME9 = "kh-auto-context";
+var PLUGIN_NAME10 = "kh-auto-context";
 var INJECTION_MODE = "observe-only";
 function resolveInjectionMode(client) {
   return client.hasTransport() ? "system-injected" : "observe-only";
@@ -14244,9 +14745,9 @@ var CODEFORGE_CONSTRAINTS = [
     priority: 8
   }
 ];
-async function seedConstraints(client, log6) {
+async function seedConstraints(client, log7) {
   if (!client.hasTransport()) {
-    log6?.debug?.(`[${PLUGIN_NAME9}] seedConstraints: transport 不可用，跳过`, {});
+    log7?.debug?.(`[${PLUGIN_NAME10}] seedConstraints: transport 不可用，跳过`, {});
     return { ok: false, reason: "transport_unavailable" };
   }
   try {
@@ -14260,7 +14761,7 @@ async function seedConstraints(client, log6) {
     });
     if (result && typeof result === "object" && "ok" in result && result.ok === false) {
       const r = result;
-      log6?.warn(`[${PLUGIN_NAME9}] seedConstraints 降级`, {
+      log7?.warn(`[${PLUGIN_NAME10}] seedConstraints 降级`, {
         reason: r.reason,
         message: r.message
       });
@@ -14270,15 +14771,15 @@ async function seedConstraints(client, log6) {
         message: r.message
       };
     }
-    log6?.info(`[${PLUGIN_NAME9}] seedConstraints: 已写入 ${CODEFORGE_CONSTRAINTS.length} 条 constraints`, { count: CODEFORGE_CONSTRAINTS.length });
+    log7?.info(`[${PLUGIN_NAME10}] seedConstraints: 已写入 ${CODEFORGE_CONSTRAINTS.length} 条 constraints`, { count: CODEFORGE_CONSTRAINTS.length });
     return { ok: true, itemsWritten: CODEFORGE_CONSTRAINTS.length };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    log6?.warn(`[${PLUGIN_NAME9}] seedConstraints 失败（已静默）`, { error: message });
+    log7?.warn(`[${PLUGIN_NAME10}] seedConstraints 失败（已静默）`, { error: message });
     return { ok: false, reason: "exception", message };
   }
 }
-function createSystemInjectedHook(client, sessionId, log6) {
+function createSystemInjectedHook(client, sessionId, log7) {
   const section = `topic:auto-context-${sessionId ?? "global"}`;
   return async (markdown) => {
     try {
@@ -14289,7 +14790,7 @@ function createSystemInjectedHook(client, sessionId, log6) {
       });
       if (result && typeof result === "object" && "ok" in result && result.ok === false) {
         const r = result;
-        log6?.warn(`[${PLUGIN_NAME9}] system-injected 降级到 observe-only：${r.reason ?? "unknown"}`, {
+        log7?.warn(`[${PLUGIN_NAME10}] system-injected 降级到 observe-only：${r.reason ?? "unknown"}`, {
           sessionId,
           section,
           preview: markdown.slice(0, 200),
@@ -14298,12 +14799,12 @@ function createSystemInjectedHook(client, sessionId, log6) {
         });
         return;
       }
-      log6?.info(`[${PLUGIN_NAME9}] system-injected: 写入 KH working_memory 成功 (${markdown.length} chars)`, {
+      log7?.info(`[${PLUGIN_NAME10}] system-injected: 写入 KH working_memory 成功 (${markdown.length} chars)`, {
         sessionId,
         section
       });
     } catch (err) {
-      log6?.warn(`[${PLUGIN_NAME9}] system-injected 抛异常，降级到 observe-only`, {
+      log7?.warn(`[${PLUGIN_NAME10}] system-injected 抛异常，降级到 observe-only`, {
         sessionId,
         section,
         preview: markdown.slice(0, 200),
@@ -14320,7 +14821,7 @@ function inflightKey(sessionId, query) {
 async function runKhSearchAndInject(args) {
   const { query, ctx, opts, mode } = args;
   const cfg = opts.config ?? DEFAULT_CONFIG5;
-  const log6 = ctx.log;
+  const log7 = ctx.log;
   const startedAt = Date.now();
   const racer = opts.scheduler?.raceTimeout ?? (async (p, ms) => {
     let timer = null;
@@ -14346,7 +14847,7 @@ async function runKhSearchAndInject(args) {
     });
     result = await racer(searchPromise, cfg.timeoutMs);
   } catch (err) {
-    log6?.warn(`[${PLUGIN_NAME9}] client.search threw (sync or async), return null`, {
+    log7?.warn(`[${PLUGIN_NAME10}] client.search threw (sync or async), return null`, {
       query,
       elapsedMs: Date.now() - startedAt,
       sessionId: ctx.sessionId,
@@ -14356,7 +14857,7 @@ async function runKhSearchAndInject(args) {
     return null;
   }
   if (result === "__timeout__") {
-    log6?.warn(`[${PLUGIN_NAME9}] timeout`, {
+    log7?.warn(`[${PLUGIN_NAME10}] timeout`, {
       query,
       ms: cfg.timeoutMs,
       elapsedMs: Date.now() - startedAt,
@@ -14366,7 +14867,7 @@ async function runKhSearchAndInject(args) {
     return null;
   }
   if (!result.ok) {
-    log6?.warn(`[${PLUGIN_NAME9}] kh degraded`, {
+    log7?.warn(`[${PLUGIN_NAME10}] kh degraded`, {
       reason: result.reason,
       query,
       elapsedMs: Date.now() - startedAt,
@@ -14378,7 +14879,7 @@ async function runKhSearchAndInject(args) {
   const filtered = result.insights.filter((i) => (i.confidence ?? 0) >= cfg.minConfidence);
   if (filtered.length === 0) {
     opts.cache.record(query, []);
-    log6?.debug?.(`[${PLUGIN_NAME9}] no candidate above threshold`, {
+    log7?.debug?.(`[${PLUGIN_NAME10}] no candidate above threshold`, {
       query,
       rawCount: result.insights.length,
       elapsedMs: Date.now() - startedAt,
@@ -14391,7 +14892,7 @@ async function runKhSearchAndInject(args) {
     try {
       await ctx.injectContext(payload.markdown);
     } catch (err) {
-      log6?.warn(`[${PLUGIN_NAME9}] injectContext threw`, {
+      log7?.warn(`[${PLUGIN_NAME10}] injectContext threw`, {
         error: err instanceof Error ? err.message : String(err),
         query,
         sessionId: ctx.sessionId
@@ -14399,7 +14900,7 @@ async function runKhSearchAndInject(args) {
     }
   }
   opts.cache.record(query, filtered);
-  log6?.info(`[${PLUGIN_NAME9}] inject complete (${mode})`, {
+  log7?.info(`[${PLUGIN_NAME10}] inject complete (${mode})`, {
     query,
     mode,
     candidateCount: filtered.length,
@@ -14412,21 +14913,21 @@ async function handleMessage2(raw, opts) {
   const cfg = opts.config ?? DEFAULT_CONFIG5;
   const mode = opts.mode ?? INJECTION_MODE;
   const ctx = raw ?? {};
-  const log6 = ctx.log;
+  const log7 = ctx.log;
   const text = (ctx.content ?? "").trim();
   if (!shouldInject(text, cfg)) {
-    log6?.debug?.(`[${PLUGIN_NAME9}] skip (filter)`, { textLen: text.length });
+    log7?.debug?.(`[${PLUGIN_NAME10}] skip (filter)`, { textLen: text.length });
     return;
   }
   const query = extractQuery(text);
   if (!query)
     return;
   if (opts.cache.shouldSkip(query)) {
-    log6?.debug?.(`[${PLUGIN_NAME9}] cache hit, skip`, { query });
+    log7?.debug?.(`[${PLUGIN_NAME10}] cache hit, skip`, { query });
     return;
   }
   if (inflight2.size >= INFLIGHT_CAP) {
-    log6?.warn(`[${PLUGIN_NAME9}] inflight cap reached, skip`, {
+    log7?.warn(`[${PLUGIN_NAME10}] inflight cap reached, skip`, {
       query,
       inflightSize: inflight2.size,
       cap: INFLIGHT_CAP,
@@ -14437,7 +14938,7 @@ async function handleMessage2(raw, opts) {
   const key = inflightKey(ctx.sessionId, query);
   inflight2.add(key);
   runKhSearchAndInject({ query, ctx, opts, mode }).catch((err) => {
-    log6?.warn(`[${PLUGIN_NAME9}] runKhSearchAndInject 顶层兜底捕获`, {
+    log7?.warn(`[${PLUGIN_NAME10}] runKhSearchAndInject 顶层兜底捕获`, {
       error: err instanceof Error ? err.message : String(err),
       query,
       sessionId: ctx.sessionId
@@ -14446,32 +14947,32 @@ async function handleMessage2(raw, opts) {
     inflight2.delete(key);
   });
 }
-logLifecycle(PLUGIN_NAME9, "import");
+logLifecycle(PLUGIN_NAME10, "import");
 var sharedClient2 = new KhClient;
 var sharedCache = new QueryCache(DEFAULT_CONFIG5.cacheTtlMs);
 var khAutoContextServer = async (ctx) => {
-  const log6 = makePluginLogger(PLUGIN_NAME9);
+  const log7 = makePluginLogger(PLUGIN_NAME10);
   const runtimeMode = resolveInjectionMode(sharedClient2);
-  logLifecycle(PLUGIN_NAME9, "activate", {
+  logLifecycle(PLUGIN_NAME10, "activate", {
     directory: ctx.directory,
     minConfidence: DEFAULT_CONFIG5.minConfidence,
     timeoutMs: DEFAULT_CONFIG5.timeoutMs,
     mode: runtimeMode,
     transport_available: sharedClient2.hasTransport()
   });
-  seedConstraints(sharedClient2, log6).catch((err) => {
-    log6.warn("seedConstraints 顶层兜底捕获", {
+  seedConstraints(sharedClient2, log7).catch((err) => {
+    log7.warn("seedConstraints 顶层兜底捕获", {
       error: err instanceof Error ? err.message : String(err)
     });
   });
   return {
     "chat.message": async (input, output) => {
-      await safeAsync(PLUGIN_NAME9, "chat.message", async () => {
+      await safeAsync(PLUGIN_NAME10, "chat.message", async () => {
         const text = extractUserText(output);
         if (!text)
           return;
-        const injectContext = runtimeMode === "system-injected" ? createSystemInjectedHook(sharedClient2, input.sessionID, log6) : async (markdown) => {
-          log6.info(`KH context candidate (${markdown.length} chars)`, {
+        const injectContext = runtimeMode === "system-injected" ? createSystemInjectedHook(sharedClient2, input.sessionID, log7) : async (markdown) => {
+          log7.info(`KH context candidate (${markdown.length} chars)`, {
             sessionID: input.sessionID,
             mode: runtimeMode,
             preview: markdown.slice(0, 200)
@@ -14481,12 +14982,12 @@ var khAutoContextServer = async (ctx) => {
           content: text,
           sessionId: input.sessionID,
           injectContext,
-          log: log6
+          log: log7
         }, { client: sharedClient2, cache: sharedCache, mode: runtimeMode });
       });
     },
     event: async ({ event }) => {
-      await safeAsync(PLUGIN_NAME9, "event", async () => {
+      await safeAsync(PLUGIN_NAME10, "event", async () => {
         const e = event;
         if (e.type !== "session.idle")
           return;
@@ -14495,14 +14996,14 @@ var khAutoContextServer = async (ctx) => {
         if (typeof sid !== "string" || !sid)
           return;
         sharedKhCache.onSessionEnd(sid);
-        log6.debug?.(`[${PLUGIN_NAME9}] session.idle: cleared shared cache`, {
+        log7.debug?.(`[${PLUGIN_NAME10}] session.idle: cleared shared cache`, {
           sessionID: sid
         });
       });
     }
   };
 };
-var handler9 = khAutoContextServer;
+var handler10 = khAutoContextServer;
 
 // plugins/kh-reminder.ts
 init_opencode_plugin_helpers();
@@ -14623,8 +15124,8 @@ async function condense(input, opts = {}) {
 }
 
 // plugins/kh-reminder.ts
-var PLUGIN_NAME10 = "kh-reminder";
-logLifecycle(PLUGIN_NAME10, "import", {});
+var PLUGIN_NAME11 = "kh-reminder";
+logLifecycle(PLUGIN_NAME11, "import", {});
 var TRIGGER_WORDS_ZH = [
   "怎么",
   "怎样",
@@ -14770,7 +15271,7 @@ function evaluate(input) {
   lastTriggerAt.set(sessionId, now);
   return { triggered: true, reason, sessionId };
 }
-function handleObserve(raw, log6) {
+function handleObserve(raw, log7) {
   const ctx = raw ?? {};
   if (!Array.isArray(ctx.messages))
     return null;
@@ -14778,7 +15279,7 @@ function handleObserve(raw, log6) {
     const result = evaluate(ctx);
     if (result.triggered && result.reason) {
       const reasonStr = formatReason(result.reason);
-      log6?.info(`[${PLUGIN_NAME10}] ⚡ KH 提醒（observe-only） · session=${result.sessionId} · ${reasonStr}`, {
+      log7?.info(`[${PLUGIN_NAME11}] ⚡ KH 提醒（observe-only） · session=${result.sessionId} · ${reasonStr}`, {
         sessionId: result.sessionId,
         reason: result.reason,
         suggestion: "调用 smart_search 查项目历史；完成后用 save_chat_insight 沉淀"
@@ -14786,7 +15287,7 @@ function handleObserve(raw, log6) {
     }
     return result;
   } catch (err) {
-    log6?.warn(`[${PLUGIN_NAME10}] evaluate 异常（已隔离）`, {
+    log7?.warn(`[${PLUGIN_NAME11}] evaluate 异常（已隔离）`, {
       error: err instanceof Error ? err.message : String(err)
     });
     return null;
@@ -14802,9 +15303,9 @@ function formatReason(r) {
       return `no-search-in-recent-rounds (last ${r.rounds})`;
   }
 }
-var log6 = makePluginLogger(PLUGIN_NAME10);
+var log7 = makePluginLogger(PLUGIN_NAME11);
 var khReminderServer = async (ctx) => {
-  logLifecycle(PLUGIN_NAME10, "activate", {
+  logLifecycle(PLUGIN_NAME11, "activate", {
     directory: ctx.directory,
     threshold: DEFAULT_THRESHOLD,
     cooldown_ms: COOLDOWN_MS,
@@ -14812,7 +15313,7 @@ var khReminderServer = async (ctx) => {
   });
   return {
     "experimental.chat.messages.transform": async (_input, output) => {
-      await safeAsync(PLUGIN_NAME10, "experimental.chat.messages.transform", async () => {
+      await safeAsync(PLUGIN_NAME11, "experimental.chat.messages.transform", async () => {
         const list = output.messages;
         if (!Array.isArray(list) || list.length === 0)
           return;
@@ -14828,10 +15329,10 @@ var khReminderServer = async (ctx) => {
 `);
           return { role, content };
         });
-        const result = handleObserve({ messages: flat, sessionId }, log6);
+        const result = handleObserve({ messages: flat, sessionId }, log7);
         if (!result)
           return;
-        safeWriteLog(PLUGIN_NAME10, {
+        safeWriteLog(PLUGIN_NAME11, {
           hook: "experimental.chat.messages.transform",
           mode: "observe-only",
           sessionId: result.sessionId,
@@ -14844,7 +15345,7 @@ var khReminderServer = async (ctx) => {
     }
   };
 };
-var handler10 = khReminderServer;
+var handler11 = khReminderServer;
 
 // lib/memories.ts
 import { promises as fs9 } from "node:fs";
@@ -14965,13 +15466,13 @@ async function recallMemories(query, opts, cfgRaw) {
     }
   }
   const all = await listMemories({ scope: opts.scope, project: opts.project ?? cfg.projectName }, cfgRaw);
-  const tokens = tokenize(query);
+  const tokens = tokenize2(query);
   if (tokens.length === 0)
     return [];
   const now = cfg.now();
   const scored = [];
   for (const m of all) {
-    const sim = bagOfWordsScore(tokens, tokenize(m.content + " " + (m.tags ?? []).join(" ")));
+    const sim = bagOfWordsScore(tokens, tokenize2(m.content + " " + (m.tags ?? []).join(" ")));
     if (sim <= 0)
       continue;
     const age = Math.max(0, now - m.updated_at);
@@ -15021,7 +15522,7 @@ ${lines.join(`
     recalled: recalled.length
   };
 }
-function tokenize(s) {
+function tokenize2(s) {
   return s.toLowerCase().split(/[^a-z0-9_\u4e00-\u9fa5]+/u).filter((t) => t.length >= 2);
 }
 function bagOfWordsScore(query, doc) {
@@ -15046,7 +15547,7 @@ function bagOfWordsScore(query, doc) {
 
 // plugins/memories-context.ts
 init_opencode_plugin_helpers();
-var PLUGIN_NAME11 = "memories-context";
+var PLUGIN_NAME12 = "memories-context";
 var INJECTION_MODE2 = "observe-only";
 var DEFAULT_CONFIG6 = {
   minTextLength: 8,
@@ -15135,23 +15636,23 @@ async function handleMessage3(raw, opts) {
   const cfg = opts.cfg ?? DEFAULT_CONFIG6;
   const cache2 = opts.cache ?? new QueryCache2(cfg.cacheTtlMs);
   const ctx = raw ?? {};
-  const log7 = ctx.log;
+  const log8 = ctx.log;
   const text = (ctx.content ?? "").trim();
   if (!text)
     return { kind: "noop", reason: "empty", mode: INJECTION_MODE2 };
   const dir = parseDirective(text);
   if (dir.kind !== "none") {
-    return await handleDirective(dir, ctx, opts.memCfg, log7);
+    return await handleDirective(dir, ctx, opts.memCfg, log8);
   }
   if (!shouldRecall(text, cfg)) {
-    log7?.debug?.(`[${PLUGIN_NAME11}] skip (filter)`, { textLen: text.length });
+    log8?.debug?.(`[${PLUGIN_NAME12}] skip (filter)`, { textLen: text.length });
     return { kind: "noop", reason: "filtered", mode: INJECTION_MODE2 };
   }
   const query = extractQuery2(text);
   if (!query)
     return { kind: "noop", reason: "empty_query", mode: INJECTION_MODE2 };
   if (cache2.shouldSkip(query)) {
-    log7?.debug?.(`[${PLUGIN_NAME11}] cache hit`, { query });
+    log8?.debug?.(`[${PLUGIN_NAME12}] cache hit`, { query });
     return { kind: "noop", reason: "cache", mode: INJECTION_MODE2 };
   }
   const racer = opts.scheduler?.raceTimeout ?? (async (p, ms) => {
@@ -15176,7 +15677,7 @@ async function handleMessage3(raw, opts) {
   }, opts.memCfg);
   const result = await racer(injectPromise, cfg.timeoutMs);
   if (result === "__timeout__") {
-    log7?.warn(`[${PLUGIN_NAME11}] timeout`, { query, ms: cfg.timeoutMs });
+    log8?.warn(`[${PLUGIN_NAME12}] timeout`, { query, ms: cfg.timeoutMs });
     cache2.record(query, 0);
     return { kind: "noop", reason: "timeout", mode: INJECTION_MODE2 };
   }
@@ -15188,29 +15689,29 @@ async function handleMessage3(raw, opts) {
     try {
       await ctx.injectContext(result.text);
     } catch (err) {
-      log7?.warn(`[${PLUGIN_NAME11}] injectContext threw`, {
+      log8?.warn(`[${PLUGIN_NAME12}] injectContext threw`, {
         error: err instanceof Error ? err.message : String(err)
       });
     }
   }
   cache2.record(query, result.recalled);
-  log7?.info(`[${PLUGIN_NAME11}] observe-only: ${result.used}/${result.recalled} memories ready`, { query, mode: INJECTION_MODE2 });
+  log8?.info(`[${PLUGIN_NAME12}] observe-only: ${result.used}/${result.recalled} memories ready`, { query, mode: INJECTION_MODE2 });
   return { kind: "injected", payload: result, mode: INJECTION_MODE2 };
 }
-async function handleDirective(dir, ctx, memCfg, log7) {
+async function handleDirective(dir, ctx, memCfg, log8) {
   if (dir.kind === "remember") {
     const r = await addMemory({ scope: dir.scope, content: dir.content, source: "directive" }, memCfg);
     if (r.ok) {
       const target = r.written_to === "kh" ? "KH" : "本地";
       await safeReply(ctx, `\uD83E\uDDE0 已记住（${dir.scope} / ${target}，id=${r.id}）`);
-      log7?.info(`[${PLUGIN_NAME11}] /remember ok`, {
+      log8?.info(`[${PLUGIN_NAME12}] /remember ok`, {
         scope: dir.scope,
         id: r.id,
         mode: INJECTION_MODE2
       });
     } else {
       await safeReply(ctx, `❌ 记忆失败：${r.error ?? "unknown"}`);
-      log7?.warn(`[${PLUGIN_NAME11}] /remember failed`, { error: r.error });
+      log8?.warn(`[${PLUGIN_NAME12}] /remember failed`, { error: r.error });
     }
     return { kind: "remembered", result: r, mode: INJECTION_MODE2 };
   }
@@ -15241,22 +15742,22 @@ async function safeReply(ctx, text) {
     await ctx.reply(text);
   } catch {}
 }
-logLifecycle(PLUGIN_NAME11, "import");
+logLifecycle(PLUGIN_NAME12, "import");
 var sharedCache2 = new QueryCache2(DEFAULT_CONFIG6.cacheTtlMs);
 function buildMemCfg(directory) {
   return { projectRoot: directory };
 }
 var memoriesContextServer = async (ctx) => {
-  const log7 = makePluginLogger(PLUGIN_NAME11);
+  const log8 = makePluginLogger(PLUGIN_NAME12);
   const memCfg = buildMemCfg(ctx.directory);
-  logLifecycle(PLUGIN_NAME11, "activate", {
+  logLifecycle(PLUGIN_NAME12, "activate", {
     directory: ctx.directory,
     projectRoot: memCfg.projectRoot,
     mode: INJECTION_MODE2
   });
   return {
     "chat.message": async (input, output) => {
-      await safeAsync(PLUGIN_NAME11, "chat.message", async () => {
+      await safeAsync(PLUGIN_NAME12, "chat.message", async () => {
         const text = extractUserText(output);
         if (!text)
           return;
@@ -15264,36 +15765,36 @@ var memoriesContextServer = async (ctx) => {
           content: text,
           sessionId: input.sessionID,
           injectContext: async (markdown) => {
-            log7.info(`memories context candidate (${markdown.length} chars)`, {
+            log8.info(`memories context candidate (${markdown.length} chars)`, {
               sessionID: input.sessionID,
               mode: INJECTION_MODE2,
               preview: markdown.slice(0, 200)
             });
           },
           reply: async (msg) => {
-            log7.info(`directive reply (observe-only): ${msg}`, {
+            log8.info(`directive reply (observe-only): ${msg}`, {
               sessionID: input.sessionID,
               mode: INJECTION_MODE2
             });
           },
-          log: log7
+          log: log8
         }, { cache: sharedCache2, memCfg });
       });
     }
   };
 };
-var handler11 = memoriesContextServer;
+var handler12 = memoriesContextServer;
 
 // plugins/model-fallback.ts
 init_opencode_plugin_helpers();
-var PLUGIN_NAME12 = "model-fallback";
+var PLUGIN_NAME13 = "model-fallback";
 var state2 = {
   config: null,
   configPath: null,
   warnings: [],
   error: null
 };
-logLifecycle(PLUGIN_NAME12, "import");
+logLifecycle(PLUGIN_NAME13, "import");
 function loadOnce(root) {
   if (state2.config !== null || state2.error !== null)
     return;
@@ -15303,11 +15804,11 @@ function loadOnce(root) {
     state2.configPath = r.path ?? null;
     state2.warnings = r.warnings;
     if (r.warnings.length > 0) {
-      safeWriteLog(PLUGIN_NAME12, { phase: "load.warnings", warnings: r.warnings });
+      safeWriteLog(PLUGIN_NAME13, { phase: "load.warnings", warnings: r.warnings });
     }
   } else {
     state2.error = r.error ?? "unknown_load_error";
-    safeWriteLog(PLUGIN_NAME12, { phase: "load.failed", error: state2.error, path: r.path });
+    safeWriteLog(PLUGIN_NAME13, { phase: "load.failed", error: state2.error, path: r.path });
   }
 }
 var MODEL_ERR_PATTERNS = [
@@ -15352,9 +15853,9 @@ fallback 链已用尽：${meta.chain.join(" → ")}`;
 完整链：${meta.chain.join(" → ")}`;
 }
 var modelFallbackServer = async (ctx) => {
-  const log7 = makePluginLogger(PLUGIN_NAME12);
+  const log8 = makePluginLogger(PLUGIN_NAME13);
   loadOnce(ctx.directory ?? process.cwd());
-  logLifecycle(PLUGIN_NAME12, "activate", {
+  logLifecycle(PLUGIN_NAME13, "activate", {
     directory: ctx.directory,
     config_path: state2.configPath,
     config_loaded: state2.config !== null,
@@ -15364,7 +15865,7 @@ var modelFallbackServer = async (ctx) => {
   });
   return {
     "chat.params": async (input, output) => {
-      await safeAsync(PLUGIN_NAME12, "chat.params", async () => {
+      await safeAsync(PLUGIN_NAME13, "chat.params", async () => {
         if (!state2.config)
           return;
         const agent = input.agent;
@@ -15385,7 +15886,7 @@ var modelFallbackServer = async (ctx) => {
           next: meta.next_fallback,
           source: meta.source
         };
-        safeWriteLog(PLUGIN_NAME12, {
+        safeWriteLog(PLUGIN_NAME13, {
           hook: "chat.params",
           agent,
           model: currentModel,
@@ -15395,7 +15896,7 @@ var modelFallbackServer = async (ctx) => {
       });
     },
     event: async ({ event }) => {
-      await safeAsync(PLUGIN_NAME12, "event", async () => {
+      await safeAsync(PLUGIN_NAME13, "event", async () => {
         if (!state2.config)
           return;
         const e = event;
@@ -15411,8 +15912,8 @@ var modelFallbackServer = async (ctx) => {
         const model = props.model ?? "unknown/unknown";
         const meta = buildFallbackMeta(state2.config, agent, model);
         const suggestion = meta ? buildSuggestion(meta, String(message)) : `⚠️ ${agent}/${model} 失败：${message}`;
-        log7.warn(`[${PLUGIN_NAME12}] ${suggestion}`);
-        safeWriteLog(PLUGIN_NAME12, {
+        log8.warn(`[${PLUGIN_NAME13}] ${suggestion}`);
+        safeWriteLog(PLUGIN_NAME13, {
           hook: "event.error",
           eventType: e.type,
           agent,
@@ -15424,12 +15925,12 @@ var modelFallbackServer = async (ctx) => {
     }
   };
 };
-var handler12 = modelFallbackServer;
+var handler13 = modelFallbackServer;
 
 // plugins/subtask-heartbeat.ts
 init_opencode_plugin_helpers();
-var PLUGIN_NAME13 = "subtask-heartbeat";
-logLifecycle(PLUGIN_NAME13, "import", {});
+var PLUGIN_NAME14 = "subtask-heartbeat";
+logLifecycle(PLUGIN_NAME14, "import", {});
 var HEARTBEAT_INTERVAL_MS2 = 30000;
 var HEARTBEAT_DEBOUNCE_MS = 25000;
 var TOAST_DURATION_MS3 = 5000;
@@ -15663,9 +16164,9 @@ function normalizeVariant3(raw) {
     return "default";
   return raw;
 }
-async function showToast3(client, payload, log7) {
+async function showToast3(client, payload, log8) {
   if (typeof client?.tui?.showToast !== "function") {
-    log7?.debug?.("tui.showToast 不可用，noop");
+    log8?.debug?.("tui.showToast 不可用，noop");
     return false;
   }
   try {
@@ -15679,32 +16180,32 @@ async function showToast3(client, payload, log7) {
     });
     return true;
   } catch (err) {
-    log7?.warn("tui.showToast 抛错（已隔离）", {
+    log8?.warn("tui.showToast 抛错（已隔离）", {
       error: err instanceof Error ? err.message : String(err)
     });
     return false;
   }
 }
-var log7 = makePluginLogger(PLUGIN_NAME13);
+var log8 = makePluginLogger(PLUGIN_NAME14);
 var subtaskHeartbeatServer = async (ctx) => {
-  logLifecycle(PLUGIN_NAME13, "activate", {
+  logLifecycle(PLUGIN_NAME14, "activate", {
     directory: ctx.directory,
     intervalMs: HEARTBEAT_INTERVAL_MS2
   });
   const client = ctx.client;
   const interval = setInterval(() => {
-    safeAsync(PLUGIN_NAME13, "interval", async () => {
+    safeAsync(PLUGIN_NAME14, "interval", async () => {
       const swept = sweepExpiredPendingTasks();
       if (swept > 0) {
-        safeWriteLog(PLUGIN_NAME13, { hook: "interval", pending_task_swept: swept });
+        safeWriteLog(PLUGIN_NAME14, { hook: "interval", pending_task_swept: swept });
       }
       const beats = pickHeartbeats();
       if (beats.length === 0)
         return;
       for (const r of beats) {
         const t = buildHeartbeatToast(r);
-        const sent = await showToast3(client, t, log7);
-        safeWriteLog(PLUGIN_NAME13, {
+        const sent = await showToast3(client, t, log8);
+        safeWriteLog(PLUGIN_NAME14, {
           hook: "interval",
           child: r.childID,
           parent: r.parentID,
@@ -15721,7 +16222,7 @@ var subtaskHeartbeatServer = async (ctx) => {
   }
   return {
     event: async ({ event }) => {
-      await safeAsync(PLUGIN_NAME13, "event", async () => {
+      await safeAsync(PLUGIN_NAME14, "event", async () => {
         const created = extractCreatedChild(event);
         if (created) {
           const pending = dequeuePendingTask(created.parentID);
@@ -15731,7 +16232,7 @@ var subtaskHeartbeatServer = async (ctx) => {
             agent: pending?.agent ?? created.agent,
             description: pending?.description ?? null
           });
-          safeWriteLog(PLUGIN_NAME13, {
+          safeWriteLog(PLUGIN_NAME14, {
             hook: "event",
             type: "session.created",
             child: created.childID,
@@ -15741,8 +16242,8 @@ var subtaskHeartbeatServer = async (ctx) => {
             description_len: record.description?.length ?? 0
           });
           const startToast = buildStartToast(record);
-          const sent = await showToast3(client, { ...startToast, duration: START_TOAST_DURATION_MS }, log7);
-          safeWriteLog(PLUGIN_NAME13, {
+          const sent = await showToast3(client, { ...startToast, duration: START_TOAST_DURATION_MS }, log8);
+          safeWriteLog(PLUGIN_NAME14, {
             hook: "event",
             type: "session.created.toast",
             child: created.childID,
@@ -15756,8 +16257,8 @@ var subtaskHeartbeatServer = async (ctx) => {
           const r = clearInflight2(ended.sessionID);
           if (r) {
             const t = buildEndToast(r, ended.type);
-            const sent = await showToast3(client, t, log7);
-            safeWriteLog(PLUGIN_NAME13, {
+            const sent = await showToast3(client, t, log8);
+            safeWriteLog(PLUGIN_NAME14, {
               hook: "event",
               type: ended.type,
               child: r.childID,
@@ -15773,12 +16274,12 @@ var subtaskHeartbeatServer = async (ctx) => {
       const isTaskTool = input?.tool === "task";
       if (inflight3.size === 0 && !isTaskTool)
         return;
-      await safeAsync(PLUGIN_NAME13, "tool.execute.before", async () => {
+      await safeAsync(PLUGIN_NAME14, "tool.execute.before", async () => {
         if (!input || typeof input.sessionID !== "string" || typeof input.tool !== "string")
           return;
         if (isTaskTool) {
           const args = output?.args ?? null;
-          safeWriteLog(PLUGIN_NAME13, {
+          safeWriteLog(PLUGIN_NAME14, {
             hook: "tool.execute.before.task",
             sessionID: input.sessionID,
             args_keys: args && typeof args === "object" ? Object.keys(args) : null,
@@ -15790,7 +16291,7 @@ var subtaskHeartbeatServer = async (ctx) => {
               agent: extracted.subagentType,
               description: extracted.description
             });
-            safeWriteLog(PLUGIN_NAME13, {
+            safeWriteLog(PLUGIN_NAME14, {
               hook: "tool.execute.before.task.enqueued",
               parent: input.sessionID,
               agent: extracted.subagentType,
@@ -15805,12 +16306,12 @@ var subtaskHeartbeatServer = async (ctx) => {
     }
   };
 };
-var handler13 = subtaskHeartbeatServer;
+var handler14 = subtaskHeartbeatServer;
 
 // plugins/parallel-status.ts
 init_opencode_plugin_helpers();
-var PLUGIN_NAME14 = "parallel-status";
-logLifecycle(PLUGIN_NAME14, "import");
+var PLUGIN_NAME15 = "parallel-status";
+logLifecycle(PLUGIN_NAME15, "import");
 var ID_MAX_LEN = 16;
 var ID_KEEP_LEN = 13;
 function shortId(s) {
@@ -15842,8 +16343,8 @@ function formatInflightMarkdown(snapshot, now = Date.now()) {
 `);
 }
 var parallelStatusServer = async (ctx) => {
-  const log8 = makePluginLogger(PLUGIN_NAME14);
-  logLifecycle(PLUGIN_NAME14, "activate", { directory: ctx.directory });
+  const log9 = makePluginLogger(PLUGIN_NAME15);
+  logLifecycle(PLUGIN_NAME15, "activate", { directory: ctx.directory });
   return {
     "command.execute.before": async (input, output) => {
       try {
@@ -15862,72 +16363,24 @@ var parallelStatusServer = async (ctx) => {
             synthetic: false
           });
         }
-        log8.info(`[${PLUGIN_NAME14}] 已回写 ${snapshot.length} 条 inflight`);
+        log9.info(`[${PLUGIN_NAME15}] 已回写 ${snapshot.length} 条 inflight`);
       } catch (err) {
-        log8.error(`[${PLUGIN_NAME14}] command.execute.before 异常（已隔离）`, {
+        log9.error(`[${PLUGIN_NAME15}] command.execute.before 异常（已隔离）`, {
           error: err instanceof Error ? err.message : String(err)
         });
       }
     }
   };
 };
-var handler14 = parallelStatusServer;
+var handler15 = parallelStatusServer;
 
 // plugins/parallel-tool-nudge.ts
-import { readFileSync as readFileSync4, readdirSync, statSync as statSync3 } from "node:fs";
-import { join as join12 } from "node:path";
+import { readFileSync as readFileSync5, readdirSync as readdirSync2, statSync as statSync4 } from "node:fs";
+import { join as join13 } 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 = "parallel-tool-nudge";
-logLifecycle(PLUGIN_NAME15, "import", {});
+var PLUGIN_NAME16 = "parallel-tool-nudge";
+logLifecycle(PLUGIN_NAME16, "import", {});
 var PARALLEL_SAFE_TOOLS = [
   "read",
   "smart_search",
@@ -15937,17 +16390,17 @@ var PARALLEL_SAFE_TOOLS = [
   "get_working_memory"
 ];
 var DEFAULT_AGENT_KEY = "__default__";
-var NUDGE_MAX_LEN = 800;
+var NUDGE_MAX_LEN2 = 800;
 var agentToolsMap = new Map;
-function defaultReader(p) {
-  return readFileSync4(p, "utf8");
+function defaultReader2(p) {
+  return readFileSync5(p, "utf8");
 }
-function defaultDirReader(p) {
-  return readdirSync(p);
+function defaultDirReader2(p) {
+  return readdirSync2(p);
 }
-function defaultDirExists(p) {
+function defaultDirExists2(p) {
   try {
-    return statSync3(p).isDirectory();
+    return statSync4(p).isDirectory();
   } catch {
     return false;
   }
@@ -15977,19 +16430,19 @@ function parseAgentFrontmatter(content) {
   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 reader = opts.reader ?? defaultReader2;
+  const dirReader = opts.dirReader ?? defaultDirReader2;
+  const dirExists = opts.dirExists ?? defaultDirExists2;
+  const homeAgentsDir = opts.homeAgentsDir ?? join13(homedir6(), ".config", "opencode", "agents");
   const candidateDirs = [
-    join12(rootDir, ".codeforge", "agents"),
-    join12(rootDir, "agents"),
+    join13(rootDir, ".codeforge", "agents"),
+    join13(rootDir, "agents"),
     homeAgentsDir
   ];
   const result = new Map;
   const safeSet = new Set(PARALLEL_SAFE_TOOLS);
   const unionTools = new Set;
-  const log8 = makePluginLogger(PLUGIN_NAME15);
+  const log9 = makePluginLogger(PLUGIN_NAME16);
   for (const dir of candidateDirs) {
     if (!dirExists(dir))
       continue;
@@ -15997,7 +16450,7 @@ function loadAgentToolsMap(rootDir, opts = {}) {
     try {
       entries = dirReader(dir);
     } catch (err) {
-      log8.warn(`agents 目录读取失败（已跳过）`, {
+      log9.warn(`agents 目录读取失败（已跳过）`, {
         dir,
         error: err instanceof Error ? err.message : String(err)
       });
@@ -16006,12 +16459,12 @@ function loadAgentToolsMap(rootDir, opts = {}) {
     for (const entry of entries) {
       if (!entry.endsWith(".md"))
         continue;
-      const path13 = join12(dir, entry);
+      const path13 = join13(dir, entry);
       let content;
       try {
         content = reader(path13);
       } catch (err) {
-        log8.warn(`agent.md 读取失败（已跳过）`, {
+        log9.warn(`agent.md 读取失败（已跳过）`, {
           path: path13,
           error: err instanceof Error ? err.message : String(err)
         });
@@ -16019,7 +16472,7 @@ function loadAgentToolsMap(rootDir, opts = {}) {
       }
       const parsed = parseAgentFrontmatter(content);
       if (!parsed) {
-        log8.warn(`agent frontmatter 解析失败（已跳过）`, { path: path13 });
+        log9.warn(`agent frontmatter 解析失败（已跳过）`, { path: path13 });
         continue;
       }
       if (result.has(parsed.name))
@@ -16040,18 +16493,18 @@ function loadAgentToolsMap(rootDir, opts = {}) {
   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) {
+var SESSION_CAP2 = 200;
+var SESSION_TTL_MS2 = 24 * 60 * 60 * 1000;
+function pruneIfOversize2() {
+  while (sessionAgentMap.size > SESSION_CAP2) {
     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 isExpired2(entry, now) {
+  return now - entry.ts > SESSION_TTL_MS2;
 }
 function resolveAgent(sessionID, nowFn = Date.now) {
   if (!sessionID)
@@ -16060,7 +16513,7 @@ function resolveAgent(sessionID, nowFn = Date.now) {
   if (!entry)
     return "unknown";
   const now = nowFn();
-  if (isExpired(entry, now)) {
+  if (isExpired2(entry, now)) {
     sessionAgentMap.delete(sessionID);
     return "unknown";
   }
@@ -16092,12 +16545,12 @@ Heuristics:
 
 This directive is re-injected every turn — it is not optional advice.
 ────────────────────────────────────────`;
-  if (body.length <= NUDGE_MAX_LEN)
+  if (body.length <= NUDGE_MAX_LEN2)
     return body;
-  return body.slice(0, NUDGE_MAX_LEN - 4) + `
+  return body.slice(0, NUDGE_MAX_LEN2 - 4) + `
 …`;
 }
-var log8 = makePluginLogger(PLUGIN_NAME15);
+var log9 = makePluginLogger(PLUGIN_NAME16);
 var parallelToolNudgeServer = async (ctx) => {
   try {
     const loaded = loadAgentToolsMap(ctx.directory ?? process.cwd());
@@ -16105,30 +16558,30 @@ var parallelToolNudgeServer = async (ctx) => {
     for (const [k, v] of loaded.entries())
       agentToolsMap.set(k, v);
   } catch (err) {
-    log8.warn(`loadAgentToolsMap 失败（plugin 将 no-op）`, {
+    log9.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`, {
+    log9.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", {
+  logLifecycle(PLUGIN_NAME16, "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,
+    session_cap: SESSION_CAP2,
+    session_ttl_ms: SESSION_TTL_MS2,
     no_op: agentToolsMap.size === 0
   });
   return {
     "chat.params": async (input, _output) => {
-      await safeAsync(PLUGIN_NAME15, "chat.params", async () => {
+      await safeAsync(PLUGIN_NAME16, "chat.params", async () => {
         if (agentToolsMap.size === 0)
           return;
         const sid = input?.sessionID;
@@ -16136,11 +16589,11 @@ var parallelToolNudgeServer = async (ctx) => {
         if (!sid || !agent)
           return;
         sessionAgentMap.set(sid, { agent, ts: Date.now() });
-        pruneIfOversize();
+        pruneIfOversize2();
       });
     },
     "experimental.chat.system.transform": async (input, output) => {
-      await safeAsync(PLUGIN_NAME15, "experimental.chat.system.transform", async () => {
+      await safeAsync(PLUGIN_NAME16, "experimental.chat.system.transform", async () => {
         if (agentToolsMap.size === 0)
           return;
         if (!output || !Array.isArray(output.system))
@@ -16150,7 +16603,7 @@ var parallelToolNudgeServer = async (ctx) => {
         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, {
+        safeWriteLog(PLUGIN_NAME16, {
           hook: "experimental.chat.system.transform",
           sessionID: sid,
           agent,
@@ -16162,12 +16615,12 @@ var parallelToolNudgeServer = async (ctx) => {
     }
   };
 };
-var handler15 = parallelToolNudgeServer;
+var handler16 = parallelToolNudgeServer;
 
 // plugins/pwsh-utf8.ts
 init_opencode_plugin_helpers();
-var PLUGIN_NAME16 = "pwsh-utf8";
-logLifecycle(PLUGIN_NAME16, "import", {});
+var PLUGIN_NAME17 = "pwsh-utf8";
+logLifecycle(PLUGIN_NAME17, "import", {});
 var PRELUDE = "chcp 65001 *> $null; " + "[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new(); " + "$OutputEncoding = [System.Text.UTF8Encoding]::new(); ";
 function prependUtf8Prelude(command) {
   if (typeof command !== "string")
@@ -16180,15 +16633,15 @@ function prependUtf8Prelude(command) {
     return command;
   return PRELUDE + command;
 }
-var handler16 = async (_ctx) => {
+var handler17 = 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_NAME16, "activate", { enabled, platform: process.platform, reason });
+  logLifecycle(PLUGIN_NAME17, "activate", { enabled, platform: process.platform, reason });
   if (!enabled)
     return {};
   return {
     "tool.execute.before": async (input, output) => {
-      await safeAsync(PLUGIN_NAME16, "tool.execute.before", async () => {
+      await safeAsync(PLUGIN_NAME17, "tool.execute.before", async () => {
         if (input.tool !== "bash")
           return;
         const args = output.args ?? {};
@@ -16197,7 +16650,7 @@ var handler16 = async (_ctx) => {
         if (next !== undefined && next !== original) {
           args["command"] = next;
           output.args = args;
-          safeWriteLog(PLUGIN_NAME16, {
+          safeWriteLog(PLUGIN_NAME17, {
             hook: "tool.execute.before",
             tool: input.tool,
             callID: input.callID,
@@ -16530,8 +16983,8 @@ function isRecoveryWorthShowing(plan) {
 }
 
 // plugins/session-recovery.ts
-var PLUGIN_NAME17 = "session-recovery";
-logLifecycle(PLUGIN_NAME17, "import", {});
+var PLUGIN_NAME18 = "session-recovery";
+logLifecycle(PLUGIN_NAME18, "import", {});
 async function processSessionStart(currentSessionId, opts = {}) {
   if (opts.disabled) {
     return { ok: true, injected: false, reason: "disabled" };
@@ -16541,7 +16994,7 @@ async function processSessionStart(currentSessionId, opts = {}) {
     excludeIds.add(currentSessionId);
   const r = await scanLastSession({ ...opts, excludeIds: [...excludeIds] });
   if (!r.ok) {
-    opts.log?.warn?.(`[${PLUGIN_NAME17}] 扫描失败：${r.error}`);
+    opts.log?.warn?.(`[${PLUGIN_NAME18}] 扫描失败：${r.error}`);
     return { ok: false, injected: false, reason: "scan_error", error: r.error };
   }
   const plan = r.plan;
@@ -16555,7 +17008,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_NAME17}] injectRecovery 异常：${msg}`);
+      opts.log?.warn?.(`[${PLUGIN_NAME18}] injectRecovery 异常：${msg}`);
       return { ok: false, injected: false, plan, reason: "inject_error", error: msg };
     }
   }
@@ -16584,13 +17037,13 @@ function renderPrompt(plan) {
   return lines.join(`
 `);
 }
-var log9 = makePluginLogger(PLUGIN_NAME17);
+var log10 = makePluginLogger(PLUGIN_NAME18);
 var _lastInjection = null;
 var sessionRecoveryServer = async (ctx) => {
-  logLifecycle(PLUGIN_NAME17, "activate", { directory: ctx.directory });
+  logLifecycle(PLUGIN_NAME18, "activate", { directory: ctx.directory });
   return {
     event: async ({ event }) => {
-      await safeAsync(PLUGIN_NAME17, "event", async () => {
+      await safeAsync(PLUGIN_NAME18, "event", async () => {
         const e = event;
         if (!e || typeof e.type !== "string")
           return;
@@ -16600,12 +17053,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: log9,
+          log: log10,
           injectRecovery: (inj) => {
             _lastInjection = inj;
           }
         });
-        safeWriteLog(PLUGIN_NAME17, {
+        safeWriteLog(PLUGIN_NAME18, {
           hook: "event",
           type: "session.start",
           ok: r.ok,
@@ -16614,13 +17067,13 @@ var sessionRecoveryServer = async (ctx) => {
           last_session_id: r.plan?.last_session_id
         });
         if (r.injected && r.plan) {
-          log9.info(`[${PLUGIN_NAME17}] 注入恢复提示（last=${r.plan.last_session_id?.slice(0, 8) ?? "?"}, reason=${r.plan.reason}）`);
+          log10.info(`[${PLUGIN_NAME18}] 注入恢复提示（last=${r.plan.last_session_id?.slice(0, 8) ?? "?"}, reason=${r.plan.reason}）`);
         }
       });
     }
   };
 };
-var handler17 = sessionRecoveryServer;
+var handler18 = sessionRecoveryServer;
 
 // plugins/subtasks.ts
 import { promises as fs12 } from "node:fs";
@@ -16906,7 +17359,7 @@ function resolveMergeFns(deps) {
     worktreeHasChangesFn: deps.worktreeHasChanges ?? worktreeHasChanges
   };
 }
-async function mergeOneAttempt(r, opts, mergeFns, log10) {
+async function mergeOneAttempt(r, opts, mergeFns, log11) {
   const t0 = Date.now();
   const root = opts.mergeRoot;
   const {
@@ -16988,7 +17441,7 @@ async function mergeOneAttempt(r, opts, mergeFns, log10) {
           await mergeAbortFn({ root });
         } catch (abortErr) {
           abortFailed = true;
-          log10("error", `[parallel-merge] mergeAbort 失败（仓库可能锁死）`, {
+          log11("error", `[parallel-merge] mergeAbort 失败（仓库可能锁死）`, {
             id: r.id,
             error: describe4(abortErr)
           });
@@ -17004,13 +17457,13 @@ async function mergeOneAttempt(r, opts, mergeFns, log10) {
       }
       attempt.ok = true;
       attempt.durationMs = Date.now() - t0;
-      await safeRemoveWorktree(removeWorktreeFn, root, wt, log10, r.id);
+      await safeRemoveWorktree(removeWorktreeFn, root, wt, log11, 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);
+      await safeRemoveWorktree(removeWorktreeFn, root, wt, log11, r.id);
       return { attempt };
     }
   } catch (err) {
@@ -17024,7 +17477,7 @@ async function mergeOneAttempt(r, opts, mergeFns, log10) {
   }
 }
 async function mergeWorktrees(results, opts, deps) {
-  const log10 = deps.log ?? (() => {});
+  const log11 = deps.log ?? (() => {});
   const root = opts.mergeRoot;
   const mergeFns = resolveMergeFns(deps);
   const report = {
@@ -17066,10 +17519,10 @@ async function mergeWorktrees(results, opts, deps) {
     };
     report.attempts.push(attempt);
     report.skipped++;
-    await fireMergeAttempt(opts.onMergeAttempt, attempt, idx++, log10);
+    await fireMergeAttempt(opts.onMergeAttempt, attempt, idx++, log11);
   }
   for (const r of mergeable) {
-    const { attempt, pendingItem } = await mergeOneAttempt(r, { mergeRoot: root }, mergeFns, log10);
+    const { attempt, pendingItem } = await mergeOneAttempt(r, { mergeRoot: root }, mergeFns, log11);
     report.attempts.push(attempt);
     if (attempt.ok && !attempt.skippedReason)
       report.merged++;
@@ -17079,12 +17532,12 @@ async function mergeWorktrees(results, opts, deps) {
       report.conflicted++;
     if (pendingItem)
       report.pendingWorktrees.push(pendingItem);
-    await fireMergeAttempt(opts.onMergeAttempt, attempt, idx++, log10);
+    await fireMergeAttempt(opts.onMergeAttempt, attempt, idx++, log11);
   }
   return report;
 }
 function createMergeQueue(opts, deps = {}) {
-  const log10 = deps.log ?? (() => {});
+  const log11 = deps.log ?? (() => {});
   const mergeFns = {
     commitWorktreeIfDirtyFn: deps.commitWorktreeIfDirtyFn ?? commitWorktreeIfDirty,
     tryMergeFn: deps.tryMergeFn ?? tryMerge,
@@ -17125,10 +17578,10 @@ function createMergeQueue(opts, deps = {}) {
               conflicts: []
             });
           }
-          await fireMergeAttempt(opts.onMergeAttempt, attempt2, idx++, log10);
+          await fireMergeAttempt(opts.onMergeAttempt, attempt2, idx++, log11);
           return;
         }
-        const { attempt, abortFailed, pendingItem } = await mergeOneAttempt(result, { mergeRoot: opts.mergeRoot, summaryCharLimit: opts.summaryCharLimit }, mergeFns, log10);
+        const { attempt, abortFailed, pendingItem } = await mergeOneAttempt(result, { mergeRoot: opts.mergeRoot, summaryCharLimit: opts.summaryCharLimit }, mergeFns, log11);
         report.attempts.push(attempt);
         if (attempt.ok && !attempt.skippedReason)
           report.merged++;
@@ -17140,11 +17593,11 @@ function createMergeQueue(opts, deps = {}) {
           report.pendingWorktrees.push(pendingItem);
         if (abortFailed) {
           queueAborted = true;
-          log10("error", `[parallel-merge] queue aborted (mergeAbort failed)`, {
+          log11("error", `[parallel-merge] queue aborted (mergeAbort failed)`, {
             id: result.id
           });
         }
-        await fireMergeAttempt(opts.onMergeAttempt, attempt, idx++, log10);
+        await fireMergeAttempt(opts.onMergeAttempt, attempt, idx++, log11);
       });
     },
     async flushAndReport() {
@@ -17153,23 +17606,23 @@ function createMergeQueue(opts, deps = {}) {
     }
   };
 }
-async function safeRemoveWorktree(fn, root, wt, log10, subtaskId) {
+async function safeRemoveWorktree(fn, root, wt, log11, subtaskId) {
   try {
     await fn({ root, worktree_path: wt, force: true });
   } catch (err) {
-    log10("warn", `[parallel] removeWorktree 失败 ${subtaskId}`, {
+    log11("warn", `[parallel] removeWorktree 失败 ${subtaskId}`, {
       error: describe4(err),
       worktree: wt
     });
   }
 }
-async function fireMergeAttempt(cb, attempt, idx, log10) {
+async function fireMergeAttempt(cb, attempt, idx, log11) {
   if (!cb)
     return;
   try {
     await cb(attempt, idx);
   } catch (err) {
-    log10("warn", `[parallel] onMergeAttempt 抛错（已隔离）`, {
+    log11("warn", `[parallel] onMergeAttempt 抛错（已隔离）`, {
       id: attempt.subtaskId,
       error: describe4(err)
     });
@@ -17195,7 +17648,7 @@ async function schedule(opts) {
   }
   const now = opts.deps.now ?? Date.now;
   const start = now();
-  const log10 = opts.deps.log ?? (() => {});
+  const log11 = 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);
@@ -17228,7 +17681,7 @@ async function schedule(opts) {
       mergeAbortFn: opts.deps.mergeAbort,
       removeWorktreeFn: opts.deps.removeWorktree,
       worktreeHasChangesFn: opts.deps.worktreeHasChanges,
-      log: log10
+      log: log11
     });
   }
   const fireFinish = async (i, res) => {
@@ -17236,7 +17689,7 @@ async function schedule(opts) {
       try {
         queue.enqueue(res);
       } catch (err) {
-        log10("warn", `[parallel] queue.enqueue 抛错（已隔离）`, {
+        log11("warn", `[parallel] queue.enqueue 抛错（已隔离）`, {
           id: res.id,
           error: describe5(err)
         });
@@ -17247,7 +17700,7 @@ async function schedule(opts) {
     try {
       await opts.onSubtaskFinish(res, i);
     } catch (err) {
-      log10("warn", `[parallel] onSubtaskFinish 抛错（已隔离）`, {
+      log11("warn", `[parallel] onSubtaskFinish 抛错（已隔离）`, {
         id: res.id,
         error: describe5(err)
       });
@@ -17277,7 +17730,7 @@ async function schedule(opts) {
       try {
         await opts.onSubtaskStart(spec, i);
       } catch (err) {
-        log10("warn", `[parallel] onSubtaskStart 抛错（已隔离）`, {
+        log11("warn", `[parallel] onSubtaskStart 抛错（已隔离）`, {
           id: spec.id,
           error: describe5(err)
         });
@@ -17328,7 +17781,7 @@ async function schedule(opts) {
         try {
           await alloc.cleanup();
         } catch (err) {
-          log10("warn", `[parallel] worktree 清理失败 ${spec.id}`, {
+          log11("warn", `[parallel] worktree 清理失败 ${spec.id}`, {
             error: describe5(err)
           });
         }
@@ -17488,7 +17941,7 @@ function pickStatus(r, taskAborted, globalAborted) {
 // lib/opencode-runner.ts
 init_opencode_plugin_helpers();
 function makeOpencodeRunner(opts) {
-  const log10 = opts.log ?? (() => {});
+  const log11 = opts.log ?? (() => {});
   return async (spec, runCtx) => {
     const startedAt = Date.now();
     let childSessionId;
@@ -17509,7 +17962,7 @@ function makeOpencodeRunner(opts) {
         };
       }
       childSessionId = created.data.id;
-      log10("info", `[opencode-runner] subtask=${spec.id} session=${childSessionId} created`);
+      log11("info", `[opencode-runner] subtask=${spec.id} session=${childSessionId} created`);
       const promptText = composePromptText(spec);
       const promptPromise = opts.client.session.prompt({
         path: { id: childSessionId },
@@ -17562,7 +18015,7 @@ function makeOpencodeRunner(opts) {
         });
         changedFiles = pickDiffFiles(diff.data);
       } catch (err) {
-        log10("warn", `[opencode-runner] diff 取失败 ${spec.id}`, { error: describe6(err) });
+        log11("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"}）`;
@@ -17588,7 +18041,7 @@ function makeOpencodeRunner(opts) {
             query: opts.directory ? { directory: opts.directory } : undefined
           });
         } catch (err) {
-          log10("warn", `[opencode-runner] session.delete 失败 ${childSessionId}`, {
+          log11("warn", `[opencode-runner] session.delete 失败 ${childSessionId}`, {
             error: describe6(err)
           });
         }
@@ -17702,14 +18155,14 @@ function clip4(s, max) {
   return s.length <= max ? s : s.slice(0, max - 1) + "…";
 }
 async function sendParentNotice(client, sessionID, text, opts = {}) {
-  const log10 = opts.log ?? (() => {});
+  const log11 = opts.log ?? (() => {});
   if (!client?.session) {
-    log10("warn", "[sendParentNotice] client.session 不可用，noop");
+    log11("warn", "[sendParentNotice] client.session 不可用，noop");
     return false;
   }
   const sessionAny = client.session;
   if (typeof sessionAny.promptAsync !== "function") {
-    log10("warn", "[sendParentNotice] promptAsync 不可用（SDK 太老？），noop");
+    log11("warn", "[sendParentNotice] promptAsync 不可用（SDK 太老？），noop");
     return false;
   }
   try {
@@ -17730,12 +18183,12 @@ async function sendParentNotice(client, sessionID, text, opts = {}) {
       }
     });
     if (res && typeof res === "object" && "error" in res && res.error) {
-      log10("warn", "[sendParentNotice] promptAsync 返回 error", { error: res.error });
+      log11("warn", "[sendParentNotice] promptAsync 返回 error", { error: res.error });
       return false;
     }
     return true;
   } catch (err) {
-    log10("warn", "[sendParentNotice] 抛错（已隔离）", {
+    log11("warn", "[sendParentNotice] 抛错（已隔离）", {
       error: err instanceof Error ? err.message : String(err)
     });
     return false;
@@ -17765,9 +18218,9 @@ function buildSystemPrompt(maxSubtasks) {
 `);
 }
 async function decomposeTask(description26, opts) {
-  const log10 = opts.log ?? (() => {});
+  const log11 = opts.log ?? (() => {});
   if (opts.mockResponse) {
-    return validateAndFinalize(opts.mockResponse, undefined, log10, opts.maxSubtasks ?? DEFAULT_MAX_SUBTASKS);
+    return validateAndFinalize(opts.mockResponse, undefined, log11, opts.maxSubtasks ?? DEFAULT_MAX_SUBTASKS);
   }
   const maxSubtasks = opts.maxSubtasks ?? DEFAULT_MAX_SUBTASKS;
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
@@ -17778,7 +18231,7 @@ async function decomposeTask(description26, opts) {
       query: opts.directory ? { directory: opts.directory } : undefined
     });
     if (created.error || !created.data?.id) {
-      log10("warn", "[decompose] session.create 失败", { error: describe7(created.error) });
+      log11("warn", "[decompose] session.create 失败", { error: describe7(created.error) });
       return {
         ok: false,
         subtasks: [],
@@ -17800,22 +18253,22 @@ async function decomposeTask(description26, opts) {
       sleep(timeoutMs).then(() => ({ kind: "timeout" }))
     ]);
     if (raced.kind === "timeout") {
-      log10("warn", "[decompose] LLM 调用超时", { timeoutMs });
+      log11("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) });
+      log11("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 输出为空");
+      log11("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) });
+      log11("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) {
@@ -17823,7 +18276,7 @@ async function decomposeTask(description26, opts) {
     }
     const subtasksRaw = parsed.subtasks;
     if (!Array.isArray(subtasksRaw)) {
-      log10("warn", "[decompose] JSON 缺 subtasks 数组");
+      log11("warn", "[decompose] JSON 缺 subtasks 数组");
       return { ok: false, subtasks: [], reason: "parse_failed", raw: rawText };
     }
     const normalized = [];
@@ -17839,12 +18292,12 @@ async function decomposeTask(description26, opts) {
       normalized.push({ description: desc, hintFiles });
     }
     if (normalized.length > maxSubtasks) {
-      log10("warn", "[decompose] LLM 返回子任务超过上限", { count: normalized.length, maxSubtasks });
+      log11("warn", "[decompose] LLM 返回子任务超过上限", { count: normalized.length, maxSubtasks });
       return { ok: false, subtasks: [], reason: "parse_failed", raw: rawText };
     }
-    return validateAndFinalize(normalized, rawText, log10, maxSubtasks);
+    return validateAndFinalize(normalized, rawText, log11, maxSubtasks);
   } catch (err) {
-    log10("warn", "[decompose] 抛错", { error: describe7(err) });
+    log11("warn", "[decompose] 抛错", { error: describe7(err) });
     return { ok: false, subtasks: [], reason: "llm_unavailable" };
   } finally {
     if (childSessionId) {
@@ -17854,12 +18307,12 @@ async function decomposeTask(description26, opts) {
           query: opts.directory ? { directory: opts.directory } : undefined
         });
       } catch (err) {
-        log10("warn", "[decompose] session.delete 失败", { error: describe7(err) });
+        log11("warn", "[decompose] session.delete 失败", { error: describe7(err) });
       }
     }
   }
 }
-function validateAndFinalize(subtasks, raw, log10, maxSubtasks) {
+function validateAndFinalize(subtasks, raw, log11, maxSubtasks) {
   if (subtasks.length < 2) {
     return { ok: false, subtasks: [], reason: "single_task", raw };
   }
@@ -17869,7 +18322,7 @@ function validateAndFinalize(subtasks, raw, log10, maxSubtasks) {
     }
   }
   if (subtasks.length > maxSubtasks) {
-    log10("warn", "[decompose] LLM 返回子任务超过上限", { count: subtasks.length, maxSubtasks });
+    log11("warn", "[decompose] LLM 返回子任务超过上限", { count: subtasks.length, maxSubtasks });
     return { ok: false, subtasks: [], reason: "parse_failed", raw };
   }
   for (let i = 0;i < subtasks.length; i++) {
@@ -17883,7 +18336,7 @@ function validateAndFinalize(subtasks, raw, log10, maxSubtasks) {
         continue;
       for (const f of b) {
         if (setA.has(f.trim())) {
-          log10("info", "[decompose] hintFiles 有交集，降级 single_task", {
+          log11("info", "[decompose] hintFiles 有交集，降级 single_task", {
             a: subtasks[i].description,
             b: subtasks[j].description,
             file: f
@@ -17972,7 +18425,7 @@ function sleep(ms) {
 
 // plugins/subtasks.ts
 init_runtime_paths();
-var PLUGIN_NAME18 = "subtasks";
+var PLUGIN_NAME19 = "subtasks";
 function getLogFile(root = process.cwd()) {
   return path15.join(runtimeDir(root), "logs", "subtasks.log");
 }
@@ -18038,7 +18491,7 @@ var mockRunner = async (spec) => {
 };
 async function handleParallelCommand(raw) {
   const ctx = raw ?? {};
-  const log10 = ctx.log;
+  const log11 = 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() : "";
@@ -18052,7 +18505,7 @@ async function handleParallelCommand(raw) {
     specs = splitDescriptions(args.description, { parentId });
   }
   if (specs.length === 0) {
-    log10?.warn(`[${PLUGIN_NAME18}] /parallel 缺有效子任务`);
+    log11?.warn(`[${PLUGIN_NAME19}] /parallel 缺有效子任务`);
     await safeReply2(ctx, "⚠ /parallel 需要至少 1 个子任务（用 ; 或换行分隔）");
     return { ok: false, reason: "no_subtasks" };
   }
@@ -18078,7 +18531,7 @@ async function handleParallelCommand(raw) {
     if (!gitOk) {
       autoMerge = false;
       downgradedAutoMerge = true;
-      log10?.warn("[subtasks] mergeRoot 非 git 仓库，降级 autoMerge=false");
+      log11?.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 });
@@ -18087,17 +18540,17 @@ async function handleParallelCommand(raw) {
   }
   const canNotice = Boolean(ctx.client && ctx.parentSessionID);
   if (specs.length === 1 && rawDescription.length >= 30 && ctx.client) {
-    log10?.info(`[${PLUGIN_NAME18}] 触发 AI 拆分（描述长度=${rawDescription.length}）`);
+    log11?.info(`[${PLUGIN_NAME19}] 触发 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);
+          log11?.error(msg, data);
         else if (lvl === "warn")
-          log10?.warn(msg, data);
+          log11?.warn(msg, data);
         else
-          log10?.info(msg, data);
+          log11?.info(msg, data);
       },
       mockResponse: ctx.decomposeMockResponse
     });
@@ -18108,7 +18561,7 @@ async function handleParallelCommand(raw) {
         timeout_ms: undefined,
         args: d.hintFiles && d.hintFiles.length > 0 ? { hintFiles: d.hintFiles } : undefined
       }));
-      log10?.info(`[${PLUGIN_NAME18}] AI 拆分成功 → ${specs.length} 个子任务`);
+      log11?.info(`[${PLUGIN_NAME19}] AI 拆分成功 → ${specs.length} 个子任务`);
       if (canNotice) {
         const lines = [
           `\uD83E\uDD16 AI 已自动拆为 ${specs.length} 个并行子任务：`,
@@ -18120,7 +18573,7 @@ async function handleParallelCommand(raw) {
         });
       }
     } else if (dec.reason === "llm_unavailable" || dec.reason === "parse_failed") {
-      log10?.warn(`[${PLUGIN_NAME18}] AI 拆分失败（${dec.reason}），按单任务执行`);
+      log11?.warn(`[${PLUGIN_NAME19}] AI 拆分失败（${dec.reason}），按单任务执行`);
     }
   }
   if (canNotice) {
@@ -18135,11 +18588,11 @@ async function handleParallelCommand(raw) {
       directory: ctx.directory,
       log: (lvl, msg, data) => {
         if (lvl === "error")
-          log10?.error(msg, data);
+          log11?.error(msg, data);
         else if (lvl === "warn")
-          log10?.warn(msg, data);
+          log11?.warn(msg, data);
         else
-          log10?.info(msg, data);
+          log11?.info(msg, data);
       }
     });
   }
@@ -18183,11 +18636,11 @@ async function handleParallelCommand(raw) {
         allocateWorktree: downgradedAutoMerge ? undefined : ctx.allocateWorktree,
         log: (lvl, msg, data) => {
           if (lvl === "error")
-            log10?.error(msg, data);
+            log11?.error(msg, data);
           else if (lvl === "warn")
-            log10?.warn(msg, data);
+            log11?.warn(msg, data);
           else
-            log10?.info(msg, data);
+            log11?.info(msg, data);
         },
         tryMerge: ctx.tryMerge,
         mergeCommit: ctx.mergeCommit,
@@ -18199,7 +18652,7 @@ async function handleParallelCommand(raw) {
     });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    log10?.error(`[${PLUGIN_NAME18}] schedule 抛错`, { error: msg });
+    log11?.error(`[${PLUGIN_NAME19}] schedule 抛错`, { error: msg });
     await safeReply2(ctx, `❌ 并发调度失败：${msg}`);
     return { ok: false, reason: msg };
   }
@@ -18217,7 +18670,7 @@ async function handleParallelCommand(raw) {
   }
   await safeReply2(ctx, summaryLines.join(`
 `));
-  log10?.info(`[${PLUGIN_NAME18}] schedule 完成`, {
+  log11?.info(`[${PLUGIN_NAME19}] schedule 完成`, {
     parentId,
     success: result.digest.success,
     failed: result.digest.failed,
@@ -18230,7 +18683,7 @@ async function handleParallelCommand(raw) {
     try {
       await ctx.onCompleted(result);
     } catch (err) {
-      log10?.warn(`[${PLUGIN_NAME18}] onCompleted hook 抛错（已隔离）`, {
+      log11?.warn(`[${PLUGIN_NAME19}] onCompleted hook 抛错（已隔离）`, {
         error: err instanceof Error ? err.message : String(err)
       });
     }
@@ -18272,7 +18725,7 @@ async function writeLog(level, msg, data) {
   const line = JSON.stringify({
     ts: new Date().toISOString(),
     level,
-    plugin: PLUGIN_NAME18,
+    plugin: PLUGIN_NAME19,
     msg,
     data
   }) + `
@@ -18283,11 +18736,11 @@ async function writeLog(level, msg, data) {
     await fs12.appendFile(logFile, line, "utf8");
   } catch {}
 }
-logLifecycle(PLUGIN_NAME18, "import");
+logLifecycle(PLUGIN_NAME19, "import");
 var subtasksServer = async (ctx) => {
-  const log10 = makePluginLogger(PLUGIN_NAME18);
+  const log11 = makePluginLogger(PLUGIN_NAME19);
   const client = ctx?.client ?? undefined;
-  logLifecycle(PLUGIN_NAME18, "activate", {
+  logLifecycle(PLUGIN_NAME19, "activate", {
     directory: ctx.directory,
     hasClient: Boolean(client)
   });
@@ -18312,7 +18765,7 @@ var subtasksServer = async (ctx) => {
           const gitOk = await isGitRepo({ root: repoRoot }).catch(() => false);
           if (!gitOk) {
             autoMerge = false;
-            log10?.warn("[subtasks] worktree_isolation=true 但非 git 仓库，自动降级 autoMerge=false");
+            log11?.warn("[subtasks] worktree_isolation=true 但非 git 仓库，自动降级 autoMerge=false");
             const canNotice = Boolean(client);
             if (canNotice) {
               await sendParentNotice(client, input.sessionID, "ℹ 当前目录不是 git 仓库，worktree 隔离已自动关闭，以单目录模式运行", { directory: ctx.directory });
@@ -18341,7 +18794,7 @@ var subtasksServer = async (ctx) => {
             replyLines.push(s);
             return Promise.resolve();
           },
-          log: log10,
+          log: log11,
           client,
           parentSessionID: input.sessionID,
           directory: ctx.directory,
@@ -18354,11 +18807,11 @@ var subtasksServer = async (ctx) => {
             perTaskTimeoutMs: 5 * 60000,
             log: (lvl, msg, data) => {
               if (lvl === "error")
-                log10.error(msg, data);
+                log11.error(msg, data);
               else if (lvl === "warn")
-                log10.warn(msg, data);
+                log11.warn(msg, data);
               else
-                log10.info(msg, data);
+                log11.info(msg, data);
             }
           }) : undefined
         };
@@ -18384,20 +18837,20 @@ var subtasksServer = async (ctx) => {
           });
         }
       } catch (err) {
-        log10.error(`[${PLUGIN_NAME18}] command.execute.before 异常（已隔离）`, {
+        log11.error(`[${PLUGIN_NAME19}] command.execute.before 异常（已隔离）`, {
           error: err instanceof Error ? err.message : String(err)
         });
       }
     }
   };
 };
-var handler18 = subtasksServer;
+var handler19 = subtasksServer;
 
 // plugins/terminal-monitor.ts
 init_opencode_plugin_helpers();
 import * as crypto5 from "node:crypto";
-var PLUGIN_NAME19 = "terminal-monitor";
-logLifecycle(PLUGIN_NAME19, "import", {});
+var PLUGIN_NAME20 = "terminal-monitor";
+logLifecycle(PLUGIN_NAME20, "import", {});
 var DEFAULT_CONFIG7 = {
   minScore: 0.6,
   cooldownMs: 30000,
@@ -18679,17 +19132,17 @@ function describeError(err) {
     return String(err);
   }
 }
-var log10 = makePluginLogger(PLUGIN_NAME19);
+var log11 = makePluginLogger(PLUGIN_NAME20);
 var lru = new FingerprintLRU2;
 var _lastNotification = null;
 var terminalMonitorServer = async (ctx) => {
-  logLifecycle(PLUGIN_NAME19, "activate", {
+  logLifecycle(PLUGIN_NAME20, "activate", {
     directory: ctx.directory,
     triggerEventTypes: ["terminal.output", "terminal.exit"]
   });
   return {
     event: async ({ event }) => {
-      await safeAsync(PLUGIN_NAME19, "event", async () => {
+      await safeAsync(PLUGIN_NAME20, "event", async () => {
         const e = event;
         if (!e || typeof e.type !== "string")
           return;
@@ -18698,12 +19151,12 @@ var terminalMonitorServer = async (ctx) => {
         const ev = { type: e.type, ...e.properties ?? {} };
         const r = await processTerminalEvent(ev, {
           lru,
-          log: log10,
+          log: log11,
           notifyAgent: (msg) => {
             _lastNotification = msg;
           }
         });
-        safeWriteLog(PLUGIN_NAME19, {
+        safeWriteLog(PLUGIN_NAME20, {
           hook: "event",
           type: e.type,
           notified: r.notified,
@@ -18711,19 +19164,19 @@ var terminalMonitorServer = async (ctx) => {
           findings: r.notification?.findings.length ?? 0
         });
         if (r.notified && r.notification) {
-          log10.info(`[${PLUGIN_NAME19}] 反馈 ${r.notification.findings.length} 条 → ${r.notification.summary}`);
+          log11.info(`[${PLUGIN_NAME20}] 反馈 ${r.notification.findings.length} 条 → ${r.notification.summary}`);
         }
       });
     }
   };
 };
-var handler19 = terminalMonitorServer;
+var handler20 = terminalMonitorServer;
 
 // plugins/token-manager.ts
 init_opencode_plugin_helpers();
-var PLUGIN_NAME20 = "token-manager";
-logLifecycle(PLUGIN_NAME20, "import", {});
-async function handleMessageBefore(raw, log11, defaults) {
+var PLUGIN_NAME21 = "token-manager";
+logLifecycle(PLUGIN_NAME21, "import", {});
+async function handleMessageBefore(raw, log12, defaults) {
   const ctx = raw ?? {};
   if (!Array.isArray(ctx.messages) || ctx.messages.length === 0)
     return null;
@@ -18742,21 +19195,21 @@ async function handleMessageBefore(raw, log11, defaults) {
     };
     if (r.compressed) {
       ctx.messages = r.messages;
-      log11?.info(`[${PLUGIN_NAME20}] 压缩 ${r.before.count}→${r.after.count} 条 / ${r.before.tokens}→${r.after.tokens} tokens`);
+      log12?.info(`[${PLUGIN_NAME21}] 压缩 ${r.before.count}→${r.after.count} 条 / ${r.before.tokens}→${r.after.tokens} tokens`);
     }
     return r;
   } catch (err) {
-    log11?.warn(`[${PLUGIN_NAME20}] 压缩异常（已隔离）`, {
+    log12?.warn(`[${PLUGIN_NAME21}] 压缩异常（已隔离）`, {
       error: err instanceof Error ? err.message : String(err)
     });
     return null;
   }
 }
-var log11 = makePluginLogger(PLUGIN_NAME20);
+var log12 = makePluginLogger(PLUGIN_NAME21);
 var tokenManagerServer = async (ctx) => {
   const rt = loadRuntimeSync();
   const threshold = rt.runtime.context.condenser_threshold_ratio;
-  logLifecycle(PLUGIN_NAME20, "activate", {
+  logLifecycle(PLUGIN_NAME21, "activate", {
     directory: ctx.directory,
     threshold,
     target: DEFAULT_CONDENSE.target,
@@ -18765,7 +19218,7 @@ var tokenManagerServer = async (ctx) => {
   });
   return {
     "experimental.chat.messages.transform": async (_input, output) => {
-      await safeAsync(PLUGIN_NAME20, "experimental.chat.messages.transform", async () => {
+      await safeAsync(PLUGIN_NAME21, "experimental.chat.messages.transform", async () => {
         const list = output.messages;
         if (!Array.isArray(list) || list.length === 0)
           return;
@@ -18775,10 +19228,10 @@ var tokenManagerServer = async (ctx) => {
 `);
           return { role, content };
         });
-        const r = await handleMessageBefore({ messages: flat }, log11, { threshold });
+        const r = await handleMessageBefore({ messages: flat }, log12, { threshold });
         if (!r)
           return;
-        safeWriteLog(PLUGIN_NAME20, {
+        safeWriteLog(PLUGIN_NAME21, {
           hook: "experimental.chat.messages.transform",
           mode: "observe-only",
           before_msgs: r.before.count,
@@ -18789,13 +19242,13 @@ var tokenManagerServer = async (ctx) => {
           reason: r.reason
         });
         if (r.compressed) {
-          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)`);
+          log12.warn(`[${PLUGIN_NAME21}] 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 handler20 = tokenManagerServer;
+var handler21 = tokenManagerServer;
 
 // plugins/tool-policy.ts
 init_opencode_plugin_helpers();
@@ -18915,8 +19368,8 @@ function checkFileAccess(acl, file, op) {
 }
 
 // plugins/tool-policy.ts
-var PLUGIN_NAME21 = "tool-policy";
-logLifecycle(PLUGIN_NAME21, "import", {});
+var PLUGIN_NAME22 = "tool-policy";
+logLifecycle(PLUGIN_NAME22, "import", {});
 var EMPTY_ACL = { whitelistMode: false };
 var SUBAGENT_APPLY_DENY_LIST = new Set([
   "coder",
@@ -19000,18 +19453,18 @@ function classifyToolKind(toolName) {
     return "webfetch";
   return "other";
 }
-async function resolveCurrentAgent(client, sessionID, log12) {
+async function resolveCurrentAgent(client, sessionID, log13) {
   try {
     const sessionApi = client?.session;
     if (!sessionApi || typeof sessionApi.get !== "function") {
-      log12.warn(`client.session.get unavailable`, { sessionID });
+      log13.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 === "") {
-      log12.warn(`client.session.get returned no string agent (保守放行)`, {
+      log13.warn(`client.session.get returned no string agent (保守放行)`, {
         sessionID,
         dataKeys: data && typeof data === "object" ? Object.keys(data) : null
       });
@@ -19019,20 +19472,20 @@ async function resolveCurrentAgent(client, sessionID, log12) {
     }
     return rawAgent;
   } catch (err) {
-    log12.warn(`client.session.get failed (保守放行)`, {
+    log13.warn(`client.session.get failed (保守放行)`, {
       sessionID,
       error: err instanceof Error ? err.message : String(err)
     });
     return;
   }
 }
-var log12 = makePluginLogger(PLUGIN_NAME21);
+var log13 = makePluginLogger(PLUGIN_NAME22);
 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_NAME21, "activate", {
+  logLifecycle(PLUGIN_NAME22, "activate", {
     directory,
     acl_loaded: !!cfg.acl,
     default_mode: cfg.defaultMode,
@@ -19041,13 +19494,13 @@ var toolPolicyServer = async (ctx) => {
   return {
     "tool.execute.before": async (input, output) => {
       let denied;
-      await safeAsync(PLUGIN_NAME21, "tool.execute.before", async () => {
+      await safeAsync(PLUGIN_NAME22, "tool.execute.before", async () => {
         const toolName = input.tool;
         const argsObj = output.args ?? {};
         const needsAgentDetection = toolName === "pending_changes" && (argsObj.action === "apply" || argsObj.action === "apply_all");
         let currentAgent = undefined;
         if (needsAgentDetection) {
-          currentAgent = await resolveCurrentAgent(ctx.client, input.sessionID, log12);
+          currentAgent = await resolveCurrentAgent(ctx.client, input.sessionID, log13);
         }
         const files = [];
         const filePath = argsObj["path"] ?? argsObj["filePath"] ?? argsObj["file"];
@@ -19062,7 +19515,7 @@ var toolPolicyServer = async (ctx) => {
           mode: cfg.defaultMode,
           files: files.length ? files : undefined
         }, cfg, currentAgent);
-        safeWriteLog(PLUGIN_NAME21, {
+        safeWriteLog(PLUGIN_NAME22, {
           hook: "tool.execute.before",
           tool: toolName,
           callID: input.callID,
@@ -19072,14 +19525,14 @@ var toolPolicyServer = async (ctx) => {
           currentAgent
         });
         if (decision.action === "deny") {
-          log12.warn(`[${PLUGIN_NAME21}] DENY ${toolName}`, {
+          log13.warn(`[${PLUGIN_NAME22}] DENY ${toolName}`, {
             action: argsObj.action,
             currentAgent,
             reasons: decision.reasons
           });
           denied = new Error(`[tool-policy] DENIED: ${decision.reasons.join(" / ")}`);
         } else if (decision.action === "confirm") {
-          log12.info(`[${PLUGIN_NAME21}] CONFIRM ${toolName}: ${decision.reasons.join("; ")}`);
+          log13.info(`[${PLUGIN_NAME22}] CONFIRM ${toolName}: ${decision.reasons.join("; ")}`);
         }
       });
       if (denied)
@@ -19087,13 +19540,13 @@ var toolPolicyServer = async (ctx) => {
     }
   };
 };
-var handler21 = toolPolicyServer;
+var handler22 = toolPolicyServer;
 
 // plugins/update-checker.ts
 init_opencode_plugin_helpers();
 import { existsSync as existsSync5 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 
 // lib/update-checker-impl.ts
 import { createHash as createHash6 } from "node:crypto";
@@ -19102,15 +19555,15 @@ import {
   existsSync as existsSync4,
   mkdirSync as mkdirSync3,
   mkdtempSync,
-  readFileSync as readFileSync5,
-  readdirSync as readdirSync2,
+  readFileSync as readFileSync6,
+  readdirSync as readdirSync3,
   renameSync,
-  statSync as statSync4,
+  statSync as statSync5,
   unlinkSync,
   writeFileSync as writeFileSync2
 } from "node:fs";
 import { homedir as homedir7, tmpdir } from "node:os";
-import { dirname as dirname7, join as join17 } from "node:path";
+import { dirname as dirname7, join as join18 } from "node:path";
 import { fileURLToPath } from "node:url";
 import * as https from "node:https";
 import * as zlib from "node:zlib";
@@ -19118,7 +19571,7 @@ import * as zlib from "node:zlib";
 // lib/version-injected.ts
 function getInjectedVersion() {
   try {
-    const v = "0.3.13";
+    const v = "0.3.14";
     if (typeof v === "string" && /^\d+\.\d+\.\d+/.test(v)) {
       return v;
     }
@@ -19208,23 +19661,23 @@ function readLocalVersion() {
   try {
     const here = fileURLToPath(import.meta.url);
     const root = dirname7(dirname7(here));
-    const pkg = JSON.parse(readFileSync5(join17(root, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync6(join18(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"] ?? join17(homedir7(), ".cache", "codeforge");
+  return process.env["CODEFORGE_CACHE_DIR"] ?? join18(homedir7(), ".cache", "codeforge");
 }
 function defaultCacheFile() {
-  return join17(defaultCacheDir(), "update-check.json");
+  return join18(defaultCacheDir(), "update-check.json");
 }
 function readCache(file) {
   try {
     if (!existsSync4(file))
       return null;
-    const raw = readFileSync5(file, "utf8");
+    const raw = readFileSync6(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;
@@ -19374,14 +19827,14 @@ function defaultHttpFetcher(url, timeoutMs) {
   });
 }
 async function downloadAndExtractBundle(opts) {
-  const tmpRoot = opts.tmpDir ?? mkdtempSync(join17(tmpdir(), "codeforge-update-"));
+  const tmpRoot = opts.tmpDir ?? mkdtempSync(join18(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 = join17(tmpRoot, "package", "dist", "index.js");
+  const bundlePath = join18(tmpRoot, "package", "dist", "index.js");
   if (!existsSync4(bundlePath)) {
     throw new Error(`bundle_not_found: ${bundlePath}`);
   }
@@ -19421,11 +19874,11 @@ function extractTarToDir(tarBuf, destRoot) {
     offset += 512;
     if (typeFlag === "0" || typeFlag === "" || typeFlag === "\x00") {
       const fileBuf = tarBuf.subarray(offset, offset + size);
-      const dest = join17(destRoot, fullName);
+      const dest = join18(destRoot, fullName);
       mkdirSync3(dirname7(dest), { recursive: true });
       writeFileSync2(dest, fileBuf);
     } else if (typeFlag === "5") {
-      mkdirSync3(join17(destRoot, fullName), { recursive: true });
+      mkdirSync3(join18(destRoot, fullName), { recursive: true });
     }
     offset += Math.ceil(size / 512) * 512;
   }
@@ -19533,11 +19986,11 @@ function cleanupOldBackups(target, keep) {
     const dir = dirname7(target);
     const base = target.substring(dir.length + 1);
     const prefix = `${base}.bak.`;
-    const all = readdirSync2(dir).filter((f) => f.startsWith(prefix)).map((f) => {
-      const full = join17(dir, f);
+    const all = readdirSync3(dir).filter((f) => f.startsWith(prefix)).map((f) => {
+      const full = join18(dir, f);
       let mtimeMs = 0;
       try {
-        mtimeMs = statSync4(full).mtimeMs;
+        mtimeMs = statSync5(full).mtimeMs;
       } catch {}
       return { full, mtimeMs };
     }).sort((a, b) => b.mtimeMs - a.mtimeMs);
@@ -19556,11 +20009,11 @@ function loadCompatibility(opts) {
       const root = opts?.cwd ?? inferPluginRoot();
       if (!root)
         return null;
-      file = join17(root, "compatibility.json");
+      file = join18(root, "compatibility.json");
     }
     if (!existsSync4(file))
       return null;
-    const raw = readFileSync5(file, "utf8");
+    const raw = readFileSync6(file, "utf8");
     const obj = JSON.parse(raw);
     if (!obj || typeof obj !== "object")
       return null;
@@ -19621,20 +20074,20 @@ function compareOpencodeVersion(opts) {
 }
 
 // plugins/update-checker.ts
-var PLUGIN_NAME22 = "update-checker";
+var PLUGIN_NAME23 = "update-checker";
 var PLUGIN_VERSION = "2.0.0";
-logLifecycle(PLUGIN_NAME22, "import", { version: PLUGIN_VERSION });
+logLifecycle(PLUGIN_NAME23, "import", { version: PLUGIN_VERSION });
 var updateCheckerServer = async (ctx) => {
   const yieldResult = shouldYieldToLocalPlugin({ directory: ctx.directory });
   if (yieldResult.yield) {
-    safeWriteLog(PLUGIN_NAME22, {
+    safeWriteLog(PLUGIN_NAME23, {
       level: "info",
       msg: "dev_mode_yield_skip",
       reason: yieldResult.reason,
       markerPath: yieldResult.markerPath,
       detail: formatYieldLog(yieldResult)
     });
-    logLifecycle(PLUGIN_NAME22, "activate", {
+    logLifecycle(PLUGIN_NAME23, "activate", {
       yield_to_local: true,
       yield_reason: yieldResult.reason,
       skipped: "auto_install + background_check"
@@ -19643,7 +20096,7 @@ var updateCheckerServer = async (ctx) => {
   }
   const rt = loadRuntimeSync();
   const u = rt.runtime.update;
-  logLifecycle(PLUGIN_NAME22, "activate", {
+  logLifecycle(PLUGIN_NAME23, "activate", {
     version: PLUGIN_VERSION,
     auto_check_enabled: u.auto_check_enabled,
     interval_hours: u.interval_hours,
@@ -19655,14 +20108,14 @@ var updateCheckerServer = async (ctx) => {
     repo_fallback: u.repo,
     config_source: "codeforge.json"
   });
-  await safeAsync(PLUGIN_NAME22, "opencode_version_check", async () => {
+  await safeAsync(PLUGIN_NAME23, "opencode_version_check", async () => {
     const compat = loadCompatibility();
     const opencodeVer = detectOpencodeVersion();
     const verdict = compareOpencodeVersion({
       currentOpencodeVer: opencodeVer,
       compat
     });
-    safeWriteLog(PLUGIN_NAME22, {
+    safeWriteLog(PLUGIN_NAME23, {
       level: "info",
       msg: "opencode_version_check",
       opencodeVer,
@@ -19679,14 +20132,14 @@ var updateCheckerServer = async (ctx) => {
     }
   });
   if (!u.auto_check_enabled) {
-    safeWriteLog(PLUGIN_NAME22, {
+    safeWriteLog(PLUGIN_NAME23, {
       level: "info",
       msg: "auto-check disabled (codeforge.json update.auto_check_enabled=false)"
     });
     return {};
   }
   setImmediate(() => {
-    safeAsync(PLUGIN_NAME22, "checkAndMaybeUpdate", async () => {
+    safeAsync(PLUGIN_NAME23, "checkAndMaybeUpdate", async () => {
       const local = readLocalVersion();
       let npmResult = null;
       try {
@@ -19697,7 +20150,7 @@ var updateCheckerServer = async (ctx) => {
           timeoutMs: 5000
         });
       } catch (e) {
-        safeWriteLog(PLUGIN_NAME22, {
+        safeWriteLog(PLUGIN_NAME23, {
           level: "warn",
           msg: "npm_fetch_failed",
           error: e.message
@@ -19706,7 +20159,7 @@ var updateCheckerServer = async (ctx) => {
         return;
       }
       if (!npmResult) {
-        safeWriteLog(PLUGIN_NAME22, {
+        safeWriteLog(PLUGIN_NAME23, {
           level: "info",
           msg: "npm_no_release",
           package: u.package,
@@ -19715,7 +20168,7 @@ var updateCheckerServer = async (ctx) => {
         return;
       }
       const hasUpdate = cmpVersion(local, npmResult.version) < 0;
-      safeWriteLog(PLUGIN_NAME22, {
+      safeWriteLog(PLUGIN_NAME23, {
         level: "info",
         msg: "npm_check_result",
         local,
@@ -19730,10 +20183,10 @@ var updateCheckerServer = async (ctx) => {
    更新命令：npx ${u.package} install --global`);
         return;
       }
-      await safeAsync(PLUGIN_NAME22, "auto_install_bundle", async () => {
+      await safeAsync(PLUGIN_NAME23, "auto_install_bundle", async () => {
         const target = getOpencodeBundlePath();
         if (!target) {
-          safeWriteLog(PLUGIN_NAME22, {
+          safeWriteLog(PLUGIN_NAME23, {
             level: "warn",
             msg: "auto_install_skip",
             reason: "无法定位 opencode bundle 路径"
@@ -19752,7 +20205,7 @@ var updateCheckerServer = async (ctx) => {
           oldVersion: local,
           keepBackups: u.backup_keep
         });
-        safeWriteLog(PLUGIN_NAME22, {
+        safeWriteLog(PLUGIN_NAME23, {
           level: "info",
           msg: "auto_install_success",
           local,
@@ -19776,14 +20229,14 @@ function detectOpencodeVersion() {
 }
 function getOpencodeBundlePath() {
   const candidates = [];
-  candidates.push(join18(homedir8(), ".config", "opencode", "codeforge", "index.js"));
+  candidates.push(join19(homedir8(), ".config", "opencode", "codeforge", "index.js"));
   if (process.platform === "win32") {
     const appData = process.env["APPDATA"];
     if (appData)
-      candidates.push(join18(appData, "opencode", "codeforge", "index.js"));
+      candidates.push(join19(appData, "opencode", "codeforge", "index.js"));
     const localAppData = process.env["LOCALAPPDATA"];
     if (localAppData)
-      candidates.push(join18(localAppData, "opencode", "codeforge", "index.js"));
+      candidates.push(join19(localAppData, "opencode", "codeforge", "index.js"));
   }
   for (const c of candidates) {
     if (existsSync5(c))
@@ -19792,7 +20245,7 @@ function getOpencodeBundlePath() {
   return candidates[0] ?? null;
 }
 async function fallbackToGitHubReleases(ctx, u) {
-  await safeAsync(PLUGIN_NAME22, "github_fallback", async () => {
+  await safeAsync(PLUGIN_NAME23, "github_fallback", async () => {
     const result = await checkUpdateOnce({
       repo: u.repo,
       intervalMs: u.interval_hours * 3600 * 1000
@@ -19802,7 +20255,7 @@ async function fallbackToGitHubReleases(ctx, u) {
 }
 async function reportLegacyResult(ctx, result, repo) {
   if (result.error && !result.fromCache) {
-    safeWriteLog(PLUGIN_NAME22, {
+    safeWriteLog(PLUGIN_NAME23, {
       level: "warn",
       msg: `update check failed: ${result.error}`,
       ...result
@@ -19810,7 +20263,7 @@ async function reportLegacyResult(ctx, result, repo) {
     return;
   }
   if (!result.hasUpdate) {
-    safeWriteLog(PLUGIN_NAME22, {
+    safeWriteLog(PLUGIN_NAME23, {
       level: "info",
       msg: `up-to-date (local=${result.local}, remote=${result.remote}${result.fromCache ? ", from_cache" : ""})`,
       ...result
@@ -19820,7 +20273,7 @@ async function reportLegacyResult(ctx, result, repo) {
   const updateCmd = `bunx --bun github:${repo} install`;
   const toast = `[CodeForge] 有新版本：${result.local} → ${result.remote}
   更新命令：${updateCmd}`;
-  safeWriteLog(PLUGIN_NAME22, {
+  safeWriteLog(PLUGIN_NAME23, {
     level: "info",
     msg: "new_version_available_github_fallback",
     local: result.local,
@@ -19831,17 +20284,17 @@ async function reportLegacyResult(ctx, result, repo) {
   await postToast(ctx, toast);
 }
 async function postToast(ctx, message) {
-  await safeAsync(PLUGIN_NAME22, "client.app.log", async () => {
+  await safeAsync(PLUGIN_NAME23, "client.app.log", async () => {
     await ctx.client.app.log({
       body: {
-        service: PLUGIN_NAME22,
+        service: PLUGIN_NAME23,
         level: "info",
         message
       }
     });
   });
 }
-var handler22 = updateCheckerServer;
+var handler23 = updateCheckerServer;
 
 // plugins/workflow-engine.ts
 init_opencode_plugin_helpers();
@@ -19850,55 +20303,55 @@ import * as path19 from "node:path";
 // lib/workflow-loader.ts
 import { promises as fs14 } from "node:fs";
 import * as path18 from "node:path";
-import { z as z28 } from "zod";
-var ActionSchema = z28.object({
-  tool: z28.string().min(1, "action.tool 不能为空"),
-  args: z28.record(z28.string(), z28.unknown()).optional().default({}),
-  on_error: z28.enum(["retry", "skip", "abort"]).optional()
+import { z as z29 } from "zod";
+var ActionSchema = z29.object({
+  tool: z29.string().min(1, "action.tool 不能为空"),
+  args: z29.record(z29.string(), z29.unknown()).optional().default({}),
+  on_error: z29.enum(["retry", "skip", "abort"]).optional()
 });
-var StepSchema = z28.object({
-  name: z28.string().min(1, "step.name 不能为空"),
-  agent: z28.string().min(1, "step.agent 不能为空").describe("agent 名（与 agents/<name>.md 对应）"),
-  description: z28.string().optional(),
-  inject_context: z28.record(z28.string(), z28.unknown()).optional(),
-  requires_human_approval: z28.boolean().optional().default(false),
-  actions: z28.array(ActionSchema).optional().default([]),
-  on_error: z28.enum(["retry", "skip", "abort"]).optional().default("abort"),
-  max_retries: z28.number().int().min(0).max(10).optional().default(2),
-  timeout: z28.string().regex(/^\d+(?:ms|s|m|h)$/, "timeout 必须是 数字+单位（ms/s/m/h），如 5m").optional(),
-  auto_feedback: z28.object({
-    test_cmd: z28.string().optional().describe("测试命令，如 npm test"),
-    lint_cmd: z28.string().optional().describe("lint 命令，如 npm run lint"),
-    max_retries: z28.number().int().min(1).max(10).optional().default(3),
-    error_excerpt_lines: z28.number().int().min(1).max(50).optional().default(5),
-    escalate_to: z28.string().optional().default("reviewer").describe("超上限后兜底 agent，默认 reviewer")
+var StepSchema = z29.object({
+  name: z29.string().min(1, "step.name 不能为空"),
+  agent: z29.string().min(1, "step.agent 不能为空").describe("agent 名（与 agents/<name>.md 对应）"),
+  description: z29.string().optional(),
+  inject_context: z29.record(z29.string(), z29.unknown()).optional(),
+  requires_human_approval: z29.boolean().optional().default(false),
+  actions: z29.array(ActionSchema).optional().default([]),
+  on_error: z29.enum(["retry", "skip", "abort"]).optional().default("abort"),
+  max_retries: z29.number().int().min(0).max(10).optional().default(2),
+  timeout: z29.string().regex(/^\d+(?:ms|s|m|h)$/, "timeout 必须是 数字+单位（ms/s/m/h），如 5m").optional(),
+  auto_feedback: z29.object({
+    test_cmd: z29.string().optional().describe("测试命令，如 npm test"),
+    lint_cmd: z29.string().optional().describe("lint 命令，如 npm run lint"),
+    max_retries: z29.number().int().min(1).max(10).optional().default(3),
+    error_excerpt_lines: z29.number().int().min(1).max(50).optional().default(5),
+    escalate_to: z29.string().optional().default("reviewer").describe("超上限后兜底 agent，默认 reviewer")
   }).refine((d) => Boolean(d.test_cmd || d.lint_cmd), { message: "auto_feedback 必须至少配置 test_cmd 或 lint_cmd 之一" }).optional(),
-  on_decision: z28.object({
-    APPROVE: z28.union([
-      z28.literal("continue"),
-      z28.literal("abort"),
-      z28.object({ action: z28.literal("goto"), target: z28.string().min(1) })
+  on_decision: z29.object({
+    APPROVE: z29.union([
+      z29.literal("continue"),
+      z29.literal("abort"),
+      z29.object({ action: z29.literal("goto"), target: z29.string().min(1) })
     ]).optional(),
-    REQUEST_CHANGES: z28.union([
-      z28.literal("continue"),
-      z28.literal("abort"),
-      z28.object({ action: z28.literal("goto"), target: z28.string().min(1) })
+    REQUEST_CHANGES: z29.union([
+      z29.literal("continue"),
+      z29.literal("abort"),
+      z29.object({ action: z29.literal("goto"), target: z29.string().min(1) })
     ]).optional(),
-    BLOCK: z28.union([
-      z28.literal("continue"),
-      z28.literal("abort"),
-      z28.object({ action: z28.literal("goto"), target: z28.string().min(1) })
+    BLOCK: z29.union([
+      z29.literal("continue"),
+      z29.literal("abort"),
+      z29.object({ action: z29.literal("goto"), target: z29.string().min(1) })
     ]).optional()
   }).refine((d) => Boolean(d.APPROVE || d.REQUEST_CHANGES || d.BLOCK), { message: "on_decision 必须至少配置 APPROVE / REQUEST_CHANGES / BLOCK 之一" }).optional()
 }).strict();
-var WorkflowSchema = z28.object({
-  name: z28.string().min(1, "workflow.name 不能为空"),
-  description: z28.string().optional().default(""),
-  version: z28.string().optional().default("1.0.0"),
-  trigger: z28.string().min(1).refine((v) => /^\/[a-z][\w-]*$/.test(v) || /^event:[a-z][\w.-]+$/.test(v), "trigger 必须是 /command-name 或 event:xxx 形式"),
-  context_template: z28.string().optional(),
-  max_loops: z28.number().int().min(1).max(10).optional().default(3),
-  steps: z28.array(StepSchema).min(1, "workflow.steps 不能为空")
+var WorkflowSchema = z29.object({
+  name: z29.string().min(1, "workflow.name 不能为空"),
+  description: z29.string().optional().default(""),
+  version: z29.string().optional().default("1.0.0"),
+  trigger: z29.string().min(1).refine((v) => /^\/[a-z][\w-]*$/.test(v) || /^event:[a-z][\w.-]+$/.test(v), "trigger 必须是 /command-name 或 event:xxx 形式"),
+  context_template: z29.string().optional(),
+  max_loops: z29.number().int().min(1).max(10).optional().default(3),
+  steps: z29.array(StepSchema).min(1, "workflow.steps 不能为空")
 }).strict();
 function parseWorkflowYaml(yaml, sourcePath = "<inline>") {
   let raw;
@@ -20297,9 +20750,9 @@ async function runStepAutoFeedback(step, adapter) {
 }
 
 // plugins/workflow-engine.ts
-var PLUGIN_NAME23 = "workflow-engine";
-logLifecycle(PLUGIN_NAME23, "import", {});
-var fallbackLog2 = makePluginLogger(PLUGIN_NAME23);
+var PLUGIN_NAME24 = "workflow-engine";
+logLifecycle(PLUGIN_NAME24, "import", {});
+var fallbackLog2 = makePluginLogger(PLUGIN_NAME24);
 var _registry = null;
 async function loadRegistry(workflowsDir) {
   const { loaded, failed } = await loadWorkflowsFromDir(workflowsDir);
@@ -20316,35 +20769,35 @@ async function ensureRegistry(workflowsDir = "workflows") {
 }
 async function handleCommandInvoked(raw, workflowsDir = "workflows") {
   const ctx = raw ?? {};
-  const log13 = ctx.log ?? fallbackLog2;
+  const log14 = ctx.log ?? fallbackLog2;
   const command = typeof ctx.command === "string" ? ctx.command : null;
   if (!command) {
-    log13.warn(`[${PLUGIN_NAME23}] command.invoked 缺 command 字段`, ctx);
+    log14.warn(`[${PLUGIN_NAME24}] command.invoked 缺 command 字段`, ctx);
     return null;
   }
   const reg = await ensureRegistry(workflowsDir);
   if (reg.errors.length) {
-    log13.warn(`[${PLUGIN_NAME23}] 有 ${reg.errors.length} 个 workflow 加载失败`, reg.errors);
+    log14.warn(`[${PLUGIN_NAME24}] 有 ${reg.errors.length} 个 workflow 加载失败`, reg.errors);
   }
   const wf = reg.workflows.find((w) => matchesTrigger(w, command));
   if (!wf) {
-    log13.info(`[${PLUGIN_NAME23}] no workflow matches "${command}"`);
+    log14.info(`[${PLUGIN_NAME24}] no workflow matches "${command}"`);
     return null;
   }
-  log13.info(`[${PLUGIN_NAME23}] dispatch "${command}" → workflow "${wf.name}"`);
+  log14.info(`[${PLUGIN_NAME24}] dispatch "${command}" → workflow "${wf.name}"`);
   try {
     const result = await run(wf, {
       mode: ctx.adapter ? "real" : "dry_run",
       autonomy: ctx.autonomy ?? "semi",
       adapter: ctx.adapter
     });
-    log13.info(`[${PLUGIN_NAME23}] workflow "${wf.name}" 完成 (${result.plan.mode})`, {
+    log14.info(`[${PLUGIN_NAME24}] workflow "${wf.name}" 完成 (${result.plan.mode})`, {
       steps: result.plan.steps.length,
       results: result.results.length
     });
     return result;
   } catch (err) {
-    log13.error(`[${PLUGIN_NAME23}] workflow "${wf.name}" 执行失败`, {
+    log14.error(`[${PLUGIN_NAME24}] workflow "${wf.name}" 执行失败`, {
       error: err instanceof Error ? err.message : String(err)
     });
     throw err;
@@ -20353,15 +20806,15 @@ async function handleCommandInvoked(raw, workflowsDir = "workflows") {
 var workflowEngineServer = async (ctx) => {
   const directory = ctx.directory ?? process.cwd();
   const workflowsDir = path19.join(directory, "workflows");
-  ensureRegistry(workflowsDir).catch((err) => fallbackLog2.warn(`[${PLUGIN_NAME23}] preload workflows failed`, {
+  ensureRegistry(workflowsDir).catch((err) => fallbackLog2.warn(`[${PLUGIN_NAME24}] preload workflows failed`, {
     error: err instanceof Error ? err.message : String(err)
   }));
-  logLifecycle(PLUGIN_NAME23, "activate", { directory, workflowsDir });
+  logLifecycle(PLUGIN_NAME24, "activate", { directory, workflowsDir });
   return {
     "command.execute.before": async (input, output) => {
-      await safeAsync(PLUGIN_NAME23, "command.execute.before", async () => {
+      await safeAsync(PLUGIN_NAME24, "command.execute.before", async () => {
         const cmd = input.command.startsWith("/") ? input.command : `/${input.command}`;
-        safeWriteLog(PLUGIN_NAME23, {
+        safeWriteLog(PLUGIN_NAME24, {
           hook: "command.execute.before",
           command: cmd,
           sessionID: input.sessionID
@@ -20376,14 +20829,14 @@ var workflowEngineServer = async (ctx) => {
       });
     },
     "chat.message": async (input, output) => {
-      await safeAsync(PLUGIN_NAME23, "chat.message", async () => {
+      await safeAsync(PLUGIN_NAME24, "chat.message", async () => {
         const text = extractUserText(output).trim();
         if (!text.startsWith("/"))
           return;
         const cmd = text.split(/\s+/)[0];
         if (!cmd)
           return;
-        safeWriteLog(PLUGIN_NAME23, {
+        safeWriteLog(PLUGIN_NAME24, {
           hook: "chat.message",
           command: cmd,
           sessionID: input.sessionID
@@ -20393,11 +20846,11 @@ var workflowEngineServer = async (ctx) => {
     }
   };
 };
-var handler23 = workflowEngineServer;
+var handler24 = workflowEngineServer;
 
 // src/index.ts
 var PLUGIN_ID = "codeforge";
-var log13 = makePluginLogger(PLUGIN_ID);
+var log14 = makePluginLogger(PLUGIN_ID);
 logLifecycle(PLUGIN_ID, "import", { entry: "src/index.ts" });
 var HANDLERS = [
   { name: "agent-router", init: handler },
@@ -20407,22 +20860,23 @@ var HANDLERS = [
   { name: "auto-learning", init: handler5 },
   { name: "channels", init: handler6 },
   { name: "codeforge-tools", init: handler8 },
-  { name: "kh-auto-context", init: handler9 },
-  { name: "kh-reminder", init: handler10 },
-  { name: "memories-context", init: handler11 },
-  { name: "model-fallback", init: handler12 },
-  { name: "parallel-tool-nudge", init: handler15 },
-  { name: "pwsh-utf8", init: handler16 },
-  { name: "session-recovery", init: handler17 },
-  { name: "subtask-heartbeat", init: handler13 },
-  { name: "subtasks", init: handler18 },
-  { name: "parallel-status", init: handler14 },
-  { name: "terminal-monitor", init: handler19 },
-  { name: "token-manager", init: handler20 },
+  { name: "discover-spec-suggest", init: handler9 },
+  { name: "kh-auto-context", init: handler10 },
+  { name: "kh-reminder", init: handler11 },
+  { name: "memories-context", init: handler12 },
+  { name: "model-fallback", init: handler13 },
+  { name: "parallel-tool-nudge", init: handler16 },
+  { name: "pwsh-utf8", init: handler17 },
+  { name: "session-recovery", init: handler18 },
+  { name: "subtask-heartbeat", init: handler14 },
+  { name: "subtasks", init: handler19 },
+  { name: "parallel-status", init: handler15 },
+  { name: "terminal-monitor", init: handler20 },
+  { name: "token-manager", init: handler21 },
   { name: "tool-heartbeat", init: handler7 },
-  { name: "tool-policy", init: handler21 },
-  { name: "update-checker", init: handler22 },
-  { name: "workflow-engine", init: handler23 }
+  { name: "tool-policy", init: handler22 },
+  { name: "update-checker", init: handler23 },
+  { name: "workflow-engine", init: handler24 }
 ];
 function makeSerialHook(hookName, fns) {
   return async (input, output) => {
@@ -20430,7 +20884,7 @@ function makeSerialHook(hookName, fns) {
       try {
         await fn(input, output);
       } catch (err) {
-        log13.warn(`[${PLUGIN_ID}] ${hookName} handler 异常（已隔离）`, {
+        log14.warn(`[${PLUGIN_ID}] ${hookName} handler 异常（已隔离）`, {
           error: err instanceof Error ? err.message : String(err)
         });
       }
@@ -20443,7 +20897,7 @@ function createCodeforgeServer(opts) {
       const yieldResult = shouldYieldToLocalPlugin({ directory: input.directory });
       if (yieldResult.yield) {
         const msg = formatYieldLog(yieldResult);
-        log13.info(msg, { reason: yieldResult.reason, markerPath: yieldResult.markerPath });
+        log14.info(msg, { reason: yieldResult.reason, markerPath: yieldResult.markerPath });
         logLifecycle(PLUGIN_ID, "activate", {
           yield_to_local: true,
           yield_reason: yieldResult.reason,
@@ -20461,7 +20915,7 @@ function createCodeforgeServer(opts) {
       if (r.status === "fulfilled" && r.value && typeof r.value === "object") {
         hooksList.push(r.value);
       } else if (r.status === "rejected") {
-        log13.warn(`[${PLUGIN_ID}] handler ${HANDLERS[i].name} init failed (隔离，其他 handler 继续)`, { error: r.reason instanceof Error ? r.reason.message : String(r.reason) });
+        log14.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", {
@@ -20510,7 +20964,7 @@ function createCodeforgeServer(opts) {
           try {
             await fn(envelope);
           } catch (err) {
-            log13.warn(`[${PLUGIN_ID}] event handler 异常（已隔离）`, {
+            log14.warn(`[${PLUGIN_ID}] event handler 异常（已隔离）`, {
               error: err instanceof Error ? err.message : String(err)
             });
           }