@zhushanwen/subagent-core 0.2.0

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

@@ -0,0 +1,299 @@
+// 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

@@ -0,0 +1,241 @@
+// 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() },
+}));
+vi.mock("../../core/logger.ts", () => ({ 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));
+  });
+});