@zhushanwen/subagent-core 0.5.1 → 0.7.0

package/src/execution/__tests__/start-collect-guard.test.ts

@@ -0,0 +1,255 @@
+// src/execution/__tests__/start-collect-guard.test.ts
+//
+// startHandler 的 collect 语义（subagent-sync-collect U1 foundation）：
+//   1. E4 校验（设计 §3.1.5）：conversation:true + collect:"sync" → immediate throw，
+//      不产生半启动 record（execute 零调用）；文案指引「sync 仅支持 one-shot，
+//      去掉 conversation 或 collect」；
+//   2. 合法组合放行：collect 透传 service.execute（ExecuteOptions.collect）；
+//   3. start 响应 collect 段（设计 §3.1.1）：仅 resolved=sync 附段（async 响应字节
+//      零变化，G3）；pendingSyncCount = 未闭合批 sync 成员数（collectMode=sync 且无
+//      batchFinalized；U2 偏差#4 接线后 record 落 collectMode，枚举天然含本条，无 +1）。
+//
+// stub SubagentService 仅实现 handler 触达的方法子集（subagent-actions-core.test.ts
+// 同款形态）；真实 service 行为归属 subagent-service 各自测试。
+
+import { describe, expect, it, vi, type Mock } from "vitest";
+
+import { startHandler } from "../subagent-actions-core.ts";
+// SubagentService 的权威源是 subagent-service.ts（types.ts 只有 record/tool 契约）
+import type { SubagentService } from "../subagent-service.ts";
+import type { StatusFilter } from "../record-store.ts";
+import type {
+  ExecutionHandle,
+  SubagentRecord,
+  SubagentToolDetails,
+} from "../types.ts";
+
+function makeDetails(): SubagentToolDetails {
+  return {
+    status: "running",
+    mode: "background",
+    agent: "/home/u/agents/worker.md",
+    model: "prov/m1",
+    thinkingLevel: undefined,
+    slug: "src-slug",
+    turns: 0,
+    totalTokens: 0,
+    elapsedSeconds: 0,
+    eventLog: [],
+    displayItems: [],
+    result: undefined,
+    error: undefined,
+  } as SubagentToolDetails;
+}
+
+function makeHandle(): ExecutionHandle {
+  return { mode: "background", subagentId: "sa-new", sessionFile: undefined, details: makeDetails() };
+}
+
+/** collectRecords stub 数据行（只含 pendingSyncCount 口径判读所需字段）。 */
+function makeRec(over: Partial<SubagentRecord> = {}): SubagentRecord {
+  return {
+    id: "sa-1",
+    agent: "/home/u/agents/worker.md",
+    task: "t",
+    slug: "worker",
+    status: "running",
+    mode: "background",
+    startedAt: 1000,
+    rootSessionId: "root-A",
+    parentRecordId: undefined,
+    depth: 0,
+    endedAt: undefined,
+    turns: 1,
+    totalTokens: 42,
+    model: "prov/m1",
+    thinkingLevel: undefined,
+    eventLog: [],
+    displayItems: [],
+    ...over,
+  } as SubagentRecord;
+}
+
+// Mock<T> 具名签名 + Omit 类原生同名成员：ReturnType<typeof vi.fn>
+// （= Mock<Procedure | Constructable>）与类方法签名交叉会收窄 never
+type ServiceStub = Omit<SubagentService, "execute" | "collectRecords" | "getCollectSyncDefault"> & {
+  // 带首参形态：断言消费 execute.mock.calls[0][0]（ExecuteOptions），零参签名为空元组取不到
+  execute: Mock<(opts: Record<string, unknown>) => Promise<SubagentRecord>>;
+  collectRecords: Mock<(limit: number, statusFilter?: StatusFilter) => SubagentRecord[]>;
+  getCollectSyncDefault: Mock<() => "async" | "sync">;
+};
+
+/** startHandler 的测试包装：stub → SubagentService 断言收口一处（类私有成员不可结构模拟）。 */
+function sh(svc: ServiceStub, input: Record<string, unknown>, signal?: AbortSignal) {
+  return startHandler(
+    svc as unknown as SubagentService,
+    input as Parameters<typeof startHandler>[1],
+    signal ?? undefined,
+  );
+}
+
+function makeService(
+  collectRecordsReturn: SubagentRecord[] = [],
+  collectSyncDefault: "async" | "sync" = "async",
+): ServiceStub {
+  const execute = vi.fn(async (_opts: Record<string, unknown>) => makeHandle());
+  const collectRecords = vi.fn(() => collectRecordsReturn);
+  const getCollectSyncDefault = vi.fn(() => collectSyncDefault);
+  // [D4-① 适配] countPendingSyncRecords 经查询面聚合读 collectRecords（dev 重构后
+  // service.collectRecords 收窄 private，public 出口 = service.queries.collectRecords）。
+  return {
+    execute,
+    queries: { collectRecords },
+    collectRecords,
+    getCollectSyncDefault,
+  } as unknown as ServiceStub;
+}
+
+const BASE_INPUT = { task: "do things", slug: "do-things" };
+
+// ============================================================
+// E4：conversation + collect:"sync" 即拒
+// ============================================================
+
+describe("startHandler E4 guard (conversation + collect:sync)", () => {
+  it("throws immediately and never calls execute (不产生半启动 record)", async () => {
+    const service = makeService();
+    await expect(
+      sh(service, { ...BASE_INPUT, conversation: true, collect: "sync" }, undefined),
+    ).rejects.toThrow();
+    expect(service.execute).not.toHaveBeenCalled();
+  });
+
+  it("error copy carries the design guidance verbatim (文案锚定)", async () => {
+    const service = makeService();
+    const err = await sh(service,
+      { ...BASE_INPUT, conversation: true, collect: "sync" },
+      undefined,
+    ).catch((e: unknown) => e as Error);
+    expect(err).toBeInstanceOf(Error);
+    expect((err as Error).message).toBe(
+      'collect:"sync" only supports one-shot subagents — it cannot be combined with conversation:true. ' +
+      'Remove either conversation or collect (use collect:"async", or omit it, for conversational subagents).',
+    );
+  });
+
+  it("allows conversation:true + collect:async (async 语义与 conversation 正交)", async () => {
+    const service = makeService();
+    const result = await sh(service,
+      { ...BASE_INPUT, conversation: true, collect: "async" },
+      undefined,
+    );
+    expect(result.subagentId).toBe("sa-new");
+    expect(service.execute).toHaveBeenCalledTimes(1);
+  });
+
+  it("allows collect:sync alone (one-shot sync 是合法主场景)", async () => {
+    const service = makeService();
+    const result = await sh(service, { ...BASE_INPUT, collect: "sync" }, undefined);
+    expect(result.subagentId).toBe("sa-new");
+    expect(service.execute).toHaveBeenCalledTimes(1);
+  });
+
+  it("E4 also blocks conversation when config default is sync (偏差#3 接线：resolved 含 config 默认)", async () => {
+    const service = makeService([], "sync");
+    await expect(
+      sh(service, { ...BASE_INPUT, conversation: true }, undefined),
+    ).rejects.toThrow('collect:"sync" only supports one-shot subagents');
+    expect(service.execute).not.toHaveBeenCalled();
+  });
+
+  it("config default=sync applies when collect omitted (缺省读真实 config，U2 偏差#3)", async () => {
+    const service = makeService([], "sync");
+    const result = await sh(service, { ...BASE_INPUT }, undefined);
+    expect(result.response.collect).toBeDefined();
+    expect(service.getCollectSyncDefault).toHaveBeenCalledTimes(1);
+  });
+
+  it("reads config default via service accessor when collect omitted (async 默认零附段)", async () => {
+    const service = makeService([], "async");
+    const result = await sh(service, { ...BASE_INPUT }, undefined);
+    expect(result.response.collect).toBeUndefined();
+    expect(service.getCollectSyncDefault).toHaveBeenCalledTimes(1);
+  });
+});
+
+// ============================================================
+// collect 透传 + 响应 collect 段
+// ============================================================
+
+describe("startHandler collect forwarding + response collect segment", () => {
+  it("forwards collect to service.execute via ExecuteOptions.collect", async () => {
+    const service = makeService();
+    await sh(service, { ...BASE_INPUT, collect: "sync" }, undefined);
+    const opts = service.execute.mock.calls[0]?.[0] as { collect?: string };
+    expect(opts.collect).toBe("sync");
+  });
+
+  it("omits collect in ExecuteOptions when not provided (resolved≠sync 时保持 undefined，async 缺省语义)", async () => {
+    const service = makeService();
+    await sh(service, { ...BASE_INPUT }, undefined);
+    const opts = service.execute.mock.calls[0]?.[0] as { collect?: string };
+    expect(opts.collect).toBeUndefined();
+  });
+
+  it("B1：config default=sync + 省略 collect → execute 收 collect:\"sync\"（缺省解析作用于 record 本体）", async () => {
+    // 修复前：execute 收原始 input.collect=undefined → createRecordForMode 只认
+    // ==="sync" → record 走 async 逐条通知而响应声称已入批（设计 §3.1.3/types.ts:689
+    // 承诺「缺省 = config 默认」作用于 record）。修复后 resolved=sync 落值。
+    const service = makeService([], "sync");
+    await sh(service, { ...BASE_INPUT }, undefined);
+    const opts = service.execute.mock.calls[0]?.[0] as { collect?: string };
+    expect(opts.collect).toBe("sync");
+  });
+
+  it("B1：config default=sync 时显式 collect:\"async\" 优先（execute 收 \"async\"）", async () => {
+    const service = makeService([], "sync");
+    await sh(service, { ...BASE_INPUT, collect: "async" }, undefined);
+    const opts = service.execute.mock.calls[0]?.[0] as { collect?: string };
+    expect(opts.collect).toBe("async");
+  });
+
+  it("attaches collect segment counting this very record from the enumeration (U2 偏差#4：无 +1 补偿)", async () => {
+    // 本条 record（id=sa-new）已由 createRecordForMode 落 collectMode 入枚举：
+    // stub 枚举返回本条 + 另一未闭合 sync → count=2（无 +1 补偿即含本条）
+    const service = makeService([
+      makeRec({ id: "sa-new", collectMode: "sync" }),
+      makeRec({ id: "sa-other", collectMode: "sync", status: "running" }),
+      makeRec({ id: "sa-gone", collectMode: "sync", batchFinalized: true }),
+    ]);
+    const result = await sh(service, { ...BASE_INPUT, collect: "sync" }, undefined);
+    expect(result.response.collect).toEqual({ mode: "sync", pendingSyncCount: 2 });
+  });
+
+  it("reports the enumeration verbatim when no sync records exist yet (如实反映，无补偿)", async () => {
+    const service = makeService([]);
+    const result = await sh(service, { ...BASE_INPUT, collect: "sync" }, undefined);
+    expect(result.response.collect).toEqual({ mode: "sync", pendingSyncCount: 0 });
+  });
+
+  it("counts pending unmarked sync members from the enumeration (跨轮续累口径)", async () => {
+    const service = makeService([
+      makeRec({ id: "sa-1", collectMode: "sync" }), // 未闭合（无 batchFinalized）→ 计入
+      makeRec({ id: "sa-2", collectMode: "sync", batchFinalized: true }), // 已离场 → 排除
+      makeRec({ id: "sa-3" }), // async → 排除
+      makeRec({ id: "sa-4", collectMode: "sync", batchFinalized: false }), // 显式 false → 计入
+    ]);
+    const result = await sh(service, { ...BASE_INPUT, collect: "sync" }, undefined);
+    expect(result.response.collect).toEqual({ mode: "sync", pendingSyncCount: 2 });
+  });
+
+  it("omits the collect segment for async starts (G3: async 响应字节零变化)", async () => {
+    for (const input of [{ ...BASE_INPUT }, { ...BASE_INPUT, collect: "async" as const }]) {
+      const service = makeService();
+      const result = await sh(service, input, undefined);
+      expect(result.response.collect).toBeUndefined();
+      // G3 字节锚：response 其余字段与既有形态全等
+      expect(result.response).toEqual({
+        status: "running",
+        mode: "background",
+        message: result.response.message,
+        notifyContract: "ledger+at-least-once",
+      });
+    }
+  });
+});

package/src/execution/__tests__/stream-sink-retirement.test.ts

@@ -103,14 +103,6 @@ vi.mock("../manifest-store.ts", () => {
   return { ManifestStore: vi.fn(function (_recordsDir: string) { return new FakeManifestStore(); }) };
 });
 
-vi.mock("../engine/engines/pi/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 { spawn } from "node:child_process";
 
 import { ModelConfigService } from "../model-config-service.ts";
@@ -233,6 +225,11 @@ describe("退役步骤 2 判定层：createBackgroundStream", () => {
 });
 
 // ── 接线层：service → 工厂的参数透传（mode 传错 = 判定失效）──
+// [W3 改写] 驱动方式从 inproc spawn（FakeChild close）改为协议 seam
+//（registerFakePiEngine 替身）——kickOffChatRound 的 stream 创建先于 pool acquire，
+// 替身 run 挂起即可观察工厂入参。
+import { registerFakePiEngine } from "./helpers/fake-engine-port.ts";
+import { clearEngines } from "../engine/registry.ts";
 
 describe("退役步骤 2 接线层：kickOffChatRound 透传 mode/sink 给工厂", () => {
   beforeEach(() => {
@@ -242,6 +239,7 @@ describe("退役步骤 2 接线层：kickOffChatRound 透传 mode/sink 给工厂
 
   afterEach(() => {
     for (const key of RELAY_ENV_KEYS) delete process.env[key];
+    clearEngines();
     vi.restoreAllMocks();
   });
 
@@ -250,9 +248,11 @@ describe("退役步骤 2 接线层：kickOffChatRound 透传 mode/sink 给工厂
     ["tui", "tui"],
     ["undefined（headless）", undefined],
   ])("mode=%s：工厂收到 initSession 注入的 mode 与 streamSink", async (_label, mode) => {
+    clearEngines();
+    registerFakePiEngine();
     const service = setupService(mode);
-    await executeBackground(service);
-    expect(mockCreateStream).toHaveBeenCalledTimes(1);
+    await service.execute({ task: "retire test", slug: "test", ctxModel, conversation: true });
+    await vi.waitFor(() => expect(mockCreateStream).toHaveBeenCalledTimes(1));
     const [recordId, sinkArg, modeArg] = mockCreateStream.mock.calls[0]!;
     expect(typeof recordId).toBe("string");
     expect(sinkArg).toHaveProperty("setWidget");

package/src/execution/__tests__/subagent-actions-core.test.ts

@@ -144,11 +144,17 @@ function makeService(over: Record<string, unknown> = {}): SubagentService {
     getRecordForAction: vi.fn(),
     closeSubagent: vi.fn(),
     deliverChatMessage: vi.fn(),
+    // [U2] startHandler 缺省 collect 解析读真实 config（偏差#3 接线）：stub 缺省 async
+    //（本文件不测 collect 语义，专项见 start-collect-guard.test.ts）。
+    getCollectSyncDefault: vi.fn(() => "async" as const),
     ...over,
   };
   return {
     execute: m.execute,
     cancel: m.cancel,
+    // [U2 偏差#3 接线] startHandler 经平铺访问器读 config 缺省 collect（真实 service
+    // 为平铺方法 subagent-service.ts:1786，非 queries 聚合面成员），stub 须同构挂载。
+    getCollectSyncDefault: m.getCollectSyncDefault,
     queries: {
       findRecord: m.findRecord,
       lookupRecordAnyState: m.lookupRecordAnyState,

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

@@ -21,8 +21,7 @@ const { loggerMock } = vi.hoisted(() => ({
 }));
 vi.mock("../../core/logger.ts", () => ({ getLogger: () => loggerMock }));
 
-const { killChildSpy, foreignLiveSpy } = vi.hoisted(() => ({
-  killChildSpy: vi.fn(),
+const { foreignLiveSpy } = vi.hoisted(() => ({
   foreignLiveSpy: vi.fn<() => { pid: number; id: string; startedAt: number } | undefined>(),
 }));
 vi.mock("../alive-store.ts", () => ({
@@ -34,15 +33,6 @@ vi.mock("../alive-store.ts", () => ({
   findForeignLiveInstance: foreignLiveSpy,
 }));
 
-vi.mock("../engine/engines/pi/session-runner.ts", () => ({
-  runSpawn: vi.fn(),
-  killAllSpawnedChildren: vi.fn(),
-  getChildByRecord: vi.fn(() => undefined),
-  registerSpawnedChildForRecord: vi.fn(),
-  spawnedChildren: new Map(),
-  killRecordChildWithEscalation: killChildSpy,
-}));
-
 import { ModelConfigService } from "../model-config-service.ts";
 import type { RecordStore } from "../record-store.ts";
 import { SubagentService } from "../subagent-service.ts";
@@ -120,6 +110,19 @@ describe("T5③ cold-lookup running candidate foreign-instance guard", () => {
   let store: RecordStore;
 
   beforeEach(() => {
+    // 身份 env 剥离：initSession 会把 PI_SUBAGENT_ROOT_SESSION_ID 读作 sessionRootId 基线
+    //（env 优先于入参 sessionId）——宿主进程（xyz-agent 子 agent 环境）泄漏的身份 env
+    // 会让「root-session」桩记录归属校验恒不匹配 → 冷查用例误红（与 collect-coordinator-
+    // service.test.ts 同款剥离纪律）。
+    for (const k of [
+      "PI_SUBAGENT_ROOT_SESSION_ID",
+      "PI_SUBAGENT_SELF_RECORD_ID",
+      "PI_SUBAGENT_DEPTH",
+      "PI_SUBAGENT_ROOT_CWD",
+      "PI_SUBAGENT_FORK_DEPTH",
+    ] as const) {
+      delete process.env[k];
+    }
     foreignLiveSpy.mockReset();
     foreignLiveSpy.mockReturnValue(undefined);
     ({ agentDir, service, store } = setup());

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

@@ -22,16 +22,10 @@ const { loggerMock } = vi.hoisted(() => ({
 }));
 vi.mock("../../core/logger.ts", () => ({ getLogger: () => loggerMock }));
 
-const { killChildSpy } = vi.hoisted(() => ({ killChildSpy: vi.fn() }));
-vi.mock("../engine/engines/pi/session-runner.ts", () => ({
-  runSpawn: vi.fn(),
-  killAllSpawnedChildren: vi.fn(),
-  getChildByRecord: vi.fn(() => undefined),
-  registerSpawnedChildForRecord: vi.fn(),
-  spawnedChildren: new Map(),
-  killRecordChildWithEscalation: killChildSpy,
-}));
-
+// [W3 改写] 原 vi.mock(inproc pi 引擎目录/session-runner) 随删件消亡——chat 轮次走协议 seam
+//（registerFakePiEngine 替身，kickOffChatRound 的 notify 门经 engine.run 应答驱动）。
+import { registerFakePiEngine } from "./helpers/fake-engine-port.ts";
+import { clearEngines } from "../engine/registry.ts";
 import { bindNotifyLedgerHost, NOTIFY_LEDGER_CUSTOM_TYPE, _resetNotifyLedgerForTest } from "../notify-ledger.ts";
 import { createRecord } from "../execution-record.ts";
 import { ModelConfigService } from "../model-config-service.ts";
@@ -95,8 +89,10 @@ describe("T4① notify gate closedReason whitelist", () => {
     expect(notifyGateAllowsDelivery(undefined)).toBe(true);
   });
 
-  it("kickOffChatRound.then does not inject parent-new closed records into the session", async () => {
+  it("kickOffChatRound 应答回注不注入 parent-new closed records（notify 门白名单）", async () => {
     const { agentDir, service, pi } = setup();
+    clearEngines();
+    const fake = registerFakePiEngine();
     const record = createRecord("sa-gate-new", {
       agent: "general-purpose",
       model: "test/model",
@@ -107,34 +103,33 @@ describe("T4① notify gate closedReason whitelist", () => {
       rootSessionId: "root-session",
       controller: new AbortController(),
     });
-    // 模拟 disposeAllRecords 先行编排性关闭后，迟到的 kickOffChatRound.then 回注
+    // 模拟 disposeAllRecords 先行编排性关闭后，迟到的 kickOffChatRound 应答回注
     record.closedReason = "parent-new";
-    const stub = vi.fn().mockResolvedValue({
-      text: "",
-      turns: 0,
-      durationMs: 1,
-      success: false,
-      error: "closed due to parent-new",
-      sessionId: record.id,
-      toolCalls: [],
-    });
-    (service as unknown as Record<string, unknown>).runAndFinalize = stub;
-    // [D4 后形态] 轮次编排入口 kickOffChatRound（私有，bracket 调用先例见
-    // subagent-service-recovery-bounds.test.ts privateFn）；opts 形参仍是 ExecuteOptions
-    //（task/slug），chat 分支由 ticket lossless 携带——task 声明形参不参与校验。
+    // [W3] 轮次编排入口 kickOffChatRound（私有，bracket 调用先例）——协议 run 发起后
+    // 挂起，编排性关闭先行，再模拟引擎应答（迟到回注被门拦）。
     const kickOffChatRound = (
       service as unknown as Record<string, (...args: unknown[]) => void>
     )["kickOffChatRound"];
-    kickOffChatRound.call(service, record, { task: "t", slug: "gate" }, {}, {}, undefined, 1000, undefined);
-    await vi.waitFor(() => expect(stub).toHaveBeenCalled());
+    const identity = {
+      agent: "general-purpose",
+      agentConfig: undefined,
+      resolved: { model: { id: "model", name: "Model", provider: "test", reasoning: false }, thinkingLevel: undefined },
+    };
+    kickOffChatRound.call(service, record, { task: "t", slug: "gate" }, identity, undefined, 1000);
+    await vi.waitFor(() => expect(fake.runs.length).toBe(1));
+    fake.runs[0]!.settle({ content: "late round text" });
     await Promise.resolve();
     await Promise.resolve();
     expect(pi.sendMessage).not.toHaveBeenCalled();
+    service.dispose();
+    clearEngines();
     fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
-  it("kickOffChatRound.then still notifies for real failure closures (gc)", async () => {
+  it("kickOffChatRound 应答回注对真实失败关闭（gc）仍通知", async () => {
     const { agentDir, service, pi } = setup();
+    clearEngines();
+    const fake = registerFakePiEngine();
     const record = createRecord("sa-gate-gc", {
       agent: "general-purpose",
       model: "test/model",
@@ -146,12 +141,20 @@ describe("T4① notify gate closedReason whitelist", () => {
       controller: new AbortController(),
     });
     record.closedReason = "gc";
-    (service as unknown as Record<string, unknown>).runAndFinalize = vi.fn().mockResolvedValue({});
     const kickOffChatRound = (
       service as unknown as Record<string, (...args: unknown[]) => void>
     )["kickOffChatRound"];
-    kickOffChatRound.call(service, record, { task: "t", slug: "gate" }, {}, {}, undefined, 1000, undefined);
+    const identity = {
+      agent: "general-purpose",
+      agentConfig: undefined,
+      resolved: { model: { id: "model", name: "Model", provider: "test", reasoning: false }, thinkingLevel: undefined },
+    };
+    kickOffChatRound.call(service, record, { task: "t", slug: "gate" }, identity, undefined, 1000);
+    await vi.waitFor(() => expect(fake.runs.length).toBe(1));
+    fake.runs[0]!.settle({ content: "round" });
     await vi.waitFor(() => expect(pi.sendMessage).toHaveBeenCalled());
+    service.dispose();
+    clearEngines();
     fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 });

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

@@ -25,15 +25,8 @@ const { loggerMock } = vi.hoisted(() => ({
 }));
 vi.mock("../../core/logger.ts", () => ({ getLogger: () => loggerMock }));
 
-// mock session-runner（import 链需要 runSpawn/killAllSpawnedChildren/getChildByRecord 存在）
-vi.mock("../engine/engines/pi/session-runner.ts", () => ({
-  runSpawn: vi.fn(),
-  killAllSpawnedChildren: vi.fn(),
-  getChildByRecord: vi.fn(() => undefined),
-  registerSpawnedChildForRecord: vi.fn(),
-  killRecordChildWithEscalation: vi.fn(),
-  spawnedChildren: new Map(),
-}));
+// [W3 改写] 原 vi.mock(inproc pi 引擎目录/session-runner) 随删件消亡——本文件只测
+// getRecordForAction 守卫（纯内存判定，不触引擎链路），现存 import 无需再 mock 引擎替身。
 
 import { createRecord } from "../execution-record.ts";
 import { ModelConfigService } from "../model-config-service.ts";