@zhushanwen/subagent-core 0.2.0 → 0.4.0

package/src/execution/__tests__/create-concurrency-pool.test.ts

@@ -0,0 +1,194 @@
+// src/execution/__tests__/create-concurrency-pool.test.ts
+//
+// U4（subagent-core-sink-design D7）：并发池工厂 createConcurrencyPool({maxConcurrent, queuePolicy})。
+// 排队策略差异是宿主声明的有意决策（pi=priority / zsw=strict-fifo），保留为参数而非消灭。
+// 锚定：
+//   ①缺省策略与既有 DefaultConcurrencyPool 行为逐点等值（pi 零回归）；
+//   ②priority / strict-fifo 两策略排队顺序语义互斥可辨。
+//
+// pool 的排队/放行是纯 Promise resolve（microtask），无 timer 参与——microtask flush
+// 推进，不引入真实 setTimeout（TEST-STRATEGY 禁真实等待），无需 fake timers。
+import { describe, expect, it } from "vitest";
+
+import { createConcurrencyPool, DefaultConcurrencyPool } from "../concurrency-pool.ts";
+
+/** microtask flush：让排队条目的 resolve/.then 链跑完（pool 无 timer 语义）。 */
+async function flushMicrotasks(): Promise<void> {
+  for (let i = 0; i < 10; i++) {
+    await Promise.resolve();
+  }
+}
+
+describe("createConcurrencyPool 工厂（U4/D7）", () => {
+  it("缺省 queuePolicy 与既有 DefaultConcurrencyPool 行为逐点等值（active/排队/release 对照）", async () => {
+    const factory = createConcurrencyPool({ maxConcurrent: 2 });
+    const classic = new DefaultConcurrencyPool(2);
+
+    // 槽位放行与 active 计数一致
+    await factory.acquire(0);
+    await factory.acquire(0);
+    await classic.acquire(0);
+    await classic.acquire(0);
+    expect(factory.active).toBe(classic.active);
+    expect(factory.active).toBe(2);
+
+    // 超额 acquire 同样排队（不放行）
+    let factoryQueued = false;
+    let classicQueued = false;
+    const fq = factory.acquire(0).then(() => {
+      factoryQueued = true;
+    });
+    const cq = classic.acquire(0).then(() => {
+      classicQueued = true;
+    });
+    await flushMicrotasks();
+    expect(factoryQueued).toBe(false);
+    expect(classicQueued).toBe(false);
+
+    // release 后排队条目同样获得槽位，active 语义一致
+    factory.release();
+    classic.release();
+    await flushMicrotasks();
+    expect(factoryQueued).toBe(true);
+    expect(classicQueued).toBe(true);
+    expect(factory.active).toBe(classic.active);
+
+    // 清理后归零一致
+    factory.release();
+    classic.release();
+    factory.release();
+    classic.release();
+    await flushMicrotasks();
+    expect(factory.active).toBe(0);
+    expect(classic.active).toBe(0);
+    await Promise.allSettled([fq, cq]);
+  });
+
+  it("queuePolicy 缺省值等值：不传 queuePolicy 与显式 'priority' 产出同序放行", async () => {
+    const implicit = createConcurrencyPool({ maxConcurrent: 1 });
+    const explicit = createConcurrencyPool({ maxConcurrent: 1, queuePolicy: "priority" });
+
+    const implicitOrder: string[] = [];
+    const explicitOrder: string[] = [];
+
+    // 同一序列：低优先级先入队、高优先级后入队 → priority 策略下高优先级插队
+    for (const [pool, order] of [
+      [implicit, implicitOrder],
+      [explicit, explicitOrder],
+    ] as const) {
+      await pool.acquire(0);
+      const low = pool.acquire(1000).then(() => {
+        order.push("low");
+        pool.release();
+      });
+      const high = pool.acquire(0).then(() => {
+        order.push("high");
+        pool.release();
+      });
+      pool.release();
+      await Promise.all([low, high]);
+    }
+
+    expect(implicitOrder).toEqual(["high", "low"]);
+    expect(explicitOrder).toEqual(implicitOrder);
+  });
+
+  it("queuePolicy:'priority' 高优先级先获得释放的槽位（pi 既有行为）", async () => {
+    const pool = createConcurrencyPool({ maxConcurrent: 1, queuePolicy: "priority" });
+    await pool.acquire(1000); // 低优先级占满
+
+    let lowAcquired = false;
+    let highAcquired = false;
+    const low = pool.acquire(1000).then(() => {
+      lowAcquired = true;
+    });
+    const high = pool.acquire(0).then(() => {
+      highAcquired = true;
+    });
+    await flushMicrotasks();
+    expect(lowAcquired).toBe(false);
+    expect(highAcquired).toBe(false);
+
+    pool.release();
+    await flushMicrotasks();
+    expect(highAcquired).toBe(true);
+    expect(lowAcquired).toBe(false);
+    pool.release();
+    await Promise.allSettled([low, high]);
+  });
+
+  it("queuePolicy:'strict-fifo' 忽略 priority，纯入队顺序放行", async () => {
+    const pool = createConcurrencyPool({ maxConcurrent: 1, queuePolicy: "strict-fifo" });
+    await pool.acquire(0); // 占满
+
+    const order: number[] = [];
+    // 入队顺序 priority: 10 → 0 → 5。priority 策略会让 0 最先；strict-fifo 必须按 10 → 0 → 5
+    const a = pool.acquire(10).then(() => {
+      order.push(10);
+      pool.release();
+    });
+    const b = pool.acquire(0).then(() => {
+      order.push(0);
+      pool.release();
+    });
+    const c = pool.acquire(5).then(() => {
+      order.push(5);
+      pool.release();
+    });
+    pool.release(); // 放行队首（seq 最小 = a）
+
+    await Promise.all([a, b, c]);
+    expect(order).toEqual([10, 0, 5]);
+  });
+
+  it("queuePolicy:'strict-fifo' 高优先级不插队（与 priority 策略语义互斥可辨）", async () => {
+    const pool = createConcurrencyPool({ maxConcurrent: 1, queuePolicy: "strict-fifo" });
+    await pool.acquire(0); // 占满
+
+    let lowFirstAcquired = false;
+    let highSecondAcquired = false;
+    // 低优先级先入队，高优先级后入队——priority 策略会放行 high；strict-fifo 必须放行 low
+    const low = pool.acquire(1000).then(() => {
+      lowFirstAcquired = true;
+    });
+    const high = pool.acquire(0).then(() => {
+      highSecondAcquired = true;
+    });
+    await flushMicrotasks();
+    expect(lowFirstAcquired).toBe(false);
+    expect(highSecondAcquired).toBe(false);
+
+    pool.release();
+    await flushMicrotasks();
+    expect(lowFirstAcquired).toBe(true);
+    expect(highSecondAcquired).toBe(false);
+
+    pool.release();
+    await flushMicrotasks();
+    expect(highSecondAcquired).toBe(true);
+    await Promise.allSettled([low, high]);
+  });
+
+  it("策略不影响并发语义：strict-fifo 的 clamp/active 与 priority 一致", async () => {
+    const pool = createConcurrencyPool({ maxConcurrent: 0, queuePolicy: "strict-fifo" });
+    // clamp 到 1（C3 修复语义策略无关）
+    expect(pool.maxConcurrent).toBe(1);
+    await pool.acquire(0);
+    expect(pool.active).toBe(1);
+    pool.release();
+    expect(pool.active).toBe(0);
+  });
+
+  it("strict-fifo 下排队条目 abort 仍 reject（AbortError，H2 语义策略无关）", async () => {
+    const pool = createConcurrencyPool({ maxConcurrent: 1, queuePolicy: "strict-fifo" });
+    await pool.acquire(0); // 占满
+
+    const controller = new AbortController();
+    const queued = pool.acquire(0, undefined, controller.signal);
+    await flushMicrotasks();
+    expect(pool.active).toBe(1); // 仍在排队
+
+    controller.abort();
+    await expect(queued).rejects.toMatchObject({ name: "AbortError" });
+  });
+});

package/src/execution/__tests__/delivery-methods.test.ts

@@ -34,6 +34,8 @@ vi.mock("../session-runner.ts", () => {
   return {
     runSpawn: vi.fn(),
     killAllSpawnedChildren: vi.fn(),
+    registerSpawnedChildForRecord: vi.fn(),
+    killRecordChildWithEscalation: vi.fn(),
     spawnedChildren,
     getChildByRecord: (id: string): unknown => spawnedChildren.get(id),
   };

package/src/execution/__tests__/descendant-sweep.test.ts

@@ -0,0 +1,269 @@
+// src/execution/__tests__/descendant-sweep.test.ts
+//
+// [T2-② / P-T2b 主路径] 后代级联补杀 sweep + session-pending 差集清单导出。
+//
+// 设计：docs/design/subagent-core-unbounded-wait-audit.md §7.2 T2-②；P-T2b 裁决
+//（probe/p-t2b-report.md）：pi SIGTERM 不级联孤儿后台后代（NO-CASCADE 三次稳定复现），
+// 补杀为主路径。覆盖：
+//   - listActivePendingFromSessionFile：register−unregister 差集、sessionId 提取、
+//     与 count 口径共享增量游标（交错调用不错位）。
+//   - sweepDescendantsOfSession：迭代展开至叶、pid 存活校验、cmdline（pi/--mode rpc）
+//     防误杀校验、反查失败 skip（T5 marker fallback TODO 锚点）。
+//   - looksLikePiRpcProcess：命中 / 拒绝形态矩阵。
+//   - killPidWithEscalation：SIGTERM 后 30s 仍活升级 SIGKILL（fake timers）。
+//
+// 真实 fs（临时目录）+ mock process.kill / spawnSync——session-pending 增量游标与
+// findSessionFileByHeaderId 的文件形态语义被真实执行。
+
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// 只 mock spawnSync（ps 探测受控）；spawn 等其余实现保留 actual（本文件不经 runSpawn）。
+vi.mock("node:child_process", async () => {
+  const actual = await import("node:child_process");
+  return {
+    ...actual,
+    spawnSync: vi.fn(),
+  };
+});
+
+import {
+  looksLikePiRpcProcess,
+  sweepDescendantsOfSession,
+} from "../session-runner.ts";
+import {
+  clearPendingCursors,
+  listActivePendingFromSessionFile,
+  readActivePendingFromSessionFile,
+} from "../session-pending.ts";
+import { writeAliveMarker } from "../alive-store.ts";
+
+const mockSpawnSync = vi.mocked(spawnSync);
+
+const ALIVE_PID_CHILD = 424_242;
+const ALIVE_PID_GRAND = 424_243;
+const DEAD_PID = 999_999;
+
+/** process.kill 受控：signal=0 探活（死 pid 抛 ESRCH），其余记录到 kills。 */
+const kills: Array<{ pid: number; signal: string | number }> = [];
+
+function entryLine(customType: string, data: Record<string, unknown>): string {
+  return `${JSON.stringify({
+    type: "custom",
+    customType,
+    data,
+    timestamp: "2026-09-01T00:00:00.000Z",
+    id: `e-${Math.random().toString(36).slice(2)}`,
+  })}\n`;
+}
+
+function registerData(id: string, sessionId: string): Record<string, unknown> {
+  return { id, type: "session", name: `desc-${id}`, status: "active", registeredAt: 1, expiresAt: undefined, sessionId };
+}
+
+let sessionDir = "";
+
+beforeEach(() => {
+  clearPendingCursors();
+  kills.length = 0;
+  mockSpawnSync.mockReset();
+  sessionDir = fs.mkdtempSync(path.join(os.tmpdir(), "desc-sweep-"));
+  vi.spyOn(process, "kill").mockImplementation(((pid: number, signal?: string | number) => {
+    if ((signal ?? 0) === 0) {
+      if (pid === DEAD_PID) {
+        const err = new Error("No such process") as NodeJS.ErrnoException;
+        err.code = "ESRCH";
+        throw err;
+      }
+      return true;
+    }
+    kills.push({ pid, signal: signal as string | number });
+    return true;
+  }) as typeof process.kill);
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  clearPendingCursors();
+  fs.rmSync(sessionDir, { recursive: true, force: true });
+});
+
+/** 标准三层树：root（层主）→ child-sess → grand-sess（叶）。 */
+function writeThreeLevelTree(): { rootFile: string; childFile: string; grandFile: string } {
+  const rootFile = path.join(sessionDir, "20260901T000000-000_root-sess.jsonl");
+  const childFile = path.join(sessionDir, "20260901T000001-000_child-sess.jsonl");
+  const grandFile = path.join(sessionDir, "20260901T000002-000_grand-sess.jsonl");
+  // 层主：注册了 child（未 unregister）
+  fs.writeFileSync(rootFile, entryLine("pending:register", registerData("bg-1", "child-sess")));
+  // child：注册了 grand（未 unregister）——sweep 须迭代至叶
+  fs.writeFileSync(childFile, entryLine("pending:register", registerData("bg-2", "grand-sess")));
+  // grand：叶，无 pending
+  fs.writeFileSync(grandFile, "other entry line\n");
+  // .alive sidecar：pid 线索来源
+  writeAliveMarker(childFile, { pid: ALIVE_PID_CHILD, id: "child-sess", startedAt: Date.now() });
+  writeAliveMarker(grandFile, { pid: ALIVE_PID_GRAND, id: "grand-sess", startedAt: Date.now() });
+  return { rootFile, childFile, grandFile };
+}
+
+/** ps -p <pid> -o command= 的完整 SpawnSyncReturns 形态（测试桩用，字段补齐省 as 链）。 */
+function psResult(stdout: string): ReturnType<typeof spawnSync> {
+  return {
+    pid: 0,
+    output: [null, stdout, ""],
+    stdout,
+    stderr: "",
+    status: 0,
+    signal: null,
+  } as ReturnType<typeof spawnSync>;
+}
+
+/** ps 探测默认桩：全部存活 pid 返回 pi rpc 形态。 */
+function stubCmdlineByPid(): void {
+  mockSpawnSync.mockImplementation((_cmd: string, args: readonly string[]) => {
+    const pid = Number(args[1]);
+    return psResult(`node /usr/local/bin/pi --mode rpc --no-extensions --session-dir /tmp/sess-${pid}\n`);
+  });
+}
+
+describe("[T2-②] listActivePendingFromSessionFile（差集清单）", () => {
+  it("register−unregister 差集 + sessionId/type 提取", () => {
+    const f = path.join(sessionDir, "a.jsonl");
+    fs.writeFileSync(
+      f,
+      entryLine("pending:register", registerData("bg-1", "sess-1")) +
+        entryLine("pending:register", registerData("bg-2", "sess-2")) +
+        entryLine("pending:unregister", { id: "bg-1" }),
+    );
+    const r = listActivePendingFromSessionFile(f);
+    expect(r.error).toBeUndefined();
+    expect(r.items).toHaveLength(1);
+    expect(r.items[0]).toMatchObject({ id: "bg-2", sessionId: "sess-2", type: "session" });
+  });
+
+  it("count 与 list 交错调用共享增量游标（结果一致、不丢条目）", () => {
+    const f = path.join(sessionDir, "b.jsonl");
+    fs.writeFileSync(f, entryLine("pending:register", registerData("bg-1", "sess-1")));
+    // 先 count（建立游标），后 append 再 list——增量读入新行
+    const c1 = readActivePendingFromSessionFile(f);
+    expect(c1.count).toBe(0); // 端口缺席时缺省 0（core notify-ports 默认实现）
+    fs.appendFileSync(f, entryLine("pending:register", registerData("bg-2", "sess-2")));
+    const r = listActivePendingFromSessionFile(f);
+    expect(r.items.map((i) => i.id).sort()).toEqual(["bg-1", "bg-2"]);
+  });
+
+  it("sessionFile undefined / 不可读 → error 面空清单", () => {
+    expect(listActivePendingFromSessionFile(undefined).error).toBeDefined();
+    expect(listActivePendingFromSessionFile(path.join(sessionDir, "missing.jsonl")).error).toBeDefined();
+  });
+});
+
+describe("[T2-②] sweepDescendantsOfSession（迭代补杀）", () => {
+  it("层主→后代→孙迭代展开至叶，双校验通过者逐个 SIGTERM", () => {
+    const { rootFile } = writeThreeLevelTree();
+    stubCmdlineByPid();
+
+    const r = sweepDescendantsOfSession(rootFile, sessionDir, "keep-alive watchdog");
+    expect(r.killed.sort()).toEqual([ALIVE_PID_CHILD, ALIVE_PID_GRAND].sort());
+    expect(r.skipped).toHaveLength(0);
+    const sigterms = kills.filter((k) => k.signal === "SIGTERM").map((k) => k.pid);
+    expect(sigterms.sort()).toEqual([ALIVE_PID_CHILD, ALIVE_PID_GRAND].sort());
+  });
+
+  it("SIGTERM 后 30s 仍存活 → 升级 SIGKILL（fake timers）", async () => {
+    vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
+    const { rootFile } = writeThreeLevelTree();
+    stubCmdlineByPid();
+
+    sweepDescendantsOfSession(rootFile, sessionDir, "test-escalation");
+    expect(kills.filter((k) => k.signal === "SIGKILL")).toHaveLength(0);
+
+    await vi.advanceTimersByTimeAsync(30_000);
+    const sigkills = kills.filter((k) => k.signal === "SIGKILL").map((k) => k.pid);
+    expect(sigkills.sort()).toEqual([ALIVE_PID_CHILD, ALIVE_PID_GRAND].sort());
+  });
+
+  it("cmdline 非 pi --mode rpc → pid 复用守卫拦截，不杀（但迭代继续展开其后代）", () => {
+    const { rootFile, childFile, grandFile } = writeThreeLevelTree();
+    // 伪造无关进程占住 child 的 pid；grand 正常
+    mockSpawnSync.mockImplementation((_cmd: string, args: readonly string[]) => {
+      const pid = Number(args[1]);
+      return psResult(
+        pid === ALIVE_PID_CHILD ? "vim notes.txt\n" : "pi --mode rpc\n",
+      );
+    });
+    void childFile;
+    void grandFile;
+
+    const r = sweepDescendantsOfSession(rootFile, sessionDir, "test-guard");
+    expect(r.killed).toEqual([ALIVE_PID_GRAND]); // child 被拦，grand 不受影响
+    expect(r.skipped).toHaveLength(1);
+    expect(r.skipped[0]).toMatchObject({ sessionId: "child-sess", pid: ALIVE_PID_CHILD });
+    expect(r.skipped[0].reason).toContain("pid reuse guard");
+    expect(kills.map((k) => k.pid)).toEqual([ALIVE_PID_GRAND]);
+  });
+
+  it("存活校验不过（pid 已死）→ skip 不杀", () => {
+    const { rootFile, childFile } = writeThreeLevelTree();
+    // child 的 marker 指向死 pid
+    writeAliveMarker(childFile, { pid: DEAD_PID, id: "child-sess", startedAt: Date.now() });
+    stubCmdlineByPid();
+
+    const r = sweepDescendantsOfSession(rootFile, sessionDir, "test-dead");
+    expect(r.killed).toEqual([ALIVE_PID_GRAND]);
+    expect(r.skipped[0]).toMatchObject({ pid: DEAD_PID, reason: expect.stringContaining("not alive") });
+  });
+
+  it("sessionId 反查失败 / 无 alive marker → skip 留 T5 锚点原因，不中断其余分支", () => {
+    const rootFile = path.join(sessionDir, "20260901T000010-000_root2.jsonl");
+    const childFile = path.join(sessionDir, "20260901T000011-000_naked-sess.jsonl");
+    // 两条 register：missing-sess 反查不到；naked-sess 有文件但无 .alive marker
+    fs.writeFileSync(
+      rootFile,
+      entryLine("pending:register", registerData("bg-m", "missing-sess")) +
+        entryLine("pending:register", { id: "bg-n", type: "session", name: "naked", status: "active", registeredAt: 1, expiresAt: undefined, sessionId: "naked-sess" }),
+    );
+    fs.writeFileSync(childFile, "");
+
+    const r = sweepDescendantsOfSession(rootFile, sessionDir, "test-skip");
+    expect(r.killed).toHaveLength(0);
+    expect(r.skipped).toHaveLength(2);
+    const reasons = r.skipped.map((s) => s.reason).join(" | ");
+    expect(reasons).toContain("not found in sessionDir");
+    expect(reasons).toContain("pending T5");
+    expect(reasons).toContain("no alive marker");
+  });
+
+  it("rootSessionFile undefined → 空 result（无层主快照不扫）", () => {
+    stubCmdlineByPid();
+    const r = sweepDescendantsOfSession(undefined, sessionDir, "test-empty");
+    expect(r.killed).toHaveLength(0);
+    expect(r.skipped).toHaveLength(0);
+    expect(kills).toHaveLength(0);
+  });
+});
+
+describe("[T2-②] looksLikePiRpcProcess（pid 复用防误杀校验）", () => {
+  it.each([
+    ["pi --mode rpc --no-extensions --session-dir /tmp/x", true],
+    ["node /usr/local/bin/pi --mode rpc --session-dir /tmp/x", true],
+    ["/opt/pi/bin/pi --mode=rpc", true],
+    ["pi.js --mode rpc", true],
+  ])("命中 pi rpc 形态: %s", (cmdline, expected) => {
+    expect(looksLikePiRpcProcess(cmdline)).toBe(expected);
+  });
+
+  it.each([
+    ["vim notes.txt"],
+    ["nginx: master process"],
+    ["tail -f /dev/null"],
+    ["node server.js --mode rpc"], // 有 --mode rpc 但命令不是 pi
+    ["pi --mode json"], // pi 但非 rpc
+    ["api --mode rpc"], // 含 "pi" 子串但非 pi 词形
+  ])("拒绝无关形态: %s", (cmdline) => {
+    expect(looksLikePiRpcProcess(cmdline)).toBe(false);
+  });
+});

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

@@ -26,7 +26,18 @@
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
-import { DialogGlobalQueue, type UiRequest, type UiResponse } from "../dialog-queue.ts";
+const { loggerMock } = vi.hoisted(() => ({
+  loggerMock: {
+    debug: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  },
+}));
+vi.mock("../../core/logger.ts", () => ({
+  getLogger: () => loggerMock,
+}));
+
+import { DEFAULT_DIALOG_TIMEOUT_MS, DialogGlobalQueue, type UiRequest, type UiResponse } from "../dialog-queue.ts";
 
 // ── 类型助手 ────────────────────────────────────────────────
 // UiRequest 最小形状（method + id）。dialog 类：select/confirm/input/editor。
@@ -44,6 +55,8 @@ function fireAndForgetReq(id: string): UiRequest {
 
 beforeEach(() => {
   vi.useFakeTimers();
+  loggerMock.warn.mockClear();
+  loggerMock.error.mockClear();
 });
 
 afterEach(() => {
@@ -297,3 +310,188 @@ describe("DialogGlobalQueue — #19 单一推进点 + child close 集成语义",
     expect(queue.size).toBe(0);
   });
 });
+
+// ── LC-3/T2⑦：dialog 超时上界（有意的行为变更：「等用户无限久」→ 默认 30min 有界）──
+// 设计权威源：docs/design/subagent-core-unbounded-wait-audit.md §7.2 T2 措施⑦。
+// 覆盖：①传 timeout 按传值 settle（错误消息含恢复指引与已等待时长）②未传挂 30min 默认上界
+// ③超时后队列继续（L2 processing 释放，不全局卡死）④handler 与队列级竞态 settle 恰一次。
+
+describe("DialogGlobalQueue — dialog 超时上界（LC-3/T2⑦）", () => {
+  /** 探测 pending 是否已 settle（fake timers 下不能直接 await 未定 Promise）。 */
+  function probe(pending: Promise<UiResponse>): { settled: () => boolean } {
+    const state = { settled: false };
+    void pending.then(() => {
+      state.settled = true;
+    });
+    return { settled: () => state.settled };
+  }
+
+  it("请求方传 timeout → 按传值超时 settle cancelled，日志含恢复指引与已等待时长", async () => {
+    const queue = new DialogGlobalQueue();
+    const handler = vi.fn((): Promise<UiResponse> => new Promise<UiResponse>(() => {}));
+    const p = queue.enqueue({ ...dialogReq("r1"), timeout: 1000 }, handler);
+
+    // 999ms（未到点）：不 settle
+    await vi.advanceTimersByTimeAsync(999);
+    const before = probe(p);
+    await vi.advanceTimersByTimeAsync(0);
+    expect(before.settled()).toBe(false);
+
+    // 第 1000ms：到点 settle cancelled（不 reject——enqueue 公共契约 Promise 不 reject）
+    await vi.advanceTimersByTimeAsync(1);
+    await expect(p).resolves.toEqual({ cancelled: true });
+
+    // 完整错误消息承载在父进程日志：含已等待时长 + 「重新发起提问」恢复指引
+    expect(loggerMock.warn).toHaveBeenCalledTimes(1);
+    const msg = loggerMock.warn.mock.calls[0][0] as string;
+    expect(msg).toContain("1000ms");
+    expect(msg).toContain("重新发起提问");
+    // 队列状态已释放
+    expect(queue.size).toBe(0);
+  });
+
+  it("未传 timeout → 挂 DEFAULT_DIALOG_TIMEOUT_MS（30min）默认上界 settle cancelled", async () => {
+    const queue = new DialogGlobalQueue();
+    const handler = vi.fn((): Promise<UiResponse> => new Promise<UiResponse>(() => {}));
+    const p = queue.enqueue(dialogReq("r1"), handler);
+
+    // 30min - 1ms：不 settle（原行为是永不 settle，此处锁死「有上界」语义）
+    await vi.advanceTimersByTimeAsync(DEFAULT_DIALOG_TIMEOUT_MS - 1);
+    const before = probe(p);
+    await vi.advanceTimersByTimeAsync(0);
+    expect(before.settled()).toBe(false);
+
+    await vi.advanceTimersByTimeAsync(1);
+    await expect(p).resolves.toEqual({ cancelled: true });
+    expect(loggerMock.warn).toHaveBeenCalledTimes(1);
+    const msg = loggerMock.warn.mock.calls[0][0] as string;
+    expect(msg).toContain(`${DEFAULT_DIALOG_TIMEOUT_MS}ms`);
+    expect(msg).toContain("重新发起提问");
+  });
+
+  it("timeout 非法（<=0）→ 回落默认上界（不因脏参数拆掉上界回到无界）", async () => {
+    const queue = new DialogGlobalQueue();
+    const handler = vi.fn((): Promise<UiResponse> => new Promise<UiResponse>(() => {}));
+    const p = queue.enqueue({ ...dialogReq("r1"), timeout: 0 }, handler);
+
+    await vi.advanceTimersByTimeAsync(DEFAULT_DIALOG_TIMEOUT_MS - 1);
+    const before = probe(p);
+    await vi.advanceTimersByTimeAsync(0);
+    expect(before.settled()).toBe(false);
+
+    await vi.advanceTimersByTimeAsync(1);
+    await expect(p).resolves.toEqual({ cancelled: true });
+  });
+
+  it("超时后 L2 processing 释放，队列继续处理后续项（不全局卡死）", async () => {
+    const queue = new DialogGlobalQueue();
+    const blocking = vi.fn((): Promise<UiResponse> => new Promise<UiResponse>(() => {}));
+    const nextHandler = vi.fn(async (): Promise<UiResponse> => ({ value: "r2-ok" }));
+
+    // r1 永挂（host UI promise 挂死形态），带 timeout:1000；r2 排队
+    const p1 = queue.enqueue({ ...dialogReq("r1"), timeout: 1000 }, blocking);
+    const p2 = queue.enqueue(dialogReq("r2"), nextHandler);
+    expect(nextHandler).toHaveBeenCalledTimes(0);
+
+    // r1 超时 → settle + 推进 r2
+    await vi.advanceTimersByTimeAsync(1000);
+    await expect(p1).resolves.toEqual({ cancelled: true });
+    expect(nextHandler).toHaveBeenCalledTimes(1);
+    await expect(p2).resolves.toEqual({ value: "r2-ok" });
+  });
+
+  it("竞态恰一次（超时先到）：超时 settle 后迟到的 handler 结果不覆盖，队列不重复推进", async () => {
+    const queue = new DialogGlobalQueue();
+    let resolveHandler: ((v: UiResponse) => void) | undefined;
+    const handler = vi.fn(
+      (): Promise<UiResponse> =>
+        new Promise<UiResponse>((resolve) => {
+          resolveHandler = resolve;
+        }),
+    );
+    const nextHandler = vi.fn(async (): Promise<UiResponse> => ({ value: "next-ok" }));
+
+    const p1 = queue.enqueue({ ...dialogReq("r1"), timeout: 1000 }, handler);
+    const p2 = queue.enqueue(dialogReq("r2"), nextHandler);
+
+    // 超时先 settle
+    await vi.advanceTimersByTimeAsync(1000);
+    await expect(p1).resolves.toEqual({ cancelled: true });
+    expect(loggerMock.warn).toHaveBeenCalledTimes(1);
+
+    // 迟到的 handler 结果不覆盖（Promise 恰 settle 一次），r2 也已被推进恰一次
+    resolveHandler!({ value: "late" });
+    await vi.advanceTimersByTimeAsync(0);
+    await expect(p1).resolves.toEqual({ cancelled: true });
+    expect(loggerMock.warn).toHaveBeenCalledTimes(1);
+    expect(nextHandler).toHaveBeenCalledTimes(1);
+    await expect(p2).resolves.toEqual({ value: "next-ok" });
+  });
+
+  it("竞态恰一次（handler 先到）：handler 正常完成后迟到超时点不触发第二次 settle 与超时日志", async () => {
+    const queue = new DialogGlobalQueue();
+    let resolveHandler: ((v: UiResponse) => void) | undefined;
+    const handler = vi.fn(
+      (): Promise<UiResponse> =>
+        new Promise<UiResponse>((resolve) => {
+          resolveHandler = resolve;
+        }),
+    );
+
+    const p = queue.enqueue({ ...dialogReq("r1"), timeout: 1000 }, handler);
+    resolveHandler!({ value: "fast" });
+    await vi.advanceTimersByTimeAsync(0);
+    await expect(p).resolves.toEqual({ value: "fast" });
+    expect(loggerMock.warn).toHaveBeenCalledTimes(0);
+
+    // 越过原超时点：timer 已被 clearTimeout，无第二次 settle、无超时日志
+    await vi.advanceTimersByTimeAsync(2000);
+    await expect(p).resolves.toEqual({ value: "fast" });
+    expect(loggerMock.warn).toHaveBeenCalledTimes(0);
+    expect(queue.size).toBe(0);
+  });
+});
+
+// ── A2-2：reject/rejectAll 抢先 settle 后超时 timer 必须撤下 ────────────────
+// 修复前：clearTimeout 只在 processNext 的 handler settle/throw 两路径——handler 永挂时
+// await 永不 resume，rejectChildDialogs/rejectAll 抢先 settle 后 timer 仍 armed 到期，
+// 触发虚假「dialog timed out」warn + 句柄滞留至超时点（30min~24.8 天）。
+
+describe("DialogGlobalQueue — reject 抢先 settle 后超时 timer 清理（A2-2）", () => {
+  it("current 被 rejectChildDialogs 抢先 settle → timer 撤下，到期无虚假 warn、无句柄滞留", async () => {
+    const queue = new DialogGlobalQueue();
+    // host UI promise 永挂（rejectChildDialogs 的设计触发场景）
+    const handler = vi.fn((): Promise<UiResponse> => new Promise<UiResponse>(() => {}));
+    const p = queue.enqueue({ ...dialogReq("r1"), timeout: 1000 }, handler, { child: { pid: 42 } });
+
+    await vi.advanceTimersByTimeAsync(0);
+    expect(handler).toHaveBeenCalledTimes(1); // 已成 current，超时 timer 已 armed
+    expect(vi.getTimerCount()).toBe(1);
+
+    // child close：抢先 settle 为 cancelled
+    queue.rejectChildDialogs({ pid: 42 });
+    await expect(p).resolves.toEqual({ cancelled: true });
+    expect(vi.getTimerCount()).toBe(0); // timer 已随 settle 清除，无句柄滞留
+
+    // 越过原超时点：不触发虚假「dialog timed out」warn、无第二次 settle
+    await vi.advanceTimersByTimeAsync(2000);
+    await expect(p).resolves.toEqual({ cancelled: true });
+    expect(loggerMock.warn).not.toHaveBeenCalled();
+  });
+
+  it("rejectAll 抢先 settle current → 同样撤下 timer（无虚假 warn、无句柄滞留）", async () => {
+    const queue = new DialogGlobalQueue();
+    const handler = vi.fn((): Promise<UiResponse> => new Promise<UiResponse>(() => {}));
+    const p = queue.enqueue({ ...dialogReq("r1"), timeout: 1000 }, handler);
+
+    await vi.advanceTimersByTimeAsync(0);
+    expect(vi.getTimerCount()).toBe(1);
+
+    queue.rejectAll();
+    await expect(p).resolves.toEqual({ cancelled: true });
+    expect(vi.getTimerCount()).toBe(0);
+
+    await vi.advanceTimersByTimeAsync(2000);
+    expect(loggerMock.warn).not.toHaveBeenCalled();
+  });
+});