@zhushanwen/subagent-core 0.7.1 → 0.9.0

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

@@ -1,20 +1,18 @@
 // src/execution/__tests__/subagent-service-recovery-bounds.test.ts
 //
 // [u-svc / T2] 服务侧回收上界与 kill 收敛：
-//   - T2④/LC-2：closeChatIdle / closeAfterRoundSettled / cancelBackground 三条终止路径
-//     收敛到 killRecordChildWithEscalation（spy 断言调用点与参数）+ [W3] 引擎侧终止
-//     意图（协议 interact cancel/close fire-and-forget）；
+//   - T2④/LC-2：closeChatIdle / cancelBackground 终止路径收敛到
+//     killRecordChildWithEscalation（spy 断言调用点与参数）；
 //   - T2⑥/PS-1：disposeAllRecords 补三回收面（controller.abort + kill + disarm idle timer
 //     + disarm settled watchdog）；
-//   - T2③/LC-1 + D9：热路径投递 armMidRoundNoProgress（挂载点在编排层
-//     deliverChatMessage 的 interact 受理点；中段无进展检测 + 到期处置：kill + 失败
-//     终态化 + error 含 'settled watchdog' 标记与恢复指引）。
+//   - T2③/LC-1 + D9：Continuation 轮 armMidRoundNoProgress（挂载点在 kickOffChatRound
+//     轮开跑；中段无进展检测 + 到期处置经 Continuation.onWatchdogFire → run 收敛失败
+//     分支统一收口，error 含 'settled watchdog' 标记与恢复指引）。
 //
-// [W3 改写] 替身从 inproc session-runner/stdin-writer mock 改为协议 seam
-//（registerFakePiEngine）：投递 = engine.interact(message) 受理；终止意图 =
-// engine.interact(cancel/close)。T2⑧（非 EPIPE 写失败 re-arm idle timer）随
-// inproc pi 引擎目录 删除归 pi-subagent-cli 包内（写失败语义在引擎进程内，core 已无
-// 可泄漏的本地方案进程），core 侧不再可等价改写。
+// [W3 改写 → H1 U6] 替身 = 协议 seam（registerFakePiEngine）。[H1 U6] interact 断言
+//（cancel/close 终止意图受理）随 interact 面退役删除：真实杀链 = 轮级 abort signal →
+// 协议 cancel 帧（引擎侧杀链）+ 镜像置死记账 + 引擎退出链收割（红线①）；
+// closeAfterRoundSettled 用例随载体退役删除（T2⑧ 段同前批登记归 pi 包）。
 //
 // mock 形态：真实 SubagentService + ServiceInternals cast 暴露 store + logger +
 // spawned-children 的 kill 入口换 spy（importOriginal 保留镜像真实现）。
@@ -47,7 +45,9 @@ import type { PiLike } from "../subagent-service.ts";
 import { armSettledWatchdog, hasSettledWatchdog, SETTLED_MID_ROUND_NO_PROGRESS_MS, _resetSettledWatchdogsForTest } from "../settled-watchdog.ts";
 import { armIdleTimer, hasIdleTimer, _resetLifecycleState } from "../lifecycle-manager.ts";
 import { _resetCoreSpawnedChildrenMirrorForTest } from "../engine/host/spawned-children.ts";
-import type { ExecutionRecord } from "../types.ts";
+// AgentResult = execution 层那份（execution/types.ts:259，主字段 text/turns/sessionId），
+// 与 acquirePoolOrFinalize 签名一致；engine/types.ts 只有消歧注释无此导出。
+import type { AgentResult, ExecutionRecord } from "../types.ts";
 
 function makeTmpAgentDir(): string {
   return fs.mkdtempSync(path.join(os.tmpdir(), "svc-recovery-bounds-"));
@@ -102,23 +102,21 @@ function privateFn<K extends string>(service: SubagentService, key: K): (...args
 }
 
 /**
- * message 投递入口（[W3] 协议形态：编排层私有 deliverChatMessage → engine.interact(message)；
- * 冷路径 = engine_session_not_resumable → run chat + resume）。
+ * message 投递入口（[H1 U6] Continuation 编排：deliverChatMessage → onMessage →
+ * 新 run + resume 锚点）。
  */
 async function deliverChat(
   service: SubagentService,
   record: ExecutionRecord,
   text: string,
-  interrupt: boolean,
 ): Promise<void> {
   return (
     privateFn(service, "deliverChatMessage") as (
       this: SubagentService,
       r: ExecutionRecord,
       t: string,
-      i: boolean,
     ) => Promise<void>
-  ).call(service, record, text, interrupt);
+  ).call(service, record, text);
 }
 
 describe("T2④ service-side kill convergence", () => {
@@ -149,10 +147,8 @@ describe("T2④ service-side kill convergence", () => {
     const ok = service.cancel(record.id);
     expect(ok).toBe(true);
     expect(killChildSpy).toHaveBeenCalledWith(record.id, "cancelBackground");
-    // [W3] 实际终止在引擎进程内：协议 interact cancel fire-and-forget
-    await vi.waitFor(() => {
-      expect(fake.interacts.some((c) => c.action.kind === "cancel")).toBe(true);
-    });
+    // [H1 U6] 在途 run 的实际终止经 controller.abort → 轮级 signal（cancel 帧 + 杀链）；
+    // 旧 interact cancel 受理断言随 interact 面退役。
   });
 
   it("closeChatIdle (via closeSubagent force:false on idle) routes through killRecordChildWithEscalation and disarms timers", async () => {
@@ -164,19 +160,8 @@ describe("T2④ service-side kill convergence", () => {
     expect(killChildSpy).toHaveBeenCalledWith(record.id, "closeChatIdle");
     expect(hasIdleTimer(record.id)).toBe(false);
     expect(hasSettledWatchdog(record.id)).toBe(false);
-    // [W3] 引擎侧 close force（idle 进程回收）
-    await vi.waitFor(() => {
-      const close = fake.interacts.find((c) => c.action.kind === "close");
-      expect(close?.action).toMatchObject({ kind: "close", payload: { force: true } });
-    });
-  });
-
-  it("closeAfterRoundSettled routes through killRecordChildWithEscalation", async () => {
-    const record = makeRecord({ id: "sa-close-round" });
-    await (
-      privateFn(service, "closeAfterRoundSettled") as (this: SubagentService, r: ExecutionRecord) => Promise<void>
-    ).call(service, record);
-    expect(killChildSpy).toHaveBeenCalledWith(record.id, "closeAfterRoundSettled");
+    // [H1 U6] 旧引擎侧 close force 受理断言随 interact 面退役（无在跑轮无需进程回收，
+    // Path A 保活进程由镜像记账 + reaper 兜底回收）。
   });
 
   it("disposeAllRecords applies all recovery surfaces: abort + escalation kill + disarm idle/settled timers", () => {
@@ -230,42 +215,134 @@ describe("T2③ hot-path settled watchdog", () => {
   });
 
   it("arms the settled watchdog after a successful hot-path prompt", async () => {
-    const record = makeRecord({ id: "sa-hot-arm" });
+    // [H1 U2] deliverChatMessage = Continuation 派发（续聊轮需 sessionFile 锚点）
+    const record = makeRecord({ id: "sa-hot-arm", sessionFile: path.join(agentDir, "sa-hot-arm.jsonl") });
+    fs.writeFileSync(record.sessionFile!, "{}\n", "utf-8");
     store.register(record);
-    await deliverChat(service, record, "hello", false);
-    expect(fake.interacts.length).toBe(1);
+    await deliverChat(service, record, "hello");
+    await vi.waitFor(() => expect(fake.runs.length).toBe(1));
     expect(hasSettledWatchdog(record.id)).toBe(true);
   });
 
-  it("onMidTimeout: kills the child (engine cancel), fails the round, error carries 'settled watchdog' marker and recovery hint", async () => {
+  it("onMidTimeout: kills the child (engine cancel + round abort), fails the round via run settlement, error carries 'settled watchdog' marker and recovery hint", async () => {
     // fake timers 必须先于 arm 生效（useFakeTimers 不接管已存在的真实 timer）
     vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
-    const record = makeRecord({ id: "sa-hot-timeout" });
+    // [H1 U2] Continuation 轮需要 sessionFile 锚点
+    const record = makeRecord({ id: "sa-hot-timeout", sessionFile: path.join(agentDir, "sa-hot-timeout.jsonl") });
+    fs.writeFileSync(record.sessionFile!, "{}\n", "utf-8");
     store.register(record);
-    await deliverChat(service, record, "hello", false);
+    await deliverChat(service, record, "hello");
+    await vi.waitFor(() => expect(fake.runs.length).toBe(1));
     expect(hasSettledWatchdog(record.id)).toBe(true);
 
-    // [D9 两段式] 热路径 prompt 发出后挂中段：静默满中段窗长触发（本测试替身不驱动
-    // 协议事件，中段静默形态直达）
+    // [D9 两段式] 轮开跑后挂中段：静默满中段窗长触发（本测试替身不驱动协议事件，
+    // 中段静默形态直达）
     await vi.advanceTimersByTimeAsync(SETTLED_MID_ROUND_NO_PROGRESS_MS + 1);
 
-    // kill 收敛入口被触发（onTimeout 第一步）
-    expect(killChildSpy).toHaveBeenCalledWith(record.id, "settled watchdog (hot path)");
+    // kill 收敛入口被触发（[H1 U2] Continuation watchdog fire → killRoundChildForWatchdog，
+    // source 含 phase 名——旧 onHotPathSettledWatchdogTimeout 的 "(hot path)" 标记退役）
+    expect(killChildSpy).toHaveBeenCalledWith(record.id, "settled watchdog (mid-round)");
     // watchdog 到期自清（armedTimers 先删条目再执行回调）
     expect(hasSettledWatchdog(record.id)).toBe(false);
-    // 该轮失败终态化（chatMode → MF-6 回退 resumable）+ 失败通知
-    expect(record.resumable).toBe(true);
+    // [H1 U2] fire abort 轮 signal → 在途 run 收敛（替身模拟 abort 合成失败终态）→
+    // onRunSettled 失败分支簿记（chatMode → MF-6 回退 resumable）+ 失败通知
+    fake.runs[0]!.settle({
+      content: "",
+      error: "engine_run_failed: run aborted (settled watchdog mid-round no-progress); the process was terminated to bound the wait. Recovery: check state with subagents action:'list', then re-send your message to continue.",
+      exitCode: null,
+    });
+    await vi.waitFor(() => expect(record.resumable).toBe(true));
     expect(record.status).toBe("running");
-    expect(record.result).toContain("settled watchdog");
-    expect(record.result).toContain("Recovery");
-    expect(record.result).toContain("action:'list'");
-    // 失败通知送达（内核直发路径）
+    // [H1 U2 / D7] 失败轮 lastError 写失败原因（result = 前值 ?? 失败摘要——失败摘要
+    // 由 Continuation 失败通知独立承载）
+    expect(record.lastError).toContain("settled watchdog");
+    expect(record.lastError).toContain("Recovery");
+    expect(record.lastError).toContain("action:'list'");
+    // 失败通知送达（Continuation 独立载荷——正文带失败摘要与恢复指引）
     expect(pi.sendMessage).toHaveBeenCalled();
     const sendMessageCalls = (pi.sendMessage as unknown as ReturnType<typeof vi.fn>).mock.calls as Array<[{ content?: string }]>;
     const notifyContent = sendMessageCalls[0]?.[0]?.content ?? "";
     expect(notifyContent).toContain("settled watchdog");
-    // [W3] 引擎侧终止意图（fire-and-forget；fake timers 下只断言受理动作已发出）
-    const cancel = fake.interacts.find((c) => c.action.kind === "cancel");
-    expect(cancel).toBeDefined();
+    // [H1 U6] 引擎侧终止意图（watchdog fire 的 cancel 受理断言）随 interact 面退役——
+    // fire 的真实 kill = killRoundChildForWatchdog（镜像置死）+ abort 轮 signal → cancel 帧。
+  });
+});
+
+// ── [S11] 残余守卫分支：cancel tombstone 幂等 / 池排队 abort / record-access 越界 ──
+
+describe("S11 守卫分支组", () => {
+  let agentDir: string;
+  let service: SubagentService;
+  let store: RecordStore;
+  let pi: MockPi;
+  let fake: FakePiEnginePort;
+
+  beforeEach(() => {
+    vi.restoreAllMocks();
+    killChildSpy.mockClear();
+    ({ agentDir, service, store, pi, fake } = setup());
+  });
+
+  afterEach(() => {
+    service.dispose();
+    clearEngines();
+    _resetLifecycleState();
+    _resetSettledWatchdogsForTest();
+    _resetCoreSpawnedChildrenMirrorForTest();
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+  });
+
+  it("cancel tombstone 幂等：已终态 record 再 cancel → CAS 未抢到返回 false（stop 手段仍执行，零收尾副作用）", async () => {
+    const record = makeRecord({ id: "sa-tombstone" });
+    record.status = "closed";
+    record.closedReason = "cancelled";
+    store.register(record);
+    const emitSpy = vi.fn();
+    store.onChange(emitSpy);
+
+    const ok = service.cancel(record.id);
+
+    expect(ok).toBe(false); // CAS 未抢到：覆写终态 + tombstone 双标 + notify 双发不可执行
+    expect(record.status).toBe("closed"); // 终态不被覆写
+    expect(record.closedReason).toBe("cancelled");
+    // stop 手段无条件先执行（cancel 语义 = 进程必死，幂等无害）
+    expect(killChildSpy).toHaveBeenCalledWith(record.id, "cancelBackground");
+    // 收尾副作用归 CAS 赢家：无 markCancelled 落盘 entry（state-write 面）
+    const stateWrites = (pi.appendEntry as unknown as ReturnType<typeof vi.fn>).mock.calls.filter(
+      (c: unknown[]) => String(c[0]).includes("state-write-failed"),
+    );
+    expect(stateWrites).toHaveLength(0);
+  });
+
+  it("排队被 abort 池分支：池满排队 + signal 已 aborted → finalizeAborted（cancelled 终态）", async () => {
+    const record = makeRecord({ id: "sa-pool-abort" });
+    store.register(record);
+    const ro = privateFn(service, "runOrchestration") as unknown as {
+      acquirePoolOrFinalize: (r: ExecutionRecord, s: AbortSignal | undefined, p: number) => Promise<AgentResult | undefined>;
+    };
+    // 先占满池（占满 effective = max(1, maxConcurrent - depth) 个槽位），迫使目标 record 排队
+    const pool = privateFn(service, "pool") as unknown as {
+      maxConcurrent: number;
+      acquire: (p: number, max?: number, s?: AbortSignal) => Promise<void>;
+      release: () => void;
+    };
+    const slots = Math.max(1, pool.maxConcurrent - record.depth);
+    for (let i = 0; i < slots; i++) await pool.acquire(0);
+    const controller = new AbortController();
+    controller.abort(); // 排队窗内 abort（pre-aborted signal → acquire reject AbortError）
+
+    const result = await ro.acquirePoolOrFinalize(record, controller.signal, 0);
+    for (let i = 0; i < slots; i++) pool.release();
+
+    // S1：排队中被 abort 走 cancelled（与已运行被 abort 一致），返回终态 result 供 early-return
+    expect(result).toBeDefined();
+    expect(record.status).toBe("closed");
+    expect(record.closedReason).toBe("cancelled");
+  });
+
+  it("record-access 越界守卫：disposed 后 lookupRecordAnyState → undefined（不抛）", async () => {
+    service.dispose();
+    const record = service.queries.lookupRecordAnyState("any-id");
+    expect(record).toBeUndefined();
   });
 });

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

@@ -1,6 +1,9 @@
 // src/__tests__/subagent-service.test.ts
 //
-// SubagentService 生命周期 + 公共 API 边界测试。
+// SubagentService 生命周期 + 公共 API 边界测试（[H3/R5 测试归位] 本文件为壳级测试：
+// 装配 / dispose 编排 / 转发面 / 跨域 emit 记账。run 域 execute 入口用例已迁
+// run-orchestration.test.ts；ModelConfigService ctxModel 缓存已迁
+// model-config-service.test.ts）。
 //
 // 范围:initSession / dispose / query / cancel / listRunning / collectRecords /
 // onChange / assertReady -- 这些不依赖动态 import Pi SDK(getSdk)。
@@ -19,13 +22,14 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import { createRecord } from "../execution-record.ts";
 import { ModelConfigService } from "../model-config-service.ts";
-import type { ModelInfo, ModelRegistryLike } from "../model-resolver.ts";
+import type { ModelInfo } from "../model-resolver.ts";
 import type { RecordStore } from "../record-store.ts";
 import type { UiRequest, UiRequestHandler } from "../dialog-queue.ts";
 import type { PiLike } from "../subagent-service.ts";
-import { getSubagentService, setSubagentService,SubagentService } from "../subagent-service.ts";
+import { SubagentService } from "../subagent-service.ts";
+// [H3/R6] 单例访问器外移支撑文件 service/service-bootstrap.ts（壳不再导出）。
+import { getSubagentService, setSubagentService } from "../service/service-bootstrap.ts";
 import type { ExecutionRecord } from "../types.ts";
-import type { WorktreeManager } from "../worktree-manager.ts";
 
 // ── 工具:建临时 agentDir + 真实 ModelConfigService ──
 
@@ -331,9 +335,11 @@ describe("SubagentService", () => {
   // private 字段，用 Reflect.get 取（与 R0-D 块访问 store 同模式）。
 
   describe("dispose uiRequestHandler stub (dispose-cleanup)", () => {
-    /** 从 service 取出 private uiRequestHandler（trailing ui_request 实际调用入口）。 */
+    /** 从 service 取出 private uiRequestHandler（trailing ui_request 实际调用入口）。
+     *  [R1 深绑改写] uiRequestHandler 随域 #2 聚合迁入 SessionBaselines，深绑路径改为
+     *  service → baselines 聚合实例（断言对象与强度不变，路径对齐终态结构）。 */
     function getHandler(service: SubagentService): UiRequestHandler | undefined {
-      return Reflect.get(service, "uiRequestHandler") as UiRequestHandler | undefined;
+      return (Reflect.get(service, "baselines") as { uiRequestHandler: UiRequestHandler | undefined }).uiRequestHandler;
     }
 
     /** 最小 UiRequest（method 无关紧要——stub 不论 method 一律返回 cancelled）。 */
@@ -387,136 +393,11 @@ describe("SubagentService", () => {
   });
 
   // ============================================================
-  // execute() worktree 路径（worktree 与 fork 解耦后）
+  // execute() worktree 路径（worktree 与 fork 解耦）
+  // → [H3/R5 测试归位] 整块迁至 run-orchestration.test.ts（run 域聚合同名域测试
+  //   文件；用例名与断言零改动）。此处不留转发桩——vitest 按文件发现，无注册面。
   // ============================================================
-  //
-  // worktree（文件隔离）与 fork（上下文继承）已解耦：worktree:true 可独立于 fork 工作
-  // （worktreeManager.create 只看 opts.worktree，不读 fork）。此组验证三种 fork/worktree
-  // 组合下 worktree 路径的行为（均不应抛 'requires fork'——该 guard 已移除）：
-  //   1. worktree:true + fork:false → 解耦后正常（创建 worktree 路径，不抛 requires fork）
-  //   2. worktree:true + fork:true  → 创建 worktree 路径（测试环境 git 失败，抛非 requires fork 错）
-  //   3. worktree:false + fork:false → 默认路径（不创建 worktree）
-  //
-  // 本文件不 mock spawn（保持与文件头声明一致——execute 集成测试在 execute-nesting /
-  // run-spawn-integration），因此 case 验证「不抛 requires fork」而非「执行完成」：
-  // 执行越过 worktree 创建后在后续步骤（worktreeManager.create 调 git / runSpawn 调
-  // spawn）抛与 fork/worktree 无关的错。用 try/catch 断言抛出的不是 requires fork。
-
-  describe("execute() worktree 路径（worktree 与 fork 解耦）", () => {
-    /** 构造已就绪的 service（initSession + initModel 注入 ctxModel，使 resolveIdentity 不因 model 拗错）。 */
-    function makeReadyService(): SubagentService {
-      const service = new SubagentService({ cwd: agentDir, modelService });
-      service.initSession({ pi: makePi(), sessionId: "s1" });
-      // 注入 modelRegistry + ctxModel：让 resolveIdentity 越过 resolveModel，
-      // 使 guard 之后的失败点稳定在 worktreeManager.create（git）或 runSpawn（spawn），
-      // 而非 modelService.resolveModel——避免与 guard 无关的 model 错误掩盖被测点。
-      modelService.initModel({
-        modelRegistry: {
-          getAvailable: () => [],
-          find: () => undefined,
-          hasConfiguredAuth: () => false,
-        },
-        sessionId: "s1",
-        ctxModel: { id: "ctx-model", name: "Ctx", provider: "p", reasoning: false },
-      });
-      return service;
-    }
-
-    it("worktree:true + fork:false → 解耦后不抛 'requires fork'（worktree 独立于 fork）", async () => {
-      const service = makeReadyService();
-      // 解耦后 worktree:true+fork:false 不再 throw requires fork（worktreeManager.create 只看 worktree）
-      try {
-        await service.execute({
-          task: "worktree without fork (decoupled)",
-          slug: "test",
-          worktree: true,
-          fork: false,
-          ctxModel: { id: "ctx-model", name: "Ctx", provider: "p", reasoning: false },
-        });
-      } catch (err) {
-        // 解耦后绝不抛 requires fork（执行继续到 worktreeManager.create/spawn 才可能抛其他错）
-        expect((err as Error).message).not.toMatch(/requires fork/);
-      }
-    });
-
-    it("worktree:true + fork:true → 创建 worktree 路径（不抛 'requires fork'）", async () => {
-      const service = makeReadyService();
-      // 执行继续：先创建 record，然后 worktreeManager.create 调 git（测试环境无 repo → 抛与 fork 无关的错）
-      try {
-        await service.execute({
-          task: "worktree with fork",
-          slug: "test",
-          worktree: true,
-          fork: true,
-          ctxModel: { id: "ctx-model", name: "Ctx", provider: "p", reasoning: false },
-        });
-        // 若未抛（理论上 worktreeManager.create 在某些环境成功）也 OK——重点是没命中 guard
-      } catch (err) {
-        // guard 放行：抛出的错误绝不能是 "requires fork"
-        expect((err as Error).message).not.toMatch(/requires fork/);
-      }
-    });
-
-    it("worktree:false + fork:false → 默认路径（不创建 worktree，不抛 'requires fork'）", async () => {
-      const service = makeReadyService();
-      // 默认路径：runSpawn 调 child_process.spawn（测试环境无真实 pi → 抛与 fork 无关的错）
-      try {
-        await service.execute({
-          task: "default path",
-          slug: "test",
-          worktree: false,
-          fork: false,
-          ctxModel: { id: "ctx-model", name: "Ctx", provider: "p", reasoning: false },
-        });
-      } catch (err) {
-        // guard 放行：抛出的错误绝不能是 "requires fork"
-        expect((err as Error).message).not.toMatch(/requires fork/);
-      }
-    });
 
-    // ============================================================
-    // create-await 竞态守卫（Phase 2）：create 的 await 窗口内 dispose/cancel
-    // 可把 record CAS 成 closed——守卫须主动 cleanup + early-failed 返回，不 kickOff。
-    // 实现约束固化：「赋值 record.worktreeHandle → 终态检查 → 轮次 kick-off」
-    // 必须同一同步段（中间禁止 await），本用例即该不变量的回归锚点。
-    // ============================================================
-    it("守卫：create await 窗口内 dispose 抢先 → cleanup 被调 + early-failed 返回（不 kickOff）", async () => {
-      const service = makeReadyService();
-      const wtm = Reflect.get(service, "worktreeManager") as WorktreeManager;
-      const handle = Object.freeze({
-        path: "/tmp/wt-guard",
-        branch: "pi-sub-guard",
-        baseCommit: "abc123",
-        mainCwd: "/repo",
-      }) as Parameters<WorktreeManager["cleanup"]>[0];
-      let resolveCreate!: (h: unknown) => void;
-      vi.spyOn(wtm, "create").mockImplementation(
-        () => new Promise<unknown>((r) => { resolveCreate = r; }) as ReturnType<WorktreeManager["create"]>,
-      );
-      const cleanupSpy = vi.spyOn(wtm, "cleanup").mockResolvedValue(undefined);
-
-      const execP = service.execute({
-        task: "guard test",
-        slug: "test",
-        worktree: true,
-        fork: false,
-        ctxModel: { id: "ctx-model", name: "Ctx", provider: "p", reasoning: false },
-      });
-      // 微任务推进：record 已建 + execute 挂在 pending create 上
-      await new Promise((r) => { setTimeout(r, 0); });
-      // dispose 抢先（无需 record id）：CAS running → closed，此时 worktreeHandle 仍
-      // undefined（dispose 的 fire-and-forget cleanup 跳过）——守卫是唯一的清理点
-      service.disposeAllRecords("parent-shutdown");
-      resolveCreate(handle);
-
-      const ret = await execP;
-      // 守卫生效：handle 被主动清理（不等 60s reaper）
-      expect(cleanupSpy).toHaveBeenCalledWith(handle);
-      // 返回 early-failed 形态（details.status 已 closed），而非 kickOff 的 running 形态
-      expect(ret.mode).toBe("background");
-      expect(ret.details).toMatchObject({ status: "closed" });
-    });
-  });
   //
   // [背景] PR #82 在 subagent-service.ts 新增 emitPendingRegister/Unregister 调用，
   // 5 个 emit 点：register（execute L309）、unregister(failed)（finalizeFailed 经
@@ -698,88 +579,9 @@ describe("SubagentService", () => {
 
 // ============================================================
 // ModelConfigService ctxModel 缓存(renderCall 标题行 model 显示的核心)
+// → [H3/R5 测试归位] 整块迁至 model-config-service.test.ts（被测主体 =
+//   ModelConfigService 模块，非 SubagentService；用例名与断言零改动）。
 // ============================================================
-//
-// [HISTORICAL] 99f20da1e 后 renderCall 拿不到主 agent model(ToolRenderContext 无 model),
-// resolveModel 第三层拗错→降级不显示 model。修复:session_start 缓存 ctxModel,
-// resolveModel 第三参默认用缓存。此测试验证该透传链路。
-
-describe("ModelConfigService ctxModel 缓存", () => {
-  let agentDir: string;
-
-  beforeEach(() => {
-    agentDir = makeTmpAgentDir();
-  });
-  afterEach(() => {
-    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
-  });
-
-  /** 最小 mock registry:空可用列表(ctxModel 路径不需要 lookup)。 */
-  function makeEmptyRegistry(): ModelRegistryLike {
-    return {
-      getAvailable: () => [],
-      find: () => undefined,
-      hasConfiguredAuth: () => false,
-    };
-  }
-
-  it("initModel 传 ctxModel 后,resolveModel 不传第三参返回缓存 model", () => {
-    const svc = makeModelService(agentDir);
-    const mainModel: ModelInfo = {
-      id: "main-model",
-      name: "Main",
-      provider: "anthropic",
-      reasoning: false,
-    };
-    svc.initModel({
-      modelRegistry: makeEmptyRegistry(),
-      sessionId: "sess-1",
-      ctxModel: mainModel,
-    });
-
-    // agent 无 model 声明 + 无 override → 走第三层 ctxModel 缓存
-    const r = svc.resolveModel("general-purpose");
-    expect(r.model).toBe(mainModel);
-    expect(r.model.provider).toBe("anthropic");
-  });
-
-  it("显式 ctxModel 参数优先于缓存(execute 路径覆盖 renderCall 缓存)", () => {
-    const svc = makeModelService(agentDir);
-    const cached: ModelInfo = { id: "cached", name: "C", provider: "p1", reasoning: false };
-    const explicit: ModelInfo = { id: "explicit", name: "E", provider: "p2", reasoning: false };
-    svc.initModel({
-      modelRegistry: makeEmptyRegistry(),
-      sessionId: "sess-1",
-      ctxModel: cached,
-    });
-
-    // execute 传显式 ctxModel → 用显式,不用缓存
-    const r = svc.resolveModel("general-purpose", undefined, explicit);
-    expect(r.model).toBe(explicit);
-  });
-
-  it("setCtxModel 刷新缓存(model_select 后 renderCall 能看到新 model)", () => {
-    const svc = makeModelService(agentDir);
-    const m1: ModelInfo = { id: "m1", name: "1", provider: "p", reasoning: false };
-    const m2: ModelInfo = { id: "m2", name: "2", provider: "p", reasoning: false };
-    svc.initModel({ modelRegistry: makeEmptyRegistry(), sessionId: "s", ctxModel: m1 });
-
-    expect(svc.resolveModel("general-purpose").model).toBe(m1);
-    svc.setCtxModel(m2); // 模拟 model_select 刷新
-    expect(svc.resolveModel("general-purpose").model).toBe(m2);
-  });
-
-  it("缓存为空且无 override/agentConfig.model → 拗错(不静默降级)", () => {
-    const svc = makeModelService(agentDir);
-    svc.initModel({
-      modelRegistry: makeEmptyRegistry(),
-      sessionId: "s",
-      // ctxModel 不传 → 缓存为空
-    });
-    // 空 registry + 空 ctxModel → 第三层不可用 → 拗错
-    expect(() => svc.resolveModel("general-purpose")).toThrow(/No available model/);
-  });
-});
 
 // ============================================================
 // execute() 集成测试 — 已由 execute-integration.test.ts 覆盖