@zhushanwen/subagent-core 0.4.0 → 0.5.1

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

@@ -1,7 +1,7 @@
 // src/execution/__tests__/subagent-service-notify-gate.test.ts
 //
 // [u-svc / T4] 通知可靠性（subagent-service 侧三措施）：
-//   - T4①/PS-2：kickOffBackground.then notify 门按 closedReason 白名单放行——
+//   - T4①/PS-2：kickOffChatRound.then notify 门按 closedReason 白名单放行——
 //     parent-new/parent-fork 不注入（可能已切换的）新 session（A-6 决策落实）；
 //   - T4②/PS-4：idleTimeoutMs 非法值（>2^31-1 / 非有限值）在 spawn 入口同步 fail-fast，
 //     错误含合法范围（不静默 clamp、不静默不挂）；
@@ -23,7 +23,7 @@ const { loggerMock } = vi.hoisted(() => ({
 vi.mock("../../core/logger.ts", () => ({ getLogger: () => loggerMock }));
 
 const { killChildSpy } = vi.hoisted(() => ({ killChildSpy: vi.fn() }));
-vi.mock("../session-runner.ts", () => ({
+vi.mock("../engine/engines/pi/session-runner.ts", () => ({
   runSpawn: vi.fn(),
   killAllSpawnedChildren: vi.fn(),
   getChildByRecord: vi.fn(() => undefined),
@@ -76,7 +76,7 @@ function setup(initOverrides: Partial<{ isIdle: () => boolean }> = {}): {
   pi: MockPi;
 } {
   const agentDir = makeTmpAgentDir();
-  const modelService = new ModelConfigService({ agentDir });
+  const modelService = new ModelConfigService({ agentDir, cwd: agentDir });
   const service = new SubagentService({ cwd: agentDir, modelService });
   const pi = makePi();
   service.initSession({ pi, sessionId: "root-session", isIdle: initOverrides.isIdle });
@@ -95,18 +95,19 @@ describe("T4① notify gate closedReason whitelist", () => {
     expect(notifyGateAllowsDelivery(undefined)).toBe(true);
   });
 
-  it("kickOffBackground.then does not inject parent-new closed records into the session", async () => {
+  it("kickOffChatRound.then does not inject parent-new closed records into the session", async () => {
     const { agentDir, service, pi } = setup();
     const record = createRecord("sa-gate-new", {
       agent: "general-purpose",
       model: "test/model",
       mode: "background",
+      slug: "t",
       task: "test",
       startedAt: 1000,
       rootSessionId: "root-session",
       controller: new AbortController(),
     });
-    // 模拟 disposeAllRecords 先行编排性关闭后，迟到的 kickOffBackground.then 回注
+    // 模拟 disposeAllRecords 先行编排性关闭后，迟到的 kickOffChatRound.then 回注
     record.closedReason = "parent-new";
     const stub = vi.fn().mockResolvedValue({
       text: "",
@@ -118,23 +119,27 @@ describe("T4① notify gate closedReason whitelist", () => {
       toolCalls: [],
     });
     (service as unknown as Record<string, unknown>).runAndFinalize = stub;
-    const kickOffBackground = (
+    // [D4 后形态] 轮次编排入口 kickOffChatRound（私有，bracket 调用先例见
+    // subagent-service-recovery-bounds.test.ts privateFn）；opts 形参仍是 ExecuteOptions
+    //（task/slug），chat 分支由 ticket lossless 携带——task 声明形参不参与校验。
+    const kickOffChatRound = (
       service as unknown as Record<string, (...args: unknown[]) => void>
-    )["kickOffBackground"];
-    kickOffBackground.call(service, record, { task: "t" }, {}, {}, undefined, 1000, undefined);
+    )["kickOffChatRound"];
+    kickOffChatRound.call(service, record, { task: "t", slug: "gate" }, {}, {}, undefined, 1000, undefined);
     await vi.waitFor(() => expect(stub).toHaveBeenCalled());
     await Promise.resolve();
     await Promise.resolve();
     expect(pi.sendMessage).not.toHaveBeenCalled();
-    fs.rmSync(agentDir, { recursive: true, force: true });
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
-  it("kickOffBackground.then still notifies for real failure closures (gc)", async () => {
+  it("kickOffChatRound.then still notifies for real failure closures (gc)", async () => {
     const { agentDir, service, pi } = setup();
     const record = createRecord("sa-gate-gc", {
       agent: "general-purpose",
       model: "test/model",
       mode: "background",
+      slug: "t",
       task: "test",
       startedAt: 1000,
       rootSessionId: "root-session",
@@ -142,12 +147,12 @@ describe("T4① notify gate closedReason whitelist", () => {
     });
     record.closedReason = "gc";
     (service as unknown as Record<string, unknown>).runAndFinalize = vi.fn().mockResolvedValue({});
-    const kickOffBackground = (
+    const kickOffChatRound = (
       service as unknown as Record<string, (...args: unknown[]) => void>
-    )["kickOffBackground"];
-    kickOffBackground.call(service, record, { task: "t" }, {}, {}, undefined, 1000, undefined);
+    )["kickOffChatRound"];
+    kickOffChatRound.call(service, record, { task: "t", slug: "gate" }, {}, {}, undefined, 1000, undefined);
     await vi.waitFor(() => expect(pi.sendMessage).toHaveBeenCalled());
-    fs.rmSync(agentDir, { recursive: true, force: true });
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 });
 
@@ -160,30 +165,30 @@ describe("T4② idleTimeoutMs entry fail-fast", () => {
   });
 
   afterEach(() => {
-    fs.rmSync(agentDir, { recursive: true, force: true });
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
   it("execute rejects idleTimeoutMs above the setTimeout limit with the valid range in the message", async () => {
-    await expect(service.execute({ task: "x", idleTimeoutMs: MAX_TIMER_DELAY_MS + 1 })).rejects.toThrow(
+    await expect(service.execute({ task: "x", slug: "test", idleTimeoutMs: MAX_TIMER_DELAY_MS + 1 })).rejects.toThrow(
       new RegExp(`${MAX_TIMER_DELAY_MS}`),
     );
-    await expect(service.execute({ task: "x", idleTimeoutMs: 3_000_000_000 })).rejects.toThrow(/2\^31-1/);
+    await expect(service.execute({ task: "x", slug: "test", idleTimeoutMs: 3_000_000_000 })).rejects.toThrow(/2\^31-1/);
   });
 
   it("execute rejects non-finite idleTimeoutMs", async () => {
-    await expect(service.execute({ task: "x", idleTimeoutMs: Number.NaN })).rejects.toThrow(/not a finite number/);
+    await expect(service.execute({ task: "x", slug: "test", idleTimeoutMs: Number.NaN })).rejects.toThrow(/not a finite number/);
   });
 
   it("rejects before any record is created (no side effects)", async () => {
     const internals = service as unknown as ServiceInternals;
-    await expect(service.executeAndAwait({ task: "x", idleTimeoutMs: 3_000_000_000 })).rejects.toThrow();
+    await expect(service.executeAndAwait({ task: "x", slug: "test", idleTimeoutMs: 3_000_000_000 })).rejects.toThrow();
     expect(internals.store.listRunning()).toHaveLength(0);
   });
 
   it("accepts valid values (0 = explicit disable, positive within limit)", async () => {
     // 校验通过后执行链继续（runSpawn 被 mock，返回 undefined result 会在后续流程抛错/
     // 返回——但绝不能是 idleTimeoutMs 校验错误）
-    await expect(service.execute({ task: "x", idleTimeoutMs: 0 })).rejects.not.toThrow(/idleTimeoutMs/);
+    await expect(service.execute({ task: "x", slug: "test", idleTimeoutMs: 0 })).rejects.not.toThrow(/idleTimeoutMs/);
   });
 });
 
@@ -199,7 +204,7 @@ describe("T4④ shutdown flush blocked → pending persisted for replay", () =>
 
   afterEach(() => {
     _resetNotifyLedgerForTest();
-    fs.rmSync(agentDir, { recursive: true, force: true });
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
   it("persists undelivered pending notifications as ledger entries on dispose when main agent is busy", () => {
@@ -256,7 +261,7 @@ describe("T4④ shutdown flush blocked → pending persisted for replay", () =>
     // idle service：flush 投出（无门拦），dispose 无复写动作
     const idleService = new SubagentService({
       cwd: agentDir,
-      modelService: new ModelConfigService({ agentDir }),
+      modelService: new ModelConfigService({ agentDir, cwd: agentDir }),
     });
     const piIdle = makePi();
     idleService.initSession({ pi: piIdle, sessionId: "root-session", isIdle: () => true });

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

@@ -26,7 +26,7 @@ const { loggerMock } = vi.hoisted(() => ({
 vi.mock("../../core/logger.ts", () => ({ getLogger: () => loggerMock }));
 
 // mock session-runner（import 链需要 runSpawn/killAllSpawnedChildren/getChildByRecord 存在）
-vi.mock("../session-runner.ts", () => ({
+vi.mock("../engine/engines/pi/session-runner.ts", () => ({
   runSpawn: vi.fn(),
   killAllSpawnedChildren: vi.fn(),
   getChildByRecord: vi.fn(() => undefined),
@@ -59,11 +59,12 @@ function makePi(): PiLike {
   } as unknown as PiLike;
 }
 
-/** 暴露私有字段供测试注入身份。 */
+/** 暴露私有字段供测试注入身份。[D3-⑤] 基线住进 execNesting（公共层
+ * ExecutionNestingContext），注入经 setBaseline 测试面。 */
 interface ServiceInternals {
   store: RecordStore;
   sessionRootId: string | null;
-  execCtxBaseline: { recordId: string | undefined; depth: number } | null;
+  execNesting: { setBaseline(state: { recordId: string | undefined; depth: number } | null): void };
 }
 
 /** 构造一个 chatMode idle record（message/close action 的典型目标态）。 */
@@ -77,12 +78,12 @@ function makeRecord(
     model: "test/model",
     mode: "background",
     task: "test",
-    slug: "test",
     startedAt: 1000,
     rootSessionId: sessionRootId,
     chatMode: true,
     controller: new AbortController(),
     ...overrides,
+    slug: overrides.slug ?? "test",
   });
 }
 
@@ -95,7 +96,7 @@ describe("[v4 A-5 / P7] getRecordForAction 直接父校验", () => {
 
   beforeEach(() => {
     agentDir = makeTmpAgentDir();
-    const modelService = new ModelConfigService({ agentDir });
+    const modelService = new ModelConfigService({ agentDir, cwd: agentDir });
     service = new SubagentService({ cwd: agentDir, modelService });
     // initSession 建立 sessionRootId=sessionId（本 session 树的根）。execCtxBaseline 的
     // 真实值由 initSession 从 env 读取（见 recursive-visibility-baseline.test.ts），但本测试
@@ -108,65 +109,65 @@ describe("[v4 A-5 / P7] getRecordForAction 直接父校验", () => {
 
   afterEach(() => {
     service.dispose();
-    fs.rmSync(agentDir, { recursive: true, force: true });
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
   // ---------- 身份 sa-A：直接父，放行孙级 B ----------
 
   it("身份=sa-A（直接父）→ 放行操作孙级 record B（parentRecordId=sa-A）", () => {
-    const recordB = makeRecord("sa-B", sessionRootId, { parentRecordId: "sa-A", depth: 2, status: "idle" });
+    const recordB = makeRecord("sa-B", sessionRootId, { parentRecordId: "sa-A", depth: 2, status: "running" });
     store.register(recordB);
-    internals.execCtxBaseline = PARENT_A;
+    internals.execNesting.setBaseline(PARENT_A);
 
-    expect(service.getRecordForAction("sa-B")).toBe(recordB);
+    expect(service.chatActions.getRecordForAction("sa-B")).toBe(recordB);
   });
 
   // ---------- 身份 undefined（主进程）：拒绝孙级，放行根层 ----------
 
   it("身份=undefined（主进程）拒绝孙级 record B，错误含 'direct parent' + 'parent=sa-A'", () => {
-    const recordB = makeRecord("sa-B", sessionRootId, { parentRecordId: "sa-A", depth: 2, status: "idle" });
+    const recordB = makeRecord("sa-B", sessionRootId, { parentRecordId: "sa-A", depth: 2, status: "running" });
     store.register(recordB);
-    internals.execCtxBaseline = MAIN_PROCESS;
+    internals.execNesting.setBaseline(MAIN_PROCESS);
 
-    expect(() => service.getRecordForAction("sa-B")).toThrow(/direct parent/);
-    expect(() => service.getRecordForAction("sa-B")).toThrow(/see \/subagents list, parent=sa-A/);
+    expect(() => service.chatActions.getRecordForAction("sa-B")).toThrow(/direct parent/);
+    expect(() => service.chatActions.getRecordForAction("sa-B")).toThrow(/see \/subagents list, parent=sa-A/);
   });
 
   it("身份=undefined（主进程）放行顶层 record（parentRecordId=undefined 视为根层）", () => {
-    const topRecord = makeRecord("sa-top", sessionRootId, { parentRecordId: undefined, depth: 0, status: "idle" });
+    const topRecord = makeRecord("sa-top", sessionRootId, { parentRecordId: undefined, depth: 0, status: "running" });
     store.register(topRecord);
-    internals.execCtxBaseline = MAIN_PROCESS;
+    internals.execNesting.setBaseline(MAIN_PROCESS);
 
-    expect(service.getRecordForAction("sa-top")).toBe(topRecord);
+    expect(service.chatActions.getRecordForAction("sa-top")).toBe(topRecord);
   });
 
   // ---------- 身份 sa-B（兄弟进程）：拒绝孙级 ----------
 
   it("身份=sa-B（兄弟进程）拒绝孙级 record B（parentRecordId=sa-A ≠ baseline sa-B）", () => {
-    const recordB = makeRecord("sa-B", sessionRootId, { parentRecordId: "sa-A", depth: 2, status: "idle" });
+    const recordB = makeRecord("sa-B", sessionRootId, { parentRecordId: "sa-A", depth: 2, status: "running" });
     store.register(recordB);
-    internals.execCtxBaseline = SIBLING_B;
+    internals.execNesting.setBaseline(SIBLING_B);
 
-    expect(() => service.getRecordForAction("sa-B")).toThrow(/direct parent/);
-    expect(() => service.getRecordForAction("sa-B")).toThrow(/see \/subagents list, parent=sa-A/);
+    expect(() => service.chatActions.getRecordForAction("sa-B")).toThrow(/direct parent/);
+    expect(() => service.chatActions.getRecordForAction("sa-B")).toThrow(/see \/subagents list, parent=sa-A/);
   });
 
   // ---------- 身份缺省语义 + 更深递归 ----------
 
   it("子进程（baseline=sa-A）拒绝顶层 record（身份缺省视为根层，仅主进程可操作）", () => {
-    const topRecord = makeRecord("sa-top", sessionRootId, { parentRecordId: undefined, depth: 0, status: "idle" });
+    const topRecord = makeRecord("sa-top", sessionRootId, { parentRecordId: undefined, depth: 0, status: "running" });
     store.register(topRecord);
-    internals.execCtxBaseline = PARENT_A;
+    internals.execNesting.setBaseline(PARENT_A);
 
-    expect(() => service.getRecordForAction("sa-top")).toThrow(/direct parent/);
+    expect(() => service.chatActions.getRecordForAction("sa-top")).toThrow(/direct parent/);
   });
 
   it("P7 场景：主进程拒绝曾孙 record C（parentRecordId=sa-B），错误含 baseline=root + parent=sa-B", () => {
-    const recordC = makeRecord("sa-C", sessionRootId, { parentRecordId: "sa-B", depth: 3, status: "idle" });
+    const recordC = makeRecord("sa-C", sessionRootId, { parentRecordId: "sa-B", depth: 3, status: "running" });
     store.register(recordC);
-    internals.execCtxBaseline = MAIN_PROCESS;
+    internals.execNesting.setBaseline(MAIN_PROCESS);
 
-    const fn = () => service.getRecordForAction("sa-C");
+    const fn = () => service.chatActions.getRecordForAction("sa-C");
     expect(fn).toThrow(/direct parent/);
     expect(fn).toThrow(/see \/subagents list, parent=sa-B/);
     expect(fn).toThrow(/baseline=\(root\)/);
@@ -174,10 +175,10 @@ describe("[v4 A-5 / P7] getRecordForAction 直接父校验", () => {
 
   it("rootSessionId 不匹配仍优先拒绝（直接父校验在 rootSessionId 校验之后，不绕过归属守卫）", () => {
     // 跨 session 树的 record：rootSessionId 不匹配 → 走首个 throw（not found or not owned）
-    const foreignRecord = makeRecord("sa-foreign", "other-session", { parentRecordId: "sa-A", depth: 2, status: "idle" });
+    const foreignRecord = makeRecord("sa-foreign", "other-session", { parentRecordId: "sa-A", depth: 2, status: "running" });
     store.register(foreignRecord);
-    internals.execCtxBaseline = PARENT_A;
+    internals.execNesting.setBaseline(PARENT_A);
 
-    expect(() => service.getRecordForAction("sa-foreign")).toThrow(/not found or not owned/);
+    expect(() => service.chatActions.getRecordForAction("sa-foreign")).toThrow(/not found or not owned/);
   });
 });

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

@@ -5,9 +5,12 @@
 //     收敛到 killRecordChildWithEscalation（spy 断言调用点与参数）；
 //   - T2⑥/PS-1：disposeAllRecords 补三回收面（controller.abort + kill + disarm idle timer
 //     + disarm settled watchdog）；
-//   - T2③/LC-1：deliverMessage 热路径 armSettledWatchdog（挂载 + 到期 onTimeout 处置：
-//     kill + 失败终态化 + error 含 'settled watchdog' 标记与恢复指引）；
-//   - T2⑧/PS-3：deliverMessage 非 EPIPE 失败 re-arm idle timer（进程不再裸奔）。
+//   - T2③/LC-1 + D9：热路径投递 armMidRoundNoProgress（挂载点 D2 下沉后在编排层
+//     deliverChatMessage 的 interact 返回点；挂载中段无进展检测 + 到期 onMidTimeout/
+//     onSettleTimeout 处置：kill + 失败终态化 + error 含 'settled watchdog' 标记与恢复
+//     指引；agent_end 交棒收尾段的接线在 session-runner stdout pump，两路径共用）；
+//   - T2⑧/PS-3：非 EPIPE 热路径写失败 re-arm idle timer（进程不再裸奔；挂载位 D2
+//     下沉后在 PiEngine.deliverPrompt 的非 EPIPE catch——编排层无法区分错误类别）。
 //
 // mock 形态沿用 subagent-service-message-close.test.ts（真实 SubagentService + ServiceInternals
 // cast 暴露 store + mock session-runner/stdin-writer/logger）。
@@ -24,8 +27,8 @@ const { loggerMock } = vi.hoisted(() => ({
 vi.mock("../../core/logger.ts", () => ({ getLogger: () => loggerMock }));
 
 // killRecordChildWithEscalation 换 spy（收敛调用点断言）；spawnedChildren 用真 Map
-//（deliverMessage 热路径判定 / EPIPE 兜底按值删除的消费者）；getChildByRecord 从同
-// 一 Map 查（mock 工厂与测试共享同一实例）。
+//（热路径投递判定 / EPIPE 兜底按值删除的消费者）；getChildByRecord 从同一 Map 查
+//（mock 工厂与测试共享同一实例）。D2 后模块物理下沉 engines/pi/（mock 路径随迁）。
 const { killChildSpy, spawnedMap, getChildByRecordMock } = vi.hoisted(() => {
   const map = new Map<string, unknown>();
   return {
@@ -34,7 +37,7 @@ const { killChildSpy, spawnedMap, getChildByRecordMock } = vi.hoisted(() => {
     getChildByRecordMock: vi.fn((recordId: string) => map.get(recordId)),
   };
 });
-vi.mock("../session-runner.ts", () => ({
+vi.mock("../engine/engines/pi/session-runner.ts", () => ({
   runSpawn: vi.fn(),
   killAllSpawnedChildren: vi.fn(),
   getChildByRecord: getChildByRecordMock,
@@ -45,7 +48,7 @@ vi.mock("../session-runner.ts", () => ({
 
 // sendPromptCommand 换 spy（控制热路径写成功 / 抛非 EPIPE 错误）。
 const { sendPromptCommandMock } = vi.hoisted(() => ({ sendPromptCommandMock: vi.fn() }));
-vi.mock("../stdin-writer.ts", () => ({
+vi.mock("../engine/engines/pi/stdin-writer.ts", () => ({
   sendPromptCommand: sendPromptCommandMock,
   clearEpipeFailure: vi.fn(),
   recordEpipeFailure: vi.fn(() => 1),
@@ -59,7 +62,7 @@ import { ModelConfigService } from "../model-config-service.ts";
 import type { RecordStore } from "../record-store.ts";
 import { SubagentService } from "../subagent-service.ts";
 import type { PiLike } from "../subagent-service.ts";
-import { armSettledWatchdog, hasSettledWatchdog, SETTLED_WATCHDOG_TIMEOUT_MS, _resetSettledWatchdogsForTest } from "../settled-watchdog.ts";
+import { armSettledWatchdog, hasSettledWatchdog, SETTLED_MID_ROUND_NO_PROGRESS_MS, _resetSettledWatchdogsForTest } from "../settled-watchdog.ts";
 import { armIdleTimer, hasIdleTimer, _resetLifecycleState } from "../lifecycle-manager.ts";
 import type { ExecutionRecord } from "../types.ts";
 
@@ -108,7 +111,7 @@ type MockPi = ReturnType<typeof makePi>;
 
 function setup(): { agentDir: string; service: SubagentService; store: RecordStore; pi: MockPi } {
   const agentDir = makeTmpAgentDir();
-  const modelService = new ModelConfigService({ agentDir });
+  const modelService = new ModelConfigService({ agentDir, cwd: agentDir });
   const service = new SubagentService({ cwd: agentDir, modelService });
   const pi = makePi();
   service.initSession({ pi, sessionId: "root-session" });
@@ -121,6 +124,26 @@ function privateFn<K extends string>(service: SubagentService, key: K): (...args
   return (service as unknown as Record<string, (...args: never[]) => unknown>)[key];
 }
 
+/**
+ * message 投递入口（D2 后形态：编排层私有 deliverChatMessage → PiEngine.interactRecord
+ * → deliverPrompt；旧直调形态 deliverMessage 已随协议知识下沉删除）。
+ */
+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);
+}
+
 describe("T2④ service-side kill convergence", () => {
   let agentDir: string;
   let service: SubagentService;
@@ -138,7 +161,7 @@ describe("T2④ service-side kill convergence", () => {
     _resetLifecycleState();
     _resetSettledWatchdogsForTest();
     spawnedMap.clear();
-    fs.rmSync(agentDir, { recursive: true, force: true });
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
   it("cancelBackground (via cancel) routes through killRecordChildWithEscalation", async () => {
@@ -156,7 +179,7 @@ describe("T2④ service-side kill convergence", () => {
     spawnedMap.set(record.id, new FakeChild());
     armIdleTimer(record.id, () => {}); // Path A：idle timer armed（进程保活）
     armSettledWatchdog(record.id, () => {});
-    await service.closeSubagent(record, false);
+    await service["closeSubagent"](record, false);
     expect(killChildSpy).toHaveBeenCalledWith(record.id, "closeChatIdle");
     expect(hasIdleTimer(record.id)).toBe(false);
     expect(hasSettledWatchdog(record.id)).toBe(false);
@@ -223,28 +246,30 @@ describe("T2③ hot-path settled watchdog", () => {
     _resetLifecycleState();
     _resetSettledWatchdogsForTest();
     spawnedMap.clear();
-    fs.rmSync(agentDir, { recursive: true, force: true });
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
   it("arms the settled watchdog after a successful hot-path prompt", async () => {
     const record = makeRecord({ id: "sa-hot-arm" });
     store.register(record);
     spawnedMap.set(record.id, new FakeChild());
-    await service.deliverMessage(record, "hello", false);
+    await deliverChat(service, record, "hello", false);
     expect(sendPromptCommandMock).toHaveBeenCalledTimes(1);
     expect(hasSettledWatchdog(record.id)).toBe(true);
   });
 
-  it("onTimeout: kills the child, fails the round, error carries 'settled watchdog' marker and recovery hint", async () => {
+  it("onMidTimeout: kills the child, fails the round, 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" });
     store.register(record);
     spawnedMap.set(record.id, new FakeChild());
-    await service.deliverMessage(record, "hello", false);
+    await deliverChat(service, record, "hello", false);
     expect(hasSettledWatchdog(record.id)).toBe(true);
 
-    await vi.advanceTimersByTimeAsync(SETTLED_WATCHDOG_TIMEOUT_MS + 1);
+    // [D9 两段式] 热路径 prompt 发出后挂中段：静默满中段窗长触发（本测试 mock 了
+    // session-runner，无 stdout pump 驱动事件刷新/交棒，中段静默形态直达）
+    await vi.advanceTimersByTimeAsync(SETTLED_MID_ROUND_NO_PROGRESS_MS + 1);
 
     // kill 收敛入口被触发（onTimeout 第一步）
     expect(killChildSpy).toHaveBeenCalledWith(record.id, "settled watchdog (hot path)");
@@ -278,7 +303,7 @@ describe("T2⑧ non-EPIPE hot-path failure re-arms idle timer", () => {
     _resetLifecycleState();
     _resetSettledWatchdogsForTest();
     spawnedMap.clear();
-    fs.rmSync(agentDir, { recursive: true, force: true });
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
   it("re-arms the idle timer (default duration) and rethrows on non-EPIPE write failure", async () => {
@@ -289,7 +314,7 @@ describe("T2⑧ non-EPIPE hot-path failure re-arms idle timer", () => {
       throw new Error("write after end: ERR_STREAM_DESTROYED");
     });
 
-    await expect(service.deliverMessage(record, "hello", false)).rejects.toThrow(/ERR_STREAM_DESTROYED/);
+    await expect(deliverChat(service, record, "hello", false)).rejects.toThrow(/ERR_STREAM_DESTROYED/);
 
     // 防泄漏前提恢复：入口 disarm 过的 idle timer 被 re-arm（进程不再裸奔）
     expect(hasIdleTimer(record.id)).toBe(true);
@@ -303,14 +328,14 @@ describe("T2⑧ non-EPIPE hot-path failure re-arms idle timer", () => {
     const record = makeRecord({ id: "sa-nonpipe-bad" });
     // 直接注入非法值模拟「入口校验前已存在的 record」/ 回归形态：re-arm 首选值非法 →
     // 降级挂 DEFAULT（防御性兜底可见，不静默不挂）
-    record.idleTimeoutMs = 3_000_000_000;
+    (record as { idleTimeoutMs: number }).idleTimeoutMs = 3_000_000_000;
     store.register(record);
     spawnedMap.set(record.id, new FakeChild());
     sendPromptCommandMock.mockImplementation(() => {
       throw new Error("ERR_STREAM_DESTROYED");
     });
 
-    await expect(service.deliverMessage(record, "hello", false)).rejects.toThrow(/ERR_STREAM_DESTROYED/);
+    await expect(deliverChat(service, record, "hello", false)).rejects.toThrow(/ERR_STREAM_DESTROYED/);
     expect(hasIdleTimer(record.id)).toBe(true);
   });
 });