@zhushanwen/pi-subagent-workflow 0.4.1 → 0.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhushanwen/pi-subagent-workflow",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "type": "module",
   "main": "index.ts",
   "description": "Unified subagent execution and multi-agent workflow orchestration for Pi — spawned-process agent runtime with sync/background modes, stateful workflow management with persistence, state machine, and execution tracing.",

package/src/execution/__tests__/execute-nesting.test.ts

@@ -105,6 +105,22 @@ vi.mock("../finalized-marker.ts", () => ({
   readFinalized: vi.fn(() => false),
 }));
 
+// manifest-store mock：writeManifest 用真实 fs.promises 写盘，但本文件 fs 同步方法已 mock
+// （目录从不真实创建）→ open/rename/unlink 全 ENOENT → bestEffort 异步 console.debug。
+// 这些延迟 console 通过 worker RPC（onUserConsoleLog）回流，与 vitest teardown 形成 race：
+// "Closing rpc while onUserConsoleLog was pending" → unhandled rejection / exit 1（flaky）。
+// 本组用例测编排逻辑（pool / depth / throttle），不测 manifest 持久化（有 manifest-store.test.ts
+// 独立覆盖）。故 mock 成 no-op，消除 teardown race 的根因——异步 console 输出。
+vi.mock("../manifest-store.ts", () => {
+  class FakeManifestStore {
+    writeManifest = vi.fn(async () => {});
+    readManifest = vi.fn(async () => null);
+    listAllSync = vi.fn(() => []);
+    recoverTmpFiles = vi.fn(async () => []);
+  }
+  return { ManifestStore: FakeManifestStore };
+});
+
 // temp-prompt：mock 掉真实 fs.promises I/O，消除 fake-timers 下的 flaky 竞态
 // （详见 run-spawn-integration.test.ts 同名 mock 的注释）。
 vi.mock("../temp-prompt.ts", () => ({

package/src/interface/__tests__/workflow-tool-prompt.test.ts

@@ -40,8 +40,8 @@ describe("U1: workflow tool prompt mentions built-in workflows", () => {
   });
 
   it("tool-workflow.ts promptGuidelines 含 run action 的正例", () => {
-    // 给出 workflow run <name> 的调用示例，LLM 才知道参数格式。
-    expect(TOOL_WORKFLOW_SRC).toMatch(/workflow run .+--args/i);
+    // 给出 run 调用的 JSON 示例，LLM 才知道参数格式（action/name/args 嵌套）。
+    expect(TOOL_WORKFLOW_SRC).toContain('{"action":"run","name":"');
   });
 
   it("promptGuidelines 含 JSON 调用正例（run/status/lifecycle）", () => {
@@ -69,4 +69,15 @@ describe("U1: workflow tool prompt mentions built-in workflows", () => {
     // 反向交叉引用：list 的指引里要提到用 workflow tool 的 run action 启动脚本。
     expect(TOOL_WORKFLOW_SCRIPT_SRC).toMatch(/workflow.*tool.*run|run.*workflow.*tool/i);
   });
+
+  it("tool-workflow.ts promptGuidelines 强化 anti-generate（直接 run，不要 generate）", () => {
+    // session 证据：弱模型看到 workflow list 后倾向 workflow-script generate 而非直接 run。
+    // 提示词必须显式禁止对内置编排使用 generate。
+    expect(TOOL_WORKFLOW_SRC).toContain("NEVER use workflow-script action:generate");
+  });
+
+  it("tool-workflow-script.ts promptGuidelines 强化 anti-generate（CRITICAL ANTI-PATTERN）", () => {
+    expect(TOOL_WORKFLOW_SCRIPT_SRC).toContain("CRITICAL ANTI-PATTERN");
+    expect(TOOL_WORKFLOW_SCRIPT_SRC).toContain("NEVER generate");
+  });
 });

package/src/interface/commands.ts

@@ -66,6 +66,36 @@ export function registerWorkflowsCommand(
 ): void {
   api.registerCommand("workflows", {
     description: "Open workflow panel. /workflows [runId] | /workflows pause|resume|abort <runId>",
+    getArgumentCompletions(prefix: string) {
+      const trimmed = prefix.trimStart();
+      const parts = trimmed.split(/\s+/).filter(Boolean);
+
+      // 第一级：lifecycle 动词（带尾随空格，选中后继续补 runId）
+      if (parts.length <= 1) {
+        return [
+          { label: "pause", value: "pause ", description: "Pause a workflow run" },
+          { label: "resume", value: "resume ", description: "Resume a paused workflow run" },
+          { label: "abort", value: "abort ", description: "Abort a workflow run" },
+        ].filter((opt) => opt.label.startsWith(trimmed.toLowerCase()));
+      }
+
+      // 第二级：lifecycle 动词后补全当前 session 的 runId
+      if (parts[0] === "pause" || parts[0] === "resume" || parts[0] === "abort") {
+        try {
+          const runs = sortedRuns(getRuns());
+          if (runs.length === 0) return null;
+          return runs.map((r) => ({
+            label: r.runId,
+            value: r.runId,
+            description: `${r.spec.scriptName} [${r.state.status}]`,
+          }));
+        } catch {
+          // 拿不到运行时数据（getRuns 抛错）→ 静默降级，补全失败不影响 command
+          return null;
+        }
+      }
+      return null;
+    },
     handler: async (args: string, ctx: ExtensionCommandContext) => {
       // ── RPC 模式（xyz-agent GUI）：解析 lifecycle action 直接执行，不打开 TUI ──
       // hasUI 在 TUI 和 RPC 都为 true，不能用于区分；用 ctx.mode === "rpc" 判定 GUI 通道。

package/src/interface/subagents.ts

@@ -9,12 +9,45 @@ import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-c
 
 import { getSubagentService } from "../execution/subagent-service.ts";
 import { parseSubagentRpcCommand } from "./command-actions.ts";
+import { LIST_LIMIT } from "./list-shared.ts";
 import { createSubagentsView } from "./list-view.ts";
 
 /** 注册 /subagents 命令（= list overlay）。 */
 export function registerSubagentsCommand(pi: ExtensionAPI): void {
   pi.registerCommand("subagents", {
     description: "Subagents: /subagents [<id>] | /subagents cancel <id>",
+    getArgumentCompletions(prefix: string) {
+      const trimmed = prefix.trimStart();
+      const parts = trimmed.split(/\s+/).filter(Boolean);
+
+      // 第一级：cancel 动词（带尾随空格，选中后继续补 record id）
+      if (parts.length <= 1) {
+        return [
+          { label: "cancel", value: "cancel ", description: "Cancel a running subagent" },
+        ].filter((opt) => opt.label.startsWith(trimmed.toLowerCase()));
+      }
+
+      // 第二级：cancel 后补全当前 session 的 record id
+      if (parts[0] === "cancel") {
+        try {
+          const service = getSubagentService();
+          if (!service) return null;
+          // collectRecords 合并内存(running) + 磁盘重建 record，按 session 过滤。
+          // cancel 只对 running 有效，但全部列出便于用户辨认（终态 record 会被 service 拒绝）。
+          const records = service.collectRecords(LIST_LIMIT);
+          if (records.length === 0) return null;
+          return records.map((r) => ({
+            label: r.id,
+            value: r.id,
+            description: `${r.agent} [${r.status}]`,
+          }));
+        } catch {
+          // 拿不到运行时数据（service disposed 等）→ 静默降级，补全失败不影响 command
+          return null;
+        }
+      }
+      return null;
+    },
     handler: async (argsStr: string, ctx: ExtensionCommandContext) => {
       const service = getSubagentService();
       if (!service) {

package/src/interface/tool-workflow-script.ts

@@ -178,9 +178,10 @@ export function registerWorkflowScriptTool(
       "Use this to discover built-in workflows (chain/parallel/scatter-gather/map-reduce) " +
       "and user-generated scripts before starting a run. After listing, start a script via " +
       "the workflow tool with action:run and the script name.",
-      "ANTI-PATTERN: Do NOT generate a new script for chain/parallel/scatter-gather/map-reduce " +
-      "orchestration — these are built-in. Call action:list first. Generate only when no built-in " +
-      "matches the use case.",
+      "CRITICAL ANTI-PATTERN: NEVER generate scripts for chain/parallel/scatter-gather/map-reduce. " +
+      "These are BUILT-IN — use the workflow tool with action:run directly. " +
+      "generate is for NOVEL orchestration patterns ONLY. When in doubt, action:list first, " +
+      "then action:run — not action:generate.",
     ],
     parameters: WorkflowScriptParams,
 

package/src/interface/tool-workflow.ts

@@ -235,12 +235,12 @@ export function registerWorkflowTool(
     promptSnippet: "Run, pause, resume, abort, or check workflow status",
     promptGuidelines: [
       "PRIORITY: When user says 'workflow', 'run workflow', try run action FIRST.",
-      "BUILT-IN workflows (ready to use, no script generation needed): " +
-      "chain (analyze→transform→synthesize sequential; args: task), " +
+      "BUILT-IN workflows — run DIRECTLY with action:run, do NOT use workflow-script generate for these: " +
+      "chain (sequential 3-step: analyze→transform→synthesize; args: task), " +
       "parallel (multi-perspective analysis; args: target, optional perspectives), " +
-      "scatter-gather (split→parallel process→merge; args: task), " +
+      "scatter-gather (split→parallel→merge; args: task), " +
       "map-reduce (parallel map→reduce; args: items/itemsJson + operation). " +
-      "Example: workflow run chain --args task=\"<description>\".",
+      "Example: {\"action\":\"run\",\"name\":\"parallel\",\"args\":{\"target\":\"src/auth.ts\"}}.",
       "DISCOVERY: If unsure what workflows exist, call the workflow-script tool with " +
       "action:list first — it returns all available scripts (built-in + user-generated) " +
       "with source tags and descriptions. Then use this tool's run action to start one.",
@@ -251,6 +251,9 @@ export function registerWorkflowTool(
       "- status: {\"action\":\"status\"}. " +
       "- pause/resume/abort: {\"action\":\"pause\",\"runId\":\"<id>\"} (abort optional: ,\"error\":\"<reason>\"}).",
       "Anti-patterns: Flattening args sub-fields (task/items/...) to the top level — they belong inside args. Calling {\"action\":\"run\"} without name.",
+      "CRITICAL: For chain/parallel/scatter-gather/map-reduce orchestration, ALWAYS use action:run with the built-in name. " +
+      "NEVER use workflow-script action:generate to create these patterns — they already exist. " +
+      "workflow-script generate is ONLY for novel patterns not covered by built-ins.",
     ],
     parameters: WorkflowParams,
 

package/src/orchestration/__tests__/error-recovery-postmessage-defense.test.ts

@@ -0,0 +1,390 @@
+// src/orchestration/__tests__/error-recovery-postmessage-defense.test.ts
+//
+// W2: 主线程层 postMessage 防御测试。
+//
+// 背景：主线程有 3 处 run.runtime?.worker.postMessage(...) 调用（经 helper 函数），
+// 全部没有 try/catch。若 result 对象含不可克隆成员（function/Symbol/循环引用），
+// postMessage 同步抛 DataCloneError：
+// - postAgentResult：result 是 agent 返回值，不可克隆概率最高。DataCloneError 冒泡到
+//   dispatchAgentCall 的 .then 回调，中断后续 postBudgetUpdate/store.save/budget 检查，
+//   run 卡在 running。
+// - postBudgetUpdate：payload 是 number，风险低但无兜底。
+// - dispatchWorkflowCall 的 postResult：result 是子 workflow 任意返回值。
+//
+// 修复后三处均包 try/catch + fallback。本测试通过 mock worker.postMessage 抛
+// DataCloneError，验证：
+// 1. 调用方不抛错（流程不中断）
+// 2. fallback result（纯字符串，必可克隆）被发送
+// 3. console.error 记录诊断
+
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { describe, expect, it, vi } from "vitest";
+
+import { handleWorkerMessage, postBudgetUpdate } from "../error-recovery.ts";
+import type { LifecycleDeps, WorkerHandlers } from "../models/ports.ts";
+import type { WorkflowRun } from "../models/workflow-run.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ERROR_RECOVERY_SRC = readFileSync(
+  join(__dirname, "../error-recovery.ts"),
+  "utf-8",
+);
+
+// ── helpers ──────────────────────────────────────────────────
+
+/** flush microtask 队列，让 void .then().catch() 链路跑完。 */
+async function flushMicrotasks(): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+/** 构造一个 postMessage mock：前 n 次抛 DataCloneError，之后正常（模拟 fallback 成功）。 */
+function makeFailingPostMessage(failTimes: number): ReturnType<typeof vi.fn> {
+  let calls = 0;
+  return vi.fn(() => {
+    calls += 1;
+    if (calls <= failTimes) {
+      const err = new Error("Could not clone object: function found");
+      err.name = "DataCloneError";
+      throw err;
+    }
+    // fallback 成功路径：no-op
+  });
+}
+
+/** 构造一个永远抛 DataCloneError 的 postMessage mock（fallback 也失败）。 */
+function makeAlwaysFailingPostMessage(): ReturnType<typeof vi.fn> {
+  return vi.fn(() => {
+    const err = new Error("Could not clone object");
+    err.name = "DataCloneError";
+    throw err;
+  });
+}
+
+/** 构造 status="running" 的 mock WorkflowRun，postMessage 由调用方注入。 */
+function makeRunningRun(postMessage: ReturnType<typeof vi.fn>): WorkflowRun {
+  return {
+    state: { status: "running" },
+    runtime: { worker: { postMessage } },
+  } as unknown as WorkflowRun;
+}
+
+/** LifecycleDeps 只需 onWorkflowCall（dispatchWorkflowCall 唯一消费的 dep）。 */
+function makeDeps(onWorkflowCall?: LifecycleDeps["onWorkflowCall"]): LifecycleDeps {
+  return { onWorkflowCall } as unknown as LifecycleDeps;
+}
+
+/** WorkerHandlers 占位（workflow-call 路径不触发 handler 回调）。 */
+function makeHandlers(): WorkerHandlers {
+  return {
+    onMessage: vi.fn(async () => {}),
+    onError: vi.fn(async () => {}),
+    onExit: vi.fn(async () => {}),
+  } as unknown as WorkerHandlers;
+}
+
+interface PostedMsg {
+  type: string;
+  callId?: number;
+  result?: { content: string; error?: string };
+  budget?: { usedTokens: number; usedCost: number };
+  cached?: boolean;
+}
+
+/** 从 postMessage mock 取第 idx 次调用的第 0 参。 */
+function postedAt(postMessage: ReturnType<typeof vi.fn>, idx: number): PostedMsg {
+  return postMessage.mock.calls[idx]![0] as PostedMsg;
+}
+
+/** 静默 console.error（防御路径会打印诊断，避免污染测试输出）。 */
+function silenceConsoleError(): () => void {
+  const spy = vi.spyOn(console, "error").mockImplementation(() => {});
+  return () => spy.mockRestore();
+}
+
+// ── W2a: postBudgetUpdate try/catch ──
+
+describe("W2a: postBudgetUpdate 防御 DataCloneError", () => {
+  it("postMessage 抛错时不向上传播（流程不中断）", () => {
+    const restore = silenceConsoleError();
+    try {
+      const postMessage = makeAlwaysFailingPostMessage();
+      const run = {
+        state: {
+          status: "running",
+          budget: { usedTokens: 42, usedCost: 0.5 },
+        },
+        runtime: { worker: { postMessage } },
+      } as unknown as WorkflowRun;
+
+      // 不应抛错——防御性兜底
+      expect(() => postBudgetUpdate(run)).not.toThrow();
+    } finally {
+      restore();
+    }
+  });
+
+  it("postMessage 失败时记录 console.error 诊断", () => {
+    const restore = silenceConsoleError();
+    try {
+      const postMessage = makeAlwaysFailingPostMessage();
+      const run = {
+        state: {
+          status: "running",
+          budget: { usedTokens: 42, usedCost: 0.5 },
+        },
+        runtime: { worker: { postMessage } },
+      } as unknown as WorkflowRun;
+
+      postBudgetUpdate(run);
+
+      expect(console.error).toHaveBeenCalledTimes(1);
+      const diag = (console.error as ReturnType<typeof vi.fn>).mock.calls[0]![0] as string;
+      expect(diag).toContain("postBudgetUpdate failed");
+      expect(diag).toContain("Could not clone object");
+    } finally {
+      restore();
+    }
+  });
+
+  it("正常 payload（纯 number）成功发送", () => {
+    const postMessage = vi.fn();
+    const run = {
+      state: {
+        status: "running",
+        budget: { usedTokens: 42, usedCost: 0.5 },
+      },
+      runtime: { worker: { postMessage } },
+    } as unknown as WorkflowRun;
+
+    postBudgetUpdate(run);
+
+    expect(postMessage).toHaveBeenCalledTimes(1);
+    expect(postedAt(postMessage, 0)).toEqual({
+      type: "budget-update",
+      budget: { usedTokens: 42, usedCost: 0.5 },
+    });
+  });
+});
+
+// ── W2b: dispatchWorkflowCall postResult 闭包防御 ──
+
+describe("W2b: dispatchWorkflowCall postResult 防御 DataCloneError", () => {
+  it("result 不可克隆 → 回发纯字符串 fallback result", async () => {
+    const restore = silenceConsoleError();
+    try {
+      // 第 1 次 postMessage 抛 DataCloneError（原始 result 不可克隆），
+      // 第 2 次（fallback）成功。
+      const postMessage = makeFailingPostMessage(1);
+      const onWorkflowCall = vi.fn(async () => ({ nonCloneable: () => {} }));
+      const run = makeRunningRun(postMessage);
+      const deps = makeDeps(onWorkflowCall);
+
+      await handleWorkerMessage(
+        run,
+        { type: "workflow-call", callId: 9, name: "sub", args: {} },
+        deps,
+        makeHandlers(),
+      );
+      await flushMicrotasks();
+
+      // 调用两次：1 原始（失败）+ 1 fallback（成功）
+      expect(postMessage).toHaveBeenCalledTimes(2);
+      const fallback = postedAt(postMessage, 1);
+      expect(fallback.type).toBe("workflow-result");
+      expect(fallback.callId).toBe(9);
+      expect(fallback.result?.content).toBe("");
+      expect(fallback.result?.error).toContain("Workflow result serialization failed");
+    } finally {
+      restore();
+    }
+  });
+
+  it("postResult 不抛错到调用方（不中断 onWorkflowCall 链路）", async () => {
+    const restore = silenceConsoleError();
+    try {
+      const postMessage = makeAlwaysFailingPostMessage();
+      const onWorkflowCall = vi.fn(async () => ({ bad: () => {} }));
+      const run = makeRunningRun(postMessage);
+      const deps = makeDeps(onWorkflowCall);
+
+      // handleWorkerMessage 自身不应抛——postResult 内部已 catch
+      await expect(
+        handleWorkerMessage(
+          run,
+          { type: "workflow-call", callId: 10, name: "sub", args: {} },
+          deps,
+          makeHandlers(),
+        ),
+      ).resolves.toBeUndefined();
+      await flushMicrotasks();
+    } finally {
+      restore();
+    }
+  });
+
+  it("fallback 也失败 → console.error 记录 worker pending 将挂起", async () => {
+    const restore = silenceConsoleError();
+    try {
+      const postMessage = makeAlwaysFailingPostMessage();
+      const onWorkflowCall = vi.fn(async () => ({ bad: () => {} }));
+      const run = makeRunningRun(postMessage);
+      const deps = makeDeps(onWorkflowCall);
+
+      await handleWorkerMessage(
+        run,
+        { type: "workflow-call", callId: 11, name: "sub", args: {} },
+        deps,
+        makeHandlers(),
+      );
+      await flushMicrotasks();
+
+      // 至少 2 次尝试（原始 + fallback），fallback 失败也记日志
+      expect(postMessage.mock.calls.length).toBeGreaterThanOrEqual(2);
+      const errorCalls = (console.error as ReturnType<typeof vi.fn>).mock.calls.map((c) => c[0] as string);
+      expect(errorCalls.some((s) => s.includes("fallback also failed"))).toBe(true);
+    } finally {
+      restore();
+    }
+  });
+});
+
+// ── W2c: postAgentResult 防御（经 handleWorkerMessage 触发） ──
+//
+// postAgentResult 是私有函数，通过 workflow-call 路径无法触发。但它可经 agent-call
+// 路径的「cached replay」分支触发：dispatchAgentCall 发现 run.state.calls.get(callId)
+// 已是 done 时，直接 postAgentResult(run, callId, cached.result, true)（无需 spawn
+// 子进程）。利用这一点构造行为测试——往 cached.result 里塞不可克隆值（function），
+// mock postMessage 在首次发送 agent-result 时抛 DataCloneError，验证 fallback 路径。
+//
+// 另外补充：验证 error-recovery.ts 源码中三处 postMessage 调用点都有 try/catch 包裹，
+// 防止未来重构误删防御（类似 worker-script-builder.test.ts 的源码字符串断言模式）。
+
+/** 构造 status="running" 且 calls 已含一个 done 结果（含不可克隆成员）的 mock run。
+ *  触发 dispatchAgentCall 的 cached replay 分支（line ~234），直接走 postAgentResult。 */
+function makeRunningRunWithCachedDone(
+  postMessage: ReturnType<typeof vi.fn>,
+  callId: number,
+  result: unknown,
+): WorkflowRun {
+  const calls = new Map();
+  calls.set(callId, { status: "done", result });
+  return {
+    state: {
+      status: "running",
+      calls,
+      trace: { append: vi.fn(), update: vi.fn() },
+      budget: { isExceeded: vi.fn(() => false) },
+    },
+    runtime: { worker: { postMessage } },
+  } as unknown as WorkflowRun;
+}
+
+describe("W2c: postAgentResult 行为测试（cached replay 路径）", () => {
+  it("result 不可克隆 → 回发纯字符串 fallback result（cached: false）", async () => {
+    const restore = silenceConsoleError();
+    try {
+      // 第 1 次 postMessage 抛 DataCloneError（原始 cached.result 含 function 不可克隆），
+      // 第 2 次（fallback）成功。
+      const postMessage = makeFailingPostMessage(1);
+      // cached.result 含 function 成员 → 模拟 agent 返回不可克隆值（{ bad: () => {} }）
+      const run = makeRunningRunWithCachedDone(postMessage, 7, { bad: () => {} });
+      const deps = makeDeps();
+
+      await handleWorkerMessage(
+        run,
+        { type: "agent-call", callId: 7, opts: { prompt: "noop" } },
+        deps,
+        makeHandlers(),
+      );
+      await flushMicrotasks();
+
+      // 调用两次：1 原始 agent-result（失败）+ 1 fallback（成功）
+      expect(postMessage).toHaveBeenCalledTimes(2);
+
+      // 第 1 次：原始 agent-result，result 透传原值，cached 为 replay 的 true
+      const original = postedAt(postMessage, 0);
+      expect(original.type).toBe("agent-result");
+      expect(original.callId).toBe(7);
+      expect(original.cached).toBe(true);
+
+      // 第 2 次：fallback agent-result，result 形状为 {content:"", error:"Result serialization failed: ..."}，
+      // 且 cached 固定为 false（fallback result 非缓存命中，透传原值含义失真）
+      const fallback = postedAt(postMessage, 1);
+      expect(fallback.type).toBe("agent-result");
+      expect(fallback.callId).toBe(7);
+      expect(fallback.result?.content).toBe("");
+      expect(fallback.result?.error).toContain("Result serialization failed");
+      expect(fallback.result?.error).toContain("Could not clone object");
+      expect(fallback.cached).toBe(false);
+    } finally {
+      restore();
+    }
+  });
+
+  it("fallback 也失败 → 不向上抛错，记录 worker pending 将挂起", async () => {
+    const restore = silenceConsoleError();
+    try {
+      // postMessage 永远抛 DataCloneError（原始 + fallback 均失败）
+      const postMessage = makeAlwaysFailingPostMessage();
+      const run = makeRunningRunWithCachedDone(postMessage, 8, { bad: () => {} });
+      const deps = makeDeps();
+
+      // handleWorkerMessage 自身不应抛——postAgentResult 内部已 catch
+      await expect(
+        handleWorkerMessage(
+          run,
+          { type: "agent-call", callId: 8, opts: { prompt: "noop" } },
+          deps,
+          makeHandlers(),
+        ),
+      ).resolves.toBeUndefined();
+      await flushMicrotasks();
+
+      // 至少 2 次尝试（原始 + fallback），fallback 失败也记日志
+      expect(postMessage.mock.calls.length).toBeGreaterThanOrEqual(2);
+      const errorCalls = (console.error as ReturnType<typeof vi.fn>).mock.calls.map((c) => c[0] as string);
+      expect(errorCalls.some((s) => s.includes("postAgentResult failed"))).toBe(true);
+      expect(errorCalls.some((s) => s.includes("fallback also failed"))).toBe(true);
+    } finally {
+      restore();
+    }
+  });
+});
+
+describe("W2c: postAgentResult 防御（源码结构断言）", () => {
+  /** 校验：给定函数体内的 postMessage 调用被 try/catch 包裹。
+   *  简化策略——在函数体片段中确认存在 try { ... postMessage ... } catch。 */
+  function hasTryCatchAroundPostMessage(funcBody: string): boolean {
+    return /try\s*\{[\s\S]*?postMessage[\s\S]*?\}\s*catch/.test(funcBody);
+  }
+
+  it("postAgentResult 包含 try/catch + fallback result", () => {
+    const match = ERROR_RECOVERY_SRC.match(/function postAgentResult\([\s\S]*?\n\}/);
+    expect(match, "postAgentResult 函数定义应存在").toBeTruthy();
+    expect(hasTryCatchAroundPostMessage(match![0])).toBe(true);
+    // fallback 通过共享工厂 makeSerializeFailedResult 构造纯字符串 result（必可克隆）
+    expect(match![0]).toContain('result: makeSerializeFailedResult("Result serialization failed"');
+    expect(match![0]).toContain("Result serialization failed");
+    // 原 result 不可克隆时 cached 透传原值含义失真 → fallback 固定 cached: false
+    expect(match![0]).toContain("cached: false");
+  });
+
+  it("postBudgetUpdate 包含 try/catch", () => {
+    const match = ERROR_RECOVERY_SRC.match(/export function postBudgetUpdate\([\s\S]*?\n\}/);
+    expect(match, "postBudgetUpdate 函数定义应存在").toBeTruthy();
+    expect(hasTryCatchAroundPostMessage(match![0])).toBe(true);
+  });
+
+  it("dispatchWorkflowCall postResult 闭包包含 try/catch + fallback", () => {
+    // postResult 是 const 闭包，匹配到下一个 }; 结尾
+    const match = ERROR_RECOVERY_SRC.match(/const postResult = \(result[\s\S]*?\n  \};/);
+    expect(match, "postResult 闭包定义应存在").toBeTruthy();
+    expect(hasTryCatchAroundPostMessage(match![0])).toBe(true);
+    expect(match![0]).toContain("Workflow result serialization failed");
+    // 防御变量名遮蔽：错误变量用 err 而非 msg（外层参数名 msg）
+    expect(match![0]).toMatch(/catch \(err\)/);
+  });
+});