@zhushanwen/pi-subagent-workflow 8.6.0 → 8.7.0

package/src/execution/__tests__/dialog-queue.test.ts

@@ -1,299 +0,0 @@
-// src/__tests__/dialog-queue.test.ts
-//
-// W2 红灯测试：dialog-queue.ts — L2 跨子进程全局 dialog 串行队列。
-//
-// 测试对象：extensions/universal/subagent-workflow/src/execution/dialog-queue.ts（新建）
-// 契约来源：.fix-plans/00-master-summary.md §一 冲突 3（L2 DialogGlobalQueue 设计）
-//
-// DialogGlobalQueue 设计要点：
-//   - 进程单例，跨所有子进程共享，串行所有 dialog 类请求（isDialogMethod===true）
-//   - enqueue(req, handler): Promise<UiResponse> — 入队，返回 Promise
-//   - FIFO 串行：前一个 handler resolve 后才处理下一个
-//   - SR-4：入队项带 child 引用，child close 时把该 child 的 pending dialog 全部
-//     reject 为 cancelled（防 Promise 永挂 + 内存泄漏）
-//   - handler 抛错兜底：catch → appendEntry "subagent:dialog-handler-failed"
-//     → 回 {cancelled:true} → 继续处理下一个（不能让一个失败卡死队列）
-//   - 调用方约定只对 dialog 类调 enqueue；fire-and-forget 由调用方（factory 层）
-//     直接调 handler 不入队。enqueue 内仍防御性兼容 fire-and-forget（直接调 handler）
-//
-// 4 个 TC-E4 测试 case：
-//   1. 3 个并发 dialog 请求按 FIFO 顺序串行处理
-//   2. SR-4: child close 时 pending dialog reject 为 cancelled
-//   3. handler 抛错后队列继续处理下一个
-//   4. fire-and-forget method 不入队（直接调 handler）
-//
-// 红灯原因：dialog-queue.ts 尚未创建，import 失败。
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import { DialogGlobalQueue, type UiRequest, type UiResponse } from "../dialog-queue.ts";
-
-// ── 类型助手 ────────────────────────────────────────────────
-// UiRequest 最小形状（method + id）。dialog 类：select/confirm/input/editor。
-// fire-and-forget 类：notify/setStatus/...。
-
-function dialogReq(id: string, method: "select" | "confirm" | "input" | "editor" = "select"): UiRequest {
-  return { method, id, title: `q-${id}` };
-}
-
-function fireAndForgetReq(id: string): UiRequest {
-  return { method: "notify", id, message: `n-${id}` };
-}
-
-// ── 测试 fixture ────────────────────────────────────────────
-
-beforeEach(() => {
-  vi.useFakeTimers();
-});
-
-afterEach(() => {
-  vi.useRealTimers();
-});
-
-describe("DialogGlobalQueue — FIFO 串行（TC-E4 case 1）", () => {
-  it("3 个并发 dialog 请求按 FIFO 顺序串行处理（前一个 resolve 后才处理下一个）", async () => {
-    const queue = new DialogGlobalQueue();
-    const callOrder: string[] = [];
-    // 每个请求返回独立的可控 Promise，模拟 handler 延迟
-    const resolvers: Array<(v: UiResponse) => void> = [];
-
-    const handler = vi.fn((req: UiRequest): Promise<UiResponse> => {
-      callOrder.push(req.id);
-      return new Promise<UiResponse>((resolve) => {
-        resolvers.push(resolve);
-      });
-    });
-
-    // 并发入队 3 个 dialog 请求
-    const p1 = queue.enqueue(dialogReq("r1"), handler);
-    const p2 = queue.enqueue(dialogReq("r2"), handler);
-    const p3 = queue.enqueue(dialogReq("r3"), handler);
-
-    // 只有第一个立即被处理
-    expect(handler).toHaveBeenCalledTimes(1);
-    expect(callOrder).toEqual(["r1"]);
-
-    // resolve 第一个 → 第二个开始
-    resolvers[0]({ value: "a1" });
-    await vi.advanceTimersByTimeAsync(0);
-    expect(handler).toHaveBeenCalledTimes(2);
-    expect(callOrder).toEqual(["r1", "r2"]);
-
-    // resolve 第二个 → 第三个开始
-    resolvers[1]({ value: "a2" });
-    await vi.advanceTimersByTimeAsync(0);
-    expect(handler).toHaveBeenCalledTimes(3);
-    expect(callOrder).toEqual(["r1", "r2", "r3"]);
-
-    // resolve 第三个 → 全部 settle
-    resolvers[2]({ value: "a3" });
-    await vi.advanceTimersByTimeAsync(0);
-
-    const [r1, r2, r3] = await Promise.all([p1, p2, p3]);
-    expect(r1).toEqual({ value: "a1" });
-    expect(r2).toEqual({ value: "a2" });
-    expect(r3).toEqual({ value: "a3" });
-  });
-});
-
-describe("DialogGlobalQueue — SR-4 child close reject（TC-E4 case 2）", () => {
-  it("child close 时该 child 的 pending dialog reject 为 cancelled（防 Promise 永挂）", async () => {
-    const queue = new DialogGlobalQueue();
-    const child = { pid: 20001 };
-
-    const handler = vi.fn(
-      (): Promise<UiResponse> => new Promise<UiResponse>(() => {}),
-    );
-
-    // 入队一个永远不 resolve 的 dialog，绑定 child
-    const pending = queue.enqueue(dialogReq("r1"), handler, { child });
-
-    // 模拟 child close —— pending 必须被 reject 为 cancelled
-    queue.rejectChildDialogs(child);
-
-    await expect(pending).resolves.toEqual({ cancelled: true });
-  });
-
-  it("child close 不影响其他 child 的 pending dialog", async () => {
-    const queue = new DialogGlobalQueue();
-    const childA = { pid: 30001 };
-    const childB = { pid: 30002 };
-
-    const handler = vi.fn(
-      (): Promise<UiResponse> => new Promise<UiResponse>(() => {}),
-    );
-
-    const pendingA = queue.enqueue(dialogReq("a1"), handler, { child: childA });
-    const pendingB = queue.enqueue(dialogReq("b1"), handler, { child: childB });
-
-    // close childA —— 只有 pendingA 被 reject，pendingB 仍 pending
-    queue.rejectChildDialogs(childA);
-
-    await expect(pendingA).resolves.toEqual({ cancelled: true });
-    // pendingB 不被 reject（仍 pending）—— 用 race + real timer 验证它没 settle。
-    // fake timer 下 setTimeout 不自动跑，临时切 real timer 做 10ms 超时探测。
-    vi.useRealTimers();
-    const settled = await Promise.race([
-      pendingB.then(() => true),
-      new Promise<boolean>((resolve) => setTimeout(() => resolve(false), 10)),
-    ]);
-    expect(settled).toBe(false);
-    vi.useFakeTimers();
-  });
-});
-
-describe("DialogGlobalQueue — handler 抛错兜底（TC-E4 case 3）", () => {
-  it("handler 第一次抛错 → 回 cancelled → 队列继续处理下一个（不卡死）", async () => {
-    const queue = new DialogGlobalQueue();
-    const callOrder: string[] = [];
-
-    const handler = vi.fn((req: UiRequest): Promise<UiResponse> => {
-      callOrder.push(req.id);
-      if (req.id === "r1") {
-        return Promise.reject(new Error("handler boom"));
-      }
-      return Promise.resolve<UiResponse>({ value: "ok-" + req.id });
-    });
-
-    const p1 = queue.enqueue(dialogReq("r1"), handler);
-    const p2 = queue.enqueue(dialogReq("r2"), handler);
-
-    await vi.advanceTimersByTimeAsync(0);
-
-    // r1 抛错兜底回 cancelled（不向上抛）
-    await expect(p1).resolves.toEqual({ cancelled: true });
-    // r2 正常处理
-    await expect(p2).resolves.toEqual({ value: "ok-r2" });
-
-    expect(callOrder).toEqual(["r1", "r2"]);
-  });
-});
-
-describe("DialogGlobalQueue — fire-and-forget 防御性兼容（TC-E4 case 4）", () => {
-  it("fire-and-forget method（notify）防御性直接调 handler，不串行等待（调用方约定不传此类）", async () => {
-    const queue = new DialogGlobalQueue();
-    const callOrder: string[] = [];
-
-    // 第一个 dialog 请求永不 resolve（占住队列）
-    const blockingHandler = vi.fn(
-      (): Promise<UiResponse> => new Promise<UiResponse>(() => {}),
-    );
-    const ffHandler = vi.fn((req: UiRequest): Promise<UiResponse> => {
-      callOrder.push(req.id);
-      return Promise.resolve<UiResponse>({ ack: true });
-    });
-
-    // 入队一个 blocking dialog（占住队列）
-    queue.enqueue(dialogReq("d1"), blockingHandler);
-    // fire-and-forget 必须立即被调用，不等 d1 resolve
-    const ffResult = await queue.enqueue(fireAndForgetReq("f1"), ffHandler);
-
-    expect(ffHandler).toHaveBeenCalledTimes(1);
-    expect(callOrder).toEqual(["f1"]);
-    expect(ffResult).toEqual({ ack: true });
-    // blocking dialog 的 handler 仍只调用一次，ff 没有插入队列等待
-    expect(blockingHandler).toHaveBeenCalledTimes(1);
-  });
-});
-
-// ── A4+C12：rejectAll + #19 单一推进点 + child close 集成语义 ──
-
-describe("DialogGlobalQueue — rejectAll settle 全部 pending + 清状态（#10/session_shutdown）", () => {
-  it("rejectAll 把 current + 队列所有 pending settle 为 cancelled，并清空 queue/current/processing", async () => {
-    const queue = new DialogGlobalQueue();
-    const child = { pid: 50001 };
-    const blocking = vi.fn((): Promise<UiResponse> => new Promise<UiResponse>(() => {}));
-
-    // r1 占 current（永不 settle）；r2/r3 在队列等（含跨 child 的 r3）
-    const p1 = queue.enqueue(dialogReq("r1"), blocking, { child });
-    const p2 = queue.enqueue(dialogReq("r2"), blocking, { child });
-    const p3 = queue.enqueue(dialogReq("r3"), blocking);
-    expect(queue.size).toBe(2);
-
-    queue.rejectAll();
-
-    // 全部 settle 为 cancelled（Promise 不永挂）
-    await expect(p1).resolves.toEqual({ cancelled: true });
-    await expect(p2).resolves.toEqual({ cancelled: true });
-    await expect(p3).resolves.toEqual({ cancelled: true });
-    // 状态清空
-    expect(queue.size).toBe(0);
-  });
-
-  it("rejectAll 幂等：重复调用不抛错，状态保持清空，已 settle 的 Promise 不重复 resolve", async () => {
-    const queue = new DialogGlobalQueue();
-    const blocking = vi.fn((): Promise<UiResponse> => new Promise<UiResponse>(() => {}));
-    const p1 = queue.enqueue(dialogReq("r1"), blocking);
-
-    queue.rejectAll();
-    await expect(p1).resolves.toEqual({ cancelled: true });
-
-    // 再次调用——幂等（settled 标志保证只 settle 一次），不抛错
-    expect(() => queue.rejectAll()).not.toThrow();
-    expect(queue.size).toBe(0);
-    // p1 仍是 cancelled（防重复 resolve）
-    await expect(p1).resolves.toEqual({ cancelled: true });
-  });
-
-  it("rejectAll 后队列仍可正常 enqueue 新请求（状态完全重置，processing 不残留）", async () => {
-    const queue = new DialogGlobalQueue();
-    const blocking = vi.fn((): Promise<UiResponse> => new Promise<UiResponse>(() => {}));
-    queue.enqueue(dialogReq("r1"), blocking);
-    queue.rejectAll();
-
-    // rejectAll 后 enqueue 新 dialog，能正常处理（processing 已重置为 false）
-    const okHandler = vi.fn(async (): Promise<UiResponse> => ({ value: "new" }));
-    const p = queue.enqueue(dialogReq("after"), okHandler);
-    await vi.advanceTimersByTimeAsync(0);
-    await expect(p).resolves.toEqual({ value: "new" });
-    expect(okHandler).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe("DialogGlobalQueue — #19 单一推进点 + child close 集成语义", () => {
-  it("#19 单一推进点：rejectChildDialogs 取消占住 current 的永不 settle dialog 后，队列下一个 item 被推进处理（不卡死）", async () => {
-    const queue = new DialogGlobalQueue();
-    const childA = { pid: 60001 };
-    const blockingHandler = vi.fn((): Promise<UiResponse> => new Promise<UiResponse>(() => {}));
-    const r2Handler = vi.fn(async (): Promise<UiResponse> => ({ value: "r2-ok" }));
-
-    // r1 占 current（永不 settle，模拟等用户输入卡死）；r2（另一 child）排队等待
-    const p1 = queue.enqueue(dialogReq("r1"), blockingHandler, { child: childA });
-    const p2 = queue.enqueue(dialogReq("r2"), r2Handler);
-    expect(blockingHandler).toHaveBeenCalledTimes(1);
-    expect(r2Handler).toHaveBeenCalledTimes(0); // r2 还在等 r1 settle
-
-    // childA close → rejectChildDialogs settle r1；#19：settleItem 内唯一 processNext 推进 r2
-    queue.rejectChildDialogs(childA);
-    await vi.advanceTimersByTimeAsync(0);
-
-    await expect(p1).resolves.toEqual({ cancelled: true });
-    // 关键：r2 被推进（队列没卡死在永不 settle 的 r1）
-    expect(r2Handler).toHaveBeenCalledTimes(1);
-    await expect(p2).resolves.toEqual({ value: "r2-ok" });
-  });
-
-  it("child close 集成语义：queue 中同一 child 的多个 pending 被 rejectChildDialogs 一次全部 settle cancelled", async () => {
-    // 模拟 session-runner child 'close' 事件 → dialogQueue.rejectChildDialogs(child) 清理路径。
-    // 绑定点在 session-runner（非 dialog-queue 内部），本测试验证 rejectChildDialogs 公共方法语义。
-    // 用 blocker 占 current（另一 child）使被测 child 的项全排队，聚焦验证 queue 批量 cancel。
-    const queue = new DialogGlobalQueue();
-    const blocker = { pid: 70000 };
-    const child = { pid: 70001 };
-    const blocking = vi.fn((): Promise<UiResponse> => new Promise<UiResponse>(() => {}));
-
-    // blocker 占 current（永不 settle），让 child 的项都进队列
-    queue.enqueue(dialogReq("blk"), blocking, { child: blocker });
-    const p1 = queue.enqueue(dialogReq("c1"), blocking, { child });
-    const p2 = queue.enqueue(dialogReq("c2"), blocking, { child });
-    const p3 = queue.enqueue(dialogReq("c3"), blocking, { child });
-    expect(queue.size).toBe(3);
-
-    queue.rejectChildDialogs(child);
-
-    await expect(p1).resolves.toEqual({ cancelled: true });
-    await expect(p2).resolves.toEqual({ cancelled: true });
-    await expect(p3).resolves.toEqual({ cancelled: true });
-    expect(queue.size).toBe(0);
-  });
-});

package/src/execution/__tests__/epipe-fallback.test.ts

@@ -1,241 +0,0 @@
-// src/execution/__tests__/epipe-fallback.test.ts
-//
-// deliverMessage EPIPE 兜底集成测试——热路径 stdin 写入 EPIPE 时自动转冷路径 resume + 消息重放。
-//
-// 场景覆盖：
-//   1. 首次 EPIPE → 自动转冷路径 resumeRound（runSpawn 收到 resume 参数 + 原消息）
-//   2. 连续 2 次 EPIPE → throw 含恢复指引（防无限循环）
-//   3. 热路径成功写入后清零 EPIPE 计数（正常路径不受影响）
-
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import type { ChildProcess } from "node:child_process";
-import { PassThrough } from "node:stream";
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-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 }));
-
-// mock session-runner：runSpawn 受控 + killAllSpawnedChildren 空实现；
-// getChildByRecord/spawnedChildren 提供真实 Map 语义。
-vi.mock("../session-runner.ts", () => {
-  const spawnedChildren = new Map<string, unknown>();
-  return {
-    runSpawn: vi.fn(),
-    killAllSpawnedChildren: vi.fn(),
-    spawnedChildren,
-    getChildByRecord: (id: string): unknown => spawnedChildren.get(id),
-  };
-});
-
-import { runSpawn, spawnedChildren } from "../session-runner.ts";
-import * as lifecycle from "../lifecycle-manager.ts";
-import { createRecord } from "../execution-record.ts";
-import { ModelConfigService } from "../model-config-service.ts";
-import type { ModelInfo } from "../model-resolver.ts";
-import { SubagentService } from "../subagent-service.ts";
-import type { PiLike } from "../subagent-service.ts";
-import type { AgentResult, ExecutionRecord } from "../types.ts";
-
-const mockRunSpawn = vi.mocked(runSpawn);
-
-function makeTmpAgentDir(): string {
-  return fs.mkdtempSync(path.join(os.tmpdir(), "epipe-test-"));
-}
-
-function makePi(): PiLike & {
-  appendEntry: ReturnType<typeof vi.fn>;
-  events: { emit: ReturnType<typeof vi.fn> };
-  sendMessage: ReturnType<typeof vi.fn>;
-} {
-  return { appendEntry: vi.fn(), events: { emit: vi.fn() }, sendMessage: vi.fn() };
-}
-
-function makeResult(success: boolean): AgentResult {
-  return {
-    text: success ? "done" : "err",
-    turns: 1,
-    durationMs: 100,
-    success,
-    error: success ? undefined : "boom",
-    sessionId: "sess-1",
-    toolCalls: [],
-  };
-}
-
-/** chatMode running-resumable record（第一轮已完成，等待续聊；v4 B-1 旧 idle 折入 running）。 */
-function makeIdleRecord(id = "sa-epipe"): ExecutionRecord {
-  const record = createRecord(id, {
-    agent: "general-purpose",
-    model: "test/test-model",
-    thinkingLevel: "low",
-    mode: "background",
-    task: "initial task",
-    slug: "epipe-chat",
-    startedAt: 1000,
-    rootSessionId: "root-session",
-    chatMode: true,
-  });
-  record.status = "running";
-  record.round = 1;
-  record.controller = new AbortController();
-  return record;
-}
-
-/**
- * 构造 EPIPE child：stdin.write 抛 {code:'EPIPE'}，模拟子进程已退出但 close 事件尚未到达的窗口。
- */
-function makeEpipeChild(): ChildProcess {
-  const fakeStdin = {
-    write: vi.fn(() => {
-      const err = Object.assign(new Error("write after end"), { code: "EPIPE" });
-      throw err;
-    }),
-    destroyed: false,
-  } as unknown as PassThrough;
-  return { stdin: fakeStdin, pid: 99999 } as unknown as ChildProcess;
-}
-
-/**
- * 构造正常 child：PassThrough stdin（可正常写入）。
- */
-function makeNormalChild(): ChildProcess {
-  return { stdin: new PassThrough(), pid: 88888 } as unknown as ChildProcess;
-}
-
-// ============================================================
-// deliverMessage EPIPE 兜底
-// ============================================================
-
-describe("deliverMessage EPIPE 兜底（热路径 stdin EPIPE → 冷路径 resume）", () => {
-  let agentDir: string;
-  let service: SubagentService;
-  let record: ExecutionRecord;
-
-  beforeEach(() => {
-    agentDir = makeTmpAgentDir();
-    const modelService = new ModelConfigService({ agentDir });
-    service = new SubagentService({ cwd: agentDir, modelService });
-    service.initSession({ pi: makePi(), sessionId: "root-session" });
-    record = makeIdleRecord();
-    record.sessionFile = path.join(agentDir, "fake-session.jsonl");
-    spawnedChildren.clear();
-    mockRunSpawn.mockReset();
-    lifecycle._resetLifecycleState();
-    loggerMock.warn.mockClear();
-  });
-
-  afterEach(() => {
-    service.dispose();
-    spawnedChildren.clear();
-    lifecycle._resetLifecycleState();
-    fs.rmSync(agentDir, { recursive: true, force: true });
-  });
-
-  it("首次 EPIPE → 自动转冷路径 resumeRound + 原消息重放", async () => {
-    mockRunSpawn.mockResolvedValueOnce(makeResult(true));
-    // 注册 EPIPE child（热路径会命中但 stdin.write 抛 EPIPE）
-    spawnedChildren.set(record.id, makeEpipeChild());
-
-    // deliverMessage 不 throw（首次 EPIPE 走 resume 兜底）
-    await expect(service.deliverMessage(record, "msg after epipe", false)).resolves.toBeUndefined();
-
-    // spawnedChildren 中的死进程条目已清理（EPIPE catch 块 delete）
-    expect(spawnedChildren.has(record.id)).toBe(false);
-
-    // resumeRound 被触发（冷路径），runSpawn 收到 resume 参数 + 原消息
-    await vi.waitFor(() => expect(mockRunSpawn).toHaveBeenCalledTimes(1));
-    const call = mockRunSpawn.mock.calls[0]!;
-    expect(call[1]).toBe("msg after epipe");
-    expect(call[4]).toEqual({
-      sessionFile: record.sessionFile,
-      model: record.model,
-      thinkingLevel: record.thinkingLevel,
-    });
-
-    // warn 日志包含 EPIPE 关键词
-    expect(loggerMock.warn).toHaveBeenCalled();
-    const warnCalls = loggerMock.warn.mock.calls;
-    const epipeWarn = warnCalls.find((c: unknown[]) =>
-      typeof c[0] === "string" && c[0].includes("EPIPE"),
-    );
-    expect(epipeWarn).toBeDefined();
-  });
-
-  it("连续 2 次 EPIPE → throw 含恢复指引（防无限循环）", async () => {
-    mockRunSpawn.mockResolvedValue(makeResult(true));
-    // 注册 EPIPE child
-    spawnedChildren.set(record.id, makeEpipeChild());
-
-    // 第 1 次：EPIPE → resume（不 throw）
-    await service.deliverMessage(record, "first epipe", false);
-    await vi.waitFor(() => expect(mockRunSpawn).toHaveBeenCalledTimes(1));
-
-    // resume 完成后 record 回 running（v4 B-1：finalizeRoundToIdle 设 running，旧 idle 折入）
-    await vi.waitFor(() => expect(record.status).toBe("running"));
-
-    // 第 2 次：再次注入 EPIPE child + EPIPE
-    spawnedChildren.set(record.id, makeEpipeChild());
-
-    // 第 2 次 EPIPE → throw 含恢复指引（连续 2 次触发 exhaustion）
-    // 注意：第二 EPIPE 时 count 已为 2，catch 块立即 throw（不经过 resumeRound）。
-    let thrown: unknown;
-    try {
-      await service.deliverMessage(record, "second epipe", false);
-    } catch (err) {
-      thrown = err;
-    }
-    expect(thrown).toBeInstanceOf(Error);
-    expect((thrown as Error).message).toContain("EPIPE fallback exhausted");
-    expect((thrown as Error).message).toContain("2 consecutive EPIPE");
-    expect((thrown as Error).message).toContain("action:'close'");
-    expect((thrown as Error).message).toContain("action:'start'");
-  });
-
-  it("热路径成功写入后清零 EPIPE 计数（正常路径不受 EPIPE 计数影响）", async () => {
-    mockRunSpawn.mockResolvedValue(makeResult(true));
-
-    // 第 1 轮：EPIPE → resume
-    spawnedChildren.set(record.id, makeEpipeChild());
-    await service.deliverMessage(record, "epipe msg", false);
-    await vi.waitFor(() => expect(mockRunSpawn).toHaveBeenCalledTimes(1));
-    await vi.waitFor(() => expect(record.status).toBe("running"));
-
-    // 第 2 轮：正常 child，成功写入（清零 EPIPE 计数）
-    spawnedChildren.set(record.id, makeNormalChild());
-    await service.deliverMessage(record, "normal msg", true);
-    // 不 throw，status=running（热路径成功）
-    expect(record.status).toBe("running");
-
-    // 第 3 轮：再次 EPIPE → 但因为第 2 轮清零了计数，这次是首次 EPIPE（不 throw）
-    // 需要先让 record 回 running（等待续聊态）
-    record.status = "running";
-    spawnedChildren.set(record.id, makeEpipeChild());
-    await expect(service.deliverMessage(record, "after reset", false)).resolves.toBeUndefined();
-  });
-
-  it("EPIPE 兜底与冷路径共用 in-flight 守卫：resume 在途时 EPIPE 兜底不再二次 spawn（review round2 MF1）", async () => {
-    // 冷路径发起 resume，runSpawn 挂起（spawn 异步窗口内）
-    let releaseFirst!: (r: AgentResult) => void;
-    mockRunSpawn.mockImplementationOnce(
-      () => new Promise<AgentResult>((res) => { releaseFirst = res; }),
-    );
-    await service.deliverMessage(record, "cold path first", false);
-    await vi.waitFor(() => expect(mockRunSpawn).toHaveBeenCalledTimes(1));
-
-    // 注册 EPIPE child → deliverMessage 走热路径 → stdin EPIPE → 兜底调 resumeRound
-    // → in-flight 命中 → throw（不再走第二次 spawn。EPIPE 计数仍 +1 但未达阈值 2，
-    // exhaustion 分支不触发；throw 由兜底路径的 resumeRound 守卫抛出）
-    spawnedChildren.set(record.id, makeEpipeChild());
-    await expect(service.deliverMessage(record, "epipe during resume", false)).rejects.toThrow(
-      /already starting a new round/,
-    );
-    expect(mockRunSpawn).toHaveBeenCalledTimes(1);
-
-    releaseFirst(makeResult(true));
-  });
-});