@zhushanwen/subagent-core 0.4.0 → 0.5.1

package/src/orchestration/__tests__/agent-call-catch-fallback.test.ts

@@ -12,7 +12,7 @@
 
 import { describe, expect, it, vi } from "vitest";
 
-import { handleWorkerMessage } from "../error-recovery.ts";
+import { handleWorkerMessage } from "../worker-message-pump.ts";
 import type { LifecycleDeps, WorkerHandlers } from "../models/ports.ts";
 import { Trace } from "../models/trace.ts";
 import type { WorkflowRun } from "../models/workflow-run.ts";

package/src/orchestration/__tests__/agent-call-stream.test.ts

@@ -8,7 +8,7 @@
 
 import { describe, expect, it, vi } from "vitest";
 
-import { handleWorkerMessage } from "../error-recovery.ts";
+import { handleWorkerMessage } from "../worker-message-pump.ts";
 import type { LifecycleDeps, WorkerHandlers } from "../models/ports.ts";
 import { Trace } from "../models/trace.ts";
 import type { WorkflowRun } from "../models/workflow-run.ts";
@@ -122,7 +122,7 @@ describe("U5: widgetKey 格式", () => {
       expect(setWidget.mock.calls.length).toBeGreaterThanOrEqual(1);
     });
 
-    const widgetKey = setWidget.mock.calls[0][0] as string;
+    const widgetKey = setWidget.mock.calls[0]![0] as string;
     expect(widgetKey).toBe("subagent-stream-wf-test-123-2");
   });
 });

package/src/orchestration/__tests__/args-validator.test.ts

@@ -123,6 +123,20 @@ describe("validateRunArgs — 校验语义", () => {
     }
   });
 
+  it("TC6c: parameters 非 object（数组）→ ArgsValidationError「expected object」", () => {
+    // 锚定 schema 形状守卫分支：数组 parameters 在 null-scan/compile 之前 fail-fast
+    const spec = makeSpec([{ target: "string" }] as unknown as Record<string, unknown>, { a: 1 });
+    try {
+      validateRunArgs(spec);
+      expect.unreachable("should throw");
+    } catch (err) {
+      expect(err).toBeInstanceOf(ArgsValidationError);
+      expect((err as ArgsValidationError).message).toContain(
+        "invalid parameter schema (expected object)",
+      );
+    }
+  });
+
   it("TC6b: strictSchema:false 容忍自定义关键字与 format（design-review major-3 回归）", () => {
     const spec = makeSpec(
       { type: "object", properties: { target: { type: "string", format: "uri" } }, required: ["target"], "x-custom": true },

package/src/orchestration/__tests__/error-recovery-rebuild-failure.test.ts

@@ -19,7 +19,7 @@ import {
 import {
   handleWorkerError,
   resetRebuildFailureInjectionForTest,
-} from "../error-recovery.ts";
+} from "../worker-message-pump.ts";
 import { Budget } from "../models/budget.ts";
 import { RunRuntime } from "../models/run-runtime.ts";
 import { Trace } from "../models/trace.ts";

package/src/orchestration/__tests__/error-recovery-terminal-hardening.test.ts

@@ -22,7 +22,7 @@ import {
   handleWorkerError,
   handleWorkerExit,
   handleWorkerMessage,
-} from "../error-recovery.ts";
+} from "../worker-message-pump.ts";
 import { Budget } from "../models/budget.ts";
 import { RunRuntime } from "../models/run-runtime.ts";
 import { toRunSnapshot } from "../run-snapshot.ts";
@@ -69,12 +69,14 @@ function makeDeps(opts: {
   emitThrows?: boolean;
   /** onRunDone 同步抛错（模拟 evictDoneRunsBeyondCap 等收尾异常）。 */
   onRunDoneThrows?: boolean;
-} = {}): LifecycleDeps & {
-  store: { save: ReturnType<typeof vi.fn> };
-  workerHost: { start: ReturnType<typeof vi.fn> };
-  eventBus: { emit: ReturnType<typeof vi.fn> };
-  onRunDone: ReturnType<typeof vi.fn>;
-  log: ReturnType<typeof vi.fn>;
+} = {}): Omit<LifecycleDeps, "store" | "workerHost" | "runner" | "eventBus" | "onRunDone" | "log"> & {
+  // 真实类型整体保留（接口成员完整），仅 mock 方法交叉 vi.fn 能力
+  store: LifecycleDeps["store"] & { save: LifecycleDeps["store"]["save"] & ReturnType<typeof vi.fn> };
+  workerHost: LifecycleDeps["workerHost"] & { start: LifecycleDeps["workerHost"]["start"] & ReturnType<typeof vi.fn> };
+  runner: LifecycleDeps["runner"] & { run: LifecycleDeps["runner"]["run"] & ReturnType<typeof vi.fn> };
+  eventBus: NonNullable<LifecycleDeps["eventBus"]> & { emit: NonNullable<LifecycleDeps["eventBus"]>["emit"] & ReturnType<typeof vi.fn> };
+  onRunDone: LifecycleDeps["onRunDone"] & ReturnType<typeof vi.fn>;
+  log: LifecycleDeps["log"] & ReturnType<typeof vi.fn>;
 } {
   return {
     store: { save: vi.fn(async () => {}) },
@@ -239,7 +241,7 @@ describe("[OR-6] log 消息消费 + 未知类型 default 留痕", () => {
     expect(run.state.errorLogs).toEqual([{ level: "log", message: "step 1 done" }]);
     expect(run.state.status).toBe("running"); // 不触发终态
     expect(deps.store.save).not.toHaveBeenCalled();
-    expect(deps.log).toHaveBeenCalledWith("debug", "workflow:error-recovery", "worker log", {
+    expect(deps.log).toHaveBeenCalledWith("debug", "workflow:worker-message-pump", "worker log", {
       runId: "wf-log-1",
       phase: "build",
       message: "step 1 done",
@@ -289,7 +291,7 @@ describe("[OR-6] log 消息消费 + 未知类型 default 留痕", () => {
     await handleWorkerMessage(run, { type: "future-unknown-type", payload: 1 }, deps, makeHandlers());
 
     expect(warnSpy.mock.calls.map((c) => String(c[0])).some((m) => m.includes("unknown worker message type") && m.includes("future-unknown-type"))).toBe(true);
-    expect(deps.log).toHaveBeenCalledWith("warn", "workflow:error-recovery", "unknown worker message type", {
+    expect(deps.log).toHaveBeenCalledWith("warn", "workflow:worker-message-pump", "unknown worker message type", {
       runId: "wf-log-3",
       type: "future-unknown-type",
     });

package/src/orchestration/__tests__/execute-agent-call.test.ts

@@ -6,16 +6,17 @@
 import { describe, expect, it, vi } from "vitest";
 
 import {
+  classifyFailureKind,
+  describeMissingParsedOutput,
   DETERMINISTIC_SCHEMA_FAILURE_PREFIX,
-  executeAgentCall,
   isDeterministicSchemaFailureMsg,
   isStaleContextErrorMsg,
   STALE_CONTEXT_PATTERNS,
-} from "../execute-agent-call.ts";
+} from "../../execution/engine/engines/pi/output-collector.ts";
+import { executeAgentCall } from "../execute-agent-call.ts";
 import { AgentCall } from "../models/agent-call.ts";
 import { Budget } from "../models/budget.ts";
 import type { AgentRunner } from "../models/ports.ts";
-import { describeMissingParsedOutput } from "../../execution/output-collector.ts";
 import type { ToolCall } from "../../execution/types.ts";
 import { Trace } from "../models/trace.ts";
 import type { ExecutionTraceNode } from "../models/types.ts";
@@ -67,6 +68,15 @@ function createMockRunner(impl?: ReturnType<typeof vi.fn>): AgentRunner & { run:
   return { run } as unknown as AgentRunner & { run: ReturnType<typeof vi.fn> };
 }
 
+/**
+ * [D5-③] 构造带真实分诊的失败 result——failureKind 经产出侧 classifyFailureKind
+ * 分类（复刻 collectResult → mapper 透传后的消费侧视角），避免手写字面量与
+ * 产出侧词表脱钩。
+ */
+function makeFailedResult(error: string): AgentResult {
+  return makeMockResult({ error, failureKind: classifyFailureKind(error) });
+}
+
 // ── U2: executeAgentCall 透传 stream 给 runner.run ──
 
 describe("U2: executeAgentCall 透传 stream", () => {
@@ -201,8 +211,9 @@ describe("isOrphaned 守卫", () => {
   it("U2: 谓词 true + stale-context 失败路径 → trace.update 0 次，markDone 保留（覆盖 stale finalize 调用点）", async () => {
     const { call, trace } = makeAgentCallAndTrace();
     const updateSpy = vi.spyOn(trace, "update");
+    // "context canceled" 经产出侧词表分类为 stale_context（D5-③ 后消费侧读字段）
     const runner = createMockRunner(
-      vi.fn().mockResolvedValue(makeMockResult({ error: "context canceled" })),
+      vi.fn().mockResolvedValue(makeFailedResult("context canceled")),
     );
     const budget = new Budget();
 
@@ -297,9 +308,11 @@ describe("W4b: stale 分诊对齐 pi 真实文案", () => {
   });
 
   it("真实文案 → executeAgentCall 不重试（runner.run 恰 1 次）+ markDone failed", async () => {
+    // [D5-③] 全链路锁：产出侧 classifyFailureKind（真实文案 → stale_context）→
+    // 消费侧读 failureKind 字段分诊（不扫文案）
     const { call, trace } = makeAgentCallAndTrace();
     const runner = createMockRunner(
-      vi.fn().mockResolvedValue(makeMockResult({ error: PI_REAL_STALE_MESSAGE })),
+      vi.fn().mockResolvedValue(makeFailedResult(PI_REAL_STALE_MESSAGE)),
     );
     const budget = new Budget();
 
@@ -351,7 +364,7 @@ describe("MF-1: 确定性 schema 失败不重试", () => {
 
     const { call, trace } = makeAgentCallAndTrace();
     const runner = createMockRunner(
-      vi.fn().mockResolvedValue(makeMockResult({ error: attribution })),
+      vi.fn().mockResolvedValue(makeFailedResult(attribution)),
     );
     const budget = new Budget();
 
@@ -368,7 +381,7 @@ describe("MF-1: 确定性 schema 失败不重试", () => {
     const attribution = describeMissingParsedOutput([])!;
     const { call, trace } = makeAgentCallAndTrace();
     const runner = createMockRunner(
-      vi.fn().mockResolvedValue(makeMockResult({ error: attribution })),
+      vi.fn().mockResolvedValue(makeFailedResult(attribution)),
     );
     const budget = new Budget();
 
@@ -384,7 +397,11 @@ describe("MF-1: 确定性 schema 失败不重试", () => {
     const { call, trace } = makeAgentCallAndTrace();
     const runner = createMockRunner(
       vi.fn().mockResolvedValue(
-        makeMockResult({ error: attribution, usage: { input: 100, output: 50, cost: 0.01 } }),
+        makeMockResult({
+          error: attribution,
+          failureKind: "schema_deterministic",
+          usage: { input: 100, output: 50, cacheRead: 0, cacheWrite: 0, cost: 0.01, contextTokens: 0, turns: 0 },
+        }),
       ),
     );
     const budget = new Budget();
@@ -402,7 +419,7 @@ describe("MF-1: 确定性 schema 失败不重试", () => {
     const attribution = state2Attribution();
     const { call, trace } = makeAgentCallAndTrace();
     const runner = createMockRunner(
-      vi.fn().mockResolvedValue(makeMockResult({ error: attribution })),
+      vi.fn().mockResolvedValue(makeFailedResult(attribution)),
     );
     const budget = new Budget();
 
@@ -414,7 +431,7 @@ describe("MF-1: 确定性 schema 失败不重试", () => {
   it("态③（no details，无标记）→ 照常重试（可重试语义保留）", async () => {
     vi.useFakeTimers();
     try {
-      // 态③真实文案（不带确定性标记）——矩阵执行面锁定：无标记 = 可重试
+      // 态③真实文案（不带确定性标记）——矩阵执行面锁定：无标记 = unknown = 可重试
       const msg = describeMissingParsedOutput([
         { toolName: "structured-output", result: { content: [] } },
       ])!;
@@ -423,7 +440,7 @@ describe("MF-1: 确定性 schema 失败不重试", () => {
       const { call, trace } = makeAgentCallAndTrace();
       const runner = createMockRunner(
         vi.fn()
-          .mockResolvedValueOnce(makeMockResult({ error: msg }))
+          .mockResolvedValueOnce(makeFailedResult(msg))
           .mockResolvedValueOnce(makeMockResult()),
       );
       const budget = new Budget();
@@ -449,3 +466,126 @@ describe("MF-1: 确定性 schema 失败不重试", () => {
     expect(isDeterministicSchemaFailureMsg(DETERMINISTIC_SCHEMA_FAILURE_PREFIX)).toBe(true);
   });
 });
+
+// ── D5-③: failureKind 三态结构化分诊（V5③④ 验收的执行面锁定） ──
+//
+// 语义守恒（r1 MF4 钉正，最高优先约束）：unknown（含字段缺省）= 可重试——保持
+// 收敛前（子串分诊时代）的默认重试语义；仅 stale_context（不重试、换参重发由
+// 上层编排）与 schema_deterministic 维持特判。词表识别已收敛到产出侧
+// output-collector.classifyFailureKind（消费侧只读字段）。
+
+describe("D5-③: failureKind 三态分诊", () => {
+  it("stale_context → 不退避不重试：runner.run 恰 1 次 + 终态 failed（V5③）", async () => {
+    const { call, trace } = makeAgentCallAndTrace();
+    const runner = createMockRunner(
+      vi.fn().mockResolvedValue(makeMockResult({
+        error: PI_REAL_STALE_MESSAGE,
+        failureKind: "stale_context",
+      })),
+    );
+    const budget = new Budget();
+
+    await executeAgentCall(call, runner, budget, new AbortController().signal, trace);
+
+    expect(runner.run).toHaveBeenCalledTimes(1);
+    expect(call.attempts).toBe(1);
+    expect(call.status).toBe("done");
+    expect(call.result?.error).toBe(PI_REAL_STALE_MESSAGE);
+    expect(trace.find(0)?.status).toBe("failed");
+  });
+
+  it("schema_deterministic → 不重试特判维持：runner.run 恰 1 次（V5③ 同族）", async () => {
+    const attribution = state2Attribution();
+    const { call, trace } = makeAgentCallAndTrace();
+    const runner = createMockRunner(
+      vi.fn().mockResolvedValue(makeMockResult({
+        error: attribution,
+        failureKind: "schema_deterministic",
+      })),
+    );
+    const budget = new Budget();
+
+    await executeAgentCall(call, runner, budget, new AbortController().signal, trace);
+
+    expect(runner.run).toHaveBeenCalledTimes(1);
+    expect(trace.find(0)?.status).toBe("failed");
+  });
+
+  it("unknown → 默认退避重试：瞬态错误（模拟 provider 5xx）退避后第二次成功（V5④ 正向）", async () => {
+    vi.useFakeTimers();
+    try {
+      const { call, trace } = makeAgentCallAndTrace();
+      const runner = createMockRunner(
+        vi.fn()
+          .mockResolvedValueOnce(makeMockResult({
+            error: "provider 503 service unavailable",
+            failureKind: "unknown",
+          }))
+          .mockResolvedValueOnce(makeMockResult()),
+      );
+      const budget = new Budget();
+
+      const promise = executeAgentCall(call, runner, budget, new AbortController().signal, trace);
+      await vi.advanceTimersByTimeAsync(2000);
+      await promise;
+
+      expect(runner.run).toHaveBeenCalledTimes(2);
+      expect(call.status).toBe("done");
+      expect(call.result?.error).toBeUndefined();
+      expect(trace.find(0)?.status).toBe("completed");
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("failureKind 缺省（旧链路/上游未写）→ 等同 unknown 默认退避重试（V5④ 语义守恒核心断言）", async () => {
+    vi.useFakeTimers();
+    try {
+      // 字段缺省是可重试而非「保守不重试」——反转会把一切未标注路径（瞬态 provider
+      // 错误、spawn 失败）静默丢进不重试（r1 MF4 击穿反例）
+      const { call, trace } = makeAgentCallAndTrace();
+      const runner = createMockRunner(
+        vi.fn()
+          .mockResolvedValueOnce(makeMockResult({ error: "spawn EAGAIN transient" }))
+          .mockResolvedValueOnce(makeMockResult()),
+      );
+      const budget = new Budget();
+
+      const promise = executeAgentCall(call, runner, budget, new AbortController().signal, trace);
+      await vi.advanceTimersByTimeAsync(2000);
+      await promise;
+
+      expect(runner.run).toHaveBeenCalledTimes(2);
+      expect(call.status).toBe("done");
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("词表漂移失效模式：未知错误文案 → classifyFailureKind=unknown → 走退避重试（安全默认）", async () => {
+    vi.useFakeTimers();
+    try {
+      // pi 升级改写 stale 文案后，旧词表对新文案零命中——分诊降级 unknown、
+      // 保守重试（可能多耗一次调用），而不是静默漏诊挂死在不重试
+      const futurePiError = "extension runtime was superseded by a newer orchestration epoch";
+      expect(classifyFailureKind(futurePiError)).toBe("unknown");
+
+      const { call, trace } = makeAgentCallAndTrace();
+      const runner = createMockRunner(
+        vi.fn()
+          .mockResolvedValueOnce(makeFailedResult(futurePiError))
+          .mockResolvedValueOnce(makeMockResult()),
+      );
+      const budget = new Budget();
+
+      const promise = executeAgentCall(call, runner, budget, new AbortController().signal, trace);
+      await vi.advanceTimersByTimeAsync(2000);
+      await promise;
+
+      expect(runner.run).toHaveBeenCalledTimes(2);
+      expect(call.status).toBe("done");
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});

package/src/orchestration/__tests__/file-run-store.test.ts

@@ -24,13 +24,13 @@ import { WorkflowRun } from "../models/workflow-run.ts";
 import { FileRunStore } from "../file-run-store.ts";
 
 let dataRoot: string;
-let logSpy: ReturnType<typeof vi.fn>;
+let logSpy: ReturnType<typeof vi.fn<(level: import("../../core/logger.ts").LogLevel, component: string, message: string, data?: unknown) => void>>;
 let store: FileRunStore;
 
 beforeEach(() => {
   resetCoreForTests();
   dataRoot = mkdtempSync(join(tmpdir(), "file-run-store-"));
-  logSpy = vi.fn();
+  logSpy = vi.fn((_level: import("../../core/logger.ts").LogLevel, _component: string, _message: string, _data?: unknown) => {});
   const host: HostServices = {
     dataRoot: () => dataRoot,
     log: logSpy,
@@ -41,7 +41,7 @@ beforeEach(() => {
 
 afterEach(() => {
   resetCoreForTests();
-  rmSync(dataRoot, { recursive: true, force: true });
+  rmSync(dataRoot, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
 });
 
 /** 构造可持久化的 WorkflowRun（对齐 lifecycle.test.ts makeEvictableRun 模式）。 */
@@ -328,12 +328,13 @@ describe("FileRunStore — 版本衔接与 live-strip（U8 / ⛔5，D4 裁决）
 
   it("⛔5 live 字段 strip 后落盘（落盘行无 live 键，内存 run 不受影响）", async () => {
     const run = makeRun("wf-livestrip-1");
-    const node = {
+    const node: import("../models/types.ts").ExecutionTraceNode = {
       stepIndex: 0,
       agent: "coder",
       task: "do work",
       model: "test-model",
-      status: "running" as const,
+      status: "running",
+      live: undefined,
     };
     run.state.trace.append(node);
     const AgentCallMod = await import("../models/agent-call.ts");
@@ -378,7 +379,7 @@ describe("FileRunStore — stateFilePath / 端口语义", () => {
         join(altRoot, "workflow-state", "wf-x-2.jsonl"),
       );
     } finally {
-      rmSync(altRoot, { recursive: true, force: true });
+      rmSync(altRoot, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
     }
   });
 

package/src/orchestration/__tests__/launcher-nested-workflow.test.ts

@@ -618,7 +618,7 @@ describe("runAndWait model 透传", () => {
     );
     expect(result.reason).toBe("completed");
     expect(vi.mocked(runWorkflow)).toHaveBeenCalledTimes(1);
-    const spec = vi.mocked(runWorkflow).mock.calls[0][0] as RunSpec;
+    const spec = vi.mocked(runWorkflow).mock.calls[0]![0] as RunSpec;
     expect(spec.model).toBe("zai-coding-cn/glm-5.3-flash");
   });
 
@@ -628,7 +628,7 @@ describe("runAndWait model 透传", () => {
     setupRunWorkflow(childRun);
 
     await runAndWait("child-wf", {}, deps);
-    const spec = vi.mocked(runWorkflow).mock.calls[0][0] as RunSpec;
+    const spec = vi.mocked(runWorkflow).mock.calls[0]![0] as RunSpec;
     expect(spec.model).toBeUndefined();
   });
 });

package/src/orchestration/__tests__/lifecycle-abort-broadcast-signal.test.ts

@@ -324,7 +324,7 @@ describe("[OR-7] signal abort listener run 终态移除", () => {
 describe("[B-2] runWorkflow fail-fast throw 路径不泄漏 signal abort listener", () => {
   /** signal 上当前真实挂载的 abort listener 数（EventTarget 权威查询，非 spy 计数）。 */
   function liveListenerCount(signal: AbortSignal): number {
-    return getEventListeners(signal).length;
+    return getEventListeners(signal, "abort").length;
   }
 
   it("budgetTimeMs 越界 fail-fast 重试 12 次 → 每次拒绝后 listener 计数归零（无 MaxListeners 累积）", async () => {

package/src/orchestration/__tests__/lifecycle-runid-injection.test.ts

@@ -9,7 +9,7 @@
  */
 import { describe, expect, it, vi } from "vitest";
 
-import { rebuildRuntime } from "../error-recovery.ts";
+import { rebuildRuntime } from "../worker-message-pump.ts";
 import { runWorkflow } from "../lifecycle.ts";
 import type { RunSpec } from "../models/run-spec.ts";
 import type { LifecycleDeps } from "../models/ports.ts";
@@ -73,11 +73,11 @@ describe("A4 rebuild 后 _runId 稳定（tier-1 §7.1）", () => {
     const runId = await runWorkflow(spec, deps);
     expect(deps.startCalls.length).toBe(1);
 
-    const run = deps.runs.get(runId);
+    const run = deps.runs.get(runId)!;
     expect(run).toBeTruthy();
     expect(run.state.status).toBe("running");
 
-    // 触发 rebuild（对齐 error-recovery handleWorkerError 的恢复路径）
+    // 触发 rebuild（对齐 worker-message-pump handleWorkerError 的恢复路径）
     rebuildRuntime(run, deps, {
       onMessage: vi.fn(),
       onError: vi.fn(),

package/src/orchestration/__tests__/lifecycle.test.ts

@@ -87,7 +87,7 @@ function makeRunningRealRun(
   const terminate = vi.fn(async () => {});
   const controller = new AbortController();
   const abort = vi.spyOn(controller, "abort");
-  const worker = { terminate, postMessage: vi.fn() } as unknown as Parameters<typeof RunRuntime.prototype.constructor>[0];
+  const worker = { terminate, postMessage: vi.fn() } as unknown as ConstructorParameters<typeof RunRuntime>[0];
   const runtime = new RunRuntime(
     worker as never,
     controller,
@@ -217,7 +217,7 @@ describe("runWorkflow", () => {
     const deps = makeDeps();
     // worker.start 被调时探测 runs 注册状态——证明 runs.set 在 assignRuntime 之后
     let runsSizeAtWorkerStart = -1;
-    deps.workerHost.start = vi.fn(() => {
+    vi.spyOn(deps.workerHost, "start").mockImplementation(() => {
       runsSizeAtWorkerStart = deps.runs.size;
       return { postMessage: vi.fn(), terminate: vi.fn(async () => {}) };
     });
@@ -513,7 +513,7 @@ describe("terminateRunningRuns", () => {
     expect(terminateB).toHaveBeenCalledTimes(1);
   });
 
-  it("单 run save 抛错不中断其余（其余 run 仍落盘 + unregister）", async () => {
+  it("单 run save 抛错不中断其余（save best-effort：unregister 仍发 + 其余 run 照常落盘）", async () => {
     const { run: bad } = makeRunningRealRun("wf-term-err");
     const { run: good } = makeRunningRealRun("wf-term-ok");
     const deps = makeDeps();
@@ -525,10 +525,12 @@ describe("terminateRunningRuns", () => {
 
     await terminateRunningRuns(deps, "Session shutdown: run terminated");
 
-    // 抛错的 run：transition 先于 save，状态已转 done，但 unregister 被 save 失败短路
+    // [D5-② finalizeRun 收敛] save 失败 best-effort（SW-DATA-3 统一）：transition 先于
+    // save，状态已转 done；与收敛前不同，unregister 不再被 save 失败短路——否则
+    // pending 通知幽灵注销（列表残留永不清理的 running 条目）
     expect(bad.state.status).toBe("done");
     expect(bad.state.reason).toBe("failed");
-    expect(deps.eventBus.emit).not.toHaveBeenCalledWith("pending:unregister", {
+    expect(deps.eventBus.emit).toHaveBeenCalledWith("pending:unregister", {
       id: "wf-term-err",
       reason: "failed",
     });

package/src/orchestration/__tests__/non-cloneable-return-e2e.test.ts

@@ -80,7 +80,7 @@ describe("[F1] 不可克隆 return → run failed（非悬挂）— e2e", () =>
       // worker 侧 fallback 消息经 handleScriptError 超限路径写入归因
       expect(run.state.error).toContain("structured-clone failed");
       // 终态副作用齐全（对比 SW-DATA-3/F1 前的幽灵悬挂：无 unregister / 无 onRunDone）
-      expect(deps.eventBus.emit).toHaveBeenCalledWith(
+      expect(deps.eventBus!.emit).toHaveBeenCalledWith(
         "pending:unregister",
         expect.objectContaining({ id: runId, reason: "failed" }),
       );

package/src/orchestration/__tests__/run-snapshot.test.ts

@@ -14,6 +14,7 @@
 import { describe, expect, it } from "vitest";
 
 import type { ExecutionRecord } from "../../execution/types.ts";
+import type { ExecutionTraceNode } from "../models/types.ts";
 import { AgentCall } from "../models/agent-call.ts";
 import { Budget } from "../models/budget.ts";
 import { Trace } from "../models/trace.ts";
@@ -54,7 +55,7 @@ function makeLiveRecord(id: string): ExecutionRecord {
     agent: "coder",
     model: "test-model",
     thinkingLevel: undefined,
-    mode: "sync",
+    mode: "background",
     task: "do work",
     slug: "do-work",
     startedAt: 0,
@@ -206,12 +207,13 @@ describe("run-snapshot — toRunSnapshot/fromRunSnapshot 往返等值", () => {
 describe("run-snapshot — live-strip 防御内聚", () => {
   it("trace 节点与 calls[].traceNode 带 live → 序列化输出无 live 键", () => {
     const run = makeRun("wf-live-1");
-    const node = {
+    const node: ExecutionTraceNode = {
       stepIndex: 0,
       agent: "coder",
       task: "do work",
       model: "test-model",
-      status: "running" as const,
+      status: "running",
+      live: undefined,
     };
     run.state.trace.append(node);
     const call = new AgentCall(0, { prompt: "do work" }, node);
@@ -229,12 +231,13 @@ describe("run-snapshot — live-strip 防御内聚", () => {
 
   it("strip 产出新对象，不 mutate 内存 run（save 后 run 可继续跑）", () => {
     const run = makeRun("wf-live-2");
-    const node = {
+    const node: ExecutionTraceNode = {
       stepIndex: 0,
       agent: "coder",
       task: "do work",
       model: "test-model",
-      status: "running" as const,
+      status: "running",
+      live: undefined,
     };
     run.state.trace.append(node);
     node.live = makeLiveRecord("run-0");

package/src/orchestration/__tests__/script-lint.test.ts

@@ -16,6 +16,7 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
 import { lintAgentMeta, lintScript } from "../script-lint.ts";
+import type { LintFinding } from "../script-lint.ts";
 import { parseResourceMeta } from "../../shared/meta-parser.ts";
 
 const WORKFLOWS_DIR = join(__dirname, "../../../workflows");
@@ -491,6 +492,22 @@ describe("MF-4 回归：非字面量实参 agent(callVar) / agent(expr()) 跳过
     expect(descWarnings).toHaveLength(1);
     expect(descWarnings[0].line).toBe(2);
   });
+
+  it("`agent(` 换行 `{` 的多行字面量调用保留追踪（argTail 为空分支）", () => {
+    // agent( 与 { 分离两行：argTail 为空不跳过，范围跨三行闭合——缺 description
+    // 报 1 条且行号落在调用起点（锚定 matchAgentCallHead 的空 argTail 保留路径）
+    const src = [
+      `await agent(`,
+      `  { prompt: "x" }`,
+      `);`,
+      ``,
+    ].join("\n");
+    const result = lintScript(src);
+
+    const descWarnings = warnings(result.findings).filter((w) => /description.*unnamed/i.test(w.message));
+    expect(descWarnings).toHaveLength(1);
+    expect(descWarnings[0].line).toBe(1);
+  });
 });
 
 // ── MF-4 回归：checkAgentDescription 的两个跳过分支 ────────────────

package/src/orchestration/__tests__/test-mocks.ts

@@ -68,6 +68,7 @@ export function mkCtx(
     ui: mkUi(),
     // pi 在 xyz-agent 下以 rpc 子进程模式运行；rpc 模式 hasUI 为 true（SDK 契约注释）
     mode: "rpc",
+    scopedModels: [],
     hasUI: true,
     cwd: "/tmp",
     sessionManager: {
@@ -168,6 +169,7 @@ export function mkPi(
     registerTool: vi.fn(),
     registerCommand: vi.fn(),
     registerShortcut: vi.fn(),
+    registerMarkdownTransformer: vi.fn(),
     registerFlag: vi.fn(),
     getFlag: vi.fn(() => undefined),
     registerMessageRenderer: vi.fn(),

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

@@ -18,7 +18,7 @@
  * `void handlers.onXxx(...)` 无人接 → unhandledRejection + pending:unregister / onRunDone
  * 不执行（pending 通知幽灵注销）。修复后 save 失败仅 logger.error，状态机继续推进。
  *
- * mock 构建参考 error-recovery-handlers.test.ts（plain-object WorkflowRun mock）。
+ * mock 构建参考 worker-message-pump-handlers.test.ts（plain-object WorkflowRun mock）。
  */
 import { describe, expect, it, vi } from "vitest";
 
@@ -27,16 +27,17 @@ import {
   handleWorkerMessage,
   handleScriptError,
   handleWorkerError,
-} from "../error-recovery.ts";
+} from "../worker-message-pump.ts";
 import type { LifecycleDeps, WorkerHandlers } from "../models/ports.ts";
+import type { DoneReason, RunStatus } from "../models/types.ts";
 import type { WorkflowRun } from "../models/workflow-run.ts";
 import type { WorkerHandle } from "../worker-handle.ts";
 
-/** [F1] 归因文案——与 error-recovery.ts 常量一致（不直接 import 常量以锚定对外文案）。 */
+/** [F1] 归因文案——与 worker-message-pump.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）─────────────────
+// ── helpers（对齐 worker-message-pump-handlers.test.ts）─────────────────
 
 interface RunMockOpts {
   workerErrorCount?: number;
@@ -70,11 +71,11 @@ function makeRunningRun(opts: RunMockOpts = {}): WorkflowRun {
       worker: { postMessage: vi.fn() },
       receivedTerminalMessage: opts.receivedTerminalMessage,
     },
-    transition(target: string, reason?: string): void {
+    transition(this: WorkflowRun, target: RunStatus, reason?: DoneReason): void {
       this.state.status = target;
       if (target === "done") this.state.reason = reason;
     },
-    replaceRuntime(rt: unknown): void {
+    replaceRuntime(this: WorkflowRun, rt: NonNullable<WorkflowRun["runtime"]>): void {
       this.runtime = rt;
     },
   } as unknown as WorkflowRun;