@zhushanwen/subagent-core 0.2.0

package/src/execution/__tests__/spawn-args.test.ts

@@ -0,0 +1,445 @@
+// src/__tests__/spawn-args.test.ts
+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 } from "vitest";
+
+import { mirrorMainProcessFlags } from "../argv-mirror.ts";
+import { MAX_FORK_DEPTH } from "../session-context-resolver.ts";
+import { buildEnvBlock, buildSpawnArgs } from "../session-runner.ts";
+
+describe("buildSpawnArgs", () => {
+  // [U1 D2] modelRef 为必填（spawn 前置守卫：未经裁决的裸字符串类型层面不可达）。
+  const baseParams = {
+    modelRef: { provider: "openai", id: "gpt-4o" },
+    thinkingLevel: undefined as string | undefined,
+    agentTools: undefined as string[] | undefined,
+    appendSystemPromptPath: undefined as string | undefined,
+    sessionDir: "/sessions/dir",
+    forkSource: undefined as string | undefined,
+    skillPaths: undefined as string[] | undefined,
+  };
+
+  it("基础参数：--mode rpc --session-dir + --model provider/id，不含 -p 也不含 task（task 经 stdin 传）", () => {
+    const args = buildSpawnArgs(baseParams);
+    expect(args).toEqual([
+      "--mode", "rpc", "--session-dir", "/sessions/dir", "--model", "openai/gpt-4o",
+    ]);
+  });
+
+  it("不含 -p / --print（rpc mode 下 -p 被 resolveAppMode 无视，是死代码）", () => {
+    const args = buildSpawnArgs(baseParams);
+    expect(args).not.toContain("-p");
+    expect(args).not.toContain("--print");
+  });
+
+  it("modelRef → --model 值恒为 `${provider}/${id}`（全等拼接，不重写输入）", () => {
+    // 含大小写差异的 provider/id 原样拼接（大小写敏感规则：放行即全等回显）
+    const args = buildSpawnArgs({
+      ...baseParams,
+      modelRef: { provider: "zai-coding-cn", id: "GLM-5.3-Flash" },
+    });
+    const idx = args.indexOf("--model");
+    expect(args[idx + 1]).toBe("zai-coding-cn/GLM-5.3-Flash");
+  });
+
+  it("modelRef + thinkingLevel → model 后缀 :level", () => {
+    const args = buildSpawnArgs(
+      { ...baseParams, thinkingLevel: "high" },
+    );
+    const idx = args.indexOf("--model");
+    expect(args[idx + 1]).toBe("openai/gpt-4o:high");
+  });
+
+  it("agentTools → --tools 逗号分隔", () => {
+    const args = buildSpawnArgs(
+      { ...baseParams, agentTools: ["read", "bash", "edit"] },
+    );
+    const idx = args.indexOf("--tools");
+    expect(args[idx + 1]).toBe("read,bash,edit");
+  });
+
+  it("appendSystemPromptPath → --append-system-prompt <path>", () => {
+    const args = buildSpawnArgs(
+      { ...baseParams, appendSystemPromptPath: "/tmp/prompt.md" },
+    );
+    const idx = args.indexOf("--append-system-prompt");
+    expect(args[idx + 1]).toBe("/tmp/prompt.md");
+  });
+
+  it("forkSource → --fork <path>", () => {
+    const args = buildSpawnArgs(
+      { ...baseParams, forkSource: "/sessions/parent.jsonl" },
+    );
+    const idx = args.indexOf("--fork");
+    expect(args[idx + 1]).toBe("/sessions/parent.jsonl");
+  });
+
+  it("skillPaths 多个 → 每个 push --skill <path>", () => {
+    const args = buildSpawnArgs(
+      { ...baseParams, skillPaths: ["/skills/a", "/skills/b", "/skills/c"] },
+    );
+    // 三个 --skill token，后跟各自路径，顺序保留
+    const skillIdxs = args
+      .map((a, i) => (a === "--skill" ? i : -1))
+      .filter((i) => i >= 0);
+    expect(skillIdxs).toHaveLength(3);
+    expect(args[skillIdxs[0] + 1]).toBe("/skills/a");
+    expect(args[skillIdxs[1] + 1]).toBe("/skills/b");
+    expect(args[skillIdxs[2] + 1]).toBe("/skills/c");
+  });
+
+  it("skillPaths 空数组 → 不含 --skill", () => {
+    const args = buildSpawnArgs(
+      { ...baseParams, skillPaths: [] },
+    );
+    expect(args).not.toContain("--skill");
+  });
+
+  it("skillPaths undefined → 不含 --skill", () => {
+    const args = buildSpawnArgs(baseParams);
+    expect(args).not.toContain("--skill");
+  });
+
+  it("全参数组合：所有 flag 存在，不含 -p 也不含 positional task", () => {
+    const args = buildSpawnArgs(
+      {
+        ...baseParams,
+        thinkingLevel: "low",
+        agentTools: ["read"],
+        appendSystemPromptPath: "/tmp/p.md",
+        sessionDir: "/s",
+        forkSource: "/parent.jsonl",
+        skillPaths: ["/skills/x"],
+      },
+    );
+    // 末尾应是最后一个 --skill 的路径（task 不再作为 positional arg 出现）
+    expect(args[args.length - 1]).toBe("/skills/x");
+    expect(args).toContain("--fork");
+    expect(args).toContain("--tools");
+    expect(args).toContain("--skill");
+    expect(args).not.toContain("-p");
+  });
+
+  it("空 tools 数组不追加 --tools", () => {
+    const args = buildSpawnArgs(
+      { ...baseParams, agentTools: [] },
+    );
+    expect(args).not.toContain("--tools");
+  });
+
+  it("含未注册扩展工具名（如 ask_user）正常透传 — 子进程 Pi 静默忽略未注册的 allowlist 项", () => {
+    // 场景：orchestrator 模板声明了 ask_user，但用户环境未装 pi-ask-user 扩展。
+    // 期望：subagent-workflow 不做特殊处理，仅原样透传给 pi CLI；
+    // 静默兼容的责任在 Pi（args.ts 不校验、agent-session 的 _rebuildSystemPrompt
+    // 对未注册工具名静默过滤）。本测试钉死这个透传行为，避免有人擅自加
+    // 「未注册工具检测」导致原本兼容的场景崩溃。
+    const args = buildSpawnArgs({
+      ...baseParams,
+      agentTools: ["todo", "goal_control", "workflow", "subagent", "ask_user"],
+    });
+    const idx = args.indexOf("--tools");
+    expect(idx).toBeGreaterThanOrEqual(0);
+    expect(args[idx + 1]).toBe(
+      "todo,goal_control,workflow,subagent,ask_user",
+    );
+  });
+
+  // ============================================================
+  // mirrorFlags 透传：子进程镜像主进程 extension/approve flag
+  // ============================================================
+
+  it("mirrorFlags 透传：noExtensions+approve+noContextFiles+extensionPaths 全量 push（TC5）", () => {
+    const args = buildSpawnArgs({
+      ...baseParams,
+      mirrorFlags: { noExtensions: true, approve: true, noContextFiles: true, extensionPaths: ["/e1", "/e2"] },
+    });
+    expect(args).toContain("--no-extensions");
+    expect(args).toContain("--approve");
+    expect(args).toContain("--no-context-files");
+    // 每个 extension 独立 token，顺序保留
+    const extIdxs = args.map((a, i) => (a === "--extension" ? i : -1)).filter((i) => i >= 0);
+    expect(extIdxs).toHaveLength(2);
+    expect(args[extIdxs[0] + 1]).toBe("/e1");
+    expect(args[extIdxs[1] + 1]).toBe("/e2");
+  });
+
+  it("mirrorFlags 全 false/空 → 不追加任何目标 flag（TC6）", () => {
+    const args = buildSpawnArgs({
+      ...baseParams,
+      mirrorFlags: { noExtensions: false, approve: false, noContextFiles: false, extensionPaths: [] },
+    });
+    expect(args).not.toContain("--no-extensions");
+    expect(args).not.toContain("--approve");
+    expect(args).not.toContain("--extension");
+    expect(args).not.toContain("--no-context-files");
+    // 仅基础参数
+    expect(args).toEqual(["--mode", "rpc", "--session-dir", "/sessions/dir", "--model", "openai/gpt-4o"]);
+  });
+
+  it("mirrorFlags undefined → 行为等同旧版（TC7）", () => {
+    const args = buildSpawnArgs(baseParams);
+    expect(args).toEqual(["--mode", "rpc", "--session-dir", "/sessions/dir", "--model", "openai/gpt-4o"]);
+    expect(args).not.toContain("--extension");
+    expect(args).not.toContain("--no-extensions");
+    expect(args).not.toContain("--approve");
+    expect(args).not.toContain("--no-context-files");
+  });
+
+  it("noContextFiles 镜像：主进程 argv 含 --no-context-files → 子进程 args 含该 flag", () => {
+    // 端到端链路断言：主 pi 进程以 --no-context-files 启动（用户 opt-out context files）
+    // → mirrorMainProcessFlags 解析 → buildSpawnArgs 产出同 flag 给每个 subagent。
+    // 缺此镜像时，--extension 镜像带入的 @zhushanwen/pi-system-prompt 检查子进程
+    // 自己的 argv（无 flag）→ 全局 AGENTS.md 注入在 subagent system prompt 照常生效，
+    // 用户 opt-out 被绕过。
+    const mainArgv = [
+      "bun", "/pi", "--mode", "rpc", "--no-context-files",
+      "--extension", "/staged/@zhushanwen/pi-system-prompt/index.js",
+    ];
+    const args = buildSpawnArgs({ ...baseParams, mirrorFlags: mirrorMainProcessFlags(mainArgv) });
+    expect(args).toContain("--no-context-files");
+    // extension 镜像照常（两者共存才构成完整契约）
+    const extIdx = args.indexOf("--extension");
+    expect(args[extIdx + 1]).toBe("/staged/@zhushanwen/pi-system-prompt/index.js");
+  });
+
+  it("noContextFiles 不镜像：主进程 argv 不含 flag → 子进程 args 不含（默认行为不变）", () => {
+    const mainArgv = ["bun", "/pi", "--mode", "rpc"];
+    const args = buildSpawnArgs({ ...baseParams, mirrorFlags: mirrorMainProcessFlags(mainArgv) });
+    expect(args).not.toContain("--no-context-files");
+  });
+
+  // ============================================================
+  // sessionFile（M1 resume 基建）：--session <file> 紧跟 --session-dir
+  // ============================================================
+
+  it("sessionFile 存在 → 紧跟 --session-dir 追加 --session <file>", () => {
+    const args = buildSpawnArgs({
+      ...baseParams,
+      sessionFile: "/sessions/sub/abc.jsonl",
+    });
+    const idx = args.indexOf("--session");
+    expect(idx).toBeGreaterThan(-1);
+    expect(args[idx + 1]).toBe("/sessions/sub/abc.jsonl");
+    // 位置紧跟 --session-dir <dir> 之后（--model 之前）
+    const sessionDirIdx = args.indexOf("--session-dir");
+    expect(idx).toBe(sessionDirIdx + 2);
+  });
+
+  it("sessionFile undefined → 不含 --session（向后兼容）", () => {
+    const args = buildSpawnArgs(baseParams);
+    expect(args).not.toContain("--session");
+    expect(args).toEqual(["--mode", "rpc", "--session-dir", "/sessions/dir", "--model", "openai/gpt-4o"]);
+  });
+
+  it("sessionFile + modelRef + thinkingLevel → 三者都进 args（resume 全参数）", () => {
+    const args = buildSpawnArgs({
+      ...baseParams,
+      sessionFile: "/sessions/sub/resume.jsonl",
+      thinkingLevel: "high",
+    });
+    // --session <file>
+    const sessionIdx = args.indexOf("--session");
+    expect(sessionIdx).toBeGreaterThan(-1);
+    expect(args[sessionIdx + 1]).toBe("/sessions/sub/resume.jsonl");
+    // --model provider/id:level（thinkingLevel 作 model 后缀）
+    const modelIdx = args.indexOf("--model");
+    expect(modelIdx).toBeGreaterThan(-1);
+    expect(args[modelIdx + 1]).toBe("openai/gpt-4o:high");
+  });
+});
+
+// ============================================================
+// mirrorMainProcessFlags：从主进程 argv 解析可镜像的 flag
+// ============================================================
+
+describe("mirrorMainProcessFlags", () => {
+  it("--extension 多次出现（空格分隔）+ 布尔 flag（TC1）", () => {
+    const r = mirrorMainProcessFlags([
+      "bun", "/pi", "--mode", "rpc", "--no-extensions", "--approve",
+      "--extension", "/a", "--extension", "/b",
+    ]);
+    expect(r).toEqual({ noExtensions: true, approve: true, extensionPaths: ["/a", "/b"], noContextFiles: false });
+  });
+
+  it("--extension=path 等号形式 + 短形式 -e/-ne/-a（TC2）", () => {
+    const r = mirrorMainProcessFlags([
+      "bun", "/pi", "--extension=/x", "-ne", "-a",
+    ]);
+    expect(r).toEqual({ noExtensions: true, approve: true, extensionPaths: ["/x"], noContextFiles: false });
+  });
+
+  it("混合形式（空格 + 等号），顺序保留（TC3）", () => {
+    const r = mirrorMainProcessFlags([
+      "bun", "/pi", "--extension", "/a", "--extension=/b", "--extension", "/c",
+    ]);
+    expect(r.extensionPaths).toEqual(["/a", "/b", "/c"]);
+    expect(r.noExtensions).toBe(false);
+    expect(r.approve).toBe(false);
+    expect(r.noContextFiles).toBe(false);
+  });
+
+  it("无目标 flag → 全空/全 false（向后兼容，TC4）", () => {
+    const r = mirrorMainProcessFlags(["bun", "/pi", "--mode", "rpc"]);
+    expect(r).toEqual({ noExtensions: false, approve: false, extensionPaths: [], noContextFiles: false });
+  });
+
+  it("--no-context-files 长形式解析 → noContextFiles: true", () => {
+    const r = mirrorMainProcessFlags([
+      "bun", "/pi", "--mode", "rpc", "--no-context-files",
+      "--extension", "/staged/@zhushanwen/pi-system-prompt/index.js",
+    ]);
+    expect(r.noContextFiles).toBe(true);
+    // 与 extension 镜像共存（实际 xyz-agent 启动形态：两 flag 同时出现）
+    expect(r.extensionPaths).toEqual(["/staged/@zhushanwen/pi-system-prompt/index.js"]);
+    expect(r.noExtensions).toBe(false);
+    expect(r.approve).toBe(false);
+  });
+
+  it("-nc 短形式解析 → noContextFiles: true（pi CLI 等价短形式）", () => {
+    const r = mirrorMainProcessFlags(["bun", "/pi", "--mode", "rpc", "-nc"]);
+    expect(r.noContextFiles).toBe(true);
+  });
+
+  it("不误吃其他 flag 值与 positional 参数（TC8）", () => {
+    const r = mirrorMainProcessFlags([
+      "bun", "/pi", "--no-extensions", "--skill", "/sk", "some prompt text",
+    ]);
+    expect(r.noExtensions).toBe(true);
+    expect(r.extensionPaths).toEqual([]);
+    // --skill 的 /sk 不混入 extensionPaths；positional prompt 被忽略
+  });
+
+  it("空 argv / 仅前导两项 → 全空", () => {
+    expect(mirrorMainProcessFlags([])).toEqual({ noExtensions: false, approve: false, extensionPaths: [], noContextFiles: false });
+    expect(mirrorMainProcessFlags(["bun", "/pi"])).toEqual({
+      noExtensions: false, approve: false, extensionPaths: [], noContextFiles: false,
+    });
+  });
+
+  it("--extension 末尾无值 → 跳过（不越界、不误吃下一个 token）", () => {
+    const r = mirrorMainProcessFlags(["bun", "/pi", "--extension"]);
+    expect(r.extensionPaths).toEqual([]);
+  });
+
+  it("-e 短形式多次 + 等号混用", () => {
+    const r = mirrorMainProcessFlags(["bun", "/pi", "-e", "/a", "-e=/b", "-e", "/c"]);
+    expect(r.extensionPaths).toEqual(["/a", "/b", "/c"]);
+  });
+
+  // [MF-7a] flag 判定收窄为 startsWith("--")：单 - 开头的合法路径不被误判为 flag。
+  it("[MF-7a] - 开头的路径被当值镜像（不误判 flag）", () => {
+    const r = mirrorMainProcessFlags(["bun", "/pi", "--extension", "-weird-dir/ext.js"]);
+    expect(r.extensionPaths).toEqual(["-weird-dir/ext.js"]);
+  });
+
+  // [MF-7a] -- 开头的真 flag 仍正确跳过：--extension 后跟 --flag 时不吃值、不越界。
+  it("[MF-7a] --extension 后跟 -- 开头真 flag → 不吃值", () => {
+    const r = mirrorMainProcessFlags([
+      "bun", "/pi", "--extension", "--approve", "--extension", "/real.js",
+    ]);
+    expect(r.extensionPaths).toEqual(["/real.js"]);
+    expect(r.approve).toBe(true);
+  });
+});
+
+// ============================================================
+// buildEnvBlock（M1 恢复）
+// ============================================================
+
+describe("buildEnvBlock", () => {
+  // buildEnvBlock 内部按 cwd 缓存 git branch（模块级 Map），用真实 git 仓库测最稳。
+  // 用临时 git 仓库隔离，避免污染主仓库 branch 缓存。
+  // buildEnvBlock 已异步化（execFile + Promise 包装），所有直接调用需 await。
+  let tmpGitRepo: string;
+  const testBranch = "test-env-branch";
+
+  beforeEach(() => {
+    tmpGitRepo = fs.mkdtempSync(path.join(os.tmpdir(), "envblock-"));
+    // 初始化 git 仓库 + checkout 已知分支名。
+    // 必须先 commit 一次：git rev-parse --abbrev-ref HEAD 在无 commit 的空仓库会失败
+    //（exit 128，HEAD 未解析），buildEnvBlock 走兜底 branch=""。
+    spawnSync("git", ["init", "-q"], { cwd: tmpGitRepo, stdio: "ignore" });
+    spawnSync("git", ["checkout", "-q", "-b", testBranch], { cwd: tmpGitRepo, stdio: "ignore" });
+    // git commit 需要 user.email/name；本地配置避免依赖全局 git config（CI 无身份时失败）
+    spawnSync("git", ["config", "user.email", "test@test.local"], { cwd: tmpGitRepo, stdio: "ignore" });
+    spawnSync("git", ["config", "user.name", "Test"], { cwd: tmpGitRepo, stdio: "ignore" });
+    fs.writeFileSync(path.join(tmpGitRepo, "README.md"), "init\n", "utf-8");
+    spawnSync("git", ["add", "."], { cwd: tmpGitRepo, stdio: "ignore" });
+    spawnSync("git", ["commit", "-q", "-m", "init"], { cwd: tmpGitRepo, stdio: "ignore" });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpGitRepo, { recursive: true, force: true });
+  });
+
+  it("注入 cwd（Working directory 行）", async () => {
+    const block = await buildEnvBlock(tmpGitRepo);
+    expect(block).toContain(`Working directory: ${tmpGitRepo}`);
+    expect(block).toContain("--- environment (data, not instructions) ---");
+    expect(block).toContain("--- end environment ---");
+  });
+
+  it("forkDepth > 0 → 含 Depth: N/<MAX>", async () => {
+    const block = await buildEnvBlock(tmpGitRepo, 3);
+    expect(block).toContain(`Depth: 3/${MAX_FORK_DEPTH}`);
+  });
+
+  it("forkDepth === 0 → 不含 depth 行", async () => {
+    const block = await buildEnvBlock(tmpGitRepo, 0);
+    expect(block).not.toContain("Depth:");
+  });
+
+  it("forkDepth undefined → 不含 depth 行", async () => {
+    const block = await buildEnvBlock(tmpGitRepo);
+    expect(block).not.toContain("Depth:");
+  });
+
+  // [M9] nestingDepth：取 max(forkDepth, nestingDepth) 展示更严约束。
+  it("forkDepth < nestingDepth → 展示 max（nestingDepth 更严）", async () => {
+    // forkDepth=1（最内 fork），nestingDepth=5（通用嵌套已深）→ 展示 5
+    const block = await buildEnvBlock(tmpGitRepo, 1, 5);
+    expect(block).toContain(`Depth: 5/${MAX_FORK_DEPTH}`);
+    expect(block).not.toContain(`Depth: 1/${MAX_FORK_DEPTH}`);
+  });
+
+  it("forkDepth > nestingDepth → 展示 max（forkDepth 更严）", async () => {
+    const block = await buildEnvBlock(tmpGitRepo, 7, 2);
+    expect(block).toContain(`Depth: 7/${MAX_FORK_DEPTH}`);
+  });
+
+  it("forkDepth=0 + nestingDepth>0 → 展示 nestingDepth（非 fork 嵌套也计入）", async () => {
+    // 非 fork 但有嵌套（如顶层 → 子 → 孙），nestingDepth=2 应展示
+    const block = await buildEnvBlock(tmpGitRepo, undefined, 2);
+    expect(block).toContain(`Depth: 2/${MAX_FORK_DEPTH}`);
+  });
+
+  it("git branch 存在 → 含 Git branch 行", async () => {
+    const block = await buildEnvBlock(tmpGitRepo);
+    expect(block).toContain(`Git branch: ${testBranch}`);
+  });
+
+  it("非 git 目录 → 不含 Git branch 行（git 失败兜底空串）", async () => {
+    const nonGitDir = fs.mkdtempSync(path.join(os.tmpdir(), "envblock-nogit-"));
+    try {
+      const block = await buildEnvBlock(nonGitDir);
+      expect(block).not.toContain("Git branch:");
+      // 但仍含 working directory（环境块始终输出）
+      expect(block).toContain(`Working directory: ${nonGitDir}`);
+    } finally {
+      fs.rmSync(nonGitDir, { recursive: true, force: true });
+    }
+  });
+
+  it("git 失败（execFile err 回调）→ 不崩，静默省略 branch", async () => {
+    // 旧版 spy 挂在测试本地对象字面量上（同名同步 git API 的对象包装），从未真正拦截
+    // session-runner 的模块绑定——此前通过是靠 /some/cwd 不存在使真实 git 失败的副作用。
+    // 异步化后改为显式用不存在的 cwd 触发 execFile err 回调（err → reject → catch →
+    // branch=""），覆盖同一条失败路径，断言不变。
+    const block = await buildEnvBlock("/some/cwd");
+    expect(block).not.toContain("Git branch:");
+    expect(block).toContain("Working directory: /some/cwd");
+  });
+});

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/universal/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");
+  });
+});