@zhushanwen/pi-subagent-workflow 8.6.0 → 8.8.0

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

@@ -1,405 +0,0 @@
-// 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";
-
-// Mock 共享 logger，让 logger.error 可被 spy（源码已从 console.error 改为 logger.error）
-const { loggerMock } = vi.hoisted(() => ({
-  loggerMock: {
-    debug: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    info: vi.fn(),
-  },
-}));
-vi.mock("@zhushanwen/pi-extension-logger", () => ({
-  getLogger: () => loggerMock,
-}));
-
-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;
-}
-
-/** 清空 logger.error 调用记录（防御路径会打印诊断，避免污染跨用例断言）。 */
-function silenceConsoleError(): () => void {
-  loggerMock.error.mockClear();
-  return () => {
-    loggerMock.error.mockClear();
-  };
-}
-
-// ── 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(loggerMock.error).toHaveBeenCalledTimes(1);
-      const diag = loggerMock.error.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 = loggerMock.error.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 = loggerMock.error.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\)/);
-  });
-});

package/src/orchestration/__tests__/error-recovery-serialize-failed-result.test.ts

@@ -1,56 +0,0 @@
-// src/orchestration/__tests__/error-recovery-serialize-failed-result.test.ts
-//
-// makeSerializeFailedResult 独立单测（W2 防御关键纯函数）。
-//
-// 背景：postMessage 序列化失败时，主线程需回发「必可克隆」的 fallback result
-// 让 worker 内 pending Promise resolve（否则 agent()/workflow() 永久挂起，只能靠
-// timeout 兜底）。两条 fallback 路径（postAgentResult / dispatchWorkflowCall.postResult）
-// 共享 makeSerializeFailedResult 构造逻辑——本测试锁住其返回 shape，确保两条路径
-// 不漂移。
-//
-// 验证点：
-//   1. content 恒为 ""（纯字符串 fallback，必可克隆——不含 function/Symbol/循环引用）
-//   2. error 形如 "<prefix>: <errMsg>"（前缀区分调用方，便于诊断定位）
-//   3. prefix / errMsg 各自原样透传（含空串、特殊字符、多行）
-
-import { describe, expect, it } from "vitest";
-
-import { makeSerializeFailedResult } from "../error-recovery.ts";
-
-describe("makeSerializeFailedResult", () => {
-  it("返回 {content:'', error:'<prefix>: <errMsg>'} 形状（必可克隆 fallback）", () => {
-    const result = makeSerializeFailedResult("Result serialization failed", "DataCloneError: ...");
-    expect(result).toEqual({
-      content: "",
-      error: "Result serialization failed: DataCloneError: ...",
-    });
-  });
-
-  it("content 恒为空串（纯字符串 fallback，不含不可克隆成员）", () => {
-    // 无论入参如何，content 必为 ""——postMessage 必须能克隆这个 fallback result。
-    const result = makeSerializeFailedResult("any prefix", "any error");
-    expect(result.content).toBe("");
-  });
-
-  it("error 由 prefix + ': ' + errMsg 拼接（前缀区分调用方，便于诊断）", () => {
-    const result = makeSerializeFailedResult("Workflow result serialization failed", "boom");
-    expect(result.error).toBe("Workflow result serialization failed: boom");
-    // 分隔符固定为 ": "——两条 fallback 路径共享同一构造逻辑。
-    expect(result.error).toContain(": ");
-  });
-
-  it("prefix 与 errMsg 原样透传（含空串、特殊字符、多行）", () => {
-    // 空串 prefix
-    expect(makeSerializeFailedResult("", "err").error).toBe(": err");
-    // 空串 errMsg
-    expect(makeSerializeFailedResult("prefix", "").error).toBe("prefix: ");
-    // 含冒号 / 换行 / unicode 的 errMsg（原样透传，不做转义）
-    const weird = "err: with: colons\nand newline 中文 🚀";
-    expect(makeSerializeFailedResult("P", weird).error).toBe(`P: ${weird}`);
-  });
-
-  it("返回对象字段仅 content + error（无多余字段，shape 稳定不漂移）", () => {
-    const result = makeSerializeFailedResult("p", "e");
-    expect(Object.keys(result).sort()).toEqual(["content", "error"]);
-  });
-});

package/src/orchestration/__tests__/error-recovery-workflow-call.test.ts

@@ -1,166 +0,0 @@
-/**
- * dispatchWorkflowCall — workflow-call 消息路由测试。
- *
- * 通过 handleWorkerMessage 触发 workflow-call case，验证：
- * - onWorkflowCall 回调被正确调用（name + args + parentRun）
- * - 成功时 postMessage(workflow-result, result)
- * - onWorkflowCall reject 时 postMessage 含 error
- * - onWorkflowCall 未注入时 postMessage 含 error（向后兼容）
- * - stale 完成守卫（resolve 前 run 已终态 → 不 postMessage）
- */
-import { describe, expect, it, vi } from "vitest";
-
-import { handleWorkerMessage } from "../error-recovery.ts";
-import type { LifecycleDeps, WorkerHandlers } from "../models/ports.ts";
-import type { WorkflowRun } from "../models/workflow-run.ts";
-
-// ── helpers ──────────────────────────────────────────────────
-
-/** flush microtask 队列，让 void .then().catch() 链路跑完。 */
-async function flushMicrotasks(): Promise<void> {
-  await new Promise((resolve) => setTimeout(resolve, 0));
-}
-
-/** 构造一个 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 };
-}
-
-/** 从 postMessage mock 取第 0 次调用的第 0 参，类型安全窄化。 */
-function firstPosted(postMessage: ReturnType<typeof vi.fn>): PostedMsg {
-  return postMessage.mock.calls[0]![0] as PostedMsg;
-}
-
-// ── tests ────────────────────────────────────────────────────
-
-describe("dispatchWorkflowCall (workflow-call routing)", () => {
-  it("calls onWorkflowCall with name and args", async () => {
-    const postMessage = vi.fn();
-    const onWorkflowCall = vi.fn(async () => ({ content: "ok" }));
-    const run = makeRunningRun(postMessage);
-    const deps = makeDeps(onWorkflowCall);
-
-    await handleWorkerMessage(
-      run,
-      { type: "workflow-call", callId: 1, name: "sub", args: { k: 1 } },
-      deps,
-      makeHandlers(),
-    );
-    await flushMicrotasks();
-
-    expect(onWorkflowCall).toHaveBeenCalledTimes(1);
-    expect(onWorkflowCall).toHaveBeenCalledWith("sub", { k: 1 }, run);
-  });
-
-  it("posts workflow-result on success", async () => {
-    const postMessage = vi.fn();
-    const onWorkflowCall = vi.fn(async () => ({ content: "result-data" }));
-    const run = makeRunningRun(postMessage);
-    const deps = makeDeps(onWorkflowCall);
-
-    await handleWorkerMessage(
-      run,
-      { type: "workflow-call", callId: 2, name: "sub", args: {} },
-      deps,
-      makeHandlers(),
-    );
-    await flushMicrotasks();
-
-    expect(postMessage).toHaveBeenCalledWith({
-      type: "workflow-result",
-      callId: 2,
-      result: { content: "result-data" },
-    });
-  });
-
-  it("posts error result when onWorkflowCall rejects", async () => {
-    const postMessage = vi.fn();
-    const onWorkflowCall = vi.fn(async () => {
-      throw new Error("boom");
-    });
-    const run = makeRunningRun(postMessage);
-    const deps = makeDeps(onWorkflowCall);
-
-    await handleWorkerMessage(
-      run,
-      { type: "workflow-call", callId: 3, name: "sub", args: {} },
-      deps,
-      makeHandlers(),
-    );
-    await flushMicrotasks();
-
-    expect(postMessage).toHaveBeenCalledTimes(1);
-    const sent = firstPosted(postMessage);
-    expect(sent.type).toBe("workflow-result");
-    expect(sent.callId).toBe(3);
-    expect(sent.result.error).toBe("boom");
-  });
-
-  it("posts error result when onWorkflowCall not injected", async () => {
-    const postMessage = vi.fn();
-    const run = makeRunningRun(postMessage);
-    const deps = makeDeps(undefined);
-
-    await handleWorkerMessage(
-      run,
-      { type: "workflow-call", callId: 4, name: "sub", args: {} },
-      deps,
-      makeHandlers(),
-    );
-    await flushMicrotasks();
-
-    expect(postMessage).toHaveBeenCalledTimes(1);
-    const sent = firstPosted(postMessage);
-    expect(sent.type).toBe("workflow-result");
-    expect(sent.result.error).toContain("onWorkflowCall not injected");
-  });
-
-  it("does not post when run reaches terminal state before result arrives", async () => {
-    const postMessage = vi.fn();
-    let resolveWorkflow: (value: unknown) => void = () => {};
-    const workflowPromise = new Promise<unknown>((r) => {
-      resolveWorkflow = r;
-    });
-    const onWorkflowCall = vi.fn(() => workflowPromise);
-    const run = makeRunningRun(postMessage);
-    const deps = makeDeps(onWorkflowCall);
-
-    await handleWorkerMessage(
-      run,
-      { type: "workflow-call", callId: 5, name: "sub", args: {} },
-      deps,
-      makeHandlers(),
-    );
-
-    // dispatchWorkflowCall 已触发，onWorkflowCall pending。
-    // 在 resolve 前终止 run（转终态 done）—— stale 完成守卫应阻止 postMessage。
-    run.state.status = "done";
-    resolveWorkflow({ content: "late" });
-    await flushMicrotasks();
-
-    expect(postMessage).not.toHaveBeenCalled();
-  });
-});