@zhushanwen/pi-subagent-workflow 8.5.0 → 8.7.0

package/src/execution/__tests__/get-record-for-action-restart.test.ts

@@ -1,254 +0,0 @@
-// src/execution/__tests__/get-record-for-action-restart.test.ts
-//
-// [M10] getRecordForAction 跨重启磁盘重建分支测试（subagent-service.ts L933-951）。
-//
-// 背景：内存 miss → collectRecords(1000,"all",undefined).find(status==="running") →
-// createRecord({chatMode: true}) → register → 回填 sessionFile/round。代码注释
-// （L946-949）自设强制约束「改动此处必须带 S3 回归场景（跨重启 message 续聊验证）」
-// ——该 S3 场景此前不存在，分支零测试。该分支含多个仅此处独有的决策：
-//   - 无条件 chatMode: true（v4 A-3 跨重启恢复入口，V3 方案 A 方向）
-//   - rootSessionFilter 传 undefined 后置校验（异树仍 throw not owned）
-//   - sessionFile/round 从磁盘重建结果回填（round 无磁盘持久化 → undefined）
-//
-// fixture 构造参照 record-store.test.ts 的 writeSessionJsonl（真实 .jsonl 文件，
-// identity custom entry + assistant message；无 .alive sidecar → record-store
-// sidecar 矩阵分支 4 → status="running" 跨重启可续聊态）。
-
-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";
-
-const { loggerMock } = vi.hoisted(() => ({
-  loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn(), info: vi.fn() },
-}));
-vi.mock("@zhushanwen/pi-extension-logger", () => ({ getLogger: () => loggerMock }));
-
-// mock session-runner：import 链需要（getRecordForAction 本身不调 spawn，仅守卫读
-// hasLiveProcessHandle——默认无活进程，与跨重启场景一致）。
-vi.mock("../session-runner.ts", () => ({
-  runSpawn: vi.fn(),
-  killAllSpawnedChildren: vi.fn(),
-  getChildByRecord: vi.fn(() => undefined),
-  spawnedChildren: new Map(),
-}));
-
-import { writeFinalized } from "../finalized-marker.ts";
-import { ModelConfigService } from "../model-config-service.ts";
-import { getSubagentSessionDir } from "../path-encoding.ts";
-import { RecordStore } from "../record-store.ts";
-import { SubagentService } from "../subagent-service.ts";
-
-// 身份 env 名（与 subagent-service.ts 常量一致；beforeEach/afterEach 清理防泄漏——
-// 测试进程可能继承 subagent env，会污染 rootCwd 编码目录与 sessionRootId 基线）。
-const IDENTITY_ENV_KEYS = [
-  "PI_SUBAGENT_ROOT_SESSION_ID",
-  "PI_SUBAGENT_SELF_RECORD_ID",
-  "PI_SUBAGENT_DEPTH",
-  "PI_SUBAGENT_ROOT_CWD",
-  "PI_SUBAGENT_FORK_DEPTH",
-] as const;
-
-/** initSession 注入的最小 pi duck-type（同 subagent-service PiLike 形状，结构匹配即可）。 */
-interface PiStub {
-  appendEntry(customType: string, data?: unknown): void;
-  events: { emit(channel: string, data: unknown): void };
-  sendMessage(
-    message: { customType: string; content: string; display: boolean; details?: unknown },
-    options?: { triggerTurn?: boolean; deliverAs?: "steer" | "followUp" | "nextTurn" },
-  ): void;
-}
-
-function makePi(): PiStub {
-  return {
-    appendEntry: vi.fn(),
-    events: { emit: vi.fn() },
-    sendMessage: vi.fn(),
-  };
-}
-
-/** 写一个最小合法 session.jsonl（session header + identity entry + 1 条 assistant message）。
- *  不写任何 sidecar（.alive/.cancelled/.finalized）→ sidecar 矩阵分支 4 → running。 */
-function writeSessionJsonl(
-  sessionsDir: string,
-  identity: {
-    id: string;
-    rootSessionId: string;
-    parentRecordId?: string;
-    depth?: number;
-    chatMode?: boolean;
-    worktree?: boolean;
-  },
-): string {
-  const file = path.join(sessionsDir, `${identity.id}.jsonl`);
-  const startedAt = 1_700_000_000_000;
-  const lines = [
-    JSON.stringify({
-      type: "session",
-      version: 3,
-      id: "sess-uuid",
-      timestamp: new Date(startedAt).toISOString(),
-      cwd: "/tmp",
-    }),
-    JSON.stringify({
-      type: "custom",
-      id: "id-1",
-      parentId: null,
-      timestamp: new Date(startedAt).toISOString(),
-      customType: "subagent-identity",
-      data: {
-        id: identity.id,
-        agent: "general-purpose",
-        mode: "background",
-        task: "restart recovery task",
-        slug: "restart-test",
-        startedAt,
-        rootSessionId: identity.rootSessionId,
-        ...(identity.parentRecordId !== undefined ? { parentRecordId: identity.parentRecordId } : {}),
-        ...(identity.depth !== undefined ? { depth: identity.depth } : {}),
-        ...(identity.chatMode !== undefined ? { chatMode: identity.chatMode } : {}),
-        ...(identity.worktree !== undefined ? { worktree: identity.worktree } : {}),
-      },
-    }),
-    JSON.stringify({
-      type: "message",
-      id: "msg-1",
-      parentId: "id-1",
-      timestamp: new Date(startedAt + 1000).toISOString(),
-      message: {
-        role: "assistant",
-        content: [{ type: "text", text: "first round done" }],
-        usage: { input: 10, output: 20, cacheRead: 0, cacheWrite: 0 },
-        stopReason: "stop",
-        timestamp: startedAt + 1000,
-      },
-    }),
-  ];
-  fs.writeFileSync(file, `${lines.join("\n")}\n`, "utf-8");
-  return file;
-}
-
-/** 暴露私有 store 供断言 register 副作用。 */
-interface ServiceInternals {
-  store: RecordStore;
-}
-
-describe("[M10] getRecordForAction 跨重启磁盘重建（S3 回归场景）", () => {
-  let agentDir: string;
-  let sessionsDir: string;
-  let service: SubagentService;
-  let store: RecordStore;
-
-  beforeEach(() => {
-    for (const k of IDENTITY_ENV_KEYS) delete process.env[k];
-    agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "restart-recon-"));
-    sessionsDir = getSubagentSessionDir(agentDir, agentDir);
-    fs.mkdirSync(sessionsDir, { recursive: true });
-
-    const modelService = new ModelConfigService({ agentDir, cwd: agentDir });
-    service = new SubagentService({ cwd: agentDir, modelService });
-    // 根进程身份：无 env → sessionRootId = sessionId（自己是 root）、execCtxBaseline = null
-    service.initSession({ pi: makePi(), sessionId: "root-session" });
-    store = (service as unknown as ServiceInternals).store;
-  });
-
-  afterEach(() => {
-    service.dispose();
-    // maxRetries：collectRecords 触发的 fire-and-forget sessions-index 写可能与删除
-    // 并发（ENOTEMPTY 竞态，全量并行跑时机器负载高会放大窗口）
-    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
-    for (const k of IDENTITY_ENV_KEYS) delete process.env[k];
-  });
-
-  it("内存 miss + 磁盘 running（无 .alive）→ 重建 record：chatMode 无条件 true、sessionFile 回填、register 进内存", () => {
-    // identity entry 故意不带 chatMode 字段——证明重建分支的无条件 chatMode:true
-    //（不依赖磁盘是否记录过对话模式标志）
-    const file = writeSessionJsonl(sessionsDir, { id: "sa-restart-1", rootSessionId: "root-session" });
-    expect(store.getMutable("sa-restart-1")).toBeUndefined(); // 前置：内存确无
-
-    const record = service.getRecordForAction("sa-restart-1");
-
-    // [v4 A-3] 无条件 chatMode=true（跨重启恢复入口）
-    expect(record.chatMode).toBe(true);
-    // sessionFile 从磁盘重建结果回填
-    expect(record.sessionFile).toBe(file);
-    // round 从 found 回填：light 磁盘重建无 round（内存态字段，跨重启不恢复）→ undefined
-    expect(record.round).toBeUndefined();
-    // 身份字段从磁盘 identity entry 回填
-    expect(record.agent).toBe("general-purpose");
-    expect(record.task).toBe("restart recovery task");
-    expect(record.slug).toBe("restart-test");
-    expect(record.rootSessionId).toBe("root-session");
-    expect(record.parentRecordId).toBeUndefined();
-    expect(record.status).toBe("running");
-    // register 生效：进内存，二次调用走内存命中（同一引用）
-    expect(store.getMutable("sa-restart-1")).toBe(record);
-    expect(service.getRecordForAction("sa-restart-1")).toBe(record);
-  });
-
-  it("rootSessionId 校验仍生效：异树 record（other-session）→ throw not found or not owned", () => {
-    // rootSessionFilter 传 undefined（扫全量磁盘），异树 record 会被 find 命中并重建，
-    // 但后置校验 record.rootSessionId !== this.sessionRootId 必须拦截
-    writeSessionJsonl(sessionsDir, { id: "sa-foreign", rootSessionId: "other-session" });
-
-    expect(() => service.getRecordForAction("sa-foreign")).toThrow(/not found or not owned/);
-  });
-
-  it("直接父校验仍生效：孙级 record（parentRecordId=sa-parent）→ 主进程 throw direct parent", () => {
-    writeSessionJsonl(sessionsDir, {
-      id: "sa-grand",
-      rootSessionId: "root-session",
-      parentRecordId: "sa-parent",
-      depth: 2,
-    });
-
-    // 重建后 parentRecordId=sa-parent ≠ 主进程 baseline(undefined) → cross-layer 守卫拦截
-    expect(() => service.getRecordForAction("sa-grand")).toThrow(/direct parent/);
-  });
-
-  it(".finalized sidecar（closed 终态）不重建 → throw not found or not owned", () => {
-    const file = writeSessionJsonl(sessionsDir, { id: "sa-fin", rootSessionId: "root-session" });
-    writeFinalized(file); // sidecar 矩阵分支 2 → status=closed → find(status==="running") miss
-
-    expect(() => service.getRecordForAction("sa-fin")).toThrow(/not found or not owned/);
-    expect(store.getMutable("sa-fin")).toBeUndefined(); // 未重建注册
-  });
-
-  // ============================================================
-  // [review round2] 跨重启 worktree 绑定丢失防护
-  // ============================================================
-  // 场景：worktree:true + conversation:true 的 subagent 在父进程重启后续聊。WorktreeHandle
-  // 不可序列化、重建后恒缺失，若无守卫 → 冷路径 resume 的 spawn cwd 静默回落主 repo
-  //（隔离失效，正是 worktree 要防的并发写冲突场景）。
-  it("[review round2] worktree record 跨重启重建 → hadWorktree 标记 + 续聊被拒（行动语言）", async () => {
-    writeSessionJsonl(sessionsDir, {
-      id: "sa-wt",
-      rootSessionId: "root-session",
-      worktree: true,
-    });
-
-    const record = service.getRecordForAction("sa-wt");
-    // hadWorktree 从磁盘 identity entry 的 worktree 标志恢复
-    expect(record.hadWorktree).toBe(true);
-    // handle 无法恢复（不可序列化）
-    expect(record.worktreeHandle).toBeUndefined();
-
-    // 冷路径续聊（无活进程）→ resumeRound 守卫拒绝，不 spawn 回落主 repo
-    await expect(service.deliverMessage(record, "resume after restart", false)).rejects.toThrow(
-      /worktree isolation.*lost when the parent process restarted/,
-    );
-  });
-
-  it("[review round2] 非 worktree record 跨重启重建 → 续聊不受 worktree 守卫拦截（向后兼容）", async () => {
-    // identity entry 无 worktree 字段（旧文件）→ found.worktree undefined → hadWorktree false
-    writeSessionJsonl(sessionsDir, { id: "sa-nowt", rootSessionId: "root-session" });
-
-    const record = service.getRecordForAction("sa-nowt");
-    expect(record.hadWorktree).toBe(false);
-
-    // deliverMessage 冷路径不被 worktree 守卫拦截（resume 正常发起；后续 spawn 编排
-    // 超出本用例关注点——runSpawn 在本文件是 no-op mock）
-    await expect(service.deliverMessage(record, "resume normal", false)).resolves.toBeUndefined();
-  });
-});

package/src/execution/__tests__/gui-mode-dispatch.test.ts

@@ -1,59 +0,0 @@
-// src/__tests__/gui-mode-dispatch.test.ts
-//
-// S6: ctx.mode RPC 分发契约测试。
-//
-// 审查发现：sdk-contract.test.ts 只测 ctx.model 透传，未覆盖 ctx.mode === "rpc"
-// 时 __gui__ 被填充、ctx.mode === "tui" 时不填充的 GUI 通道分发。
-//
-// adapter() 是纯函数，ctx.mode === "rpc" → details.__gui__ 被附加，
-// ctx.mode === "tui"/"json"/"print" → details.__gui__ 为 undefined。
-
-import type { GuiContext } from "@xyz-agent/extension-protocol";
-import { describe, expect, it } from "vitest";
-
-import type { AdapterInput } from "../../interface/subagent-actions.ts";
-import { adapter } from "../../interface/subagent-actions.ts";
-
-function makeStartInput(): AdapterInput {
-	return {
-		action: "start",
-		domain: {
-			subagentId: "test-id",
-			sessionFile: "/test/session.jsonl",
-			slug: "test-slug",
-			response: { status: "started" },
-		},
-	} as unknown as AdapterInput;
-}
-
-describe("S6: ctx.mode dispatches __gui__ output correctly", () => {
-	it("ctx.mode=rpc → details.__gui__ is populated", () => {
-		const ctx = { mode: "rpc", hasUI: true } as GuiContext;
-		const result = adapter(makeStartInput(), ctx);
-		expect(result.details).toHaveProperty("__gui__");
-		expect(result.details.__gui__).toBeDefined();
-	});
-
-	it("ctx.mode=tui → details.__gui__ is undefined (TUI renders differently)", () => {
-		const ctx = { mode: "tui", hasUI: true } as GuiContext;
-		const result = adapter(makeStartInput(), ctx);
-		expect(result.details.__gui__).toBeUndefined();
-	});
-
-	it("ctx.mode=json → details.__gui__ is undefined (headless)", () => {
-		const ctx = { mode: "json", hasUI: false } as GuiContext;
-		const result = adapter(makeStartInput(), ctx);
-		expect(result.details.__gui__).toBeUndefined();
-	});
-
-	it("ctx.mode=print → details.__gui__ is undefined (headless)", () => {
-		const ctx = { mode: "print", hasUI: false } as GuiContext;
-		const result = adapter(makeStartInput(), ctx);
-		expect(result.details.__gui__).toBeUndefined();
-	});
-
-	it("ctx=undefined → details.__gui__ is undefined (backward compat)", () => {
-		const result = adapter(makeStartInput(), undefined);
-		expect(result.details.__gui__).toBeUndefined();
-	});
-});

package/src/execution/__tests__/helpers/mock-extension-api.ts

@@ -1,30 +0,0 @@
-/**
- * 创建一个结构兼容的 ExtensionAPI mock，供 sdk-contract / 注册契约测试用。
- *
- * ExtensionAPI 有 ~30 个必需方法（on/registerTool/registerCommand/...），逐个手写
- * 不现实。本 helper 用 Proxy 把所有未显式 override 的方法/属性短路为 no-op 函数，
- * 让对象**结构兼容** ExtensionAPI——避免 `as unknown as ExtensionAPI` 双重断言
- * （taste/no-unsafe-cast 规则禁止）。测试只需 override 关心的方法：
- *
- *   const pi = mockExtensionApi({
- *     registerCommand: (name) => { capturedName = name; },
- *   });
- *
- * Proxy 的 trap 对所有属性访问返回 override 值或 no-op 函数，运行时安全
- * （注册 handler 只调用被 override 的方法，其余方法测试不触及）。
- */
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-
-export function mockExtensionApi(
-  overrides: Record<string, unknown> = {},
-): ExtensionAPI {
-  const noop = (): void => { /* test mock: method not invoked by this test */ };
-  // Proxy<T> 泛型参数决定返回类型——直接声明为 ExtensionAPI，
-  // TS 接受（Proxy handler 对 target 的类型不约束 T）。
-  return new Proxy<ExtensionAPI>(overrides as ExtensionAPI, {
-    get(target, prop: string | symbol): unknown {
-      if (prop in target) return target[prop as keyof ExtensionAPI];
-      return noop;
-    },
-  });
-}

package/src/execution/__tests__/helpers/spawn-mock.ts

@@ -1,238 +0,0 @@
-// src/execution/__tests__/helpers/spawn-mock.ts
-//
-// run-spawn-* 三文件（integration/edges/rpc-mode）共享的 FakeChild + 工具函数。
-//
-// 背景：vitest 的 vi.mock 会被提升到文件顶部，工厂函数体内**不能引用顶层 import 的变量**
-//（vitest 官方文档明确警告）。例外：async 工厂内可用 `await import()`（在模块需求时执行，
-// 此时所有模块已加载）。故本 helper 不导出「mock 工厂函数」（无法被 vi.mock 顶层引用），
-// 而是导出 **FakeChild class + 工具函数**，让各测试文件的 vi.mock 工厂用 `await import`
-// 动态取回 FakeChild。这样每个 vi.mock 工厂从 ~15 行（定义 class + vi.fn）缩到 ~4 行，
-// 且 FakeChild 定义只有一个权威来源。
-//
-// 共享内容（原 ~80 行 × 3 重复）：
-//   - FakeChild：EventEmitter + PassThrough stdout/stderr/stdin + kill 记录（class 定义）
-//   - lastSpawnedChild(mockSpawn)：从 mock.results 取回最近 spawn 返回的 FakeChild
-//   - waitForSpawn(mockSpawn)：轮询等 spawn 被调（比 vi.waitFor 在该 vitest 版本下可靠）
-//   - emitStdoutLine / sessionHeader：构造 stdout 行的辅助
-//   - makeRecord / makeOpts / makeCtx：构造最小合法的 record/opts/ctx（3 文件一致）
-//
-// 各测试文件 vi.mock 模式（每文件独立声明，vitest 的 vi.mock 是文件作用域）：
-//   ```ts
-//   vi.mock("node:child_process", async () => {
-//     const { EventEmitter } = await import("node:events");
-//     const events = { EventEmitter }; // 兼容旧注释
-//     const { FakeChild } = await import("./helpers/spawn-mock.ts");
-//     return {
-//       spawn: vi.fn(() => new FakeChild()),
-//       // buildEnvBlock 用 execFile 异步取 git branch：默认 err-first 兜底（catch → branch=""），
-//       // 形态同 worktree-manager.test.ts 的 setupExecFile
-//       execFile: vi.fn(
-//         (
-//           _cmd: string,
-//           _args: readonly string[],
-//           _opts: unknown,
-//           cb: (err: Error | null, stdout?: string, stderr?: string) => void,
-//         ) => cb(new Error("execFile not configured in this test")),
-//       ),
-//     };
-//   });
-//   vi.mock("node:fs", async () => {
-//     const actual = await import("node:fs");
-//     return {
-//       default: { ...actual, mkdirSync: vi.fn(), existsSync: vi.fn(() => false),
-//                   appendFileSync: vi.fn(), writeFileSync: vi.fn(), readdirSync: vi.fn(() => []) },
-//       mkdirSync: vi.fn(), existsSync: vi.fn(() => false),
-//       appendFileSync: vi.fn(), writeFileSync: vi.fn(), readdirSync: vi.fn(() => []),
-//       promises: actual.promises,
-//     };
-//   });
-//   vi.mock("../alive-store.ts", () => ({ writeAliveMarker: vi.fn() }));
-//   vi.mock("../temp-prompt.ts", () => ({
-//     writePromptToTempFile: vi.fn(async (agent: string) => {
-//       const safeName = agent.replace(/[^\w.-]+/g, "_");
-//       return { dir: `/tmp/fake-${safeName}`, filePath: `/tmp/fake-${safeName}/prompt-${safeName}.md` };
-//     }),
-//     cleanupTempPrompt: vi.fn(async () => {}),
-//   }));
-//   ```
-
-import type { ChildProcess } from "node:child_process";
-import { EventEmitter } from "node:events";
-import { PassThrough } from "node:stream";
-
-import { createRecord } from "../../execution-record.ts";
-import type { RunOptions, SessionRunnerContext } from "../../session-runner.ts";
-
-/** FakeChild 的假 pid（满足 ChildProcess.pid 形状，无真实进程语义）。 */
-const FAKE_PID = 12345;
-
-/** waitForSpawn 默认超时（ms），超时说明 spawn 未被调（runSpawn 前置 await 卡死）。 */
-const WAIT_SPAWN_TIMEOUT_MS = 1000;
-
-/** waitForSpawn 轮询间隔（ms），微任务级等待的粒度。 */
-const SPAWN_POLL_INTERVAL_MS = 5;
-
-/**
- * FakeChild：模拟 ChildProcess（EventEmitter + PassThrough streams）。
- *
- * 测试通过 mockSpawn.mock.results.at(-1).value 取回实例，控制 emit data/close/error 时序。
- *
- * 导出 class（而非只在工厂内部定义）是为了：
- *   1. vi.mock 工厂内 `await import("./helpers/spawn-mock.ts")` 后 `new FakeChild()` 与
- *      测试侧 `instanceof FakeChild` / 类型断言用同一个 class。
- *   2. C13 e2e 测试可直接 `new FakeChild()` 手动构造 child 喂给 ui-request-queue（不经 spawn）。
- */
-export class FakeChild extends EventEmitter {
-  pid = FAKE_PID;
-  stdout = new PassThrough();
-  stderr = new PassThrough();
-  stdin = new PassThrough();
-  killed = false;
-  killSignal: string | undefined;
-  kill(sig?: string): boolean {
-    this.killed = true;
-    this.killSignal = sig;
-    return true;
-  }
-}
-
-/**
- * spawn mock 返回的 fake child 类型（结构子集）。
- *
- * 测试文件优先 import { FakeChild } 用真实 class 类型；此 interface 仅为兼容现有
- * describe 块内 `child: FakeChild` 的类型注解风格（与原代码一致，降低 diff 噪声）。
- */
-export interface FakeChildLike {
-  pid: number;
-  stdout: PassThrough;
-  stderr: PassThrough;
-  stdin: PassThrough;
-  killed: boolean;
-  killSignal: string | undefined;
-  kill(sig?: string): boolean;
-  emit(event: string, ...args: unknown[]): boolean;
-}
-
-/**
- * 从最近一次 spawn 调用取回返回的 FakeChild（测试控制器）。
- *
- * @param mockSpawn 调用方用 `vi.mocked(spawn)` 取回的 mock 引用
- */
-export function lastSpawnedChild<
-  T extends { mock: { results: Array<{ value: ChildProcess | unknown }> } },
->(mockSpawn: T): FakeChild {
-  const result = mockSpawn.mock.results.at(-1);
-  if (!result) throw new Error("spawn was not called yet");
-  return result.value as FakeChild;
-}
-
-/**
- * 等待 runSpawn 内部调到 spawn（拿到 child 控制器）。
- *
- * runSpawn 是 async，spawn 在 buildEnvBlock + writePromptToTempFile 两个 await 之后才调
- *（均为微任务级延迟）。用 setTimeout 轮询 mockSpawn.mock.results，比 vi.waitFor 在该
- * vitest 版本下更可靠（vi.waitFor 偶发过早 resolve 导致后续读取竞态）。
- *
- * [快照语义] 等待的是「调用时刻之后**新发生**的一次 spawn」，而非「任意历史 spawn」。
- * 旧实现只在 results 为空时等待（即只在文件/测试内首次 spawn 有效）：同一文件第二次
- * runSpawn 时立即返回，而新 runSpawn 尚未跨过 await 到达 spawn → lastSpawnedChild 取回
- * **上一次**的 child，stdout/close 事件发给已死的旧 child，当前 runSpawn 永远收不到
- * close → 测试超时。buildEnvBlock 异步化（多一个 await 微任务）后该隐式时序假设失效，
- * 故改为快照 baseline：等待 results.length 超过调用时的快照值，天然对「每测试/每文件
- * N 次 spawn」都正确（调用前先记 baseline，本次 runSpawn 的 spawn 必然使 length 增长）。
- *
- * @param mockSpawn 调用方用 `vi.mocked(spawn)` 取回的 mock 引用
- */
-export async function waitForSpawn<
-  T extends { mock: { results: unknown[] } },
->(mockSpawn: T, timeoutMs: number = WAIT_SPAWN_TIMEOUT_MS): Promise<void> {
-  const start = Date.now();
-  const baseline = mockSpawn.mock.results.length;
-  while (mockSpawn.mock.results.length <= baseline) {
-    if (Date.now() - start > timeoutMs) {
-      throw new Error(`spawn was not called within ${timeoutMs}ms`);
-    }
-    await new Promise((r) => setTimeout(r, SPAWN_POLL_INTERVAL_MS));
-  }
-}
-
-/** 向 stdout 写一行（自动补换行，runSpawn 按 \n split 行）。 */
-export function emitStdoutLine(child: FakeChild, obj: Record<string, unknown>): void {
-  child.stdout.write(`${JSON.stringify(obj)}\n`);
-}
-
-/** 构造 session header 行（stdout 首行）。 */
-export function sessionHeader(id = "sess-abc"): Record<string, unknown> {
-  return {
-    type: "session",
-    id,
-    timestamp: "2026-07-03T12-00-00-000Z",
-    cwd: "/tmp/test",
-  };
-}
-
-/**
- * 让 sessionFile 存在校验通过——runSpawn 在进程退出后用 existsSync(record.sessionFile)
- * 判断是否补写 identity。默认 mock existsSync 返回 false（兜底查找），此 helper 在指定
- * 路径返回 true。
- */
-export function mockSessionFileExists(
-  mockExistsSync: { mockImplementation: (fn: (p: unknown) => boolean) => void },
-  sessionFilePath: string,
-): void {
-  mockExistsSync.mockImplementation((p: unknown) => String(p) === sessionFilePath);
-}
-
-// ── record / opts / ctx 构造（3 文件一致的最小合法形状）──
-
-/** 构造最小合法的 ExecutionRecord（runSpawn 入参）。 */
-export function makeRecord(id = "run-1") {
-  return createRecord(id, {
-    agent: "general-purpose",
-    model: "test-model",
-    mode: "sync",
-    task: "do something",
-    startedAt: 1_000_000,
-    rootSessionId: "root-session",
-    parentRecordId: undefined,
-    depth: 0,
-  });
-}
-
-/** 构造最小合法的 RunOptions（runSpawn 入参，可 override 关键字段）。 */
-export function makeOpts(overrides: Partial<RunOptions> = {}): RunOptions {
-  return {
-    resolved: {
-      model: {
-        id: "test-model",
-        name: "Test Model",
-        provider: "test",
-        reasoning: false,
-      },
-      thinkingLevel: undefined,
-    },
-    agentConfig: undefined,
-    appendSystemPrompt: undefined,
-    skillPath: undefined,
-    schema: undefined,
-    maxTurns: undefined,
-    graceTurns: undefined,
-    signal: undefined,
-    onEvent: undefined,
-    ...overrides,
-  };
-}
-
-/** 构造最小合法的 SessionRunnerContext（runSpawn 入参，可 override 关键字段）。 */
-export function makeCtx(overrides: Partial<SessionRunnerContext> = {}): SessionRunnerContext {
-  return {
-    cwd: "/tmp/test",
-    agentDir: "/tmp/test/agents",
-    skillDirs: [],
-    mainCwd: "/tmp/test",
-    mainSessionFile: undefined,
-    sessionRootId: "root-session-test",
-    rootCwd: "/tmp/test",
-    ...overrides,
-  };
-}

package/src/execution/__tests__/host-mode.test.ts

@@ -1,87 +0,0 @@
-// src/__tests__/host-mode.test.ts
-//
-// W1 红灯测试：host-mode.ts 主进程运行模式分类工具。
-//
-// 测试对象：extensions/universal/subagent-workflow/src/execution/host-mode.ts（新建）
-// 契约来源：.fix-plans/00-master-summary.md §一 冲突 4 + §2.5（W4 守卫消费点）
-//
-// 三个导出：
-//   - resolveHostMode(mode): ExtensionMode | undefined → "tui" | "gui" | "headless"
-//   - willRespondToAskUser(mode): boolean（tui/gui → true，headless → false）
-//   - hasInteractiveUI(mode): boolean（非 headless → true）
-//
-// 红灯原因：host-mode.ts 尚未创建，import 失败。
-
-import { describe, expect, it } from "vitest";
-
-import {
-  hasInteractiveUI,
-  resolveHostMode,
-  willRespondToAskUser,
-} from "../host-mode.ts";
-
-describe("resolveHostMode — ExtensionMode 聚合为 HostMode", () => {
-  it('"tui" → "tui"（纯 Pi TUI，ctx.ui.custom 可用）', () => {
-    expect(resolveHostMode("tui")).toBe("tui");
-  });
-
-  it('"rpc" → "gui"（xyz-agent GUI，sidecar 通道）', () => {
-    expect(resolveHostMode("rpc")).toBe("gui");
-  });
-
-  it('"json" → "headless"（无交互通道）', () => {
-    expect(resolveHostMode("json")).toBe("headless");
-  });
-
-  it('"print" → "headless"（无交互通道）', () => {
-    expect(resolveHostMode("print")).toBe("headless");
-  });
-
-  it('undefined → "headless"（向后兼容：mode 未穿透时按 headless）', () => {
-    expect(resolveHostMode(undefined)).toBe("headless");
-  });
-});
-
-describe("willRespondToAskUser — 主进程是否响应子进程 ask_user", () => {
-  it("tui → true（冲突 3 裁决：TUI 必须注入 handler）", () => {
-    expect(willRespondToAskUser("tui")).toBe(true);
-  });
-
-  it("rpc → true（GUI 透传所有 UI）", () => {
-    expect(willRespondToAskUser("rpc")).toBe(true);
-  });
-
-  it("json → false（headless 无 UI 通道）", () => {
-    expect(willRespondToAskUser("json")).toBe(false);
-  });
-
-  it("print → false（headless 无 UI 通道）", () => {
-    expect(willRespondToAskUser("print")).toBe(false);
-  });
-
-  it("undefined → false（向后兼容）", () => {
-    expect(willRespondToAskUser(undefined)).toBe(false);
-  });
-});
-
-describe("hasInteractiveUI — 是否有交互 UI 通道", () => {
-  it("tui → true", () => {
-    expect(hasInteractiveUI("tui")).toBe(true);
-  });
-
-  it("rpc → true", () => {
-    expect(hasInteractiveUI("rpc")).toBe(true);
-  });
-
-  it("json → false", () => {
-    expect(hasInteractiveUI("json")).toBe(false);
-  });
-
-  it("print → false", () => {
-    expect(hasInteractiveUI("print")).toBe(false);
-  });
-
-  it("undefined → false", () => {
-    expect(hasInteractiveUI(undefined)).toBe(false);
-  });
-});