@andyqiu/codeforge 0.3.9 → 0.3.10

package/dist/index.js

@@ -10769,6 +10769,14 @@ function applyAnchor(content, edit, eol, beforeHash) {
   if (!edit.anchor) {
     return { ok: false, reason: "invalid_input", message: "anchor 不能为空" };
   }
+  if (edit.anchor.includes(`
+`)) {
+    return {
+      ok: false,
+      reason: "invalid_input",
+      message: "anchor 不能含换行符（仅支持单行匹配）；多行改动请改用 pending_changes.stage 整文件暂存"
+    };
+  }
   const lines = splitLines(content);
   const hits = findAnchorLines(lines, edit.anchor, edit.regex === true);
   if (hits.length === 0) {
@@ -10971,6 +10979,7 @@ function finish(before, after, beforeHash, affected) {
 // tools/ast-edit.ts
 var description16 = [
   "AST 风格的精确文件编辑：anchor + 哈希校验，避免 LLM 「整文件重写」误改无关代码。",
+  "**anchor 仅支持单行**：含 `\\n` 的多行 anchor 会被直接拒绝（reason=invalid_input）；多行改动请改用 `pending_changes.stage` 整文件暂存。",
   "**何时调用**：",
   "- 需要在指定 anchor（行特征）后插入代码（hook 注入、import 添加）",
   "- 重命名一个标识符（rename_symbol，全文件词边界匹配）",
@@ -10978,6 +10987,7 @@ var description16 = [
   "**何时不需要**：",
   "- 整文件重写更合理（直接 pending-changes.stage 整文件）",
   "- 只是 1-2 个字符的 typo（用 edit 工具更直接）",
+  "- 多行 anchor / 跨行匹配（请用 pending_changes.stage 整文件）",
   "**安全约束**：",
   "- 必须传 before_hash（如果文件已存在），不一致会被拒绝",
   "- 默认 auto_stage=true：结果直接进 pending-changes 等待人审，不立刻落盘"
@@ -10995,7 +11005,7 @@ var AnchorAction = Common.extend({
     "insert_after_anchor",
     "insert_before_anchor"
   ]),
-  anchor: z17.string().min(1).describe("anchor 文本子串或正则源"),
+  anchor: z17.string().min(1).describe("anchor 文本子串或正则源（必须单行；含 \\n 会被拒绝，多行改动请用 pending_changes.stage）"),
   regex: z17.boolean().optional().describe("anchor 是否按 RegExp 解释，默认 false"),
   occurrence: z17.number().int().min(1).optional().describe("第几次匹配（1-based），默认 1；多次命中时必须显式指定"),
   payload: z17.string().describe("要写入的内容；引擎会按文件原 EOL 处理")
@@ -13517,76 +13527,146 @@ var codeforgeToolsServer = async (ctx) => {
 };
 var handler8 = codeforgeToolsServer;
 
-// plugins/hello-world.ts
-init_opencode_plugin_helpers();
-var PLUGIN_NAME9 = "hello-world";
-var PLUGIN_VERSION = "1.0.0";
-try {
-  logLifecycle(PLUGIN_NAME9, "import", { version: PLUGIN_VERSION });
-  safeWriteLog(PLUGIN_NAME9, { phase: "import", version: PLUGIN_VERSION });
-} catch (importErr) {
-  console.error(`[${PLUGIN_NAME9}] import lifecycle log failed:`, importErr);
-}
-var helloWorldServer = async (ctx) => {
-  logLifecycle(PLUGIN_NAME9, "activate", {
-    version: PLUGIN_VERSION,
-    directory: ctx.directory,
-    worktree: ctx.worktree,
-    projectId: ctx.project?.id
-  });
-  await safeAsync(PLUGIN_NAME9, "client.app.log", async () => {
-    await ctx.client.app.log({
-      body: {
-        service: PLUGIN_NAME9,
-        level: "info",
-        message: `${PLUGIN_NAME9} v${PLUGIN_VERSION} activated in ${ctx.directory}`
-      }
+// plugins/kh-auto-context.ts
+init_kh_client();
+
+// lib/kh-shared-context.ts
+var DEFAULT_MAX_PER_SESSION = 20;
+var DEFAULT_TTL_MS = 5 * 60 * 1000;
+
+class SessionScopedCache {
+  cache = new Map;
+  inflight = new Map;
+  generation = new Map;
+  ttlMs;
+  maxPerSession;
+  now;
+  constructor(opts = {}) {
+    this.ttlMs = opts.ttlMs ?? DEFAULT_TTL_MS;
+    this.maxPerSession = opts.maxPerSession ?? DEFAULT_MAX_PER_SESSION;
+    this.now = opts.now ?? (() => Date.now());
+  }
+  async searchOrGet(args) {
+    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);
+      if (entry && this.now() - entry.cachedAt < this.ttlMs) {
+        sessionMap.delete(queryHash);
+        sessionMap.set(queryHash, entry);
+        return entry.result;
+      }
+      if (entry)
+        sessionMap.delete(queryHash);
+    }
+    const pending = this.inflight.get(inflightKey);
+    if (pending)
+      return pending;
+    const startGen = this.generation.get(sessionId) ?? 0;
+    const promise = this.doSearchAndMaybeCache(client, sessionId, queryHash, query, limit, timeoutMs, startGen).finally(() => {
+      this.inflight.delete(inflightKey);
     });
-  });
-  return {
-    event: async ({ event }) => {
-      await safeAsync(PLUGIN_NAME9, "event", async () => {
-        const e = event;
-        const propKeys = e.properties && typeof e.properties === "object" ? Object.keys(e.properties).slice(0, 10) : [];
-        safeWriteLog(PLUGIN_NAME9, {
-          hook: "event",
-          type: e.type ?? "unknown",
-          propKeys
-        });
-      });
-    },
-    "chat.message": async (input, output) => {
-      await safeAsync(PLUGIN_NAME9, "chat.message", async () => {
-        const text = extractUserText(output);
-        safeWriteLog(PLUGIN_NAME9, {
-          hook: "chat.message",
-          sessionID: input.sessionID,
-          agent: input.agent,
-          messageID: input.messageID,
-          textPreview: text.slice(0, 80),
-          textLen: text.length,
-          partsCount: output.parts?.length ?? 0
-        });
-      });
-    },
-    "tool.execute.before": async (input, _output) => {
-      await safeAsync(PLUGIN_NAME9, "tool.execute.before", async () => {
-        safeWriteLog(PLUGIN_NAME9, {
-          hook: "tool.execute.before",
-          tool: input.tool,
-          sessionID: input.sessionID,
-          callID: input.callID
-        });
+    this.inflight.set(inflightKey, promise);
+    return promise;
+  }
+  onSessionEnd(sessionId) {
+    this.generation.set(sessionId, (this.generation.get(sessionId) ?? 0) + 1);
+    this.cache.delete(sessionId);
+    const prefix = `${sessionId}::`;
+    for (const key of this.inflight.keys()) {
+      if (key.startsWith(prefix)) {
+        this.inflight.delete(key);
+      }
+    }
+  }
+  _snapshot() {
+    const perSession = {};
+    let total = 0;
+    for (const [sid, map] of this.cache.entries()) {
+      perSession[sid] = map.size;
+      total += map.size;
+    }
+    const generations = {};
+    for (const [sid, g] of this.generation.entries()) {
+      generations[sid] = g;
+    }
+    return {
+      cacheSize: total,
+      inflightSize: this.inflight.size,
+      sessions: Array.from(this.cache.keys()),
+      perSession,
+      generations
+    };
+  }
+  _reset() {
+    this.cache.clear();
+    this.inflight.clear();
+    this.generation.clear();
+  }
+  hashQuery(sessionId, query) {
+    return `${sessionId}::${query}`;
+  }
+  async doSearchAndMaybeCache(client, sessionId, queryHash, query, limit, timeoutMs, startGen) {
+    const result = await this.doSearch(client, query, limit, timeoutMs);
+    const currentGen = this.generation.get(sessionId) ?? 0;
+    if (currentGen === startGen && result.ok) {
+      this.writeCache(sessionId, queryHash, query, result);
+    }
+    return result;
+  }
+  async doSearch(client, query, limit, timeoutMs) {
+    const callPromise = (async () => {
+      try {
+        return await client.search({ query, limit });
+      } catch (err) {
+        return {
+          ok: false,
+          reason: "kh_returned_error",
+          message: err instanceof Error ? err.message : String(err)
+        };
+      }
+    })();
+    if (timeoutMs === undefined || timeoutMs <= 0) {
+      return callPromise;
+    }
+    let timer = null;
+    try {
+      const racer = new Promise((res) => {
+        timer = setTimeout(() => res({
+          ok: false,
+          reason: "kh_returned_error",
+          message: `kh search timeout after ${timeoutMs}ms`
+        }), timeoutMs);
       });
+      return await Promise.race([callPromise, racer]);
+    } finally {
+      if (timer)
+        clearTimeout(timer);
     }
-  };
-};
-var handler9 = helloWorldServer;
+  }
+  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;
+      if (oldest === undefined)
+        break;
+      sessionMap.delete(oldest);
+    }
+  }
+}
+var sharedKhCache = new SessionScopedCache;
 
 // plugins/kh-auto-context.ts
-init_kh_client();
 init_opencode_plugin_helpers();
-var PLUGIN_NAME10 = "kh-auto-context";
+var PLUGIN_NAME9 = "kh-auto-context";
 var INJECTION_MODE = "observe-only";
 function resolveInjectionMode(client) {
   return client.hasTransport() ? "system-injected" : "observe-only";
@@ -13685,7 +13765,7 @@ var CODEFORGE_CONSTRAINTS = [
 ];
 async function seedConstraints(client, log6) {
   if (!client.hasTransport()) {
-    log6?.debug?.(`[${PLUGIN_NAME10}] seedConstraints: transport 不可用，跳过`, {});
+    log6?.debug?.(`[${PLUGIN_NAME9}] seedConstraints: transport 不可用，跳过`, {});
     return { ok: false, reason: "transport_unavailable" };
   }
   try {
@@ -13699,7 +13779,7 @@ async function seedConstraints(client, log6) {
     });
     if (result && typeof result === "object" && "ok" in result && result.ok === false) {
       const r = result;
-      log6?.warn(`[${PLUGIN_NAME10}] seedConstraints 降级`, {
+      log6?.warn(`[${PLUGIN_NAME9}] seedConstraints 降级`, {
         reason: r.reason,
         message: r.message
       });
@@ -13709,11 +13789,11 @@ async function seedConstraints(client, log6) {
         message: r.message
       };
     }
-    log6?.info(`[${PLUGIN_NAME10}] seedConstraints: 已写入 ${CODEFORGE_CONSTRAINTS.length} 条 constraints`, { count: CODEFORGE_CONSTRAINTS.length });
+    log6?.info(`[${PLUGIN_NAME9}] 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_NAME10}] seedConstraints 失败（已静默）`, { error: message });
+    log6?.warn(`[${PLUGIN_NAME9}] seedConstraints 失败（已静默）`, { error: message });
     return { ok: false, reason: "exception", message };
   }
 }
@@ -13728,7 +13808,7 @@ function createSystemInjectedHook(client, sessionId, log6) {
       });
       if (result && typeof result === "object" && "ok" in result && result.ok === false) {
         const r = result;
-        log6?.warn(`[${PLUGIN_NAME10}] system-injected 降级到 observe-only：${r.reason ?? "unknown"}`, {
+        log6?.warn(`[${PLUGIN_NAME9}] system-injected 降级到 observe-only：${r.reason ?? "unknown"}`, {
           sessionId,
           section,
           preview: markdown.slice(0, 200),
@@ -13737,12 +13817,12 @@ function createSystemInjectedHook(client, sessionId, log6) {
         });
         return;
       }
-      log6?.info(`[${PLUGIN_NAME10}] system-injected: 写入 KH working_memory 成功 (${markdown.length} chars)`, {
+      log6?.info(`[${PLUGIN_NAME9}] system-injected: 写入 KH working_memory 成功 (${markdown.length} chars)`, {
         sessionId,
         section
       });
     } catch (err) {
-      log6?.warn(`[${PLUGIN_NAME10}] system-injected 抛异常，降级到 observe-only`, {
+      log6?.warn(`[${PLUGIN_NAME9}] system-injected 抛异常，降级到 observe-only`, {
         sessionId,
         section,
         preview: markdown.slice(0, 200),
@@ -13751,23 +13831,16 @@ function createSystemInjectedHook(client, sessionId, log6) {
     }
   };
 }
-async function handleMessage2(raw, opts) {
+var inflight2 = new Set;
+var INFLIGHT_CAP = 5;
+function inflightKey(sessionId, query) {
+  return `${sessionId ?? "global"}:${Date.now()}:${Math.random().toString(36).slice(2, 10)}`;
+}
+async function runKhSearchAndInject(args) {
+  const { query, ctx, opts, mode } = args;
   const cfg = opts.config ?? DEFAULT_CONFIG5;
-  const mode = opts.mode ?? INJECTION_MODE;
-  const ctx = raw ?? {};
   const log6 = ctx.log;
-  const text = (ctx.content ?? "").trim();
-  if (!shouldInject(text, cfg)) {
-    log6?.debug?.(`[${PLUGIN_NAME10}] skip (filter)`, { textLen: text.length });
-    return null;
-  }
-  const query = extractQuery(text);
-  if (!query)
-    return null;
-  if (opts.cache.shouldSkip(query)) {
-    log6?.debug?.(`[${PLUGIN_NAME10}] cache hit, skip`, { query });
-    return null;
-  }
+  const startedAt = Date.now();
   const racer = opts.scheduler?.raceTimeout ?? (async (p, ms) => {
     let timer = null;
     try {
@@ -13782,20 +13855,54 @@ async function handleMessage2(raw, opts) {
         clearTimeout(timer);
     }
   });
-  const result = await racer(opts.client.search({ query, limit: cfg.limit }), cfg.timeoutMs);
+  let result;
+  try {
+    const searchPromise = sharedKhCache.searchOrGet({
+      client: opts.client,
+      sessionId: ctx.sessionId ?? "global",
+      query,
+      limit: cfg.limit
+    });
+    result = await racer(searchPromise, cfg.timeoutMs);
+  } catch (err) {
+    log6?.warn(`[${PLUGIN_NAME9}] client.search threw (sync or async), return null`, {
+      query,
+      elapsedMs: Date.now() - startedAt,
+      sessionId: ctx.sessionId,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    opts.cache.record(query, []);
+    return null;
+  }
   if (result === "__timeout__") {
-    log6?.warn(`[${PLUGIN_NAME10}] timeout`, { query, ms: cfg.timeoutMs });
+    log6?.warn(`[${PLUGIN_NAME9}] timeout`, {
+      query,
+      ms: cfg.timeoutMs,
+      elapsedMs: Date.now() - startedAt,
+      sessionId: ctx.sessionId
+    });
     opts.cache.record(query, []);
     return null;
   }
   if (!result.ok) {
-    log6?.debug?.(`[${PLUGIN_NAME10}] kh degraded`, { reason: result.reason });
+    log6?.warn(`[${PLUGIN_NAME9}] kh degraded`, {
+      reason: result.reason,
+      query,
+      elapsedMs: Date.now() - startedAt,
+      sessionId: ctx.sessionId
+    });
     opts.cache.record(query, []);
     return null;
   }
   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`, {
+      query,
+      rawCount: result.insights.length,
+      elapsedMs: Date.now() - startedAt,
+      sessionId: ctx.sessionId
+    });
     return null;
   }
   const payload = formatInjection(query, filtered, mode);
@@ -13803,22 +13910,68 @@ async function handleMessage2(raw, opts) {
     try {
       await ctx.injectContext(payload.markdown);
     } catch (err) {
-      log6?.warn(`[${PLUGIN_NAME10}] injectContext threw`, {
-        error: err instanceof Error ? err.message : String(err)
+      log6?.warn(`[${PLUGIN_NAME9}] injectContext threw`, {
+        error: err instanceof Error ? err.message : String(err),
+        query,
+        sessionId: ctx.sessionId
       });
     }
   }
   opts.cache.record(query, filtered);
-  log6?.info(`[${PLUGIN_NAME10}] ${mode}: ${filtered.length} candidate insights ready`, { query, mode });
+  log6?.info(`[${PLUGIN_NAME9}] inject complete (${mode})`, {
+    query,
+    mode,
+    candidateCount: filtered.length,
+    elapsedMs: Date.now() - startedAt,
+    sessionId: ctx.sessionId
+  });
   return payload;
 }
-logLifecycle(PLUGIN_NAME10, "import");
+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 text = (ctx.content ?? "").trim();
+  if (!shouldInject(text, cfg)) {
+    log6?.debug?.(`[${PLUGIN_NAME9}] 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 });
+    return;
+  }
+  if (inflight2.size >= INFLIGHT_CAP) {
+    log6?.warn(`[${PLUGIN_NAME9}] inflight cap reached, skip`, {
+      query,
+      inflightSize: inflight2.size,
+      cap: INFLIGHT_CAP,
+      sessionId: ctx.sessionId
+    });
+    return;
+  }
+  const key = inflightKey(ctx.sessionId, query);
+  inflight2.add(key);
+  runKhSearchAndInject({ query, ctx, opts, mode }).catch((err) => {
+    log6?.warn(`[${PLUGIN_NAME9}] runKhSearchAndInject 顶层兜底捕获`, {
+      error: err instanceof Error ? err.message : String(err),
+      query,
+      sessionId: ctx.sessionId
+    });
+  }).finally(() => {
+    inflight2.delete(key);
+  });
+}
+logLifecycle(PLUGIN_NAME9, "import");
 var sharedClient2 = new KhClient;
 var sharedCache = new QueryCache(DEFAULT_CONFIG5.cacheTtlMs);
 var khAutoContextServer = async (ctx) => {
-  const log6 = makePluginLogger(PLUGIN_NAME10);
+  const log6 = makePluginLogger(PLUGIN_NAME9);
   const runtimeMode = resolveInjectionMode(sharedClient2);
-  logLifecycle(PLUGIN_NAME10, "activate", {
+  logLifecycle(PLUGIN_NAME9, "activate", {
     directory: ctx.directory,
     minConfidence: DEFAULT_CONFIG5.minConfidence,
     timeoutMs: DEFAULT_CONFIG5.timeoutMs,
@@ -13832,7 +13985,7 @@ var khAutoContextServer = async (ctx) => {
   });
   return {
     "chat.message": async (input, output) => {
-      await safeAsync(PLUGIN_NAME10, "chat.message", async () => {
+      await safeAsync(PLUGIN_NAME9, "chat.message", async () => {
         const text = extractUserText(output);
         if (!text)
           return;
@@ -13850,10 +14003,25 @@ var khAutoContextServer = async (ctx) => {
           log: log6
         }, { client: sharedClient2, cache: sharedCache, mode: runtimeMode });
       });
+    },
+    event: async ({ event }) => {
+      await safeAsync(PLUGIN_NAME9, "event", async () => {
+        const e = event;
+        if (e.type !== "session.idle")
+          return;
+        const props = e.properties;
+        const sid = props?.sessionID;
+        if (typeof sid !== "string" || !sid)
+          return;
+        sharedKhCache.onSessionEnd(sid);
+        log6.debug?.(`[${PLUGIN_NAME9}] session.idle: cleared shared cache`, {
+          sessionID: sid
+        });
+      });
     }
   };
 };
-var handler10 = khAutoContextServer;
+var handler9 = khAutoContextServer;
 
 // plugins/kh-reminder.ts
 init_opencode_plugin_helpers();
@@ -13974,8 +14142,8 @@ async function condense(input, opts = {}) {
 }
 
 // plugins/kh-reminder.ts
-var PLUGIN_NAME11 = "kh-reminder";
-logLifecycle(PLUGIN_NAME11, "import", {});
+var PLUGIN_NAME10 = "kh-reminder";
+logLifecycle(PLUGIN_NAME10, "import", {});
 var TRIGGER_WORDS_ZH = [
   "怎么",
   "怎样",
@@ -14129,7 +14297,7 @@ function handleObserve(raw, log6) {
     const result = evaluate(ctx);
     if (result.triggered && result.reason) {
       const reasonStr = formatReason(result.reason);
-      log6?.info(`[${PLUGIN_NAME11}] ⚡ KH 提醒（observe-only） · session=${result.sessionId} · ${reasonStr}`, {
+      log6?.info(`[${PLUGIN_NAME10}] ⚡ KH 提醒（observe-only） · session=${result.sessionId} · ${reasonStr}`, {
         sessionId: result.sessionId,
         reason: result.reason,
         suggestion: "调用 smart_search 查项目历史；完成后用 save_chat_insight 沉淀"
@@ -14137,7 +14305,7 @@ function handleObserve(raw, log6) {
     }
     return result;
   } catch (err) {
-    log6?.warn(`[${PLUGIN_NAME11}] evaluate 异常（已隔离）`, {
+    log6?.warn(`[${PLUGIN_NAME10}] evaluate 异常（已隔离）`, {
       error: err instanceof Error ? err.message : String(err)
     });
     return null;
@@ -14153,9 +14321,9 @@ function formatReason(r) {
       return `no-search-in-recent-rounds (last ${r.rounds})`;
   }
 }
-var log6 = makePluginLogger(PLUGIN_NAME11);
+var log6 = makePluginLogger(PLUGIN_NAME10);
 var khReminderServer = async (ctx) => {
-  logLifecycle(PLUGIN_NAME11, "activate", {
+  logLifecycle(PLUGIN_NAME10, "activate", {
     directory: ctx.directory,
     threshold: DEFAULT_THRESHOLD,
     cooldown_ms: COOLDOWN_MS,
@@ -14163,7 +14331,7 @@ var khReminderServer = async (ctx) => {
   });
   return {
     "experimental.chat.messages.transform": async (_input, output) => {
-      await safeAsync(PLUGIN_NAME11, "experimental.chat.messages.transform", async () => {
+      await safeAsync(PLUGIN_NAME10, "experimental.chat.messages.transform", async () => {
         const list = output.messages;
         if (!Array.isArray(list) || list.length === 0)
           return;
@@ -14182,7 +14350,7 @@ var khReminderServer = async (ctx) => {
         const result = handleObserve({ messages: flat, sessionId }, log6);
         if (!result)
           return;
-        safeWriteLog(PLUGIN_NAME11, {
+        safeWriteLog(PLUGIN_NAME10, {
           hook: "experimental.chat.messages.transform",
           mode: "observe-only",
           sessionId: result.sessionId,
@@ -14195,7 +14363,7 @@ var khReminderServer = async (ctx) => {
     }
   };
 };
-var handler11 = khReminderServer;
+var handler10 = khReminderServer;
 
 // lib/memories.ts
 import { promises as fs8 } from "node:fs";
@@ -14397,7 +14565,7 @@ function bagOfWordsScore(query, doc) {
 
 // plugins/memories-context.ts
 init_opencode_plugin_helpers();
-var PLUGIN_NAME12 = "memories-context";
+var PLUGIN_NAME11 = "memories-context";
 var INJECTION_MODE2 = "observe-only";
 var DEFAULT_CONFIG6 = {
   minTextLength: 8,
@@ -14495,14 +14663,14 @@ async function handleMessage3(raw, opts) {
     return await handleDirective(dir, ctx, opts.memCfg, log7);
   }
   if (!shouldRecall(text, cfg)) {
-    log7?.debug?.(`[${PLUGIN_NAME12}] skip (filter)`, { textLen: text.length });
+    log7?.debug?.(`[${PLUGIN_NAME11}] 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_NAME12}] cache hit`, { query });
+    log7?.debug?.(`[${PLUGIN_NAME11}] cache hit`, { query });
     return { kind: "noop", reason: "cache", mode: INJECTION_MODE2 };
   }
   const racer = opts.scheduler?.raceTimeout ?? (async (p, ms) => {
@@ -14527,7 +14695,7 @@ async function handleMessage3(raw, opts) {
   }, opts.memCfg);
   const result = await racer(injectPromise, cfg.timeoutMs);
   if (result === "__timeout__") {
-    log7?.warn(`[${PLUGIN_NAME12}] timeout`, { query, ms: cfg.timeoutMs });
+    log7?.warn(`[${PLUGIN_NAME11}] timeout`, { query, ms: cfg.timeoutMs });
     cache2.record(query, 0);
     return { kind: "noop", reason: "timeout", mode: INJECTION_MODE2 };
   }
@@ -14539,13 +14707,13 @@ async function handleMessage3(raw, opts) {
     try {
       await ctx.injectContext(result.text);
     } catch (err) {
-      log7?.warn(`[${PLUGIN_NAME12}] injectContext threw`, {
+      log7?.warn(`[${PLUGIN_NAME11}] injectContext threw`, {
         error: err instanceof Error ? err.message : String(err)
       });
     }
   }
   cache2.record(query, result.recalled);
-  log7?.info(`[${PLUGIN_NAME12}] observe-only: ${result.used}/${result.recalled} memories ready`, { query, mode: INJECTION_MODE2 });
+  log7?.info(`[${PLUGIN_NAME11}] 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) {
@@ -14554,14 +14722,14 @@ async function handleDirective(dir, ctx, memCfg, log7) {
     if (r.ok) {
       const target = r.written_to === "kh" ? "KH" : "本地";
       await safeReply(ctx, `\uD83E\uDDE0 已记住（${dir.scope} / ${target}，id=${r.id}）`);
-      log7?.info(`[${PLUGIN_NAME12}] /remember ok`, {
+      log7?.info(`[${PLUGIN_NAME11}] /remember ok`, {
         scope: dir.scope,
         id: r.id,
         mode: INJECTION_MODE2
       });
     } else {
       await safeReply(ctx, `❌ 记忆失败：${r.error ?? "unknown"}`);
-      log7?.warn(`[${PLUGIN_NAME12}] /remember failed`, { error: r.error });
+      log7?.warn(`[${PLUGIN_NAME11}] /remember failed`, { error: r.error });
     }
     return { kind: "remembered", result: r, mode: INJECTION_MODE2 };
   }
@@ -14592,22 +14760,22 @@ async function safeReply(ctx, text) {
     await ctx.reply(text);
   } catch {}
 }
-logLifecycle(PLUGIN_NAME12, "import");
+logLifecycle(PLUGIN_NAME11, "import");
 var sharedCache2 = new QueryCache2(DEFAULT_CONFIG6.cacheTtlMs);
 function buildMemCfg(directory) {
   return { projectRoot: directory };
 }
 var memoriesContextServer = async (ctx) => {
-  const log7 = makePluginLogger(PLUGIN_NAME12);
+  const log7 = makePluginLogger(PLUGIN_NAME11);
   const memCfg = buildMemCfg(ctx.directory);
-  logLifecycle(PLUGIN_NAME12, "activate", {
+  logLifecycle(PLUGIN_NAME11, "activate", {
     directory: ctx.directory,
     projectRoot: memCfg.projectRoot,
     mode: INJECTION_MODE2
   });
   return {
     "chat.message": async (input, output) => {
-      await safeAsync(PLUGIN_NAME12, "chat.message", async () => {
+      await safeAsync(PLUGIN_NAME11, "chat.message", async () => {
         const text = extractUserText(output);
         if (!text)
           return;
@@ -14633,18 +14801,18 @@ var memoriesContextServer = async (ctx) => {
     }
   };
 };
-var handler12 = memoriesContextServer;
+var handler11 = memoriesContextServer;
 
 // plugins/model-fallback.ts
 init_opencode_plugin_helpers();
-var PLUGIN_NAME13 = "model-fallback";
+var PLUGIN_NAME12 = "model-fallback";
 var state2 = {
   config: null,
   configPath: null,
   warnings: [],
   error: null
 };
-logLifecycle(PLUGIN_NAME13, "import");
+logLifecycle(PLUGIN_NAME12, "import");
 function loadOnce(root) {
   if (state2.config !== null || state2.error !== null)
     return;
@@ -14654,11 +14822,11 @@ function loadOnce(root) {
     state2.configPath = r.path ?? null;
     state2.warnings = r.warnings;
     if (r.warnings.length > 0) {
-      safeWriteLog(PLUGIN_NAME13, { phase: "load.warnings", warnings: r.warnings });
+      safeWriteLog(PLUGIN_NAME12, { phase: "load.warnings", warnings: r.warnings });
     }
   } else {
     state2.error = r.error ?? "unknown_load_error";
-    safeWriteLog(PLUGIN_NAME13, { phase: "load.failed", error: state2.error, path: r.path });
+    safeWriteLog(PLUGIN_NAME12, { phase: "load.failed", error: state2.error, path: r.path });
   }
 }
 var MODEL_ERR_PATTERNS = [
@@ -14703,9 +14871,9 @@ fallback 链已用尽：${meta.chain.join(" → ")}`;
 完整链：${meta.chain.join(" → ")}`;
 }
 var modelFallbackServer = async (ctx) => {
-  const log7 = makePluginLogger(PLUGIN_NAME13);
+  const log7 = makePluginLogger(PLUGIN_NAME12);
   loadOnce(ctx.directory ?? process.cwd());
-  logLifecycle(PLUGIN_NAME13, "activate", {
+  logLifecycle(PLUGIN_NAME12, "activate", {
     directory: ctx.directory,
     config_path: state2.configPath,
     config_loaded: state2.config !== null,
@@ -14715,7 +14883,7 @@ var modelFallbackServer = async (ctx) => {
   });
   return {
     "chat.params": async (input, output) => {
-      await safeAsync(PLUGIN_NAME13, "chat.params", async () => {
+      await safeAsync(PLUGIN_NAME12, "chat.params", async () => {
         if (!state2.config)
           return;
         const agent = input.agent;
@@ -14736,7 +14904,7 @@ var modelFallbackServer = async (ctx) => {
           next: meta.next_fallback,
           source: meta.source
         };
-        safeWriteLog(PLUGIN_NAME13, {
+        safeWriteLog(PLUGIN_NAME12, {
           hook: "chat.params",
           agent,
           model: currentModel,
@@ -14746,7 +14914,7 @@ var modelFallbackServer = async (ctx) => {
       });
     },
     event: async ({ event }) => {
-      await safeAsync(PLUGIN_NAME13, "event", async () => {
+      await safeAsync(PLUGIN_NAME12, "event", async () => {
         if (!state2.config)
           return;
         const e = event;
@@ -14762,8 +14930,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_NAME13}] ${suggestion}`);
-        safeWriteLog(PLUGIN_NAME13, {
+        log7.warn(`[${PLUGIN_NAME12}] ${suggestion}`);
+        safeWriteLog(PLUGIN_NAME12, {
           hook: "event.error",
           eventType: e.type,
           agent,
@@ -14775,19 +14943,24 @@ var modelFallbackServer = async (ctx) => {
     }
   };
 };
-var handler13 = modelFallbackServer;
+var handler12 = modelFallbackServer;
 
 // plugins/subtask-heartbeat.ts
 init_opencode_plugin_helpers();
-var PLUGIN_NAME14 = "subtask-heartbeat";
-logLifecycle(PLUGIN_NAME14, "import", {});
+var PLUGIN_NAME13 = "subtask-heartbeat";
+logLifecycle(PLUGIN_NAME13, "import", {});
 var HEARTBEAT_INTERVAL_MS2 = 30000;
 var HEARTBEAT_DEBOUNCE_MS = 25000;
 var TOAST_DURATION_MS3 = 5000;
 var START_TOAST_DURATION_MS = 2000;
-var inflight2 = new Map;
+var PENDING_TASK_TTL_MS = 60000;
+var PENDING_TASK_MAX_PARENTS = 64;
+var PENDING_TASK_MAX_PER_PARENT = 16;
+var DESCRIPTION_MAX_LEN = 60;
+var inflight3 = new Map;
+var pendingTask = new Map;
 function _snapshotInflight() {
-  return [...inflight2.values()].map((r) => ({ ...r }));
+  return [...inflight3.values()].map((r) => ({ ...r }));
 }
 function getInflightSnapshot() {
   return _snapshotInflight();
@@ -14829,20 +15002,97 @@ function extractEndedSessionID(event) {
   }
   return null;
 }
+function extractSubtaskPart(event) {
+  if (!event || typeof event !== "object")
+    return null;
+  const e = event;
+  if (e.type !== "message.part.updated")
+    return null;
+  const part = e.properties?.part;
+  if (!part || typeof part !== "object")
+    return null;
+  const p = part;
+  if (p.type !== "subtask")
+    return null;
+  if (typeof p.sessionID !== "string" || p.sessionID === "")
+    return null;
+  if (typeof p.agent !== "string" || p.agent === "")
+    return null;
+  if (typeof p.description !== "string" || p.description === "")
+    return null;
+  return { parentID: p.sessionID, agent: p.agent, description: p.description };
+}
+function enqueuePendingTask(parentID, entry, now = Date.now()) {
+  const ts = entry.ts ?? now;
+  let bucket = pendingTask.get(parentID);
+  if (!bucket) {
+    if (pendingTask.size >= PENDING_TASK_MAX_PARENTS) {
+      let oldestKey = null;
+      let oldestTs = Number.POSITIVE_INFINITY;
+      for (const [k, v] of pendingTask.entries()) {
+        const headTs = v[0]?.ts ?? Number.POSITIVE_INFINITY;
+        if (headTs < oldestTs) {
+          oldestTs = headTs;
+          oldestKey = k;
+        }
+      }
+      if (oldestKey !== null)
+        pendingTask.delete(oldestKey);
+    }
+    bucket = [];
+    pendingTask.set(parentID, bucket);
+  }
+  bucket.push({ agent: entry.agent, description: entry.description, ts });
+  while (bucket.length > PENDING_TASK_MAX_PER_PARENT) {
+    bucket.shift();
+  }
+}
+function dequeuePendingTask(parentID, now = Date.now()) {
+  const bucket = pendingTask.get(parentID);
+  if (!bucket || bucket.length === 0) {
+    if (bucket)
+      pendingTask.delete(parentID);
+    return null;
+  }
+  while (bucket.length > 0 && now - bucket[0].ts > PENDING_TASK_TTL_MS) {
+    bucket.shift();
+  }
+  if (bucket.length === 0) {
+    pendingTask.delete(parentID);
+    return null;
+  }
+  const entry = bucket.shift();
+  if (bucket.length === 0)
+    pendingTask.delete(parentID);
+  return entry;
+}
+function sweepExpiredPendingTasks(now = Date.now()) {
+  let removed = 0;
+  for (const [parentID, bucket] of [...pendingTask.entries()]) {
+    while (bucket.length > 0 && now - bucket[0].ts > PENDING_TASK_TTL_MS) {
+      bucket.shift();
+      removed++;
+    }
+    if (bucket.length === 0)
+      pendingTask.delete(parentID);
+  }
+  return removed;
+}
 function registerInflight(payload, now = Date.now()) {
   const r = {
     childID: payload.childID,
     parentID: payload.parentID,
     agent: payload.agent,
+    description: payload.description ?? null,
     startedAt: now,
     lastBeatAt: now,
     lastTool: null
   };
-  inflight2.set(payload.childID, r);
+  inflight3.set(payload.childID, r);
   return r;
 }
 function recordToolBeat(sessionID, tool2, now = Date.now()) {
-  const r = inflight2.get(sessionID);
+  const r = inflight3.get(sessionID);
   if (!r)
     return null;
   r.lastBeatAt = now;
@@ -14850,15 +15100,15 @@ function recordToolBeat(sessionID, tool2, now = Date.now()) {
   return r;
 }
 function clearInflight2(sessionID) {
-  const r = inflight2.get(sessionID);
+  const r = inflight3.get(sessionID);
   if (!r)
     return null;
-  inflight2.delete(sessionID);
+  inflight3.delete(sessionID);
   return r;
 }
 function pickHeartbeats(now = Date.now()) {
   const out = [];
-  for (const r of inflight2.values()) {
+  for (const r of inflight3.values()) {
     if (now - r.lastBeatAt >= HEARTBEAT_DEBOUNCE_MS)
       out.push(r);
   }
@@ -14870,10 +15120,32 @@ function fmtElapsed(ms) {
   const s = total % 60;
   return m > 0 ? `${m}m${s.toString().padStart(2, "0")}s` : `${s}s`;
 }
+function titleCase(s) {
+  if (!s)
+    return s;
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function sanitizeDescription(s) {
+  const collapsed = s.replace(/[\r\n\t]+/g, " ").replace(/\s+/g, " ").trim();
+  if (collapsed.length <= DESCRIPTION_MAX_LEN)
+    return collapsed;
+  return collapsed.slice(0, DESCRIPTION_MAX_LEN) + "…";
+}
 function buildStartToast(r) {
-  const who = r.agent ?? "subagent";
+  if (r.agent && r.description) {
+    return {
+      message: `\uD83D\uDE80 ${titleCase(r.agent)} 启动 — ${sanitizeDescription(r.description)}`,
+      variant: "info"
+    };
+  }
+  if (r.agent) {
+    return {
+      message: `\uD83D\uDE80 ${titleCase(r.agent)} 启动`,
+      variant: "info"
+    };
+  }
   return {
-    message: `\uD83D\uDE80 子 session 启动: ${who}`,
+    message: `\uD83D\uDE80 子 session 启动: subagent`,
     variant: "info"
   };
 }
@@ -14886,15 +15158,32 @@ function buildHeartbeatToast(r, now = Date.now()) {
   };
 }
 function buildEndToast(r, type, now = Date.now()) {
-  const who = r.agent ?? "subagent";
   const elapsed = fmtElapsed(now - r.startedAt);
-  if (type === "session.error") {
-    return { message: `❌ ${who} 失败 (${elapsed})`, variant: "error" };
+  const variant = type === "session.error" || type === "session.deleted" ? "error" : "success";
+  const emoji = type === "session.error" ? "❌" : type === "session.deleted" ? "\uD83D\uDDD1️" : "✅";
+  const verb = type === "session.error" ? "失败" : type === "session.deleted" ? "被取消" : "完成";
+  if (r.agent && r.description) {
+    if (type === "session.idle" || type !== "session.error" && type !== "session.deleted") {
+      return {
+        message: `${emoji} ${titleCase(r.agent)} Task — ${sanitizeDescription(r.description)} (${elapsed})`,
+        variant
+      };
+    }
+    return {
+      message: `${emoji} ${titleCase(r.agent)} ${verb} — ${sanitizeDescription(r.description)} (${elapsed})`,
+      variant
+    };
   }
-  if (type === "session.deleted") {
-    return { message: `\uD83D\uDDD1️ ${who} 被取消 (${elapsed})`, variant: "error" };
+  if (r.agent) {
+    return {
+      message: `${emoji} ${titleCase(r.agent)} ${verb} (${elapsed})`,
+      variant
+    };
   }
-  return { message: `✅ ${who} 完成 (${elapsed})`, variant: "success" };
+  return {
+    message: `${emoji} subagent ${verb} (${elapsed})`,
+    variant
+  };
 }
 function normalizeVariant3(raw) {
   if (raw === "info" || raw === "warning")
@@ -14923,22 +15212,26 @@ async function showToast3(client, payload, log7) {
     return false;
   }
 }
-var log7 = makePluginLogger(PLUGIN_NAME14);
+var log7 = makePluginLogger(PLUGIN_NAME13);
 var subtaskHeartbeatServer = async (ctx) => {
-  logLifecycle(PLUGIN_NAME14, "activate", {
+  logLifecycle(PLUGIN_NAME13, "activate", {
     directory: ctx.directory,
     intervalMs: HEARTBEAT_INTERVAL_MS2
   });
   const client = ctx.client;
   const interval = setInterval(() => {
-    safeAsync(PLUGIN_NAME14, "interval", async () => {
+    safeAsync(PLUGIN_NAME13, "interval", async () => {
+      const swept = sweepExpiredPendingTasks();
+      if (swept > 0) {
+        safeWriteLog(PLUGIN_NAME13, { 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_NAME14, {
+        safeWriteLog(PLUGIN_NAME13, {
           hook: "interval",
           child: r.childID,
           parent: r.parentID,
@@ -14955,23 +15248,47 @@ var subtaskHeartbeatServer = async (ctx) => {
   }
   return {
     event: async ({ event }) => {
-      await safeAsync(PLUGIN_NAME14, "event", async () => {
+      await safeAsync(PLUGIN_NAME13, "event", async () => {
+        const subtask = extractSubtaskPart(event);
+        if (subtask) {
+          enqueuePendingTask(subtask.parentID, {
+            agent: subtask.agent,
+            description: subtask.description
+          });
+          safeWriteLog(PLUGIN_NAME13, {
+            hook: "event",
+            type: "message.part.updated.subtask",
+            parent: subtask.parentID,
+            agent: subtask.agent,
+            description_len: subtask.description.length
+          });
+          return;
+        }
         const created = extractCreatedChild(event);
         if (created) {
-          const record = registerInflight(created);
-          safeWriteLog(PLUGIN_NAME14, {
+          const pending = dequeuePendingTask(created.parentID);
+          const record = registerInflight({
+            childID: created.childID,
+            parentID: created.parentID,
+            agent: pending?.agent ?? created.agent,
+            description: pending?.description ?? null
+          });
+          safeWriteLog(PLUGIN_NAME13, {
             hook: "event",
             type: "session.created",
             child: created.childID,
-            parent: created.parentID
+            parent: created.parentID,
+            pending_task_matched: pending !== null,
+            agent: record.agent
           });
           const startToast = buildStartToast(record);
           const sent = await showToast3(client, { ...startToast, duration: START_TOAST_DURATION_MS }, log7);
-          safeWriteLog(PLUGIN_NAME14, {
+          safeWriteLog(PLUGIN_NAME13, {
             hook: "event",
             type: "session.created.toast",
             child: created.childID,
-            toast_sent: sent
+            toast_sent: sent,
+            start_toast_message: startToast.message
           });
           return;
         }
@@ -14981,7 +15298,7 @@ var subtaskHeartbeatServer = async (ctx) => {
           if (r) {
             const t = buildEndToast(r, ended.type);
             const sent = await showToast3(client, t, log7);
-            safeWriteLog(PLUGIN_NAME14, {
+            safeWriteLog(PLUGIN_NAME13, {
               hook: "event",
               type: ended.type,
               child: r.childID,
@@ -14994,7 +15311,9 @@ var subtaskHeartbeatServer = async (ctx) => {
       });
     },
     "tool.execute.before": async (input) => {
-      await safeAsync(PLUGIN_NAME14, "tool.execute.before", async () => {
+      if (inflight3.size === 0)
+        return;
+      await safeAsync(PLUGIN_NAME13, "tool.execute.before", async () => {
         if (!input || typeof input.sessionID !== "string" || typeof input.tool !== "string")
           return;
         recordToolBeat(input.sessionID, input.tool);
@@ -15002,12 +15321,12 @@ var subtaskHeartbeatServer = async (ctx) => {
     }
   };
 };
-var handler14 = subtaskHeartbeatServer;
+var handler13 = subtaskHeartbeatServer;
 
 // plugins/parallel-status.ts
 init_opencode_plugin_helpers();
-var PLUGIN_NAME15 = "parallel-status";
-logLifecycle(PLUGIN_NAME15, "import");
+var PLUGIN_NAME14 = "parallel-status";
+logLifecycle(PLUGIN_NAME14, "import");
 var ID_MAX_LEN = 16;
 var ID_KEEP_LEN = 13;
 function shortId(s) {
@@ -15039,8 +15358,8 @@ function formatInflightMarkdown(snapshot, now = Date.now()) {
 `);
 }
 var parallelStatusServer = async (ctx) => {
-  const log8 = makePluginLogger(PLUGIN_NAME15);
-  logLifecycle(PLUGIN_NAME15, "activate", { directory: ctx.directory });
+  const log8 = makePluginLogger(PLUGIN_NAME14);
+  logLifecycle(PLUGIN_NAME14, "activate", { directory: ctx.directory });
   return {
     "command.execute.before": async (input, output) => {
       try {
@@ -15059,21 +15378,21 @@ var parallelStatusServer = async (ctx) => {
             synthetic: false
           });
         }
-        log8.info(`[${PLUGIN_NAME15}] 已回写 ${snapshot.length} 条 inflight`);
+        log8.info(`[${PLUGIN_NAME14}] 已回写 ${snapshot.length} 条 inflight`);
       } catch (err) {
-        log8.error(`[${PLUGIN_NAME15}] command.execute.before 异常（已隔离）`, {
+        log8.error(`[${PLUGIN_NAME14}] command.execute.before 异常（已隔离）`, {
           error: err instanceof Error ? err.message : String(err)
         });
       }
     }
   };
 };
-var handler15 = parallelStatusServer;
+var handler14 = parallelStatusServer;
 
 // plugins/pwsh-utf8.ts
 init_opencode_plugin_helpers();
-var PLUGIN_NAME16 = "pwsh-utf8";
-logLifecycle(PLUGIN_NAME16, "import", {});
+var PLUGIN_NAME15 = "pwsh-utf8";
+logLifecycle(PLUGIN_NAME15, "import", {});
 var PRELUDE = "chcp 65001 *> $null; " + "[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new(); " + "$OutputEncoding = [System.Text.UTF8Encoding]::new(); ";
 function prependUtf8Prelude(command) {
   if (typeof command !== "string")
@@ -15086,14 +15405,15 @@ function prependUtf8Prelude(command) {
     return command;
   return PRELUDE + command;
 }
-var handler16 = async (_ctx) => {
+var handler15 = async (_ctx) => {
   const enabled = process.platform === "win32" && process.env.CODEFORGE_DISABLE_PWSH_UTF8 !== "1";
-  logLifecycle(PLUGIN_NAME16, "activate", { enabled, platform: process.platform });
+  const reason = enabled ? "win32" : process.platform !== "win32" ? "non-win32" : "disabled-by-env";
+  logLifecycle(PLUGIN_NAME15, "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_NAME15, "tool.execute.before", async () => {
         if (input.tool !== "bash")
           return;
         const args = output.args ?? {};
@@ -15102,7 +15422,7 @@ var handler16 = async (_ctx) => {
         if (next !== undefined && next !== original) {
           args["command"] = next;
           output.args = args;
-          safeWriteLog(PLUGIN_NAME16, {
+          safeWriteLog(PLUGIN_NAME15, {
             hook: "tool.execute.before",
             tool: input.tool,
             callID: input.callID,
@@ -15295,7 +15615,7 @@ function buildRecoveryPlan(events, meta = { id: null }, opts = {}) {
       });
     }
   }
-  const inflight3 = [...toolMap.values()].sort((a, b) => b.last_ts - a.last_ts);
+  const inflight4 = [...toolMap.values()].sort((a, b) => b.last_ts - a.last_ts);
   const proposed = window.some((t) => PENDING_CHANGES_TOOLS.has(t.tool));
   const applied = window.some((t) => APPLY_TOOLS.has(t.tool) && t.ok);
   const pending_changes_likely = proposed && !applied;
@@ -15319,7 +15639,7 @@ function buildRecoveryPlan(events, meta = { id: null }, opts = {}) {
     idleMs,
     lastUser,
     lastAgent,
-    inflight: inflight3,
+    inflight: inflight4,
     pending_changes_likely,
     open_subtasks_likely,
     reason
@@ -15330,7 +15650,7 @@ function buildRecoveryPlan(events, meta = { id: null }, opts = {}) {
     idle_ms: idleMs,
     last_user_intent: lastUser,
     last_agent: lastAgent,
-    inflight_tools: inflight3,
+    inflight_tools: inflight4,
     pending_changes_likely,
     open_subtasks_likely,
     summary
@@ -15435,8 +15755,8 @@ function isRecoveryWorthShowing(plan) {
 }
 
 // plugins/session-recovery.ts
-var PLUGIN_NAME17 = "session-recovery";
-logLifecycle(PLUGIN_NAME17, "import", {});
+var PLUGIN_NAME16 = "session-recovery";
+logLifecycle(PLUGIN_NAME16, "import", {});
 async function processSessionStart(currentSessionId, opts = {}) {
   if (opts.disabled) {
     return { ok: true, injected: false, reason: "disabled" };
@@ -15446,7 +15766,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_NAME16}] 扫描失败：${r.error}`);
     return { ok: false, injected: false, reason: "scan_error", error: r.error };
   }
   const plan = r.plan;
@@ -15460,7 +15780,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_NAME16}] injectRecovery 异常：${msg}`);
       return { ok: false, injected: false, plan, reason: "inject_error", error: msg };
     }
   }
@@ -15489,13 +15809,13 @@ function renderPrompt(plan) {
   return lines.join(`
 `);
 }
-var log8 = makePluginLogger(PLUGIN_NAME17);
+var log8 = makePluginLogger(PLUGIN_NAME16);
 var _lastInjection = null;
 var sessionRecoveryServer = async (ctx) => {
-  logLifecycle(PLUGIN_NAME17, "activate", { directory: ctx.directory });
+  logLifecycle(PLUGIN_NAME16, "activate", { directory: ctx.directory });
   return {
     event: async ({ event }) => {
-      await safeAsync(PLUGIN_NAME17, "event", async () => {
+      await safeAsync(PLUGIN_NAME16, "event", async () => {
         const e = event;
         if (!e || typeof e.type !== "string")
           return;
@@ -15510,7 +15830,7 @@ var sessionRecoveryServer = async (ctx) => {
             _lastInjection = inj;
           }
         });
-        safeWriteLog(PLUGIN_NAME17, {
+        safeWriteLog(PLUGIN_NAME16, {
           hook: "event",
           type: "session.start",
           ok: r.ok,
@@ -15519,13 +15839,13 @@ var sessionRecoveryServer = async (ctx) => {
           last_session_id: r.plan?.last_session_id
         });
         if (r.injected && r.plan) {
-          log8.info(`[${PLUGIN_NAME17}] 注入恢复提示（last=${r.plan.last_session_id?.slice(0, 8) ?? "?"}, reason=${r.plan.reason}）`);
+          log8.info(`[${PLUGIN_NAME16}] 注入恢复提示（last=${r.plan.last_session_id?.slice(0, 8) ?? "?"}, reason=${r.plan.reason}）`);
         }
       });
     }
   };
 };
-var handler17 = sessionRecoveryServer;
+var handler16 = sessionRecoveryServer;
 
 // plugins/subtasks.ts
 import { promises as fs10 } from "node:fs";
@@ -16050,7 +16370,7 @@ async function sendParentNotice(client, sessionID, text, opts = {}) {
 // plugins/subtasks.ts
 init_opencode_plugin_helpers();
 init_runtime_paths();
-var PLUGIN_NAME18 = "subtasks";
+var PLUGIN_NAME17 = "subtasks";
 function getLogFile(root = process.cwd()) {
   return path13.join(runtimeDir(root), "logs", "subtasks.log");
 }
@@ -16129,7 +16449,7 @@ async function handleParallelCommand(raw) {
     specs = splitDescriptions(args.description, { parentId });
   }
   if (specs.length === 0) {
-    log9?.warn(`[${PLUGIN_NAME18}] /parallel 缺有效子任务`);
+    log9?.warn(`[${PLUGIN_NAME17}] /parallel 缺有效子任务`);
     await safeReply2(ctx, "⚠ /parallel 需要至少 1 个子任务（用 ; 或换行分隔）");
     return { ok: false, reason: "no_subtasks" };
   }
@@ -16187,7 +16507,7 @@ async function handleParallelCommand(raw) {
     });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    log9?.error(`[${PLUGIN_NAME18}] schedule 抛错`, { error: msg });
+    log9?.error(`[${PLUGIN_NAME17}] schedule 抛错`, { error: msg });
     await safeReply2(ctx, `❌ 并发调度失败：${msg}`);
     return { ok: false, reason: msg };
   }
@@ -16195,7 +16515,7 @@ async function handleParallelCommand(raw) {
   const summaryLines = [head, "", "```", result.digest.text, "```"];
   await safeReply2(ctx, summaryLines.join(`
 `));
-  log9?.info(`[${PLUGIN_NAME18}] schedule 完成`, {
+  log9?.info(`[${PLUGIN_NAME17}] schedule 完成`, {
     parentId,
     success: result.digest.success,
     failed: result.digest.failed,
@@ -16205,7 +16525,7 @@ async function handleParallelCommand(raw) {
     try {
       await ctx.onCompleted(result);
     } catch (err) {
-      log9?.warn(`[${PLUGIN_NAME18}] onCompleted hook 抛错（已隔离）`, {
+      log9?.warn(`[${PLUGIN_NAME17}] onCompleted hook 抛错（已隔离）`, {
         error: err instanceof Error ? err.message : String(err)
       });
     }
@@ -16246,7 +16566,7 @@ async function writeLog(level, msg, data) {
   const line = JSON.stringify({
     ts: new Date().toISOString(),
     level,
-    plugin: PLUGIN_NAME18,
+    plugin: PLUGIN_NAME17,
     msg,
     data
   }) + `
@@ -16257,11 +16577,11 @@ async function writeLog(level, msg, data) {
     await fs10.appendFile(logFile, line, "utf8");
   } catch {}
 }
-logLifecycle(PLUGIN_NAME18, "import");
+logLifecycle(PLUGIN_NAME17, "import");
 var subtasksServer = async (ctx) => {
-  const log9 = makePluginLogger(PLUGIN_NAME18);
+  const log9 = makePluginLogger(PLUGIN_NAME17);
   const client = ctx?.client ?? undefined;
-  logLifecycle(PLUGIN_NAME18, "activate", {
+  logLifecycle(PLUGIN_NAME17, "activate", {
     directory: ctx.directory,
     hasClient: Boolean(client)
   });
@@ -16321,20 +16641,20 @@ var subtasksServer = async (ctx) => {
           });
         }
       } catch (err) {
-        log9.error(`[${PLUGIN_NAME18}] command.execute.before 异常（已隔离）`, {
+        log9.error(`[${PLUGIN_NAME17}] command.execute.before 异常（已隔离）`, {
           error: err instanceof Error ? err.message : String(err)
         });
       }
     }
   };
 };
-var handler18 = subtasksServer;
+var handler17 = 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_NAME18 = "terminal-monitor";
+logLifecycle(PLUGIN_NAME18, "import", {});
 var DEFAULT_CONFIG7 = {
   minScore: 0.6,
   cooldownMs: 30000,
@@ -16616,17 +16936,17 @@ function describeError(err) {
     return String(err);
   }
 }
-var log9 = makePluginLogger(PLUGIN_NAME19);
+var log9 = makePluginLogger(PLUGIN_NAME18);
 var lru = new FingerprintLRU2;
 var _lastNotification = null;
 var terminalMonitorServer = async (ctx) => {
-  logLifecycle(PLUGIN_NAME19, "activate", {
+  logLifecycle(PLUGIN_NAME18, "activate", {
     directory: ctx.directory,
     triggerEventTypes: ["terminal.output", "terminal.exit"]
   });
   return {
     event: async ({ event }) => {
-      await safeAsync(PLUGIN_NAME19, "event", async () => {
+      await safeAsync(PLUGIN_NAME18, "event", async () => {
         const e = event;
         if (!e || typeof e.type !== "string")
           return;
@@ -16640,7 +16960,7 @@ var terminalMonitorServer = async (ctx) => {
             _lastNotification = msg;
           }
         });
-        safeWriteLog(PLUGIN_NAME19, {
+        safeWriteLog(PLUGIN_NAME18, {
           hook: "event",
           type: e.type,
           notified: r.notified,
@@ -16648,18 +16968,18 @@ var terminalMonitorServer = async (ctx) => {
           findings: r.notification?.findings.length ?? 0
         });
         if (r.notified && r.notification) {
-          log9.info(`[${PLUGIN_NAME19}] 反馈 ${r.notification.findings.length} 条 → ${r.notification.summary}`);
+          log9.info(`[${PLUGIN_NAME18}] 反馈 ${r.notification.findings.length} 条 → ${r.notification.summary}`);
         }
       });
     }
   };
 };
-var handler19 = terminalMonitorServer;
+var handler18 = terminalMonitorServer;
 
 // plugins/token-manager.ts
 init_opencode_plugin_helpers();
-var PLUGIN_NAME20 = "token-manager";
-logLifecycle(PLUGIN_NAME20, "import", {});
+var PLUGIN_NAME19 = "token-manager";
+logLifecycle(PLUGIN_NAME19, "import", {});
 async function handleMessageBefore(raw, log10, defaults) {
   const ctx = raw ?? {};
   if (!Array.isArray(ctx.messages) || ctx.messages.length === 0)
@@ -16679,21 +16999,21 @@ async function handleMessageBefore(raw, log10, defaults) {
     };
     if (r.compressed) {
       ctx.messages = r.messages;
-      log10?.info(`[${PLUGIN_NAME20}] 压缩 ${r.before.count}→${r.after.count} 条 / ${r.before.tokens}→${r.after.tokens} tokens`);
+      log10?.info(`[${PLUGIN_NAME19}] 压缩 ${r.before.count}→${r.after.count} 条 / ${r.before.tokens}→${r.after.tokens} tokens`);
     }
     return r;
   } catch (err) {
-    log10?.warn(`[${PLUGIN_NAME20}] 压缩异常（已隔离）`, {
+    log10?.warn(`[${PLUGIN_NAME19}] 压缩异常（已隔离）`, {
       error: err instanceof Error ? err.message : String(err)
     });
     return null;
   }
 }
-var log10 = makePluginLogger(PLUGIN_NAME20);
+var log10 = makePluginLogger(PLUGIN_NAME19);
 var tokenManagerServer = async (ctx) => {
   const rt = loadRuntimeSync();
   const threshold = rt.runtime.context.condenser_threshold_ratio;
-  logLifecycle(PLUGIN_NAME20, "activate", {
+  logLifecycle(PLUGIN_NAME19, "activate", {
     directory: ctx.directory,
     threshold,
     target: DEFAULT_CONDENSE.target,
@@ -16702,7 +17022,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_NAME19, "experimental.chat.messages.transform", async () => {
         const list = output.messages;
         if (!Array.isArray(list) || list.length === 0)
           return;
@@ -16715,7 +17035,7 @@ var tokenManagerServer = async (ctx) => {
         const r = await handleMessageBefore({ messages: flat }, log10, { threshold });
         if (!r)
           return;
-        safeWriteLog(PLUGIN_NAME20, {
+        safeWriteLog(PLUGIN_NAME19, {
           hook: "experimental.chat.messages.transform",
           mode: "observe-only",
           before_msgs: r.before.count,
@@ -16726,13 +17046,13 @@ var tokenManagerServer = async (ctx) => {
           reason: r.reason
         });
         if (r.compressed) {
-          log10.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)`);
+          log10.warn(`[${PLUGIN_NAME19}] advise condense: ${r.before.count}→${r.after.count} msgs / ${r.before.tokens}→${r.after.tokens} tokens (observe-only, no write-back to avoid opencode message schema mismatch)`);
         }
       });
     }
   };
 };
-var handler20 = tokenManagerServer;
+var handler19 = tokenManagerServer;
 
 // plugins/tool-policy.ts
 init_opencode_plugin_helpers();
@@ -16975,10 +17295,42 @@ function checkFileAccess(acl, file, op) {
 }
 
 // plugins/tool-policy.ts
-var PLUGIN_NAME21 = "tool-policy";
-logLifecycle(PLUGIN_NAME21, "import", {});
+var PLUGIN_NAME20 = "tool-policy";
+logLifecycle(PLUGIN_NAME20, "import", {});
 var EMPTY_ACL = { whitelistMode: false };
-function decideToolCall(ctx, cfg = {}) {
+var SUBAGENT_APPLY_DENY_LIST = new Set([
+  "coder",
+  "planner",
+  "reviewer"
+]);
+function isSubagentApplyBlocked(tool2, args, currentAgent) {
+  if (tool2 !== "pending_changes")
+    return false;
+  const action = args?.action;
+  if (action !== "apply" && action !== "apply_all")
+    return false;
+  if (!currentAgent)
+    return false;
+  return SUBAGENT_APPLY_DENY_LIST.has(currentAgent);
+}
+function decideToolCall(ctx, cfg = {}, currentAgent) {
+  if (isSubagentApplyBlocked(ctx.tool, ctx.args, currentAgent)) {
+    const action2 = String(ctx.args?.action);
+    return {
+      action: "deny",
+      reasons: [
+        `[ADR-0061] subagent '${currentAgent}' 禁止调 pending_changes.${action2}` + ` — apply 必须由 codeforge orchestrator 或用户拍板`,
+        `替代路径：stage 完成后回报 codeforge，由其决定 apply 后通过 task_id 复用启动你跑测试`
+      ],
+      autonomy: {
+        effective_mode: ctx.mode ?? cfg.defaultMode ?? DEFAULT_RUNTIME.autonomy.default_mode,
+        action: "confirm",
+        downgraded: false,
+        detected_risks: ["subagent_apply_blocked"],
+        reason: `subagent '${currentAgent}' 自 apply 越权 (ADR-0061)`
+      }
+    };
+  }
   const fallbackMode = cfg.defaultMode ?? DEFAULT_RUNTIME.autonomy.default_mode;
   const mode = ctx.mode ?? fallbackMode;
   const a = evaluate2(mode, {
@@ -17028,13 +17380,39 @@ function classifyToolKind(toolName) {
     return "webfetch";
   return "other";
 }
-var log11 = makePluginLogger(PLUGIN_NAME21);
+async function resolveCurrentAgent(client, sessionID, log11) {
+  try {
+    const sessionApi = client?.session;
+    if (!sessionApi || typeof sessionApi.get !== "function") {
+      log11.warn(`client.session.get unavailable`, { sessionID });
+      return;
+    }
+    const res = await sessionApi.get({ path: { id: sessionID } });
+    const data = res?.data ?? res;
+    const rawAgent = data?.agent;
+    if (typeof rawAgent !== "string" || rawAgent === "") {
+      log11.warn(`client.session.get returned no string agent (保守放行)`, {
+        sessionID,
+        dataKeys: data && typeof data === "object" ? Object.keys(data) : null
+      });
+      return;
+    }
+    return rawAgent;
+  } catch (err) {
+    log11.warn(`client.session.get failed (保守放行)`, {
+      sessionID,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return;
+  }
+}
+var log11 = makePluginLogger(PLUGIN_NAME20);
 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_NAME20, "activate", {
     directory,
     acl_loaded: !!cfg.acl,
     default_mode: cfg.defaultMode,
@@ -17042,9 +17420,15 @@ var toolPolicyServer = async (ctx) => {
   });
   return {
     "tool.execute.before": async (input, output) => {
-      await safeAsync(PLUGIN_NAME21, "tool.execute.before", async () => {
+      let denied;
+      await safeAsync(PLUGIN_NAME20, "tool.execute.before", async () => {
         const toolName = input.tool;
         const argsObj = output.args ?? {};
+        const needsAgentDetection = toolName === "pending_changes" && (argsObj.action === "apply" || argsObj.action === "apply_all");
+        let currentAgent = undefined;
+        if (needsAgentDetection) {
+          currentAgent = await resolveCurrentAgent(ctx.client, input.sessionID, log11);
+        }
         const files = [];
         const filePath = argsObj["path"] ?? argsObj["filePath"] ?? argsObj["file"];
         if (typeof filePath === "string") {
@@ -17057,25 +17441,33 @@ var toolPolicyServer = async (ctx) => {
           args: argsObj,
           mode: cfg.defaultMode,
           files: files.length ? files : undefined
-        }, cfg);
-        safeWriteLog(PLUGIN_NAME21, {
+        }, cfg, currentAgent);
+        safeWriteLog(PLUGIN_NAME20, {
           hook: "tool.execute.before",
           tool: toolName,
           callID: input.callID,
           sessionID: input.sessionID,
           action: decision.action,
-          reasons: decision.reasons
+          reasons: decision.reasons,
+          currentAgent
         });
         if (decision.action === "deny") {
-          log11.warn(`[${PLUGIN_NAME21}] DENY ${toolName}: ${decision.reasons.join("; ")}`);
+          log11.warn(`[${PLUGIN_NAME20}] DENY ${toolName}`, {
+            action: argsObj.action,
+            currentAgent,
+            reasons: decision.reasons
+          });
+          denied = new Error(`[tool-policy] DENIED: ${decision.reasons.join(" / ")}`);
         } else if (decision.action === "confirm") {
-          log11.info(`[${PLUGIN_NAME21}] CONFIRM ${toolName}: ${decision.reasons.join("; ")}`);
+          log11.info(`[${PLUGIN_NAME20}] CONFIRM ${toolName}: ${decision.reasons.join("; ")}`);
         }
       });
+      if (denied)
+        throw denied;
     }
   };
 };
-var handler21 = toolPolicyServer;
+var handler20 = toolPolicyServer;
 
 // plugins/update-checker.ts
 init_opencode_plugin_helpers();
@@ -17106,7 +17498,7 @@ import * as zlib from "node:zlib";
 // lib/version-injected.ts
 function getInjectedVersion() {
   try {
-    const v = "0.3.9";
+    const v = "0.3.10";
     if (typeof v === "string" && /^\d+\.\d+\.\d+/.test(v)) {
       return v;
     }
@@ -17609,20 +18001,20 @@ function compareOpencodeVersion(opts) {
 }
 
 // plugins/update-checker.ts
-var PLUGIN_NAME22 = "update-checker";
-var PLUGIN_VERSION2 = "2.0.0";
-logLifecycle(PLUGIN_NAME22, "import", { version: PLUGIN_VERSION2 });
+var PLUGIN_NAME21 = "update-checker";
+var PLUGIN_VERSION = "2.0.0";
+logLifecycle(PLUGIN_NAME21, "import", { version: PLUGIN_VERSION });
 var updateCheckerServer = async (ctx) => {
   const yieldResult = shouldYieldToLocalPlugin({ directory: ctx.directory });
   if (yieldResult.yield) {
-    safeWriteLog(PLUGIN_NAME22, {
+    safeWriteLog(PLUGIN_NAME21, {
       level: "info",
       msg: "dev_mode_yield_skip",
       reason: yieldResult.reason,
       markerPath: yieldResult.markerPath,
       detail: formatYieldLog(yieldResult)
     });
-    logLifecycle(PLUGIN_NAME22, "activate", {
+    logLifecycle(PLUGIN_NAME21, "activate", {
       yield_to_local: true,
       yield_reason: yieldResult.reason,
       skipped: "auto_install + background_check"
@@ -17631,8 +18023,8 @@ var updateCheckerServer = async (ctx) => {
   }
   const rt = loadRuntimeSync();
   const u = rt.runtime.update;
-  logLifecycle(PLUGIN_NAME22, "activate", {
-    version: PLUGIN_VERSION2,
+  logLifecycle(PLUGIN_NAME21, "activate", {
+    version: PLUGIN_VERSION,
     auto_check_enabled: u.auto_check_enabled,
     interval_hours: u.interval_hours,
     package: u.package,
@@ -17643,14 +18035,14 @@ var updateCheckerServer = async (ctx) => {
     repo_fallback: u.repo,
     config_source: "codeforge.json"
   });
-  await safeAsync(PLUGIN_NAME22, "opencode_version_check", async () => {
+  await safeAsync(PLUGIN_NAME21, "opencode_version_check", async () => {
     const compat = loadCompatibility();
     const opencodeVer = detectOpencodeVersion();
     const verdict = compareOpencodeVersion({
       currentOpencodeVer: opencodeVer,
       compat
     });
-    safeWriteLog(PLUGIN_NAME22, {
+    safeWriteLog(PLUGIN_NAME21, {
       level: "info",
       msg: "opencode_version_check",
       opencodeVer,
@@ -17667,14 +18059,14 @@ var updateCheckerServer = async (ctx) => {
     }
   });
   if (!u.auto_check_enabled) {
-    safeWriteLog(PLUGIN_NAME22, {
+    safeWriteLog(PLUGIN_NAME21, {
       level: "info",
       msg: "auto-check disabled (codeforge.json update.auto_check_enabled=false)"
     });
     return {};
   }
   setImmediate(() => {
-    safeAsync(PLUGIN_NAME22, "checkAndMaybeUpdate", async () => {
+    safeAsync(PLUGIN_NAME21, "checkAndMaybeUpdate", async () => {
       const local = readLocalVersion();
       let npmResult = null;
       try {
@@ -17685,7 +18077,7 @@ var updateCheckerServer = async (ctx) => {
           timeoutMs: 5000
         });
       } catch (e) {
-        safeWriteLog(PLUGIN_NAME22, {
+        safeWriteLog(PLUGIN_NAME21, {
           level: "warn",
           msg: "npm_fetch_failed",
           error: e.message
@@ -17694,7 +18086,7 @@ var updateCheckerServer = async (ctx) => {
         return;
       }
       if (!npmResult) {
-        safeWriteLog(PLUGIN_NAME22, {
+        safeWriteLog(PLUGIN_NAME21, {
           level: "info",
           msg: "npm_no_release",
           package: u.package,
@@ -17703,7 +18095,7 @@ var updateCheckerServer = async (ctx) => {
         return;
       }
       const hasUpdate = cmpVersion(local, npmResult.version) < 0;
-      safeWriteLog(PLUGIN_NAME22, {
+      safeWriteLog(PLUGIN_NAME21, {
         level: "info",
         msg: "npm_check_result",
         local,
@@ -17718,10 +18110,10 @@ var updateCheckerServer = async (ctx) => {
    更新命令：npx ${u.package} install --global`);
         return;
       }
-      await safeAsync(PLUGIN_NAME22, "auto_install_bundle", async () => {
+      await safeAsync(PLUGIN_NAME21, "auto_install_bundle", async () => {
         const target = getOpencodeBundlePath();
         if (!target) {
-          safeWriteLog(PLUGIN_NAME22, {
+          safeWriteLog(PLUGIN_NAME21, {
             level: "warn",
             msg: "auto_install_skip",
             reason: "无法定位 opencode bundle 路径"
@@ -17740,7 +18132,7 @@ var updateCheckerServer = async (ctx) => {
           oldVersion: local,
           keepBackups: u.backup_keep
         });
-        safeWriteLog(PLUGIN_NAME22, {
+        safeWriteLog(PLUGIN_NAME21, {
           level: "info",
           msg: "auto_install_success",
           local,
@@ -17780,7 +18172,7 @@ function getOpencodeBundlePath() {
   return candidates[0] ?? null;
 }
 async function fallbackToGitHubReleases(ctx, u) {
-  await safeAsync(PLUGIN_NAME22, "github_fallback", async () => {
+  await safeAsync(PLUGIN_NAME21, "github_fallback", async () => {
     const result = await checkUpdateOnce({
       repo: u.repo,
       intervalMs: u.interval_hours * 3600 * 1000
@@ -17790,7 +18182,7 @@ async function fallbackToGitHubReleases(ctx, u) {
 }
 async function reportLegacyResult(ctx, result, repo) {
   if (result.error && !result.fromCache) {
-    safeWriteLog(PLUGIN_NAME22, {
+    safeWriteLog(PLUGIN_NAME21, {
       level: "warn",
       msg: `update check failed: ${result.error}`,
       ...result
@@ -17798,7 +18190,7 @@ async function reportLegacyResult(ctx, result, repo) {
     return;
   }
   if (!result.hasUpdate) {
-    safeWriteLog(PLUGIN_NAME22, {
+    safeWriteLog(PLUGIN_NAME21, {
       level: "info",
       msg: `up-to-date (local=${result.local}, remote=${result.remote}${result.fromCache ? ", from_cache" : ""})`,
       ...result
@@ -17808,7 +18200,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_NAME21, {
     level: "info",
     msg: "new_version_available_github_fallback",
     local: result.local,
@@ -17819,17 +18211,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_NAME21, "client.app.log", async () => {
     await ctx.client.app.log({
       body: {
-        service: PLUGIN_NAME22,
+        service: PLUGIN_NAME21,
         level: "info",
         message
       }
     });
   });
 }
-var handler22 = updateCheckerServer;
+var handler21 = updateCheckerServer;
 
 // plugins/workflow-engine.ts
 init_opencode_plugin_helpers();
@@ -18333,9 +18725,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_NAME22 = "workflow-engine";
+logLifecycle(PLUGIN_NAME22, "import", {});
+var fallbackLog2 = makePluginLogger(PLUGIN_NAME22);
 var _registry = null;
 async function loadRegistry(workflowsDir) {
   const { loaded, failed } = await loadWorkflowsFromDir(workflowsDir);
@@ -18355,32 +18747,32 @@ async function handleCommandInvoked(raw, workflowsDir = "workflows") {
   const log12 = ctx.log ?? fallbackLog2;
   const command = typeof ctx.command === "string" ? ctx.command : null;
   if (!command) {
-    log12.warn(`[${PLUGIN_NAME23}] command.invoked 缺 command 字段`, ctx);
+    log12.warn(`[${PLUGIN_NAME22}] command.invoked 缺 command 字段`, ctx);
     return null;
   }
   const reg = await ensureRegistry(workflowsDir);
   if (reg.errors.length) {
-    log12.warn(`[${PLUGIN_NAME23}] 有 ${reg.errors.length} 个 workflow 加载失败`, reg.errors);
+    log12.warn(`[${PLUGIN_NAME22}] 有 ${reg.errors.length} 个 workflow 加载失败`, reg.errors);
   }
   const wf = reg.workflows.find((w) => matchesTrigger(w, command));
   if (!wf) {
-    log12.info(`[${PLUGIN_NAME23}] no workflow matches "${command}"`);
+    log12.info(`[${PLUGIN_NAME22}] no workflow matches "${command}"`);
     return null;
   }
-  log12.info(`[${PLUGIN_NAME23}] dispatch "${command}" → workflow "${wf.name}"`);
+  log12.info(`[${PLUGIN_NAME22}] dispatch "${command}" → workflow "${wf.name}"`);
   try {
     const result = await run(wf, {
       mode: ctx.adapter ? "real" : "dry_run",
       autonomy: ctx.autonomy ?? "semi",
       adapter: ctx.adapter
     });
-    log12.info(`[${PLUGIN_NAME23}] workflow "${wf.name}" 完成 (${result.plan.mode})`, {
+    log12.info(`[${PLUGIN_NAME22}] workflow "${wf.name}" 完成 (${result.plan.mode})`, {
       steps: result.plan.steps.length,
       results: result.results.length
     });
     return result;
   } catch (err) {
-    log12.error(`[${PLUGIN_NAME23}] workflow "${wf.name}" 执行失败`, {
+    log12.error(`[${PLUGIN_NAME22}] workflow "${wf.name}" 执行失败`, {
       error: err instanceof Error ? err.message : String(err)
     });
     throw err;
@@ -18389,15 +18781,15 @@ async function handleCommandInvoked(raw, workflowsDir = "workflows") {
 var workflowEngineServer = async (ctx) => {
   const directory = ctx.directory ?? process.cwd();
   const workflowsDir = path17.join(directory, "workflows");
-  ensureRegistry(workflowsDir).catch((err) => fallbackLog2.warn(`[${PLUGIN_NAME23}] preload workflows failed`, {
+  ensureRegistry(workflowsDir).catch((err) => fallbackLog2.warn(`[${PLUGIN_NAME22}] preload workflows failed`, {
     error: err instanceof Error ? err.message : String(err)
   }));
-  logLifecycle(PLUGIN_NAME23, "activate", { directory, workflowsDir });
+  logLifecycle(PLUGIN_NAME22, "activate", { directory, workflowsDir });
   return {
     "command.execute.before": async (input, output) => {
-      await safeAsync(PLUGIN_NAME23, "command.execute.before", async () => {
+      await safeAsync(PLUGIN_NAME22, "command.execute.before", async () => {
         const cmd = input.command.startsWith("/") ? input.command : `/${input.command}`;
-        safeWriteLog(PLUGIN_NAME23, {
+        safeWriteLog(PLUGIN_NAME22, {
           hook: "command.execute.before",
           command: cmd,
           sessionID: input.sessionID
@@ -18412,14 +18804,14 @@ var workflowEngineServer = async (ctx) => {
       });
     },
     "chat.message": async (input, output) => {
-      await safeAsync(PLUGIN_NAME23, "chat.message", async () => {
+      await safeAsync(PLUGIN_NAME22, "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_NAME22, {
           hook: "chat.message",
           command: cmd,
           sessionID: input.sessionID
@@ -18429,7 +18821,7 @@ var workflowEngineServer = async (ctx) => {
     }
   };
 };
-var handler23 = workflowEngineServer;
+var handler22 = workflowEngineServer;
 
 // src/index.ts
 var PLUGIN_ID = "codeforge";
@@ -18443,22 +18835,21 @@ var HANDLERS = [
   { name: "auto-learning", init: handler5 },
   { name: "channels", init: handler6 },
   { name: "codeforge-tools", init: handler8 },
-  { name: "hello-world", init: handler9 },
-  { name: "kh-auto-context", init: handler10 },
-  { name: "kh-reminder", init: handler11 },
-  { name: "memories-context", init: handler12 },
-  { name: "model-fallback", init: handler13 },
-  { name: "pwsh-utf8", init: handler16 },
-  { name: "session-recovery", init: handler17 },
-  { name: "subtask-heartbeat", init: handler14 },
-  { name: "subtasks", init: handler18 },
-  { name: "parallel-status", init: handler15 },
-  { name: "terminal-monitor", init: handler19 },
-  { name: "token-manager", init: handler20 },
+  { name: "kh-auto-context", init: handler9 },
+  { name: "kh-reminder", init: handler10 },
+  { name: "memories-context", init: handler11 },
+  { name: "model-fallback", init: handler12 },
+  { name: "pwsh-utf8", init: handler15 },
+  { name: "session-recovery", init: handler16 },
+  { name: "subtask-heartbeat", init: handler13 },
+  { name: "subtasks", init: handler17 },
+  { name: "parallel-status", init: handler14 },
+  { name: "terminal-monitor", init: handler18 },
+  { name: "token-manager", init: handler19 },
   { name: "tool-heartbeat", init: handler7 },
-  { name: "tool-policy", init: handler21 },
-  { name: "update-checker", init: handler22 },
-  { name: "workflow-engine", init: handler23 }
+  { name: "tool-policy", init: handler20 },
+  { name: "update-checker", init: handler21 },
+  { name: "workflow-engine", init: handler22 }
 ];
 function makeSerialHook(hookName, fns) {
   return async (input, output) => {