@zhushanwen/subagent-core 0.5.1 → 0.7.0

package/src/execution/__tests__/epipe-fallback.test.ts

@@ -1,248 +0,0 @@
-// src/execution/__tests__/epipe-fallback.test.ts
-//
-// deliverChatMessage EPIPE 兜底集成测试——热路径 stdin 写入 EPIPE 时自动转冷路径续轮 + 消息重放
-//（D2 后投递协议知识在 PiEngine.deliverPrompt，编排层经 engine.interactRecord 进入）。
-//
-// 场景覆盖：
-//   1. 首次 EPIPE → 自动转冷路径续轮（runSpawn 收到 resume 参数 + 原消息）
-//   2. 连续 2 次 EPIPE → throw 含恢复指引（防无限循环）
-//   3. 热路径成功写入后清零 EPIPE 计数（正常路径不受影响）
-
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import type { ChildProcess } from "node:child_process";
-import { PassThrough } from "node:stream";
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const { loggerMock } = vi.hoisted(() => ({
-  loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn() },
-}));
-vi.mock("../../core/logger.ts", () => ({ getLogger: () => loggerMock }));
-
-// mock session-runner：runSpawn 受控 + killAllSpawnedChildren 空实现；
-// getChildByRecord/spawnedChildren 提供真实 Map 语义。
-vi.mock("../engine/engines/pi/session-runner.ts", () => {
-  const spawnedChildren = new Map<string, unknown>();
-  return {
-    runSpawn: vi.fn(),
-    killAllSpawnedChildren: vi.fn(),
-    registerSpawnedChildForRecord: vi.fn(),
-    killRecordChildWithEscalation: vi.fn(),
-    spawnedChildren,
-    getChildByRecord: (id: string): unknown => spawnedChildren.get(id),
-  };
-});
-
-import { runSpawn, spawnedChildren } from "../engine/engines/pi/session-runner.ts";
-import * as lifecycle from "../lifecycle-manager.ts";
-import { createRecord } from "../execution-record.ts";
-import { ModelConfigService } from "../model-config-service.ts";
-import type { ModelInfo } from "../model-resolver.ts";
-import { SubagentService } from "../subagent-service.ts";
-import type { PiLike } from "../subagent-service.ts";
-import type { AgentResult, ExecutionRecord } from "../types.ts";
-
-const mockRunSpawn = vi.mocked(runSpawn);
-
-function makeTmpAgentDir(): string {
-  return fs.mkdtempSync(path.join(os.tmpdir(), "epipe-test-"));
-}
-
-function makePi(): PiLike & {
-  appendEntry: ReturnType<typeof vi.fn<(customType: string, data?: unknown) => void>>;
-  events: { emit: ReturnType<typeof vi.fn<(channel: string, data: unknown) => void>> };
-  sendMessage: ReturnType<typeof vi.fn<(message: Parameters<PiLike["sendMessage"]>[0], options?: Parameters<PiLike["sendMessage"]>[1]) => void>>;
-} {
-  return {
-    appendEntry: vi.fn((customType: string, data?: unknown) => {}),
-    events: { emit: vi.fn((channel: string, data: unknown) => {}) },
-    sendMessage: vi.fn(() => {}),
-  };
-}
-
-function makeResult(success: boolean): AgentResult {
-  return {
-    text: success ? "done" : "err",
-    turns: 1,
-    durationMs: 100,
-    success,
-    error: success ? undefined : "boom",
-    sessionId: "sess-1",
-    toolCalls: [],
-  };
-}
-
-/** chatMode running-resumable record（第一轮已完成，等待续聊；v4 B-1 旧 idle 折入 running）。 */
-function makeIdleRecord(id = "sa-epipe"): ExecutionRecord {
-  const record = createRecord(id, {
-    agent: "general-purpose",
-    model: "test/test-model",
-    thinkingLevel: "low",
-    mode: "background",
-    task: "initial task",
-    slug: "epipe-chat",
-    startedAt: 1000,
-    rootSessionId: "root-session",
-    chatMode: true,
-  });
-  record.status = "running";
-  record.round = 1;
-  record.controller = new AbortController();
-  return record;
-}
-
-/**
- * 构造 EPIPE child：stdin.write 抛 {code:'EPIPE'}，模拟子进程已退出但 close 事件尚未到达的窗口。
- */
-function makeEpipeChild(): ChildProcess {
-  const fakeStdin = {
-    write: vi.fn(() => {
-      const err = Object.assign(new Error("write after end"), { code: "EPIPE" });
-      throw err;
-    }),
-    destroyed: false,
-  } as unknown as PassThrough;
-  return { stdin: fakeStdin, pid: 99999 } as unknown as ChildProcess;
-}
-
-/**
- * 构造正常 child：PassThrough stdin（可正常写入）。
- */
-function makeNormalChild(): ChildProcess {
-  return { stdin: new PassThrough(), pid: 88888 } as unknown as ChildProcess;
-}
-
-// ============================================================
-// deliverChatMessage EPIPE 兜底
-// ============================================================
-
-describe("deliverChatMessage EPIPE 兜底（热路径 stdin EPIPE → 冷路径续轮）", () => {
-  let agentDir: string;
-  let service: SubagentService;
-  let record: ExecutionRecord;
-
-  beforeEach(() => {
-    agentDir = makeTmpAgentDir();
-    const modelService = new ModelConfigService({ agentDir, cwd: agentDir });
-    service = new SubagentService({ cwd: agentDir, modelService });
-    service.initSession({ pi: makePi(), sessionId: "root-session" });
-    record = makeIdleRecord();
-    record.sessionFile = path.join(agentDir, "fake-session.jsonl");
-    spawnedChildren.clear();
-    mockRunSpawn.mockReset();
-    lifecycle._resetLifecycleState();
-    loggerMock.warn.mockClear();
-  });
-
-  afterEach(() => {
-    service.dispose();
-    spawnedChildren.clear();
-    lifecycle._resetLifecycleState();
-    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
-  });
-
-  it("首次 EPIPE → 自动转冷路径 resumeRound + 原消息重放", async () => {
-    mockRunSpawn.mockResolvedValueOnce(makeResult(true));
-    // 注册 EPIPE child（热路径会命中但 stdin.write 抛 EPIPE）
-    spawnedChildren.set(record.id, makeEpipeChild());
-
-    // 投递不 throw（首次 EPIPE 走续轮兜底）
-    await expect(service.chatActions.deliverChatMessage(record, "msg after epipe", false)).resolves.toBeUndefined();
-
-    // spawnedChildren 中的死进程条目已清理（EPIPE catch 块 delete）
-    expect(spawnedChildren.has(record.id)).toBe(false);
-
-    // 冷路径续轮被触发，runSpawn 收到 resume 参数 + 原消息
-    await vi.waitFor(() => expect(mockRunSpawn).toHaveBeenCalledTimes(1));
-    const call = mockRunSpawn.mock.calls[0]!;
-    expect(call[1]).toBe("msg after epipe");
-    expect(call[4]).toEqual({
-      sessionFile: record.sessionFile,
-      model: record.model,
-      thinkingLevel: record.thinkingLevel,
-    });
-
-    // warn 日志包含 EPIPE 关键词
-    expect(loggerMock.warn).toHaveBeenCalled();
-    const warnCalls = loggerMock.warn.mock.calls;
-    const epipeWarn = warnCalls.find((c: unknown[]) =>
-      typeof c[0] === "string" && c[0].includes("EPIPE"),
-    );
-    expect(epipeWarn).toBeDefined();
-  });
-
-  it("连续 2 次 EPIPE → throw 含恢复指引（防无限循环）", async () => {
-    mockRunSpawn.mockResolvedValue(makeResult(true));
-    // 注册 EPIPE child
-    spawnedChildren.set(record.id, makeEpipeChild());
-
-    // 第 1 次：EPIPE → resume（不 throw）
-    await service.chatActions.deliverChatMessage(record, "first epipe", false);
-    await vi.waitFor(() => expect(mockRunSpawn).toHaveBeenCalledTimes(1));
-
-    // resume 完成后 record 回 running（v4 B-1：finalizeRoundToIdle 设 running，旧 idle 折入）
-    await vi.waitFor(() => expect(record.status).toBe("running"));
-
-    // 第 2 次：再次注入 EPIPE child + EPIPE
-    spawnedChildren.set(record.id, makeEpipeChild());
-
-    // 第 2 次 EPIPE → throw 含恢复指引（连续 2 次触发 exhaustion）
-    // 注意：第二 EPIPE 时 count 已为 2，catch 块立即 throw（不经过续轮）。
-    let thrown: unknown;
-    try {
-      await service.chatActions.deliverChatMessage(record, "second epipe", false);
-    } catch (err) {
-      thrown = err;
-    }
-    expect(thrown).toBeInstanceOf(Error);
-    expect((thrown as Error).message).toContain("EPIPE fallback exhausted");
-    expect((thrown as Error).message).toContain("2 consecutive EPIPE");
-    expect((thrown as Error).message).toContain("action:'close'");
-    expect((thrown as Error).message).toContain("action:'start'");
-  });
-
-  it("热路径成功写入后清零 EPIPE 计数（正常路径不受 EPIPE 计数影响）", async () => {
-    mockRunSpawn.mockResolvedValue(makeResult(true));
-
-    // 第 1 轮：EPIPE → resume
-    spawnedChildren.set(record.id, makeEpipeChild());
-    await service.chatActions.deliverChatMessage(record, "epipe msg", false);
-    await vi.waitFor(() => expect(mockRunSpawn).toHaveBeenCalledTimes(1));
-    await vi.waitFor(() => expect(record.status).toBe("running"));
-
-    // 第 2 轮：正常 child，成功写入（清零 EPIPE 计数）
-    spawnedChildren.set(record.id, makeNormalChild());
-    await service.chatActions.deliverChatMessage(record, "normal msg", true);
-    // 不 throw，status=running（热路径成功）
-    expect(record.status).toBe("running");
-
-    // 第 3 轮：再次 EPIPE → 但因为第 2 轮清零了计数，这次是首次 EPIPE（不 throw）
-    // 需要先让 record 回 running（等待续聊态）
-    record.status = "running";
-    spawnedChildren.set(record.id, makeEpipeChild());
-    await expect(service.chatActions.deliverChatMessage(record, "after reset", false)).resolves.toBeUndefined();
-  });
-
-  it("EPIPE 兜底与冷路径共用 in-flight 守卫：resume 在途时 EPIPE 兜底不再二次 spawn（review round2 MF1）", async () => {
-    // 冷路径发起 resume，runSpawn 挂起（spawn 异步窗口内）
-    let releaseFirst!: (r: AgentResult) => void;
-    mockRunSpawn.mockImplementationOnce(
-      () => new Promise<AgentResult>((res) => { releaseFirst = res; }),
-    );
-    await service.chatActions.deliverChatMessage(record, "cold path first", false);
-    await vi.waitFor(() => expect(mockRunSpawn).toHaveBeenCalledTimes(1));
-
-    // 注册 EPIPE child → 投递走热路径 → stdin EPIPE → 兜底调冷路径续轮
-    // → in-flight 命中 → throw（不再走第二次 spawn。EPIPE 计数仍 +1 但未达阈值 2，
-    // exhaustion 分支不触发；throw 由兜底路径的 resumeRound 守卫抛出）
-    spawnedChildren.set(record.id, makeEpipeChild());
-    await expect(service.chatActions.deliverChatMessage(record, "epipe during resume", false)).rejects.toThrow(
-      /already starting a new round/,
-    );
-    expect(mockRunSpawn).toHaveBeenCalledTimes(1);
-
-    releaseFirst(makeResult(true));
-  });
-});

package/src/execution/__tests__/execution-runtime-face.test.ts

@@ -1,272 +0,0 @@
-// src/execution/__tests__/execution-runtime-face.test.ts
-//
-// U10① execution 运行时面导出形态测试 = 第三宿主最小构造示例（验收证据）。
-//
-// 示例语义（设计 docs/design/subagent-core-sink-design.md §3.3 D6 / §4 S5）：第三宿主
-// 仅凭模块导出面（不看 core 内部实现）完成——
-//   1. createSubagentService({cwd, modelService, ...}) 参数注入构造（无全局查找）；
-//   2. record 状态查询面调用（SubagentService.lookupRecordAnyState 按 id 全态查询 +
-//      RecordStore 按状态枚举 listRunning/collectRecords 与按 id findLightById/getFullRecord）；
-//   3. 错误类型族 instanceof 分流。
-//
-// 构造先例同 subagent-service.test.ts：真实 ModelConfigService 指向 tmpdir 空目录
-// （loadGlobalConfig 对不存在文件返回默认配置，AgentRegistry 空目录安全），不 mock
-// service 内核；pi 仅在 initSession 场景以最小 duck-typed mock 注入。
-
-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";
-
-// MF-4：barrel 可达性用例的命名空间导入——「仅凭 src/index.ts 导入」的字面载体
-//（不经深路径），证明第三宿主按文档用法可构造。
-import * as subagentCore from "../../index.ts";
-import { EngineError } from "../engine/common/errors.ts";
-import { EngineNotFoundError } from "../engine/registry.ts";
-import { ZcodePrepareError } from "../engine/engines/zcode/preparer.ts";
-import { ZcodeReaderError } from "../engine/engines/zcode/reader.ts";
-import { ZcodeTaskShapeError } from "../engine/engines/zcode/zcode-engine.ts";
-import { ModelConfigService } from "../model-config-service.ts";
-import {
-  SUBAGENT_RECORD_CUSTOM_TYPE,
-  toSubagentRecordEntry,
-} from "../record-entry.ts";
-import { RecordStore } from "../record-store.ts";
-import { createSubagentService, getSubagentService } from "../subagent-service.ts";
-import {
-  DirtyWorktreeError,
-  ForkDepthExceededError,
-  ResurrectDeniedError,
-} from "../types.ts";
-import { GitRunError as WorktreeManagerGitRunError } from "../worktree-manager.ts";
-import { GitRunError as WorktreeGitOpsGitRunError } from "../worktree-git-ops.ts";
-
-// ── 工具：tmpdir agentDir + 真实 ModelConfigService（第三宿主自备的最小依赖集）──
-
-function makeAgentDir(): string {
-  return fs.mkdtempSync(path.join(os.tmpdir(), "exec-runtime-face-"));
-}
-
-function makeModelService(agentDir: string): ModelConfigService {
-  // cwd 为 ModelConfigServiceInit 必填键（与 agentDir 同指 tmp 目录；构造期仅消费 agentDir）
-  return new ModelConfigService({ agentDir, cwd: agentDir });
-}
-
-/** 最小 PiLike duck-type（initSession 场景用；本文件不触发真实 pi 调用）。 */
-function makePi() {
-  return {
-    appendEntry: vi.fn(),
-    events: { emit: vi.fn() },
-    sendMessage: vi.fn(),
-  };
-}
-
-describe("execution 运行时面（U10① D6）", () => {
-  let agentDir: string;
-
-  beforeEach(() => {
-    agentDir = makeAgentDir();
-  });
-
-  afterEach(() => {
-    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
-  });
-
-  // ============================================================
-  // ① createSubagentService 工厂：参数注入构造（第三宿主最小构造示例主体）
-  // ============================================================
-  describe("createSubagentService 工厂（参数注入构造）", () => {
-    it("仅凭参数注入构造成功，不读写全局单例槽位（无全局查找）", () => {
-      // 前置：全局槽位为空（工厂与 getSubagentService/setSubagentService 单例流程解耦）
-      expect(getSubagentService()).toBeNull();
-
-      const service = createSubagentService({
-        cwd: agentDir,
-        modelService: makeModelService(agentDir),
-      });
-
-      // 构造产物可用（实例方法存在）且未被登记进全局单例槽位——
-      // session_start 单例流程行为零改动，宿主自持实例。
-      expect(typeof service["lookupRecordAnyState"]).toBe("function");
-      expect(getSubagentService()).toBeNull();
-    });
-
-    it("构造后即可调用按 id 全态查询面：空 store 返回 undefined（未 initSession 按「不存在」处理）", () => {
-      const service = createSubagentService({
-        cwd: agentDir,
-        modelService: makeModelService(agentDir),
-      });
-
-      // lookupRecordAnyState 契约：未初始化/disposed 时 assertReady 抛错 → 按「不存在」处理返回 undefined
-      expect(service["lookupRecordAnyState"]("no-such-record")).toBeUndefined();
-    });
-
-    it("initSession（宿主注入最小 pi mock）后查询面同型可用", () => {
-      const service = createSubagentService({
-        cwd: agentDir,
-        modelService: makeModelService(agentDir),
-      });
-      service.initSession({ pi: makePi(), sessionId: "s1" });
-
-      expect(service["lookupRecordAnyState"]("no-such-record")).toBeUndefined();
-      service.dispose();
-    });
-  });
-
-  // ============================================================
-  // ② record 状态查询面：按状态枚举 / 按 id（RecordStore 公共构造）
-  // ============================================================
-  describe("record 状态查询面（RecordStore）", () => {
-    it("按状态枚举查询：空 store 下 listRunning 与 collectRecords 返回空数组", () => {
-      const sessionsDir = path.join(agentDir, "sessions");
-      fs.mkdirSync(sessionsDir, { recursive: true });
-      const store = new RecordStore(sessionsDir);
-
-      expect(store.listRunning()).toEqual([]);
-      expect(store.collectRecords(10, "all", undefined)).toEqual([]);
-      expect(store.collectRecords(10, "running", undefined)).toEqual([]);
-    });
-
-    it("按 id 查询：findLightById / getFullRecord / getMutable 对缺失 id 均返回 undefined", () => {
-      const sessionsDir = path.join(agentDir, "sessions");
-      fs.mkdirSync(sessionsDir, { recursive: true });
-      const store = new RecordStore(sessionsDir);
-
-      expect(store.findLightById("missing-id")).toBeUndefined();
-      expect(store.getFullRecord("missing-id")).toBeUndefined();
-      expect(store.getMutable("missing-id")).toBeUndefined();
-    });
-  });
-
-  // ============================================================
-  // ③ 错误类型族：instanceof 分流（导出形态 = 宿主可程序化判别）
-  // ============================================================
-  describe("错误类型族 instanceof", () => {
-    it("EngineError：code 前缀 message + 结构化投影", () => {
-      const err = new EngineError("model_not_available", "no provider", "pick another model");
-      expect(err).toBeInstanceOf(Error);
-      expect(err).toBeInstanceOf(EngineError);
-      expect(err.message).toBe("model_not_available: no provider");
-      expect(err.toStructured()).toEqual({
-        code: "model_not_available",
-        message: "model_not_available: no provider",
-        recovery: "pick another model",
-      });
-    });
-
-    it("EngineNotFoundError：携带 engineId / registered / source 供分流", () => {
-      const err = new EngineNotFoundError("nope", ["pi", "zcode"], "agent.md");
-      expect(err).toBeInstanceOf(Error);
-      expect(err).toBeInstanceOf(EngineNotFoundError);
-      expect(err.code).toBe("engine_not_found");
-      expect(err.engineId).toBe("nope");
-      expect(err.registered).toEqual(["pi", "zcode"]);
-      expect(err.source).toBe("agent.md");
-    });
-
-    it("zcode 引擎错误族：ZcodePrepareError / ZcodeReaderError / ZcodeTaskShapeError", () => {
-      const prepare = new ZcodePrepareError("model_not_available", "model gone");
-      expect(prepare).toBeInstanceOf(Error);
-      expect(prepare).toBeInstanceOf(ZcodePrepareError);
-      expect(prepare.code).toBe("model_not_available");
-
-      const reader = new ZcodeReaderError("db missing", "check journal");
-      expect(reader).toBeInstanceOf(Error);
-      expect(reader).toBeInstanceOf(ZcodeReaderError);
-
-      // [U10①] 原 class 未导出（仅内部 throw），本断言钉住 export 补齐后宿主可 instanceof
-      const shape = new ZcodeTaskShapeError("capability_unsupported", "no schema");
-      expect(shape).toBeInstanceOf(Error);
-      expect(shape).toBeInstanceOf(ZcodeTaskShapeError);
-      expect(shape.code).toBe("capability_unsupported");
-      expect(shape.name).toBe("ZcodeTaskShapeError");
-    });
-
-    it("执行守卫错误族：ResurrectDeniedError / ForkDepthExceededError / DirtyWorktreeError", () => {
-      const resurrect = new ResurrectDeniedError();
-      expect(resurrect).toBeInstanceOf(Error);
-      expect(resurrect).toBeInstanceOf(ResurrectDeniedError);
-
-      const forkDepth = new ForkDepthExceededError("depth > max");
-      expect(forkDepth).toBeInstanceOf(Error);
-      expect(forkDepth).toBeInstanceOf(ForkDepthExceededError);
-
-      const dirty = new DirtyWorktreeError("uncommitted changes");
-      expect(dirty).toBeInstanceOf(Error);
-      expect(dirty).toBeInstanceOf(DirtyWorktreeError);
-    });
-
-    it("GitRunError 两处同名列（worktree-manager / worktree-git-ops）各自可 instanceof", () => {
-      const fromManager = new WorktreeManagerGitRunError("git fail", { exitCode: 1 });
-      expect(fromManager).toBeInstanceOf(Error);
-      expect(fromManager).toBeInstanceOf(WorktreeManagerGitRunError);
-      expect(fromManager).not.toBeInstanceOf(WorktreeGitOpsGitRunError);
-
-      const fromGitOps = new WorktreeGitOpsGitRunError("git fail", { exitCode: 128 });
-      expect(fromGitOps).toBeInstanceOf(Error);
-      expect(fromGitOps).toBeInstanceOf(WorktreeGitOpsGitRunError);
-      expect(fromGitOps).not.toBeInstanceOf(WorktreeManagerGitRunError);
-    });
-  });
-
-  // ============================================================
-  // ④ record-entry 自描述 entry 面（导出形态确认；投影逐字段等值由
-  //    execution-record.test.ts 钉住，此处不重复）
-  // ============================================================
-  describe("record-entry 面", () => {
-    it("SUBAGENT_RECORD_CUSTOM_TYPE 值契约：'subagent-record'", () => {
-      expect(SUBAGENT_RECORD_CUSTOM_TYPE).toBe("subagent-record");
-    });
-
-    it("toSubagentRecordEntry 可达且对最小 SubagentRecord 投影出 v===1", () => {
-      const entry = toSubagentRecordEntry({
-        id: "r1",
-        agent: "a.md",
-        task: "t",
-        slug: "s",
-        status: "running",
-        mode: "background",
-        startedAt: 1,
-        rootSessionId: undefined,
-        parentRecordId: undefined,
-        depth: 0,
-        endedAt: undefined,
-        turns: 0,
-        totalTokens: 0,
-        model: "m",
-        thinkingLevel: undefined,
-        eventLog: [],
-        displayItems: [],
-      });
-      expect(entry.v).toBe(1);
-      expect(entry.id).toBe("r1");
-    });
-  });
-
-  // ============================================================
-  // ⑤ barrel 可达性（MF-4）：仅凭 src/index.ts 导入完成第三宿主构造
-  //    （SubagentServiceInit.modelService: ModelConfigService——构造依赖
-  //    与 jsdoc 示例引用的访问器必须全部从 barrel 可达）
-  // ============================================================
-  describe("barrel 可达性（仅凭 src/index.ts 导入，MF-4）", () => {
-    it("ModelConfigService / getModelConfigService / createSubagentService 从 barrel 可达并可构造", () => {
-      // 符号面：类与访问器均为函数（导出存在性）
-      expect(typeof subagentCore.ModelConfigService).toBe("function");
-      expect(typeof subagentCore.getModelConfigService).toBe("function");
-
-      // 进程单例槽位未被本文件写入（同 ① 的全局查找断言口径）
-      expect(subagentCore.getModelConfigService()).toBeNull();
-
-      // 运行时可达：仅凭 barrel 符号完成参数注入构造（ModelConfigServiceInit
-      // = { cwd, agentDir }，指向 tmp 目录——loadGlobalConfig 对不存在文件
-      // 返回默认配置，AgentRegistry 空目录安全，同文件头既有 stub 口径）
-      const modelService = new subagentCore.ModelConfigService({ cwd: agentDir, agentDir });
-      const service = subagentCore.createSubagentService({ cwd: agentDir, modelService });
-
-      // 构造产物可用（实例方法存在），且不写进程单例槽位（第三宿主自持实例）
-      expect(typeof service["lookupRecordAnyState"]).toBe("function");
-      expect(subagentCore.getModelConfigService()).toBeNull();
-    });
-  });
-});

package/src/execution/__tests__/get-state-handshake.test.ts

@@ -1,127 +0,0 @@
-// src/execution/__tests__/get-state-handshake.test.ts
-//
-// [T1/RC-1] requestGetStateOnce 单测：agent_end 决策点惰性回补用的单次 get_state 请求辅助。
-//
-// 契约锚点（与 performGetStateHandshake 共用消息构造 sendGetStateCommand + 字段提取
-// extractGetStateFields，但不做重试循环）：
-//   1. response 到达 → resolve 提取后的 GetStateResult（无条件 finish，单次语义无重试）；
-//   2. 超时 → resolve 空对象（调用方走保守分支）；
-//   3. stdin 同步写失败（EPIPE 形态）→ resolve 空对象、永不 reject（fire-and-forget 契约）；
-//   4. 自清理：finish 后从监听表注销本请求 resolver（消费注册器返回的注销函数）；
-//      注册器不返回注销函数时退化为 no-op（与握手同形态）。
-//
-// performGetStateHandshake 既有行为由 run-spawn-rpc-mode.test.ts 集成覆盖，此处不重复。
-
-import { describe, expect, it, vi } from "vitest";
-
-import { requestGetStateOnce } from "../engine/engines/pi/get-state-handshake.ts";
-import type { ChildProcess } from "node:child_process";
-
-/** 最小 FakeChild：只需 stdin.write 行为（成功 / 可注入同步 throw）。 */
-function makeFakeStdin(behavior?: { throwOnWrite?: Error }): { child: ChildProcess; writes: string[] } {
-  const writes: string[] = [];
-  const child = {
-    stdin: {
-      write(line: string): boolean {
-        if (behavior?.throwOnWrite) throw behavior.throwOnWrite;
-        writes.push(line);
-        return true;
-      },
-    },
-  } as unknown as ChildProcess;
-  return { child, writes };
-}
-
-/** 可控的监听表：模拟 stdout pump 的 get_stateListeners（注册返回注销函数）。 */
-function makeListenerRegistry() {
-  const resolvers = new Map<string, (data: unknown) => void>();
-  const removed: string[] = [];
-  const add = (id: string, resolver: (data: unknown) => void) => {
-    resolvers.set(id, resolver);
-    return () => {
-      if (resolvers.get(id) === resolver) resolvers.delete(id);
-      removed.push(id);
-    };
-  };
-  return { resolvers, removed, add };
-}
-
-describe("requestGetStateOnce（[T1/RC-1] 惰性回补单次请求）", () => {
-  it("response 到达 → resolve 提取的 sessionFile/sessionId，并从监听表注销", async () => {
-    const { child, writes } = makeFakeStdin();
-    const reg = makeListenerRegistry();
-
-    const promise = requestGetStateOnce(child, reg.add, 1000);
-    // 消息构造：单行 JSON {id, type:"get_state"}（与 performGetStateHandshake 同一 sendGetStateCommand）
-    expect(writes).toHaveLength(1);
-    const sent = JSON.parse(writes[0]!) as { id: string; type: string };
-    expect(sent.type).toBe("get_state");
-    expect(reg.resolvers.has(sent.id)).toBe(true);
-
-    // response 到达（含空串 sessionFile 应被过滤的字段形态覆盖提取规则）
-    reg.resolvers.get(sent.id)?.({
-      sessionFile: "/tmp/sessions/abc.jsonl",
-      sessionId: "sess-1",
-    });
-
-    await expect(promise).resolves.toEqual({
-      sessionFile: "/tmp/sessions/abc.jsonl",
-      sessionId: "sess-1",
-    });
-    // 自清理：finish 后从监听表移除本请求 resolver
-    expect(reg.resolvers.has(sent.id)).toBe(false);
-    expect(reg.removed).toEqual([sent.id]);
-  });
-
-  it("response 只含部分字段（仅 sessionId）→ resolve 已提取部分（单次语义：到达即 finish，不等重试）", async () => {
-    const { child } = makeFakeStdin();
-    const reg = makeListenerRegistry();
-
-    const promise = requestGetStateOnce(child, reg.add, 1000);
-    const id = reg.resolvers.keys().next().value as string;
-    reg.resolvers.get(id)?.({ sessionId: "only-id" });
-
-    await expect(promise).resolves.toEqual({ sessionId: "only-id" });
-  });
-
-  it("超时无 response → resolve 空对象（不 reject，不调注销前的 resolver）", async () => {
-    vi.useFakeTimers();
-    try {
-      const { child } = makeFakeStdin();
-      const reg = makeListenerRegistry();
-
-      const promise = requestGetStateOnce(child, reg.add, 1000);
-      await vi.advanceTimersByTimeAsync(1000);
-
-      await expect(promise).resolves.toEqual({});
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-
-  it("stdin 同步写失败（EPIPE code，writeStdinLine rethrow 路径）→ 立即 resolve 空对象、永不 reject", async () => {
-    // writeStdinLine 只对 code 为 EPIPE / ERR_STREAM_DESTROYED 的错误 rethrow（[R3]），
-    // requestGetStateOnce 的 catch 捕获后按「回补失败」resolve 空对象（同超时语义）。
-    const epipeErr = Object.assign(new Error("write after end"), { code: "EPIPE" });
-    const { child } = makeFakeStdin({ throwOnWrite: epipeErr });
-    const reg = makeListenerRegistry();
-
-    await expect(requestGetStateOnce(child, reg.add, 1000)).resolves.toEqual({});
-    // 写失败路径不注册监听（未发出请求）
-    expect(reg.resolvers.size).toBe(0);
-  });
-
-  it("注册器不返回注销函数（void 形态，对齐旧握手调用方）→ 正常 resolve 不抛", async () => {
-    const { child } = makeFakeStdin();
-    const resolvers = new Map<string, (data: unknown) => void>();
-    const addVoid = (id: string, resolver: (data: unknown) => void): void => {
-      resolvers.set(id, resolver);
-    };
-
-    const promise = requestGetStateOnce(child, addVoid, 1000);
-    const id = resolvers.keys().next().value as string;
-    resolvers.get(id)?.({ sessionFile: "/tmp/x.jsonl" });
-
-    await expect(promise).resolves.toEqual({ sessionFile: "/tmp/x.jsonl" });
-  });
-});