@zhushanwen/pi-subagent-workflow 0.2.0 → 0.3.1

package/src/execution/__tests__/spawn-event-adapter-rpc.test.ts

@@ -0,0 +1,189 @@
+// src/__tests__/spawn-event-adapter-rpc.test.ts
+//
+// W1 红灯测试：spawn-event-adapter.ts 协议层重写 — Pi 原生格式 + method 平铺。
+//
+// 测试对象：extensions/subagent-workflow/src/execution/spawn-event-adapter.ts（改造）
+// 契约来源：.fix-plans/00-master-summary.md §二（统一接口契约）+ §一冲突 2/判定顺序
+//
+// 核心改动：
+//   1. isExtensionUiRequest 重写：判 type==="extension_ui_request" + id:string + method:string
+//      （删 jsonrpc==="2.0" 守卫 + params 守卫 — Pi 原生格式是平铺字段）
+//   2. extension_ui_request 分支：从 {id, params:Record} 改为 {id, request: ExtensionUiRequest}
+//      request 按 method 平铺（title/options/message/... 与 Pi rpc-types.ts 1:1）
+//   3. isRpcResponse 重写：判 type==="response" + command:string + success:boolean（SR-1 根因 1b）
+//   4. 判定顺序：isExtensionUiRequest 必须在 event 分支之前（否则被 typeof obj.type===string 吞）
+//
+// 红灯原因：spawn-event-adapter.ts 当前用旧 JSON-RPC 2.0 守卫，对 Pi 原生格式样本
+//   无法识别为 extension_ui_request（会落到 event 分支）。改造后这些断言才绿。
+
+import { describe, expect, it } from "vitest";
+
+import { parseSpawnLine } from "../spawn-event-adapter.ts";
+
+// ── Pi 原生协议样本构造（来源：rpc-types.ts L230-265 真实类型） ──────────
+// 10 种 method，全部 {type:"extension_ui_request", id, method, ...平铺字段}。
+// 注意：无 jsonrpc 字段、无 params 包裹、method 在顶层（非 method:"extension_ui_request"）。
+
+function piLine(methodFields: Record<string, unknown>): string {
+  return JSON.stringify({ type: "extension_ui_request", id: "req-001", ...methodFields });
+}
+
+describe("parseSpawnLine — 10 种 method 真实样本分类（Pi 原生格式）", () => {
+  describe("dialog 类（select/confirm/input/editor）", () => {
+    it("select → kind=extension_ui_request + request.method=select + title/options 平铺", () => {
+      const result = parseSpawnLine(piLine({
+        method: "select", title: "Pick one", options: ["a", "b"], timeout: 30000,
+      }));
+      expect(result?.kind).toBe("extension_ui_request");
+      if (result?.kind !== "extension_ui_request") return;
+      expect(result.id).toBe("req-001");
+      expect(result.request.method).toBe("select");
+      expect(result.request.title).toBe("Pick one");
+      expect(result.request.options).toEqual(["a", "b"]);
+    });
+
+    it("confirm → request.method=confirm + title/message 平铺", () => {
+      const result = parseSpawnLine(piLine({
+        method: "confirm", title: "Sure?", message: "Proceed?", timeout: 10000,
+      }));
+      expect(result?.kind).toBe("extension_ui_request");
+      if (result?.kind !== "extension_ui_request") return;
+      expect(result.request.method).toBe("confirm");
+      expect(result.request.title).toBe("Sure?");
+      expect(result.request.message).toBe("Proceed?");
+    });
+
+    it("input → request.method=input + title + placeholder", () => {
+      const result = parseSpawnLine(piLine({
+        method: "input", title: "Name", placeholder: "type here",
+      }));
+      expect(result?.kind).toBe("extension_ui_request");
+      if (result?.kind !== "extension_ui_request") return;
+      expect(result.request.method).toBe("input");
+      expect(result.request.placeholder).toBe("type here");
+    });
+
+    it("editor → request.method=editor + title + prefill", () => {
+      const result = parseSpawnLine(piLine({
+        method: "editor", title: "Edit", prefill: "initial text",
+      }));
+      expect(result?.kind).toBe("extension_ui_request");
+      if (result?.kind !== "extension_ui_request") return;
+      expect(result.request.method).toBe("editor");
+      expect(result.request.prefill).toBe("initial text");
+    });
+  });
+
+  describe("fire-and-forget 类（notify/setStatus/setWidget/setTitle/set_editor_text）", () => {
+    it("notify → request.method=notify + message + notifyType", () => {
+      const result = parseSpawnLine(piLine({
+        method: "notify", message: "hi", notifyType: "info",
+      }));
+      expect(result?.kind).toBe("extension_ui_request");
+      if (result?.kind !== "extension_ui_request") return;
+      expect(result.request.method).toBe("notify");
+      expect(result.request.message).toBe("hi");
+    });
+
+    it("setStatus → request.method=setStatus + statusKey/statusText", () => {
+      const result = parseSpawnLine(piLine({
+        method: "setStatus", statusKey: "k", statusText: "running",
+      }));
+      expect(result?.kind).toBe("extension_ui_request");
+      if (result?.kind !== "extension_ui_request") return;
+      expect(result.request.method).toBe("setStatus");
+      expect(result.request.statusKey).toBe("k");
+    });
+
+    it("setWidget → request.method=setWidget + widgetKey/widgetLines/widgetPlacement", () => {
+      const result = parseSpawnLine(piLine({
+        method: "setWidget", widgetKey: "w1",
+        widgetLines: ["line1"], widgetPlacement: "aboveEditor",
+      }));
+      expect(result?.kind).toBe("extension_ui_request");
+      if (result?.kind !== "extension_ui_request") return;
+      expect(result.request.method).toBe("setWidget");
+      expect(result.request.widgetKey).toBe("w1");
+      expect(result.request.widgetPlacement).toBe("aboveEditor");
+    });
+
+    it("setTitle → request.method=setTitle + title", () => {
+      const result = parseSpawnLine(piLine({ method: "setTitle", title: "My Title" }));
+      expect(result?.kind).toBe("extension_ui_request");
+      if (result?.kind !== "extension_ui_request") return;
+      expect(result.request.method).toBe("setTitle");
+      expect(result.request.title).toBe("My Title");
+    });
+
+    it("set_editor_text → request.method=set_editor_text + text", () => {
+      const result = parseSpawnLine(piLine({ method: "set_editor_text", text: "body" }));
+      expect(result?.kind).toBe("extension_ui_request");
+      if (result?.kind !== "extension_ui_request") return;
+      expect(result.request.method).toBe("set_editor_text");
+      expect(result.request.text).toBe("body");
+    });
+  });
+});
+
+describe("parseSpawnLine — 旧 JSON-RPC 2.0 格式不再被识别（守卫已删）", () => {
+  it("jsonrpc+method:extension_ui_request+params 旧格式 → 不归类为 extension_ui_request", () => {
+    // 旧格式（错误假设）：会被识别为 event 或 invalid，因为新守卫不认 jsonrpc
+    const oldFormat = JSON.stringify({
+      jsonrpc: "2.0", id: "x", method: "extension_ui_request", params: { foo: "bar" },
+    });
+    const result = parseSpawnLine(oldFormat);
+    // 旧格式的 method 字段值是 "extension_ui_request"，无 type 字段 → invalid
+    // （这是有意的：强制对齐 Pi 原生格式）
+    expect(result?.kind).not.toBe("extension_ui_request");
+  });
+});
+
+describe("parseSpawnLine — 判定顺序：isExtensionUiRequest 先于 event 分支", () => {
+  it("extension_ui_request 不被 typeof obj.type===string 吞为 event", () => {
+    // 关键 bug：extension_ui_request 有 type 字段，若 event 分支在前会被当 event
+    const result = parseSpawnLine(piLine({ method: "notify", message: "x" }));
+    // 必须是 extension_ui_request，不能是 event
+    expect(result?.kind).toBe("extension_ui_request");
+    expect(result?.kind).not.toBe("event");
+  });
+});
+
+describe("parseSpawnLine — RPC response（isRpcResponse 重写，SR-1 根因 1b）", () => {
+  it("Pi response 格式 {type:response, command, success} → kind=response", () => {
+    const result = parseSpawnLine(JSON.stringify({
+      type: "response", id: "r1", command: "run_tool", success: true,
+    }));
+    expect(result?.kind).toBe("response");
+    if (result?.kind !== "response") return;
+    expect(result.id).toBe("r1");
+    expect(result.command).toBe("run_tool");
+    expect(result.success).toBe(true);
+  });
+
+  it("Pi response 失败 {type:response, command, success:false, error}", () => {
+    const result = parseSpawnLine(JSON.stringify({
+      type: "response", command: "run_tool", success: false, error: "boom",
+    }));
+    expect(result?.kind).toBe("response");
+    if (result?.kind !== "response") return;
+    expect(result.success).toBe(false);
+    expect(result.error).toBe("boom");
+  });
+
+  it("response 含 data 字段 → 保留", () => {
+    const result = parseSpawnLine(JSON.stringify({
+      type: "response", command: "read", success: true, data: { out: 42 },
+    }));
+    expect(result?.kind).toBe("response");
+    if (result?.kind !== "response") return;
+    expect(result.data).toEqual({ out: 42 });
+  });
+
+  it("旧 JSON-RPC 2.0 response（jsonrpc+id+result）→ 不再归类为 response", () => {
+    const oldRpc = JSON.stringify({
+      jsonrpc: "2.0", id: "x", result: { answers: [] },
+    });
+    const result = parseSpawnLine(oldRpc);
+    expect(result?.kind).not.toBe("response");
+  });
+});

package/src/execution/__tests__/stdin-writer.test.ts

@@ -0,0 +1,353 @@
+// src/execution/__tests__/stdin-writer.test.ts
+//
+// stdin-writer.ts 单元测试——覆盖 respond（UiResponse 4 分支 + 序列化降级）+
+// sendPromptCommand + sendGetStateCommand + writeStdinLine 背压。
+//
+// stdin-writer 是 spawn 改造的叶子 helper，向 rpc 子进程 stdin 写 JSON 命令。
+// 与 run-spawn-integration.test.ts 的集成视角不同：本文件只测「给定 child + 入参，
+// stdin 收到的确切字节内容」，逐分支验证协议格式正确性。
+//
+// 测试策略：
+//   - 用 PassThrough 模拟 child.stdin（buffered，可事后读出 write 的字节）。
+//   - 用 minimal ChildProcess 形状（{ stdin: PassThrough }）作 respond/sendPrompt 入参。
+//   - respond 的 4 分支：value/confirmed/cancelled/ack。ack 不写 stdin（fire-and-forget）。
+//   - JSON.stringify 降级（#16）：out.value 含循环引用 → 降级 cancelled + warn。
+//   - sendPromptCommand：写 {type:"prompt",message,id} 一行。
+//   - sendGetStateCommand：返回 reqId，写 {type:"get_state",id} 一行。
+//   - writeStdinLine 背压：mock child.stdin.write 返回 false → warn 但不 throw。
+
+import type { ChildProcess } from "node:child_process";
+import { PassThrough } from "node:stream";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { respond, sendGetStateCommand, sendPromptCommand } from "../stdin-writer.ts";
+
+// ── helpers ──
+
+/** 用 PassThrough 构造最小合法的 ChildProcess（只测 stdin 写入）。 */
+function makeChild(overrides: Partial<Pick<ChildProcess, "stdin">> = {}): ChildProcess {
+  return {
+    stdin: new PassThrough(),
+    ...overrides,
+  } as unknown as ChildProcess;
+}
+
+/**
+ * 读出 child.stdin 已缓冲的全部字节（字符串）。
+ *
+ * PassThrough 默认是 flowing 模式，attach 'data' listener 后会 flush 缓冲。
+ * 这里用 readable 状态：pause + read 取出全部缓冲。
+ */
+function readStdin(child: ChildProcess): string {
+  const stream = child.stdin as unknown as PassThrough;
+  stream.pause();
+  return stream.read()?.toString() ?? "";
+}
+
+/** 从 child.stdin 已缓冲内容按行拆分（去空行），返回 JSON.parse 后的对象数组。 */
+function readStdinLines(child: ChildProcess): unknown[] {
+  const text = readStdin(child);
+  return text
+    .split("\n")
+    .map((l) => l.trim())
+    .filter((l) => l.length > 0)
+    .map((l) => JSON.parse(l));
+}
+
+let warnSpy: ReturnType<typeof vi.spyOn>;
+
+beforeEach(() => {
+  // stdin-writer 在背压 / 序列化失败时 console.warn；测试 stub 避免 noise，且可断言调用。
+  // console.error（manifest 写失败路径）也 stub 静音，但测试不断言其调用。
+  warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+  vi.spyOn(console, "error").mockImplementation(() => {});
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+// ============================================================
+// respond：UiResponse 4 分支
+// ============================================================
+
+describe("respond — UiResponse 4 分支", () => {
+  describe("value 分支", () => {
+    it("out={value:'hello'} → stdin 收到 extension_ui_response 含 value 字段", () => {
+      const child = makeChild();
+      respond(child, "req-1", { value: "hello" });
+
+      const lines = readStdinLines(child);
+      expect(lines).toHaveLength(1);
+      expect(lines[0]).toEqual({ type: "extension_ui_response", id: "req-1", value: "hello" });
+    });
+
+    it("value 为含 JSON 特殊字符的字符串 → 原样透传（不二次转义）", () => {
+      // out.value 是字符串，JSON.stringify({value: out.value}) 会正确序列化。
+      // 关键：out.value 本身不被 JSON.parse 二次处理——它就是字符串值。
+      const child = makeChild();
+      const payload = JSON.stringify({ q: "ans", n: 1 }); // 合法 JSON 字符串作为 value
+      respond(child, "req-2", { value: payload });
+
+      const lines = readStdinLines(child);
+      expect(lines[0]).toEqual({ type: "extension_ui_response", id: "req-2", value: payload });
+    });
+  });
+
+  describe("confirmed 分支", () => {
+    it("out={confirmed:true} → stdin 收到 confirmed:true", () => {
+      const child = makeChild();
+      respond(child, "req-3", { confirmed: true });
+
+      const lines = readStdinLines(child);
+      expect(lines).toHaveLength(1);
+      expect(lines[0]).toEqual({ type: "extension_ui_response", id: "req-3", confirmed: true });
+    });
+
+    it("out={confirmed:false} → stdin 收到 confirmed:false（用户拒绝 confirm）", () => {
+      const child = makeChild();
+      respond(child, "req-4", { confirmed: false });
+
+      const lines = readStdinLines(child);
+      expect(lines[0]).toEqual({ type: "extension_ui_response", id: "req-4", confirmed: false });
+    });
+  });
+
+  describe("cancelled 分支", () => {
+    it("out={cancelled:true} → stdin 收到 cancelled:true", () => {
+      const child = makeChild();
+      respond(child, "req-5", { cancelled: true });
+
+      const lines = readStdinLines(child);
+      expect(lines).toHaveLength(1);
+      expect(lines[0]).toEqual({ type: "extension_ui_response", id: "req-5", cancelled: true });
+    });
+  });
+
+  describe("ack 分支（fire-and-forget）", () => {
+    it("out={ack:true} → 不写 stdin（SR-5：fire-and-forget 不期待响应）", () => {
+      const child = makeChild();
+      respond(child, "req-6", { ack: true });
+
+      // ack 分支 line 保持 undefined → writeStdinLine 不被调 → stdin 无数据
+      expect(readStdin(child)).toBe("");
+      expect(warnSpy).not.toHaveBeenCalled();
+    });
+  });
+});
+
+// ============================================================
+// respond：JSON.stringify 降级（#16）
+// ============================================================
+
+describe("respond — JSON.stringify 失败降级为 cancelled (#16)", () => {
+  it("out.value 含循环引用 → 降级 cancelled:true + warn，不让父进程崩溃", () => {
+    // 构造循环引用对象：JSON.stringify 会抛 Converting circular structure to JSON
+    const circular: Record<string, unknown> = { a: 1 };
+    circular.self = circular;
+
+    const child = makeChild();
+    respond(child, "req-circular", { value: circular } as never);
+
+    // 降级为 cancelled
+    const lines = readStdinLines(child);
+    expect(lines).toHaveLength(1);
+    expect(lines[0]).toEqual({
+      type: "extension_ui_response",
+      id: "req-circular",
+      cancelled: true,
+    });
+    // warn 被调用（含 request id）
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    const warnArg = warnSpy.mock.calls[0]?.[0] as string;
+    expect(warnArg).toContain("req-circular");
+    expect(warnArg).toContain("JSON.stringify failed");
+  });
+
+  it("out.value 含 BigInt → JSON.stringify 抛 → 降级 cancelled + warn", () => {
+    // BigInt 不可 JSON 序列化（JSON.stringify 抛 TypeError: Do not know how to serialize a BigInt）
+    const child = makeChild();
+    respond(child, "req-bigint", { value: BigInt(123) } as never);
+
+    const lines = readStdinLines(child);
+    expect(lines[0]).toEqual({
+      type: "extension_ui_response",
+      id: "req-bigint",
+      cancelled: true,
+    });
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("降级后的 cancelled 响应格式与正常 cancelled 分支一致（协议兼容）", () => {
+    // 确保降级走的是同一个 cancelled 格式（子进程解析逻辑无需区分「真取消」vs「序列化失败」）
+    const circular: Record<string, unknown> = {};
+    circular.self = circular;
+
+    const childFail = makeChild();
+    const childCancel = makeChild();
+    respond(childFail, "same-id", { value: circular } as never);
+    respond(childCancel, "same-id", { cancelled: true });
+
+    const failLine = readStdinLines(childFail)[0];
+    const cancelLine = readStdinLines(childCancel)[0];
+    expect(failLine).toEqual(cancelLine);
+  });
+});
+
+// ============================================================
+// respond：signal.aborted 守卫
+// ============================================================
+
+describe("respond — signal 已 aborted 跳过写入", () => {
+  it("signal.aborted=true → 不写 stdin", () => {
+    const child = makeChild();
+    const controller = new AbortController();
+    controller.abort();
+
+    respond(child, "req-aborted", { value: "x" }, controller.signal);
+
+    expect(readStdin(child)).toBe("");
+  });
+
+  it("signal.aborted=false → 正常写入", () => {
+    const child = makeChild();
+    const controller = new AbortController();
+
+    respond(child, "req-active", { value: "x" }, controller.signal);
+
+    const lines = readStdinLines(child);
+    expect(lines).toHaveLength(1);
+    expect(lines[0]).toEqual({ type: "extension_ui_response", id: "req-active", value: "x" });
+  });
+});
+
+// ============================================================
+// sendPromptCommand
+// ============================================================
+
+describe("sendPromptCommand", () => {
+  it("写入 {type:'prompt',message,id} 一行，message 含完整 task 文本", () => {
+    const child = makeChild();
+    const task = "Task: do something complex\nwith newline";
+    sendPromptCommand(child, task);
+
+    const lines = readStdinLines(child);
+    expect(lines).toHaveLength(1);
+    const cmd = lines[0] as { type: string; message: string; id: string };
+    expect(cmd.type).toBe("prompt");
+    expect(cmd.message).toBe(task); // 多行 task 原样透传
+    expect(typeof cmd.id).toBe("string");
+    expect(cmd.id.length).toBeGreaterThan(0); // crypto.randomUUID 生成
+  });
+
+  it("每次调用生成不同 id（crypto.randomUUID）", () => {
+    const child = makeChild();
+    sendPromptCommand(child, "task-1");
+    sendPromptCommand(child, "task-2");
+
+    const lines = readStdinLines(child);
+    expect(lines).toHaveLength(2);
+    const id1 = (lines[0] as { id: string }).id;
+    const id2 = (lines[1] as { id: string }).id;
+    expect(id1).not.toBe(id2);
+  });
+
+  it("写入以 \\n 结尾（rpc 子进程按行读 stdin）", () => {
+    const child = makeChild();
+    sendPromptCommand(child, "task");
+
+    // 直接查 raw 字节，验证末尾换行
+    const raw = readStdin(child);
+    expect(raw.endsWith("\n")).toBe(true);
+  });
+
+  it("child.stdin 已 destroyed → 静默跳过（guard 生效，不抛错）", () => {
+    const stdin = new PassThrough();
+    stdin.destroy();
+    const child = { stdin } as unknown as ChildProcess;
+
+    expect(() => sendPromptCommand(child, "task")).not.toThrow();
+    // destroyed 后 write 无效，但函数安全返回
+  });
+
+  it("child.stdin 为 null/undefined → 静默跳过（guard 生效）", () => {
+    const child = { stdin: null } as unknown as ChildProcess;
+    expect(() => sendPromptCommand(child, "task")).not.toThrow();
+  });
+});
+
+// ============================================================
+// sendGetStateCommand
+// ============================================================
+
+describe("sendGetStateCommand", () => {
+  it("写入 {type:'get_state',id} 一行并返回相同 id（用于匹配 response）", () => {
+    const child = makeChild();
+    const returnedId = sendGetStateCommand(child);
+
+    const lines = readStdinLines(child);
+    expect(lines).toHaveLength(1);
+    const cmd = lines[0] as { type: string; id: string };
+    expect(cmd.type).toBe("get_state");
+    expect(cmd.id).toBe(returnedId); // 返回值与写入的 id 一致
+    expect(typeof cmd.id).toBe("string");
+    // get_state 命令不含其他字段（只有 type + id）
+    expect(Object.keys(cmd).sort()).toEqual(["id", "type"]);
+  });
+
+  it("写入以 \\n 结尾", () => {
+    const child = makeChild();
+    sendGetStateCommand(child);
+
+    const raw = readStdin(child);
+    expect(raw.endsWith("\n")).toBe(true);
+  });
+
+  it("每次调用返回不同 id（crypto.randomUUID）", () => {
+    const child = makeChild();
+    const id1 = sendGetStateCommand(child);
+    const id2 = sendGetStateCommand(child);
+    expect(id1).not.toBe(id2);
+  });
+});
+
+// ============================================================
+// writeStdinLine 背压（间接经 respond 测）
+// ============================================================
+
+describe("writeStdinLine 背压 — write 返回 false 时 warn 不 throw", () => {
+  it("child.stdin.write 返回 false → warn 一次，函数正常返回（不 throw）", () => {
+    // 构造 write 永远返回 false 的假 stream（模拟内核缓冲满/HWM 到达）
+    const fakeStdin = {
+      write: vi.fn(() => false),
+      destroyed: false,
+    } as unknown as PassThrough;
+    const child = { stdin: fakeStdin } as unknown as ChildProcess;
+
+    expect(() => respond(child, "req-backpressure", { value: "x" })).not.toThrow();
+
+    // write 被调一次（写入 command 行）
+    expect(fakeStdin.write).toHaveBeenCalledTimes(1);
+    const writtenArg = fakeStdin.write.mock.calls[0]?.[0] as string;
+    expect(writtenArg).toContain("extension_ui_response");
+    expect(writtenArg).toContain("req-backpressure");
+    expect(writtenArg.endsWith("\n")).toBe(true);
+    // warn 被调（背压告警）
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    const warnMsg = warnSpy.mock.calls[0]?.[0] as string;
+    expect(warnMsg).toContain("backpressure");
+  });
+
+  it("child.stdin.write 返回 true → 不 warn（正常路径）", () => {
+    const fakeStdin = {
+      write: vi.fn(() => true),
+      destroyed: false,
+    } as unknown as PassThrough;
+    const child = { stdin: fakeStdin } as unknown as ChildProcess;
+
+    respond(child, "req-ok", { value: "x" });
+
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+});

package/src/execution/__tests__/subagent-service.test.ts

@@ -18,9 +18,10 @@ import * as path from "node:path";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import { createRecord } from "../execution-record.ts";
+import { ModelConfigService } from "../model-config-service.ts";
 import type { ModelInfo, ModelRegistryLike } from "../model-resolver.ts";
 import type { RecordStore } from "../record-store.ts";
-import { ModelConfigService } from "../model-config-service.ts";
+import type { UiRequest, UiRequestHandler } from "../dialog-queue.ts";
 import type { PiLike } from "../subagent-service.ts";
 import { getSubagentService, setSubagentService,SubagentService } from "../subagent-service.ts";
 import type { ExecutionRecord } from "../types.ts";
@@ -314,6 +315,75 @@ describe("SubagentService", () => {
     });
   });
 
+  // ============================================================
+  // dispose uiRequestHandler stub（dispose-cleanup Minor 优化1）
+  // ============================================================
+  //
+  // [背景] Pi 单进程 session 串行接管。session A shutdown 发 SIGTERM 后、子进程彻底
+  // close 前（graceful shutdown 窗口几十~几百 ms），子进程的 trailing extension_ui_request
+  // 仍会被父进程 pump 解析，调到 A 的 handler 闭包（仍持有 A 的 ctx）。旧实现 dispose 不清
+  // uiRequestHandler，该闭包触发 ui-request-queue.ts catch 分支打 `[subagents] uiRequestHandler
+  // threw` 误导性 console.error。dispose 现注入 stub（始终返回 {cancelled:true}），让 trailing
+  // ui_request 干净降级，不再走旧 handler 闭包。
+  //
+  // 被测点是 SubagentService.dispose 内的 setUiRequestHandler(stub)。uiRequestHandler 是
+  // private 字段，用 Reflect.get 取（与 R0-D 块访问 store 同模式）。
+
+  describe("dispose uiRequestHandler stub (dispose-cleanup)", () => {
+    /** 从 service 取出 private uiRequestHandler（trailing ui_request 实际调用入口）。 */
+    function getHandler(service: SubagentService): UiRequestHandler | undefined {
+      return Reflect.get(service, "uiRequestHandler") as UiRequestHandler | undefined;
+    }
+
+    /** 最小 UiRequest（method 无关紧要——stub 不论 method 一律返回 cancelled）。 */
+    function makeTrailingRequest(id: string): UiRequest {
+      return { method: "notify", id };
+    }
+
+    it("dispose 后 uiRequestHandler 被 stub 替换，调用返回 {cancelled:true} 不抛错", async () => {
+      const service = new SubagentService({ cwd: agentDir, modelService });
+      service.initSession({ pi: makePi(), sessionId: "s1" });
+
+      service.dispose();
+
+      const handler = getHandler(service);
+      expect(handler).toBeDefined();
+      // 模拟 dispose 后子进程 trailing ui_request 被父进程 pump 调到 handler
+      await expect(handler!(makeTrailingRequest("trailing-1"))).resolves.toEqual({ cancelled: true });
+    });
+
+    it("dispose stub 覆盖旧 handler：trailing ui_request 不产生 [subagents] console.error 噪声", async () => {
+      // 模拟 session A 的真实 handler 闭包——在 ctx 已 disposed 后调用会抛错
+      const staleHandler: UiRequestHandler = async () => {
+        throw new Error("stale ctx");
+      };
+      const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+      const service = new SubagentService({ cwd: agentDir, modelService });
+      service.initSession({ pi: makePi(), sessionId: "s1" });
+      service.setUiRequestHandler(staleHandler);
+
+      service.dispose();
+
+      // dispose 后 handler 应被 stub 替换，不再是 staleHandler
+      const handler = getHandler(service);
+      expect(handler).not.toBe(staleHandler);
+
+      // trailing ui_request 调到的是 stub，不抛错、返回 cancelled
+      await expect(handler!(makeTrailingRequest("trailing-2"))).resolves.toEqual({ cancelled: true });
+
+      // 关键价值断言：无 "[subagents] uiRequestHandler threw" 误导性噪声
+      // （旧实现 dispose 不清 handler 时，trailing ui_request 走 staleHandler 抛错 →
+      //   ui-request-queue.ts catch 打该日志。stub 覆盖后该路径不再触发。）
+      const subagentsErrors = errorSpy.mock.calls.filter(
+        (args: unknown[]) => typeof args[0] === "string" && args[0].includes("[subagents]"),
+      );
+      expect(subagentsErrors).toHaveLength(0);
+
+      errorSpy.mockRestore();
+    });
+  });
+
   // ============================================================
   // execute() worktree fail-fast 校验 [MF#7]（commit 8e8e75966）
   // ============================================================
@@ -488,12 +558,12 @@ describe("SubagentService", () => {
       // worktree create 抛错在 kickOffBackground 之前（execute 同步 catch），返回 background 形状
       expect(handle.mode).toBe("background");
 
-      // register emit：background mode → id 前缀 bg-
+      // register emit：background mode → id 是 UUID 格式
       expect(pi.events.emit).toHaveBeenCalledWith(
         "pending:register",
         expect.objectContaining({
           type: "subagent",
-          id: expect.stringMatching(/^bg-/),
+          id: expect.any(String),
           name: "general-purpose",
         }),
       );

package/src/execution/__tests__/tool-action.test.ts

@@ -5,8 +5,8 @@
 
 import { describe, expect, it, vi } from "vitest";
 
-import type { SubagentService } from "../subagent-service.ts";
 import { adapter, cancelHandler, listHandler, startHandler } from "../../interface/subagent-actions.ts";
+import type { SubagentService } from "../subagent-service.ts";
 import type {
   ExecutionHandle,
   RecordSnapshot,
@@ -89,11 +89,11 @@ describe("startHandler", () => {
     await expect(startHandler(svc, { task: "ok", slug: "   " }, undefined)).rejects.toThrow(/slug is required/);
   });
 
-  it("slug 超 20 字符 → throw", async () => {
+  it("slug 超 35 字符 → throw", async () => {
     const svc = makeService();
     await expect(
-      startHandler(svc, { task: "ok", slug: "a".repeat(21) }, undefined),
-    ).rejects.toThrow(/≤20 chars/);
+      startHandler(svc, { task: "ok", slug: "a".repeat(36) }, undefined),
+    ).rejects.toThrow(/≤35 chars/);
   });
 
   it("background 启动 → kind=bg + bgResponse.message 含 detached", async () => {