@zhushanwen/pi-subagent-workflow 8.5.0 → 8.7.0

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

@@ -1,625 +0,0 @@
-/**
- * lifecycle — runWorkflow/abortRun/terminateRunningRuns/scheduleTimeBudget/evict 测试。
- *
- * 用真实 WorkflowRun（含真实状态机 + I1/I2 不变式守卫）+ mock RunRuntime（释放副作用
- * 可控）+ mock LifecycleDeps（store/workerHost/eventBus 可观察）。这样能真正测到
- * transition/assignRuntime/releaseRuntime 的状态机逻辑，而非全 mock 聚合根。
- *
- * 覆盖：
- * - runWorkflow：spec → 创建 run + workerHost.start + store.save + emit pending:register
- * - abortRun：done no-op / running→done + emit pending:unregister
- * - terminateRunningRuns：session 切换/关闭时仅 running 被终止（done,failed 落盘）
- * - scheduleTimeBudget：定时器到期 → abortRun(done,time_limited)（用 fake timers）
- * - evictDoneRunsBeyondCap：done run 内存淘汰白名单/排序/tie
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import {
-  abortRun,
-  evictDoneRunsBeyondCap,
-  MAX_RETAINED_DONE_RUNS,
-  runWorkflow,
-  scheduleTimeBudget,
-  terminateRunningRuns,
-} from "../lifecycle.ts";
-import { ArgsValidationError } from "../args-validator.ts";
-import { Budget } from "../models/budget.ts";
-import { RunRuntime } from "../models/run-runtime.ts";
-import { Trace } from "../models/trace.ts";
-import type { RunSpec } from "../models/run-spec.ts";
-import type { LifecycleDeps } from "../models/ports.ts";
-import { WorkflowRun } from "../models/workflow-run.ts";
-
-// ── helpers ──────────────────────────────────────────────────
-
-/** 构造一个最小 RunSpec（满足 WorkflowRun 构造的字段需求）。 */
-function makeSpec(opts: {
-  budgetTimeMs?: number;
-  budgetTokens?: number;
-  parameters?: Record<string, unknown>;
-  args?: Record<string, unknown>;
-} = {}): RunSpec {
-  return {
-    scriptSource: "execute() {}",
-    args: opts.args ?? {},
-    parameters: opts.parameters,
-    scriptName: "test-wf",
-    scriptPath: "/fake/test.js",
-    budgetTimeMs: opts.budgetTimeMs,
-    budgetTokens: opts.budgetTokens,
-  };
-}
-
-/**
- * 构造一个 status="running" 的真实 WorkflowRun，注入 mock RunRuntime。
- *
- * 流程：new WorkflowRun（status=running，I1 构造期跳过）→ assignRuntime
- * （注入 runtime，恢复 I1）。mock runtime 的 worker.terminate / controller.abort /
- * release 均可观察。
- */
-/** flush microtask 队列多次，让 void .then().catch() + async 链跑完。
- *
- * 注意：fake timers 下 setTimeout(resolve,0) 也会被拦截，故用 Promise.resolve()
- * 走原生 microtask 队列（不被 fake timers 拦截）。 */
-async function flushMicrotasks(times = 10): Promise<void> {
-  for (let i = 0; i < times; i++) {
-    await Promise.resolve();
-  }
-}
-
-function makeRunningRealRun(
-  runId: string,
-  opts: { budgetTimeMs?: number } = {},
-): { run: WorkflowRun; terminate: ReturnType<typeof vi.fn>; abort: ReturnType<typeof vi.fn> } {
-  const spec = makeSpec(opts);
-  const run = new WorkflowRun(
-    runId,
-    spec,
-    {
-      status: "running",
-      budget: new Budget({ maxTokens: 1000 }),
-      calls: new Map(),
-      trace: new Trace(),
-      errorLogs: [],
-    },
-    { startedAt: new Date().toISOString() },
-  );
-  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 runtime = new RunRuntime(
-    worker as never,
-    { withSlot: vi.fn() } as never,
-    controller,
-    undefined,
-  );
-  run.assignRuntime(runtime);
-  return { run, terminate, abort };
-}
-
-/** LifecycleDeps mock：store/workerHost/eventBus/onRunDone/log 可观察。 */
-function makeDeps(): LifecycleDeps & {
-  store: { save: ReturnType<typeof vi.fn>; loadAll: 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>;
-} {
-  return {
-    store: { save: vi.fn(async () => {}), loadAll: vi.fn(async () => []) },
-    workerHost: { start: vi.fn(() => ({ postMessage: vi.fn(), terminate: vi.fn(async () => {}) })) },
-    runner: { run: vi.fn(async () => ({})) },
-    runs: new Map(),
-    eventBus: { emit: vi.fn() },
-    onRunDone: vi.fn(),
-    log: vi.fn(),
-  } as unknown as ReturnType<typeof makeDeps>;
-}
-
-beforeEach(() => {
-  vi.useFakeTimers();
-});
-
-afterEach(() => {
-  vi.useRealTimers();
-});
-
-// ── scheduleTimeBudget ───────────────────────────────────────
-
-describe("scheduleTimeBudget", () => {
-  it("定时器到期 → abortRun(done,time_limited)", async () => {
-    const { run } = makeRunningRealRun("wf-budget-1");
-    const deps = makeDeps();
-    deps.runs.set("wf-budget-1", run);
-
-    const timer = scheduleTimeBudget("wf-budget-1", deps, 1000);
-    expect(timer).toBeDefined();
-
-    // 推进定时器到到期 + flush 让 abortRun async 链跑完
-    await vi.advanceTimersByTimeAsync(1000);
-    await flushMicrotasks();
-
-    expect(run.state.status).toBe("done");
-    expect(run.state.reason).toBe("time_limited");
-    expect(run.state.error).toContain("Time budget exceeded");
-    // 完成通知
-    expect(deps.eventBus.emit).toHaveBeenCalledWith("pending:unregister", {
-      id: "wf-budget-1",
-      reason: "time_limited",
-    });
-    expect(deps.onRunDone).toHaveBeenCalledTimes(1);
-  });
-
-  it("run 已 done 时 abortRun no-op（到期不重复 transition）", async () => {
-    const { run } = makeRunningRealRun("wf-budget-2");
-    // 先把 run 转 done（手动）
-    run.transition("done", "completed");
-    const deps = makeDeps();
-    deps.runs.set("wf-budget-2", run);
-
-    scheduleTimeBudget("wf-budget-2", deps, 500);
-    await vi.advanceTimersByTimeAsync(500);
-    await flushMicrotasks();
-
-    // 状态保持原 done/completed，未被 time_limited 覆盖
-    expect(run.state.reason).toBe("completed");
-    expect(deps.onRunDone).not.toHaveBeenCalled();
-  });
-
-  it("定时器 unref（不阻止 Node 退出）", () => {
-    const deps = makeDeps();
-    const timer = scheduleTimeBudget("wf-x", deps, 10000);
-    // unref 是 Node timer 的方法，fake timer 也支持——验证不抛错
-    expect(() => timer.unref()).not.toThrow();
-    timer.unref();
-  });
-});
-
-// ── runWorkflow ──────────────────────────────────────────────
-
-describe("runWorkflow", () => {
-  it("spec → 创建 run + 启动 worker + store.save + emit pending:register", async () => {
-    const deps = makeDeps();
-    const spec = makeSpec();
-
-    const runId = await runWorkflow(spec, deps);
-
-    expect(runId).toMatch(/^wf-/);
-    // run 注册到 deps.runs
-    expect(deps.runs.has(runId)).toBe(true);
-    const run = deps.runs.get(runId)!;
-    // status 为 running（assignRuntime 已绑定 runtime）
-    expect(run.state.status).toBe("running");
-    expect(run.runtime).toBeDefined();
-    // workerHost.start 被调
-    expect(deps.workerHost.start).toHaveBeenCalledTimes(1);
-    // store.save 持久化
-    expect(deps.store.save).toHaveBeenCalledTimes(1);
-    // pending:register 通知
-    expect(deps.eventBus.emit).toHaveBeenCalledWith("pending:register", {
-      id: runId,
-      type: "workflow",
-      name: "test-wf",
-    });
-  });
-
-  it("创建即 running：构造即 running，runs.set 在 assignRuntime 后（I1 窗口对外不可见）", async () => {
-    const deps = makeDeps();
-    // worker.start 被调时探测 runs 注册状态——证明 runs.set 在 assignRuntime 之后
-    let runsSizeAtWorkerStart = -1;
-    deps.workerHost.start = vi.fn(() => {
-      runsSizeAtWorkerStart = deps.runs.size;
-      return { postMessage: vi.fn(), terminate: vi.fn(async () => {}) };
-    });
-
-    const runId = await runWorkflow(makeSpec(), deps);
-
-    // worker.start 执行时 run 尚未注册（I1 跳过窗口不外泄）
-    expect(runsSizeAtWorkerStart).toBe(0);
-    // 完成后已注册，且构造即 running + runtime 已注入（I1 成立）
-    expect(deps.runs.has(runId)).toBe(true);
-    const run = deps.runs.get(runId)!;
-    expect(run.state.status).toBe("running");
-    expect(run.runtime).toBeDefined();
-    // save 落盘的是恢复 I1 后的聚合（status running + runtime 已绑定）
-    const savedRun = deps.store.save.mock.calls[0]![0] as WorkflowRun;
-    expect(savedRun).toBe(run);
-    expect(savedRun.state.status).toBe("running");
-  });
-
-  it("worker.start 抛错 → runWorkflow 拒绝且 runs 无孤儿注册", async () => {
-    const deps = makeDeps();
-    deps.workerHost.start = vi.fn(() => {
-      throw new Error("worker boot failed");
-    });
-
-    await expect(runWorkflow(makeSpec(), deps)).rejects.toThrow("worker boot failed");
-
-    // 无孤儿：启动失败时 run 未注册进 deps.runs（runs.set 在 start 之后）
-    expect(deps.runs.size).toBe(0);
-    expect(deps.store.save).not.toHaveBeenCalled();
-    expect(deps.eventBus.emit).not.toHaveBeenCalled();
-  });
-
-  it("带 budgetTimeMs 时调度时间预算计时器", async () => {
-    const deps = makeDeps();
-    const scheduleTimeBudgetSpy = vi.fn(() => undefined);
-    (deps as LifecycleDeps & { scheduleTimeBudget?: unknown }).scheduleTimeBudget = scheduleTimeBudgetSpy;
-    const spec = makeSpec({ budgetTimeMs: 3000 });
-
-    const runId = await runWorkflow(spec, deps);
-
-    // scheduleTimeBudget 在 lifecycle 内被调（runWorkflow 内联调，非走 deps.scheduleTimeBudget）
-    // 注意：runWorkflow 内直接调本文件的 scheduleTimeBudget，不读 deps.scheduleTimeBudget
-    expect(runId).toMatch(/^wf-/);
-  });
-
-  it("signal 已 abort → fail fast（抛错，不创建 run）", async () => {
-    const deps = makeDeps();
-    const spec = makeSpec();
-    const controller = new AbortController();
-    controller.abort();
-
-    await expect(runWorkflow(spec, deps, controller.signal)).rejects.toThrow(
-      "aborted before start",
-    );
-    expect(deps.runs.size).toBe(0);
-    expect(deps.workerHost.start).not.toHaveBeenCalled();
-  });
-
-  it("TC8: 参数校验失败 → throw ArgsValidationError + zero side effects（E9）", async () => {
-    const deps = makeDeps();
-    const controller = new AbortController();
-    const addSpy = vi.spyOn(controller.signal, "addEventListener");
-    const spec = makeSpec({
-      parameters: {
-        type: "object",
-        properties: { target: { type: "string" } },
-        required: ["target"],
-      },
-      args: {},
-    });
-
-    await expect(runWorkflow(spec, deps, controller.signal)).rejects.toThrow(ArgsValidationError);
-    expect(deps.runs.size).toBe(0);
-    expect(deps.workerHost.start).not.toHaveBeenCalled();
-    expect(deps.store.save).not.toHaveBeenCalled();
-    expect(deps.eventBus.emit).not.toHaveBeenCalled();
-    expect(addSpy).not.toHaveBeenCalled();
-    expect(deps.log).not.toHaveBeenCalled(); // 校验在 deps.log 前 throw（无日志痕迹）
-  });
-});
-
-// ── abortRun ─────────────────────────────────────────────────
-
-describe("abortRun", () => {
-  it("running run → done,aborted：releaseRuntime + emit pending:unregister", async () => {
-    const { run, terminate } = makeRunningRealRun("wf-abort-1");
-    const deps = makeDeps();
-    deps.runs.set("wf-abort-1", run);
-
-    await abortRun("wf-abort-1", deps, "user cancelled");
-
-    expect(run.state.status).toBe("done");
-    expect(run.state.reason).toBe("aborted");
-    expect(run.state.error).toBe("user cancelled");
-    expect(terminate).toHaveBeenCalledTimes(1);
-    expect(run.runtime).toBeUndefined();
-    expect(deps.eventBus.emit).toHaveBeenCalledWith("pending:unregister", {
-      id: "wf-abort-1",
-      reason: "aborted",
-    });
-    expect(deps.onRunDone).toHaveBeenCalledTimes(1);
-  });
-
-  it("done 状态 no-op（不重复 abort）", async () => {
-    const { run } = makeRunningRealRun("wf-abort-2");
-    run.transition("done", "completed");
-    const deps = makeDeps();
-    deps.runs.set("wf-abort-2", run);
-
-    await abortRun("wf-abort-2", deps, "late abort");
-
-    expect(run.state.reason).toBe("completed"); // 未被覆盖
-    expect(deps.onRunDone).not.toHaveBeenCalled();
-  });
-
-  it("自定义 doneReason（time_limited）", async () => {
-    const { run } = makeRunningRealRun("wf-abort-3");
-    const deps = makeDeps();
-    deps.runs.set("wf-abort-3", run);
-
-    await abortRun("wf-abort-3", deps, "timeout", "time_limited");
-
-    expect(run.state.reason).toBe("time_limited");
-    expect(run.state.error).toBe("timeout");
-  });
-
-  it("runId 不存在 → 抛错", async () => {
-    const deps = makeDeps();
-    await expect(abortRun("wf-missing", deps)).rejects.toThrow("not found");
-  });
-});
-
-// ── terminateRunningRuns ─────────────────────────────────────
-
-describe("terminateRunningRuns", () => {
-  it("多 run 中仅 running 被终止（done run 不动）", async () => {
-    const { run: running1 } = makeRunningRealRun("wf-term-1");
-    const { run: running2 } = makeRunningRealRun("wf-term-2");
-    const { run: doneRun } = makeRunningRealRun("wf-term-done");
-    doneRun.transition("done", "completed");
-    const deps = makeDeps();
-    deps.runs.set("wf-term-1", running1);
-    deps.runs.set("wf-term-2", running2);
-    deps.runs.set("wf-term-done", doneRun);
-
-    await terminateRunningRuns(deps, "Session switched: run terminated");
-
-    // running 全部转 done,failed
-    expect(running1.state.status).toBe("done");
-    expect(running1.state.reason).toBe("failed");
-    expect(running2.state.status).toBe("done");
-    expect(running2.state.reason).toBe("failed");
-    // done run 不被重写（保留 completed）
-    expect(doneRun.state.reason).toBe("completed");
-  });
-
-  it("每个被终止的 run 发 pending:unregister（reason=failed）且不调 onRunDone", async () => {
-    const { run: r1 } = makeRunningRealRun("wf-term-3");
-    const { run: r2 } = makeRunningRealRun("wf-term-4");
-    const deps = makeDeps();
-    deps.runs.set("wf-term-3", r1);
-    deps.runs.set("wf-term-4", r2);
-
-    await terminateRunningRuns(deps, "Session shutdown: run terminated");
-
-    expect(deps.eventBus.emit).toHaveBeenCalledWith("pending:unregister", {
-      id: "wf-term-3",
-      reason: "failed",
-    });
-    expect(deps.eventBus.emit).toHaveBeenCalledWith("pending:unregister", {
-      id: "wf-term-4",
-      reason: "failed",
-    });
-    // 对齐 session_start 恢复先例：主 agent 已离开本 session，不发完成通知
-    expect(deps.onRunDone).not.toHaveBeenCalled();
-  });
-
-  it("state.error = reason、reason 字段 = failed、run 落盘（releaseRuntime 解绑 runtime）", async () => {
-    const { run, terminate } = makeRunningRealRun("wf-term-5");
-    const deps = makeDeps();
-    deps.runs.set("wf-term-5", run);
-
-    await terminateRunningRuns(deps, "Session switched: run terminated");
-
-    expect(run.state.error).toBe("Session switched: run terminated");
-    expect(run.state.reason).toBe("failed");
-    expect(run.runtime).toBeUndefined();
-    expect(terminate).toHaveBeenCalledTimes(1);
-    expect(deps.store.save).toHaveBeenCalledTimes(1);
-    expect(deps.store.save).toHaveBeenCalledWith(run);
-  });
-
-  it("单 run save 抛错不中断其余（其余 run 仍落盘 + unregister）", async () => {
-    const { run: bad } = makeRunningRealRun("wf-term-err");
-    const { run: good } = makeRunningRealRun("wf-term-ok");
-    const deps = makeDeps();
-    deps.runs.set("wf-term-err", bad);
-    deps.runs.set("wf-term-ok", good);
-    deps.store.save = vi.fn(async (r: WorkflowRun) => {
-      if (r.runId === "wf-term-err") throw new Error("disk full");
-    });
-
-    await terminateRunningRuns(deps, "Session shutdown: run terminated");
-
-    // 抛错的 run：transition 先于 save，状态已转 done，但 unregister 被 save 失败短路
-    expect(bad.state.status).toBe("done");
-    expect(bad.state.reason).toBe("failed");
-    expect(deps.eventBus.emit).not.toHaveBeenCalledWith("pending:unregister", {
-      id: "wf-term-err",
-      reason: "failed",
-    });
-    // 其余 run 正常走完落盘 + unregister（单 run 失败不中断批量终止）
-    expect(good.state.status).toBe("done");
-    expect(deps.store.save).toHaveBeenCalledWith(good);
-    expect(deps.eventBus.emit).toHaveBeenCalledWith("pending:unregister", {
-      id: "wf-term-ok",
-      reason: "failed",
-    });
-  });
-});
-
-// ── evictDoneRunsBeyondCap ────────────────────────────────────
-
-/**
- * 构造可重水合的 WorkflowRun 快照（对齐 crash-recovery.test.ts makeRun 模式——
- * WorkflowRun.reconstruct 与构造同语义：I1 构造期跳过，running 快照合法）。
- *
- * @param runId run 标识
- * @param opts.completedAt 完成时刻 ISO 串（缺省=缺失场景，模拟旧格式/异常快照）
- * @param opts.status 状态（默认 done；running 用于白名单验证）
- */
-function makeEvictableRun(
-  runId: string,
-  opts: { completedAt?: string; status?: "running" | "done" } = {},
-): WorkflowRun {
-  const status = opts.status ?? "done";
-  return WorkflowRun.reconstruct(
-    runId,
-    {
-      scriptSource: "execute() {}",
-      args: {},
-      scriptName: "test",
-      scriptPath: "/fake/test.js",
-    },
-    {
-      status,
-      reason: status === "done" ? "completed" : undefined,
-      budget: new Budget({ maxTokens: 1000 }),
-      calls: new Map(),
-      trace: new Trace(),
-      errorLogs: [],
-    },
-    {
-      startedAt: opts.completedAt ?? "2026-08-15T00:00:00.000Z",
-      ...(opts.completedAt !== undefined ? { completedAt: opts.completedAt } : {}),
-    },
-  );
-}
-
-/** ISO 基准时刻（过去时刻），isoAt(n) = 基准 + n 分钟。 */
-const EVICT_T0 = Date.parse("2020-01-01T00:00:00.000Z");
-function isoAt(min: number): string {
-  return new Date(EVICT_T0 + min * 60_000).toISOString();
-}
-
-describe("evictDoneRunsBeyondCap（done run 内存淘汰，K=MAX_RETAINED_DONE_RUNS）", () => {
-  it("W3TC1: 状态白名单——仅 done 可淘汰，running 永不删", () => {
-    const runs = new Map<string, WorkflowRun>();
-    runs.set("wf-done-1", makeEvictableRun("wf-done-1", { completedAt: isoAt(1) }));
-    runs.set("wf-done-2", makeEvictableRun("wf-done-2", { completedAt: isoAt(2) }));
-    runs.set("wf-done-3", makeEvictableRun("wf-done-3", { completedAt: isoAt(3) }));
-    runs.set("wf-run-1", makeEvictableRun("wf-run-1", { status: "running" }));
-    runs.set("wf-run-2", makeEvictableRun("wf-run-2", { status: "running" }));
-
-    const evicted = evictDoneRunsBeyondCap(runs, 2);
-
-    // 3 done 超保留数 2 → 淘汰最旧 1 个
-    expect(evicted).toBe(1);
-    // running 全部仍在 Map（白名单外，即使 completedAt 缺失也不参与排序淘汰）
-    for (const id of ["wf-run-1", "wf-run-2"]) {
-      expect(runs.has(id)).toBe(true);
-    }
-    // done 仅剩 t2/t3 两个（t1 最旧被淘汰）
-    expect(runs.has("wf-done-1")).toBe(false);
-    expect(runs.has("wf-done-2")).toBe(true);
-    expect(runs.has("wf-done-3")).toBe(true);
-    expect(runs.size).toBe(4);
-  });
-
-  it("W3TC2: 按 meta.completedAt 升序淘汰最旧超限项 + 返回淘汰计数（非插入序）", () => {
-    const runs = new Map<string, WorkflowRun>();
-    // 插入序刻意与 completedAt 序无关：先倒序插入 t24→t0，再 delete+set 重排几个
-    // 中段条目（移到 Map 尾部）模拟一般性「完成序≠插入序」——若实现退化为按 Map
-    // 迭代首 excess 个淘汰，删的将不是 t0-t4，本用例失败
-    for (let i = 24; i >= 0; i--) {
-      runs.set(`wf-t${i}`, makeEvictableRun(`wf-t${i}`, { completedAt: isoAt(i) }));
-    }
-    for (const i of [5, 15, 20]) {
-      const run = runs.get(`wf-t${i}`)!;
-      runs.delete(`wf-t${i}`);
-      runs.set(`wf-t${i}`, run);
-    }
-
-    const evicted = evictDoneRunsBeyondCap(runs, MAX_RETAINED_DONE_RUNS);
-
-    expect(evicted).toBe(5);
-    expect(runs.size).toBe(MAX_RETAINED_DONE_RUNS);
-    // 被删的恰是 completedAt 最小的 5 个（t0-t4）
-    for (let i = 0; i < 5; i++) {
-      expect(runs.has(`wf-t${i}`)).toBe(false);
-    }
-    for (let i = 5; i < 25; i++) {
-      expect(runs.has(`wf-t${i}`)).toBe(true);
-    }
-  });
-
-  it("W3TC3: 反序 fixture——创建最早、完成最晚的 run 不被淘汰（GAP-1 回归锚点）", () => {
-    // 嵌套 workflow 竞态背景：父 run 创建最早（Map 首元素）、完成最晚（completedAt
-    // 全局最新）。同 session 累计 21 个 done 时父 run 完成瞬间触发同步裁剪——若按
-    // Map 插入序淘汰，父 run 被淘汰，runAndWait 轮询窗口内 get 不到 → 误返
-    // "Run not found"。completedAt 排序结构性消除。
-    const runs = new Map<string, WorkflowRun>();
-    // 插入序 = 创建序：wf-parent 最先插入，completedAt=t100 全局最新（先创建后完成）
-    runs.set("wf-parent", makeEvictableRun("wf-parent", { completedAt: isoAt(100) }));
-    for (let i = 0; i < 20; i++) {
-      // child(i+1) 后插入，completedAt=t0..t19（父 run 之前完成）
-      runs.set(`wf-child${i + 1}`, makeEvictableRun(`wf-child${i + 1}`, { completedAt: isoAt(i) }));
-    }
-
-    const evicted = evictDoneRunsBeyondCap(runs, MAX_RETAINED_DONE_RUNS);
-
-    expect(evicted).toBe(1);
-    // 被淘汰的是 child1（completedAt 最旧 t0），非 Map 首元素 wf-parent
-    expect(runs.has("wf-child1")).toBe(false);
-    expect(runs.has("wf-parent")).toBe(true);
-    for (let i = 2; i <= 20; i++) {
-      expect(runs.has(`wf-child${i}`)).toBe(true);
-    }
-  });
-
-  it("W3TC4: completedAt 缺失 fallback 视为最旧（排序键空串字典序最小）", () => {
-    const runs = new Map<string, WorkflowRun>();
-    // 插入序 [runC, runA, runB]——缺失者 runA 居中，防「碰巧首元素」假通过
-    runs.set("wf-runC", makeEvictableRun("wf-runC", { completedAt: isoAt(2) }));
-    runs.set("wf-runA", makeEvictableRun("wf-runA"));
-    runs.set("wf-runB", makeEvictableRun("wf-runB", { completedAt: isoAt(1) }));
-
-    const evicted = evictDoneRunsBeyondCap(runs, 2);
-
-    // runA 缺失 completedAt = 空串排序键 → 字典序最小=最旧 → 先被淘汰
-    expect(evicted).toBe(1);
-    expect(runs.has("wf-runA")).toBe(false);
-    expect(runs.has("wf-runB")).toBe(true);
-    expect(runs.has("wf-runC")).toBe(true);
-  });
-
-  it("W3TC5: tie 稳定排序——同 completedAt 按 Map 插入序确定性淘汰", () => {
-    function buildTieFixture(): Map<string, WorkflowRun> {
-      const runs = new Map<string, WorkflowRun>();
-      const tie = isoAt(50);
-      for (const id of ["wf-w1", "wf-w2", "wf-w3", "wf-w4"]) {
-        runs.set(id, makeEvictableRun(id, { completedAt: tie }));
-      }
-      return runs;
-    }
-
-    const runs = buildTieFixture();
-    const evicted = evictDoneRunsBeyondCap(runs, 2);
-
-    // tie 组内先插入者视为更旧先被淘汰
-    expect(evicted).toBe(2);
-    expect(runs.has("wf-w1")).toBe(false);
-    expect(runs.has("wf-w2")).toBe(false);
-    expect(runs.has("wf-w3")).toBe(true);
-    expect(runs.has("wf-w4")).toBe(true);
-
-    // 确定性：同 fixture 二次运行断言同一淘汰集合
-    const runs2 = buildTieFixture();
-    const evicted2 = evictDoneRunsBeyondCap(runs2, 2);
-    expect(evicted2).toBe(2);
-    expect(runs2.has("wf-w1")).toBe(false);
-    expect(runs2.has("wf-w2")).toBe(false);
-    expect(runs2.has("wf-w3")).toBe(true);
-    expect(runs2.has("wf-w4")).toBe(true);
-  });
-
-  it("W3TC6: done 数 <= keepDone 时 no-op 返回 0（恰好 K / 不足 K 两场景）", () => {
-    // 场景①：恰好 20 个 done（=K）
-    const exact = new Map<string, WorkflowRun>();
-    for (let i = 0; i < MAX_RETAINED_DONE_RUNS; i++) {
-      exact.set(`wf-ex-${i}`, makeEvictableRun(`wf-ex-${i}`, { completedAt: isoAt(i) }));
-    }
-    const evictedExact = evictDoneRunsBeyondCap(exact, MAX_RETAINED_DONE_RUNS);
-    expect(evictedExact).toBe(0);
-    expect(exact.size).toBe(MAX_RETAINED_DONE_RUNS);
-    for (let i = 0; i < MAX_RETAINED_DONE_RUNS; i++) {
-      expect(exact.has(`wf-ex-${i}`)).toBe(true);
-    }
-
-    // 场景②：5 个 done（<K）+ 混入 running
-    const under = new Map<string, WorkflowRun>();
-    for (let i = 0; i < 5; i++) {
-      under.set(`wf-un-${i}`, makeEvictableRun(`wf-un-${i}`, { completedAt: isoAt(i) }));
-    }
-    under.set("wf-un-run", makeEvictableRun("wf-un-run", { status: "running" }));
-    const evictedUnder = evictDoneRunsBeyondCap(under, MAX_RETAINED_DONE_RUNS);
-    expect(evictedUnder).toBe(0);
-    expect(under.size).toBe(6);
-    for (const id of ["wf-un-run"]) {
-      expect(under.has(id)).toBe(true);
-    }
-  });
-});