@zhushanwen/pi-subagent-workflow 8.6.0 → 8.7.0

package/src/orchestration/__tests__/worker-exit-without-result.test.ts

@@ -1,368 +0,0 @@
-/**
- * [F1] worker exit 无终态消息 → run failed（非悬挂）+ [SW-DATA-3] store.save 抛错不产生
- * unhandledRejection 的 handler 级回归测试。
- *
- * F1 背景：execute() 返回不可克隆值（function/Symbol/循环引用）→ worker 侧 _safePost 吞掉
- * DataCloneError → return 消息从未发出 → worker exit(0)。旧实现 handleWorkerExit 对
- * code===0 no-op → run 永久 running、runAndWait 无限挂起。
- *
- * 修复语义（本文件锚定）：
- * - exit(0) 且本 runtime 代际未收到 return/error 消息 → transition done,failed +
- *   WORKER_EXITED_WITHOUT_RESULT_MSG 归因 + pending:unregister + onRunDone
- * - exit(0) 但已收到终态消息（script-error 重试退避窗口）→ no-op（rebuild 即将发生）
- * - handleWorkerMessage 的 return/error 分支必须标记 receivedTerminalMessage（判定的依据）
- * - 非零 exit 行为不变（委托 handleWorkerError 重试矩阵）
- *
- * SW-DATA-3 背景：handleReturn / handleWorkerError / handleScriptError 的
- * `await deps.store.save(run)` 未捕获——ENOSPC 等落盘失败时 rejection 经 worker-host 的
- * `void handlers.onXxx(...)` 无人接 → unhandledRejection + pending:unregister / onRunDone
- * 不执行（pending 通知幽灵注销）。修复后 save 失败仅 logger.error，状态机继续推进。
- *
- * mock 构建参考 error-recovery-handlers.test.ts（plain-object WorkflowRun mock）。
- */
-import { describe, expect, it, vi } from "vitest";
-
-import {
-  handleWorkerExit,
-  handleWorkerMessage,
-  handleScriptError,
-  handleWorkerError,
-} from "../error-recovery.ts";
-import type { LifecycleDeps, WorkerHandlers } from "../models/ports.ts";
-import type { WorkflowRun } from "../models/workflow-run.ts";
-import type { WorkerHandle } from "../worker-handle.ts";
-
-/** [F1] 归因文案——与 error-recovery.ts 常量一致（不直接 import 常量以锚定对外文案）。 */
-const EXITED_WITHOUT_RESULT_MSG =
-  "worker exited before delivering a result (return value may not be structured-cloneable)";
-
-// ── helpers（对齐 error-recovery-handlers.test.ts）─────────────────
-
-interface RunMockOpts {
-  workerErrorCount?: number;
-  scriptErrorCount?: number;
-  /** 预置 receivedTerminalMessage（模拟 return/error 消息已送达）。 */
-  receivedTerminalMessage?: boolean;
-}
-
-/** 构造一个 status="running" 的 mock WorkflowRun。 */
-function makeRunningRun(opts: RunMockOpts = {}): WorkflowRun {
-  return {
-    runId: "wf-test",
-    state: {
-      status: "running",
-      budget: { usedTokens: 0, usedCost: 0, isExceeded: () => false },
-      errorLogs: [],
-      calls: new Map(),
-      trace: { removeByStepIndex: vi.fn(), append: vi.fn(), update: vi.fn() },
-    },
-    meta: {
-      startedAt: new Date().toISOString(),
-      workerErrorCount: opts.workerErrorCount,
-      scriptErrorCount: opts.scriptErrorCount,
-    },
-    spec: {
-      scriptName: "test-wf",
-      scriptSource: "execute() {}",
-      args: {},
-    },
-    runtime: {
-      worker: { postMessage: vi.fn() },
-      receivedTerminalMessage: opts.receivedTerminalMessage,
-    },
-    transition(target: string, reason?: string): void {
-      this.state.status = target;
-      if (target === "done") this.state.reason = reason;
-    },
-    replaceRuntime(rt: unknown): void {
-      this.runtime = rt;
-    },
-  } as unknown as WorkflowRun;
-}
-
-/** LifecycleDeps mock：store/workerHost/eventBus/onRunDone 可观察。 */
-function makeDeps(): LifecycleDeps & {
-  store: { save: ReturnType<typeof vi.fn> };
-  eventBus: { emit: ReturnType<typeof vi.fn> };
-  onRunDone: ReturnType<typeof vi.fn>;
-} {
-  return {
-    store: { save: vi.fn(async () => {}) },
-    workerHost: { start: vi.fn(() => ({ postMessage: vi.fn() })) },
-    runner: { run: vi.fn(async () => ({})) },
-    runs: new Map(),
-    eventBus: { emit: vi.fn() },
-    onRunDone: vi.fn(),
-    log: vi.fn(),
-  } as unknown as ReturnType<typeof makeDeps>;
-}
-
-function makeHandlers(): WorkerHandlers {
-  return {
-    onMessage: vi.fn(async () => {}),
-    onError: vi.fn(async () => {}),
-    onExit: vi.fn(async () => {}),
-  } as unknown as WorkerHandlers;
-}
-
-function makeHandle(isCurrent = true): WorkerHandle {
-  return { isCurrent } as unknown as WorkerHandle;
-}
-
-// ── [F1] handleWorkerExit：exit(0) 无终态消息 → failed ──────────────
-
-describe("handleWorkerExit — [F1] exit(0) 无终态消息", () => {
-  it("exit(0) 且未收到 return/error → run 转 done,failed，归因 structured-cloneable，unregister + onRunDone", async () => {
-    const run = makeRunningRun();
-    const deps = makeDeps();
-
-    await handleWorkerExit(run, 0, makeHandle(), deps, makeHandlers());
-
-    expect(run.state.status).toBe("done");
-    expect(run.state.reason).toBe("failed");
-    expect(run.state.error).toBe(EXITED_WITHOUT_RESULT_MSG);
-    expect(deps.eventBus.emit).toHaveBeenCalledWith(
-      "pending:unregister",
-      expect.objectContaining({ id: "wf-test", reason: "failed" }),
-    );
-    expect(deps.onRunDone).toHaveBeenCalledTimes(1);
-    expect(deps.store.save).toHaveBeenCalledTimes(1);
-  });
-
-  it("exit(0) 但已收到终态消息（script-error 重试退避窗口）→ no-op，不被误判 failed", async () => {
-    const run = makeRunningRun({ receivedTerminalMessage: true });
-    const deps = makeDeps();
-
-    await handleWorkerExit(run, 0, makeHandle(), deps, makeHandlers());
-
-    expect(run.state.status).toBe("running");
-    expect(deps.store.save).not.toHaveBeenCalled();
-    expect(deps.eventBus.emit).not.toHaveBeenCalled();
-    expect(deps.onRunDone).not.toHaveBeenCalled();
-  });
-
-  it("stale handle（isCurrent=false）仍被丢弃——修复不破坏 G-025", async () => {
-    const run = makeRunningRun();
-    const deps = makeDeps();
-
-    await handleWorkerExit(run, 0, makeHandle(false), deps, makeHandlers());
-
-    expect(run.state.status).toBe("running");
-    expect(deps.onRunDone).not.toHaveBeenCalled();
-  });
-
-  it("已终态（done）的 run 不受影响", async () => {
-    const run = makeRunningRun();
-    run.transition("done", "completed");
-    const deps = makeDeps();
-
-    await handleWorkerExit(run, 0, makeHandle(), deps, makeHandlers());
-
-    expect(run.state.reason).toBe("completed");
-    expect(deps.onRunDone).not.toHaveBeenCalled();
-  });
-
-  it("非零 exit 行为不变：委托 handleWorkerError（未超限 → 退避后 rebuild 重试，不直接 failed）", async () => {
-    // fake timers 跳过 scheduleRebuild 的真实 1s 退避
-    vi.useFakeTimers();
-    try {
-      const run = makeRunningRun();
-      const deps = makeDeps();
-      const handlers = makeHandlers();
-
-      const pending = handleWorkerExit(run, 1, makeHandle(), deps, handlers);
-      await vi.advanceTimersByTimeAsync(1000); // 退避 1s → 触发 rebuildRuntime
-      await pending;
-
-      // 未超限 → rebuild（workerHost.start 重建），run 保持 running、不判 failed
-      expect(run.state.status).toBe("running");
-      expect(run.meta.workerErrorCount).toBe(1);
-      expect(deps.workerHost.start).toHaveBeenCalledTimes(1);
-      expect(deps.onRunDone).not.toHaveBeenCalled();
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-});
-
-// ── [R4-F1] handleWorkerError：error + exit(1) 同代际双派发只计一次 ────
-
-describe("handleWorkerError — [R4-F1] 同代际双事件幂等", () => {
-  it("worker 崩溃：error 事件先到（退避窗口内）+ exit(1) 委托二次到达 → 只计一次、只 rebuild 一次", async () => {
-    // 真实时序：worker 崩溃 → onError 与 exit 几乎同时触发。handleWorkerError 进入
-    // scheduleRebuild 的退避 delay（未完成）时 exit(1) 到达 handleWorkerExit → 委托
-    // handleWorkerError 二次进入。旧实现在此处重复计数 + 第二个 scheduleRebuild
-    //（单次崩溃 workerErrorCount +2、双 rebuild 交错）。
-    vi.useFakeTimers();
-    try {
-      const run = makeRunningRun();
-      const deps = makeDeps();
-      const handlers = makeHandlers();
-
-      // 第一次：uncaught error 事件（进入退避 delay，不 await 完成）
-      const p1 = handleWorkerError(run, new Error("worker crashed"), deps, handlers);
-      // 第二次：exit(1) 在退避窗口内到达（runtime 尚未被 replace，同代际）
-      const p2 = handleWorkerExit(run, 1, makeHandle(), deps, handlers);
-      await vi.advanceTimersByTimeAsync(1000); // 跳过退避 → 第一个事件的 rebuild 执行
-      await Promise.all([p1, p2]);
-
-      // 双事件只处理一次：计数 +1（非 +2）、单次 rebuild、run 保持 running
-      expect(run.meta.workerErrorCount).toBe(1);
-      expect(deps.workerHost.start).toHaveBeenCalledTimes(1);
-      expect(run.state.status).toBe("running");
-      expect(deps.onRunDone).not.toHaveBeenCalled();
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-
-  it("幂等守卫不误伤新代际：rebuild 后新 worker 的 error 正常处理（计数/重建各自 +1）", async () => {
-    vi.useFakeTimers();
-    try {
-      const run = makeRunningRun();
-      const deps = makeDeps();
-      const handlers = makeHandlers();
-
-      // 第一代：error → 标记本代际 → 退避 → rebuild（新 RunRuntime，标志重置 false）
-      const p1 = handleWorkerError(run, new Error("crash gen-1"), deps, handlers);
-      await vi.advanceTimersByTimeAsync(1000);
-      await p1;
-      expect(deps.workerHost.start).toHaveBeenCalledTimes(1);
-
-      // 新代际（rebuildRuntime 构造的真 RunRuntime 实例）标志为 false
-      expect((run.runtime as { receivedTerminalMessage?: boolean }).receivedTerminalMessage).toBe(false);
-
-      // 新代际再崩 → 正常走重试矩阵（计数 2、第二次 rebuild）
-      const p2 = handleWorkerError(run, new Error("crash gen-2"), deps, handlers);
-      // 第二次重试退避是指数值 backoffDelay(2) = 1000×2 = 2000ms，非 1000
-      await vi.advanceTimersByTimeAsync(2000);
-      await p2;
-
-      expect(run.meta.workerErrorCount).toBe(2);
-      expect(deps.workerHost.start).toHaveBeenCalledTimes(2);
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-
-  it("超限路径同样幂等：error + exit(1) 双到达只转一次 done,failed（onRunDone 只调一次）", async () => {
-    vi.useFakeTimers();
-    try {
-      // 预置 workerErrorCount = MAX（3）：本次 error 计数到 4 → 超限 → done,failed
-      const run = makeRunningRun({ workerErrorCount: 3 });
-      const deps = makeDeps();
-      const handlers = makeHandlers();
-
-      const p1 = handleWorkerError(run, new Error("worker crashed"), deps, handlers);
-      const p2 = handleWorkerExit(run, 1, makeHandle(), deps, handlers);
-      await Promise.all([p1, p2]);
-
-      expect(run.meta.workerErrorCount).toBe(4); // 只 +1
-      expect(run.state.status).toBe("done");
-      expect(run.state.reason).toBe("failed");
-      expect(deps.onRunDone).toHaveBeenCalledTimes(1);
-      expect(deps.eventBus.emit).toHaveBeenCalledTimes(1); // 单次 unregister，无重复
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-});
-
-// ── [F1] handleWorkerMessage：return/error 标记 receivedTerminalMessage ────
-
-describe("handleWorkerMessage — [F1] 终态消息标记", () => {
-  it("return 消息将 runtime.receivedTerminalMessage 置 true，随后正常 transition done,completed", async () => {
-    const run = makeRunningRun();
-    const deps = makeDeps();
-
-    await handleWorkerMessage(run, { type: "return", result: { ok: 1 } }, deps, makeHandlers());
-
-    expect((run.runtime as { receivedTerminalMessage?: boolean }).receivedTerminalMessage).toBe(true);
-    expect(run.state.status).toBe("done");
-    expect(run.state.reason).toBe("completed");
-  });
-
-  it("error 消息同样置 true——在 rebuild 前的退避窗口内捕获（replaceRuntime 前 start 时刻）", async () => {
-    // 断言时机说明：标记的生命周期是「本 runtime 代际」。await 整个 handleWorkerMessage
-    // 后 scheduleRebuild 已完成 replaceRuntime，runtime 已换新代际（flag=false 属正确语义）。
-    // 真正需要标记保护的窗口是退避期间（旧 worker exit(0) 到达、run.runtime 仍指向旧代际），
-    // 故在 rebuildRuntime 调 workerHost.start 的时刻（replaceRuntime 之前）捕获。
-    vi.useFakeTimers();
-    try {
-      const run = makeRunningRun();
-      const deps = makeDeps();
-      let flagAtRebuildStart: boolean | undefined;
-      (deps.workerHost.start as ReturnType<typeof vi.fn>).mockImplementation(() => {
-        flagAtRebuildStart = (run.runtime as { receivedTerminalMessage?: boolean }).receivedTerminalMessage;
-        return { postMessage: vi.fn() };
-      });
-
-      const pending = handleWorkerMessage(run, { type: "error", error: "boom" }, deps, makeHandlers());
-      await vi.advanceTimersByTimeAsync(1000); // 跳过 scheduleRebuild 真实 1s 退避
-      await pending;
-
-      expect(flagAtRebuildStart).toBe(true);
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-});
-
-// ── [SW-DATA-3] store.save 抛错 → 不产生 unhandledRejection，状态机继续 ────
-
-describe("store.save 抛错（ENOSPC 等）— [SW-DATA-3] 不阻断终态推进", () => {
-  it("handleReturn（经 handleWorkerMessage return 分支）：save reject 被吸收，unregister + onRunDone 照常", async () => {
-    const run = makeRunningRun();
-    const deps = makeDeps();
-    deps.store.save.mockRejectedValue(new Error("ENOSPC: no space left on device"));
-
-    // 旧实现：await 裸抛 → handleWorkerMessage reject（worker-host 侧 void 掉）→
-    // unhandledRejection + 幽灵注销。修复后必须正常 resolve。
-    await expect(
-      handleWorkerMessage(run, { type: "return", result: { ok: 1 } }, deps, makeHandlers()),
-    ).resolves.toBeUndefined();
-
-    expect(run.state.status).toBe("done");
-    expect(deps.eventBus.emit).toHaveBeenCalledWith(
-      "pending:unregister",
-      expect.objectContaining({ id: "wf-test" }),
-    );
-    expect(deps.onRunDone).toHaveBeenCalledTimes(1);
-  });
-
-  it("handleWorkerError 重试超限：save reject 被吸收，终态 + 通知照常", async () => {
-    const run = makeRunningRun({ workerErrorCount: 3 });
-    const deps = makeDeps();
-    deps.store.save.mockRejectedValue(new Error("ENOSPC: no space left on device"));
-
-    await expect(
-      handleWorkerError(run, new Error("worker crash"), deps, makeHandlers()),
-    ).resolves.toBeUndefined();
-
-    expect(run.state.status).toBe("done");
-    expect(run.state.reason).toBe("failed");
-    expect(deps.eventBus.emit).toHaveBeenCalledWith(
-      "pending:unregister",
-      expect.objectContaining({ id: "wf-test", reason: "failed" }),
-    );
-    expect(deps.onRunDone).toHaveBeenCalledTimes(1);
-  });
-
-  it("handleScriptError 重试超限：save reject 被吸收，终态 + 通知照常", async () => {
-    const run = makeRunningRun({ scriptErrorCount: 3 });
-    const deps = makeDeps();
-    deps.store.save.mockRejectedValue(new Error("ENOSPC: no space left on device"));
-
-    await expect(
-      handleScriptError(run, "script boom", [], deps, makeHandlers()),
-    ).resolves.toBeUndefined();
-
-    expect(run.state.status).toBe("done");
-    expect(run.state.reason).toBe("failed");
-    expect(deps.eventBus.emit).toHaveBeenCalledWith(
-      "pending:unregister",
-      expect.objectContaining({ id: "wf-test", reason: "failed" }),
-    );
-    expect(deps.onRunDone).toHaveBeenCalledTimes(1);
-  });
-});

package/src/orchestration/__tests__/worker-host.test.ts

@@ -1,120 +0,0 @@
-/**
- * WorkerHostImpl — workerData 映射测试。
- *
- * Option B（run-level model/thinkingLevel）的映射点在 WorkerHostImpl.start：
- * RunSpec.model/thinkingLevel → workerData.model/thinkingLevel → worker 内
- * $MODEL/$THINKING_LEVEL globals（worker-script-builder 注入）→ agent() fallback。
- *
- * 本测试 mock node:worker_threads.Worker，捕获构造 options.workerData，
- * 直接断言映射（lifecycle.test.ts 的 workerHost.start 是 mock，看不到 workerData）。
- */
-import { describe, expect, it, vi } from "vitest";
-
-const { workerMock } = vi.hoisted(() => ({
-  workerMock: vi.fn(),
-}));
-
-vi.mock("node:worker_threads", () => ({
-  Worker: workerMock,
-}));
-
-import { WorkerHostImpl } from "../worker-host.ts";
-import type { RunSpec } from "../models/run-spec.ts";
-import type { WorkerHandlers } from "../models/ports.ts";
-
-interface WorkerOptions {
-  eval?: boolean;
-  workerData?: Record<string, unknown>;
-}
-
-/** mock Worker 实例（WorkerHandle 依赖 on/postMessage/terminate）。 */
-function fakeWorkerInstance() {
-  return { on: vi.fn(), postMessage: vi.fn(), terminate: vi.fn() };
-}
-
-function makeSpec(overrides: Partial<RunSpec> = {}): RunSpec {
-  return {
-    scriptSource: "execute() {}",
-    args: { autoCommit: true },
-    scriptName: "test-wf",
-    scriptPath: "/fake/test.js",
-    description: "test desc",
-    ...overrides,
-  };
-}
-
-function makeHandlers(): WorkerHandlers {
-  return {
-    onMessage: vi.fn(),
-    onError: vi.fn(),
-    onExit: vi.fn(),
-  };
-}
-
-describe("WorkerHostImpl.start — workerData 映射", () => {
-  it("Option B: RunSpec.model/thinkingLevel 映射进 workerData（其余字段不破坏）", () => {
-    const spec = makeSpec({
-      model: "anthropic/claude-3.5-sonnet",
-      thinkingLevel: "high",
-      budgetTokens: 5000,
-    });
-    let captured: WorkerOptions | undefined;
-    workerMock.mockImplementation(function (
-      this: unknown,
-      _code: string,
-      options: WorkerOptions,
-    ) {
-      captured = options;
-      return fakeWorkerInstance();
-    });
-
-    new WorkerHostImpl().start(spec, spec.args, makeHandlers());
-
-    expect(workerMock).toHaveBeenCalledTimes(1);
-    expect(captured).toBeDefined();
-    const wd = captured!.workerData;
-    expect(wd).toBeDefined();
-    // Option B 核心：run-level override 经 workerData 进入 worker globals
-    expect(wd!.model).toBe("anthropic/claude-3.5-sonnet");
-    expect(wd!.thinkingLevel).toBe("high");
-    // workerData 契约其余字段（防未来重构破坏 worker 启动链路）
-    expect(wd!.scriptPath).toBe("/fake/test.js");
-    expect(wd!.args).toEqual({ autoCommit: true });
-    expect(wd!.meta).toEqual({ name: "test-wf", description: "test desc" });
-    expect(wd!.budget).toEqual({ maxTokens: 5000, usedTokens: 0, usedCost: 0 });
-    expect(captured!.eval).toBe(true);
-  });
-
-  it("model/thinkingLevel 未设：workerData 字段为 undefined（继承主 agent 语义，不污染）", () => {
-    let captured: WorkerOptions | undefined;
-    workerMock.mockImplementation(function (
-      this: unknown,
-      _code: string,
-      options: WorkerOptions,
-    ) {
-      captured = options;
-      return fakeWorkerInstance();
-    });
-
-    new WorkerHostImpl().start(makeSpec(), {}, makeHandlers());
-
-    expect(captured!.workerData!.model).toBeUndefined();
-    expect(captured!.workerData!.thinkingLevel).toBeUndefined();
-  });
-
-  it("handlers 绑定：message/error/exit 三类事件注册到 worker", () => {
-    const instance = fakeWorkerInstance();
-    workerMock.mockImplementation(function (this: unknown) {
-      return instance;
-    });
-
-    const handle = new WorkerHostImpl().start(makeSpec(), {}, makeHandlers());
-
-    expect(instance.on).toHaveBeenCalledTimes(3);
-    expect(instance.on).toHaveBeenCalledWith("message", expect.any(Function));
-    expect(instance.on).toHaveBeenCalledWith("error", expect.any(Function));
-    expect(instance.on).toHaveBeenCalledWith("exit", expect.any(Function));
-    // handle 持底层 worker（RunRuntime 直接访问 ref/href）
-    expect(handle.raw).toBe(instance);
-  });
-});

package/src/orchestration/__tests__/worker-returnmeta-passthrough.test.ts

@@ -1,164 +0,0 @@
-/**
- * rfl 仪表 T1（tier-1 §7.1）：returnMeta 透传 usage/durationMs/sessionId。
- *
- * 两个对称点的运行时验证（worker-script-builder 模板字符串断言无法证明
- * 「真实 Worker 线程里 resolve 对象字段齐全」）：
- *   A1 live resolve——agent-result 消息回发完整 AgentResult，returnMeta:true
- *      时 resolve 对象 = {value, sessionFile, worktreePath, error, usage, durationMs, sessionId}
- *   A2 缓存重放——workerData.callCache 命中时重建对象同样含三字段（对称点）
- *
- * 模式与 worker-script-builder-runtime.test.ts 相同：真实 Worker 线程执行
- * buildWorkerScript 产物，主线程模拟 runtime 回发消息。
- */
-import { Worker } from "node:worker_threads";
-
-import { afterEach, describe, expect, it } from "vitest";
-
-import { buildWorkerScript } from "../worker-script-builder.ts";
-
-const USAGE = { input: 100, output: 50, cacheRead: 700, cacheWrite: 30, cost: 0.012, contextTokens: 850, turns: 3 };
-
-const createdWorkers: Worker[] = [];
-
-afterEach(() => {
-  for (const w of createdWorkers.splice(0)) {
-    w.terminate().catch(() => {});
-  }
-});
-
-interface RunOutcome {
-  returnValue?: unknown;
-  errorMessage?: string;
-  exitCode?: number;
-}
-
-/**
- * 起 Worker 跑 userScript；收到首个 agent-call 即回发 agentResult（调用方提供），
- * 等脚本 return。callCache 命中路径不会发出 agent-call（直接从缓存重建返回）。
- */
-function runWorker(
-  userScript: string,
-  opts: { agentResult?: Record<string, unknown>; callCache?: Record<number, unknown>; timeoutMs?: number },
-): Promise<RunOutcome> {
-  const timeoutMs = opts.timeoutMs ?? 4000;
-  return new Promise((resolve, reject) => {
-    const worker = new Worker(buildWorkerScript(userScript), {
-      eval: true,
-      workerData: {
-        scriptPath: "test.js",
-        args: {},
-        workspace: process.cwd(),
-        budget: { maxTokens: 0, usedTokens: 0, usedCost: 0 },
-        callCache: opts.callCache ?? {},
-      },
-    });
-    createdWorkers.push(worker);
-    const out: RunOutcome = {};
-    let settled = false;
-    const timer = setTimeout(() => {
-      worker.terminate().catch(() => {});
-      reject(new Error("Worker timed out — likely hung"));
-    }, timeoutMs);
-    const finish = (r: RunOutcome): void => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolve(r);
-    };
-    worker.on("message", (raw: unknown) => {
-      const msg = raw as { type?: string; callId?: number };
-      if (msg.type === "agent-call" && typeof msg.callId === "number") {
-        worker.postMessage({
-          type: "agent-result",
-          callId: msg.callId,
-          result: opts.agentResult ?? { content: "fallback", parsedOutput: { ok: true } },
-          cached: false,
-        });
-      } else if (msg.type === "return") {
-        out.returnValue = (raw as { result?: unknown }).result;
-        finish(out);
-      } else if (msg.type === "error") {
-        out.errorMessage = (raw as { error?: string }).error;
-        finish(out);
-      }
-    });
-    worker.on("exit", (code: number) => {
-      out.exitCode = code;
-      if (code !== 0) finish(out);
-    });
-    worker.on("error", (err: Error) => {
-      out.errorMessage = err.message;
-      finish(out);
-    });
-  });
-}
-
-const META_SCRIPT = "const meta = await agent({ prompt: 'passthrough probe', returnMeta: true }); return meta;";
-
-describe("A1 returnMeta live resolve 透传（tier-1 §7.1）", () => {
-  it("A1 agent-result 回发完整 AgentResult 时 resolve 对象含 usage/durationMs/sessionId（七字段全集）", async () => {
-    const outcome = await runWorker(META_SCRIPT, {
-      agentResult: {
-        content: "raw text",
-        parsedOutput: { ok: true },
-        sessionFile: "/tmp/sess.jsonl",
-        worktreePath: "/tmp/wt",
-        error: undefined,
-        usage: USAGE,
-        durationMs: 83_000,
-        sessionId: "sess-abc-1",
-      },
-    });
-    expect(outcome.errorMessage).toBeUndefined();
-    expect(outcome.returnValue).toEqual({
-      value: { ok: true },
-      sessionFile: "/tmp/sess.jsonl",
-      worktreePath: "/tmp/wt",
-      error: undefined,
-      usage: USAGE,
-      durationMs: 83_000,
-      sessionId: "sess-abc-1",
-    });
-  });
-
-  it("A1 旧主线程（AgentResult 无三字段）时 resolve 对象三字段为 undefined（向后兼容不抛错）", async () => {
-    const outcome = await runWorker(META_SCRIPT, {
-      agentResult: { content: "raw", parsedOutput: { v: 1 }, sessionFile: "/tmp/s.jsonl" },
-    });
-    expect(outcome.returnValue).toMatchObject({
-      value: { v: 1 },
-      sessionFile: "/tmp/s.jsonl",
-      usage: undefined,
-      durationMs: undefined,
-      sessionId: undefined,
-    });
-  });
-});
-
-describe("A2 returnMeta 缓存重放重建透传（对称点，tier-1 §7.1）", () => {
-  it("A2 workerData.callCache 命中时重建对象含 usage/durationMs/sessionId（不回发 agent-call）", async () => {
-    const outcome = await runWorker(META_SCRIPT, {
-      callCache: {
-        0: {
-          content: "cached raw",
-          parsedOutput: { cached: true },
-          sessionFile: "/tmp/cached.jsonl",
-          worktreePath: "/tmp/cwt",
-          usage: USAGE,
-          durationMs: 42_000,
-          sessionId: "sess-cache-9",
-        },
-      },
-    });
-    expect(outcome.errorMessage).toBeUndefined();
-    expect(outcome.returnValue).toEqual({
-      value: { cached: true },
-      sessionFile: "/tmp/cached.jsonl",
-      worktreePath: "/tmp/cwt",
-      error: undefined,
-      usage: USAGE,
-      durationMs: 42_000,
-      sessionId: "sess-cache-9",
-    });
-  });
-});