@zhushanwen/pi-subagent-workflow 0.2.0 → 0.3.1

package/src/execution/__tests__/channel-registry-handshake.test.ts

@@ -0,0 +1,233 @@
+// src/execution/__tests__/channel-registry-handshake.test.ts
+//
+// 决策 D（修复 M4）：channel handshake 协议升级测试。
+//
+// 测试对象：extensions/subagent-workflow/src/execution/channel-registry-access.ts
+//
+// 协议契约（与 ask-user 侧严格对齐）：
+//   key 字面量：     "@zhushanwen/pi-subagents.channelHandshake"
+//   handshake 形状： { version: 1, registry?: UiChannelRegistry, pending: [{channel,handler}] }
+//   canonical 唯一创建点：getOrCreateChannelRegistry（仅 subagent-workflow 侧创建）
+//
+// 关键不变量：
+//   1. canonical registry 永远由 subagent-workflow 创建
+//   2. ask-user 先到时只往 slot.pending 推，subagent-workflow 来时 flush
+//   3. 重复调用返回同一实例（===）
+//   4. version !== 1 时 warn + 丢弃重建
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import {
+  CHANNEL_HANDSHAKE_KEY,
+  getOrCreateChannelRegistry,
+  type ChannelRegistryHandshake,
+} from "../channel-registry-access.ts";
+
+// ── 用例隔离：每个用例前清空 globalThis 槽位 ─────────────────
+// handshake 是 globalThis 单例，跨用例污染会破坏测试确定性。
+function clearSlot(): void {
+  Reflect.deleteProperty(globalThis, CHANNEL_HANDSHAKE_KEY);
+}
+
+afterEach(() => {
+  clearSlot();
+});
+
+/** 读取当前 slot（绕过本模块的 readHandshakeSlot，测试断言用）。 */
+function readRawSlot(): ChannelRegistryHandshake | undefined {
+  return Reflect.get(globalThis, CHANNEL_HANDSHAKE_KEY) as ChannelRegistryHandshake | undefined;
+}
+
+/** 手动塞一个 slot（模拟 ask-user 先到的场景）。 */
+function injectSlot(slot: ChannelRegistryHandshake): void {
+  Reflect.set(globalThis, CHANNEL_HANDSHAKE_KEY, slot);
+}
+
+describe("getOrCreateChannelRegistry — 空 globalThis 场景", () => {
+  it("空 slot → 创建 canonical + slot，返回的 registry 有 register/resolve/list，slot.version===1，pending 为 []", () => {
+    clearSlot();
+    const registry = getOrCreateChannelRegistry();
+
+    // registry 形状：canonical 三方法
+    expect(typeof registry.register).toBe("function");
+    expect(typeof registry.resolve).toBe("function");
+    expect(typeof registry.list).toBe("function");
+
+    // slot 被填充且形状正确
+    const slot = readRawSlot();
+    expect(slot).toBeDefined();
+    expect(slot!.version).toBe(1);
+    expect(slot!.registry).toBe(registry); // slot.registry 指向返回的 registry
+    expect(slot!.pending).toEqual([]);
+  });
+});
+
+describe("getOrCreateChannelRegistry — ask-user 先到（registry 未就绪 + pending 非空）", () => {
+  it("模拟 ask-user 先到塞 pending → getOrCreate 创建 canonical + flush pending（handler 注册成功 + pending 清空）", () => {
+    clearSlot();
+    // ask-user 先到：塞 version:1 slot，registry 未就绪，pending 有 1 条
+    const handler = vi.fn();
+    injectSlot({
+      version: 1,
+      pending: [{ channel: "ask_user", handler }],
+    });
+
+    const registry = getOrCreateChannelRegistry();
+
+    // canonical registry 被创建，pending 被 flush
+    expect(registry.resolve("ask_user")).toBe(handler);
+    // pending 已清空
+    const slot = readRawSlot();
+    expect(slot!.pending).toEqual([]);
+    // slot.registry 现在指向返回的 registry
+    expect(slot!.registry).toBe(registry);
+  });
+
+  it("flush 后 registry.resolve 能拿到 handler（集成验证 resolve 真的能取到）", () => {
+    clearSlot();
+    const handler = vi.fn();
+    injectSlot({
+      version: 1,
+      pending: [{ channel: "ask_user", handler }],
+    });
+
+    const registry = getOrCreateChannelRegistry();
+    // 调一次 resolve 拿到的 handler，确认是原始 handler 引用
+    const resolved = registry.resolve("ask_user");
+    expect(resolved).toBe(handler);
+  });
+});
+
+describe("getOrCreateChannelRegistry — 二次调用（registry 已就绪）", () => {
+  it("二次调用返回同一实例引用（===），不重建，不重复 flush", () => {
+    clearSlot();
+    const first = getOrCreateChannelRegistry();
+    const second = getOrCreateChannelRegistry();
+    expect(second).toBe(first); // 引用相等
+
+    // slot.registry 也仍指向同一实例
+    const slot = readRawSlot();
+    expect(slot!.registry).toBe(first);
+    expect(slot!.registry).toBe(second);
+  });
+
+  it("二次调用不重复 flush（pending 已清空，再次调用 pending 仍为 []）", () => {
+    clearSlot();
+    const handler = vi.fn();
+    injectSlot({
+      version: 1,
+      pending: [{ channel: "ask_user", handler }],
+    });
+
+    getOrCreateChannelRegistry(); // 第一次：flush + 清空 pending
+    getOrCreateChannelRegistry(); // 第二次：应跳过 flush 分支
+
+    const slot = readRawSlot();
+    expect(slot!.pending).toEqual([]);
+    // handler 仍只被注册一次（resolve 仍是原 handler）
+    const registry = slot!.registry!;
+    expect(registry.resolve("ask_user")).toBe(handler);
+    expect(registry.list()).toEqual(["ask_user"]);
+  });
+});
+
+describe("getOrCreateChannelRegistry — canonical registry 三方法（形状验证）", () => {
+  it("返回的 registry register 后 resolve 拿到 handler，list 列出 channel 名", () => {
+    clearSlot();
+    const registry = getOrCreateChannelRegistry();
+    const handler = vi.fn();
+    registry.register("custom_channel", handler);
+
+    expect(registry.resolve("custom_channel")).toBe(handler);
+    expect(registry.list()).toContain("custom_channel");
+  });
+
+  it("未注册的 channel resolve 返回 undefined", () => {
+    clearSlot();
+    const registry = getOrCreateChannelRegistry();
+    expect(registry.resolve("not_registered")).toBeUndefined();
+  });
+});
+
+describe("getOrCreateChannelRegistry — 多条 pending flush 顺序与覆盖", () => {
+  it("多条 pending（不同 channel）flush 后都被注册，list 顺序保留插入顺序", () => {
+    clearSlot();
+    const h1 = vi.fn();
+    const h2 = vi.fn();
+    const h3 = vi.fn();
+    injectSlot({
+      version: 1,
+      pending: [
+        { channel: "alpha", handler: h1 },
+        { channel: "beta", handler: h2 },
+        { channel: "gamma", handler: h3 },
+      ],
+    });
+
+    const registry = getOrCreateChannelRegistry();
+    expect(registry.resolve("alpha")).toBe(h1);
+    expect(registry.resolve("beta")).toBe(h2);
+    expect(registry.resolve("gamma")).toBe(h3);
+    expect(registry.list()).toEqual(["alpha", "beta", "gamma"]);
+  });
+
+  it("同名 channel 后者覆盖前者（pending 内重复 channel）", () => {
+    clearSlot();
+    const old = vi.fn();
+    const fresh = vi.fn();
+    injectSlot({
+      version: 1,
+      pending: [
+        { channel: "ask_user", handler: old },
+        { channel: "ask_user", handler: fresh }, // 后者覆盖
+      ],
+    });
+
+    const registry = getOrCreateChannelRegistry();
+    expect(registry.resolve("ask_user")).toBe(fresh);
+    // list 不重复（Map key 唯一）
+    expect(registry.list()).toEqual(["ask_user"]);
+  });
+});
+
+describe("getOrCreateChannelRegistry — version 校验（向前兼容）", () => {
+  it("version !== 1（如塞 {version:2,...}）→ warn + 重建为新 slot，旧 pending 数据丢弃", () => {
+    clearSlot();
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    // 塞一个 version:2 的 slot，含旧数据
+    const staleHandler = vi.fn();
+    injectSlot({
+      version: 2 as unknown as 1, // 故意写错 version
+      registry: undefined,
+      pending: [{ channel: "ask_user", handler: staleHandler }],
+    });
+
+    const registry = getOrCreateChannelRegistry();
+
+    // warn 被调用
+    expect(warnSpy).toHaveBeenCalled();
+    // 旧 pending 数据被丢弃（staleHandler 没被注册）
+    expect(registry.resolve("ask_user")).toBeUndefined();
+    // slot 被重建为 version:1，pending 为空
+    const slot = readRawSlot();
+    expect(slot!.version).toBe(1);
+    expect(slot!.pending).toEqual([]);
+    expect(slot!.registry).toBe(registry);
+
+    warnSpy.mockRestore();
+  });
+
+  it("version !== 1 时 warn 消息包含 got/expected 字样", () => {
+    clearSlot();
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    injectSlot({ version: 99 as unknown as 1, pending: [] });
+
+    getOrCreateChannelRegistry();
+
+    const msg = warnSpy.mock.calls[0]?.[0] ?? "";
+    expect(String(msg)).toMatch(/got/);
+    expect(String(msg)).toMatch(/expected/);
+
+    warnSpy.mockRestore();
+  });
+});

package/src/execution/__tests__/crash-recovery.test.ts

@@ -89,6 +89,8 @@ vi.mock("../model-config-service.ts", () => ({
 vi.mock("../subagent-service.ts", () => ({
   SubagentService: class {
     initSession = vi.fn();
+    // W3: index.ts session_start 注入 UI handler 时调用
+    setUiRequestHandler = vi.fn();
   },
   getSubagentService: () => null,
   setSubagentService: vi.fn(),
@@ -119,10 +121,10 @@ vi.mock("../../interface/commands.ts", () => ({
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 
 import subagentsExtension from "../../index.ts";
-import { WorkflowRun } from "../../orchestration/models/workflow-run.ts";
 import { Budget } from "../../orchestration/models/budget.ts";
 import { Trace } from "../../orchestration/models/trace.ts";
 import type { WorkflowRun as WorkflowRunType } from "../../orchestration/models/workflow-run.ts";
+import { WorkflowRun } from "../../orchestration/models/workflow-run.ts";
 
 // ── helpers ──
 
@@ -195,6 +197,8 @@ function createMockPi(overrides: Record<string, unknown> = {}): {
 function createMockCtx(): Record<string, unknown> {
   return {
     cwd: "/home/user/project",
+    // [Wave1 #21] mode 必填（与 SDK ExtensionContext 契约一致）；默认 tui。
+    mode: "tui",
     modelRegistry: {
       getAvailable: () => [],
       find: () => undefined,

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/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__/execute-nesting.test.ts

@@ -117,9 +117,9 @@ vi.mock("../temp-prompt.ts", () => ({
 
 import { spawn } from "node:child_process";
 
+import { ModelConfigService } from "../model-config-service.ts";
 import type { ModelInfo, ModelRegistryLike } from "../model-resolver.ts";
 import { MAX_FORK_DEPTH } from "../session-context-resolver.ts";
-import { ModelConfigService } from "../model-config-service.ts";
 import { SubagentService } from "../subagent-service.ts";
 
 const mockSpawn = vi.mocked(spawn);

package/src/execution/__tests__/execute-options-mapper.test.ts

@@ -10,8 +10,8 @@
 import { describe, expect, it, vi } from "vitest";
 
 import type { AgentCallOpts } from "../../orchestration/models/types.ts";
-import type { ModelInfo } from "../model-resolver.ts";
 import { mapToExecuteOptions, mergeTimeoutSignal } from "../execute-options-mapper.ts";
+import type { ModelInfo } from "../model-resolver.ts";
 
 describe("mapToExecuteOptions (D-A2)", () => {
   const baseOpts: AgentCallOpts = {
@@ -22,6 +22,25 @@ describe("mapToExecuteOptions (D-A2)", () => {
     skillPath: "/path/to/skill.md",
   };
 
+  it("T3.10 slug 截断: description > SLUG_MAX_LENGTH(35) → 截断到 35", () => {
+    const opts: AgentCallOpts = { ...baseOpts, description: "a".repeat(36) };
+    const result = mapToExecuteOptions(opts);
+    expect(result.slug).toHaveLength(35);
+    expect(result.slug).toBe("a".repeat(35));
+  });
+
+  it("T3.10 slug 边界: description = 35 → 不截断", () => {
+    const opts: AgentCallOpts = { ...baseOpts, description: "a".repeat(35) };
+    const result = mapToExecuteOptions(opts);
+    expect(result.slug).toHaveLength(35);
+    expect(result.slug).toBe("a".repeat(35));
+  });
+
+  it("T3.10 slug 回落: 无 description → agentName", () => {
+    const result = mapToExecuteOptions(baseOpts);
+    expect(result.slug).toBe("worker");
+  });
+
   it("T3.4 基本映射: prompt→task, agent→agent, cwd→cwd", () => {
     const result = mapToExecuteOptions(baseOpts);
     expect(result.task).toBe("test task");
@@ -37,12 +56,12 @@ describe("mapToExecuteOptions (D-A2)", () => {
   it("T3.9 schemaEnv 透传 (D-A6 bridge)", () => {
     const opts: AgentCallOpts = { ...baseOpts, schemaEnv: '{"type":"object"}' };
     const result = mapToExecuteOptions(opts);
-    expect((result as unknown as { schemaEnv?: string }).schemaEnv).toBe('{"type":"object"}');
+    expect(result.schemaEnv).toBe('{"type":"object"}');
   });
 
   it("T3.9 schemaEnv 不传 → schemaEnv undefined", () => {
     const result = mapToExecuteOptions(baseOpts);
-    expect((result as unknown as { schemaEnv?: string }).schemaEnv).toBeUndefined();
+    expect(result.schemaEnv).toBeUndefined();
   });
 
   it("T3.5 model: opts.model 优先（显式 override 透传，不与 ctxModel 混合）", () => {