@zhushanwen/subagent-core 0.4.0 → 0.6.0

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

@@ -20,7 +20,7 @@ const { loggerMock, killEscalationSpy } = 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),
@@ -30,12 +30,13 @@ vi.mock("../session-runner.ts", () => ({
 }));
 
 import { createRecord, updateFromEvent } from "../execution-record.ts";
+import { createNotifyHost } from "../notify-host.ts";
 import { ModelConfigService } from "../model-config-service.ts";
 import { RecordStore } from "../record-store.ts";
 import { SubagentService } from "../subagent-service.ts";
 import type { PiLike } from "../subagent-service.ts";
 import type { ExecutionRecord } from "../types.ts";
-import { getChildByRecord } from "../session-runner.ts";
+import { getChildByRecord } from "../engine/engines/pi/session-runner.ts";
 
 // [T2④] kill 收敛入口 spy（工厂引用，断言服务侧三条路径收敛到它）
 const killRecordChildWithEscalationMock = killEscalationSpy;
@@ -95,7 +96,7 @@ function setup(): {
   pi: MockPi;
 } {
   const agentDir = makeTmpAgentDir();
-  const modelService = new ModelConfigService({ agentDir });
+  const modelService = new ModelConfigService({ agentDir, cwd: agentDir });
   const service = new SubagentService({ cwd: agentDir, modelService });
   // [C2] pi 提为外层引用（对照 real-chain :139-140 形态）——close 现状语义断言需读
   // pi.sendMessage.mock.calls（末条通知 content 指针行），内联构造不保留引用。
@@ -121,23 +122,23 @@ describe("getRecordForAction 归属守卫（决策 3）", () => {
 
   afterEach(() => {
     service.dispose();
-    fs.rmSync(agentDir, { recursive: true, force: true });
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
   it("正常（rootSessionId 匹配）→ 返回可变 record", () => {
     const record = makeRecord({ rootSessionId: sessionRootId });
     store.register(record);
-    expect(service.getRecordForAction(record.id)).toBe(record);
+    expect(service.chatActions.getRecordForAction(record.id)).toBe(record);
   });
 
   it("不存在 → throw not found or not owned", () => {
-    expect(() => service.getRecordForAction("sa-nonexistent")).toThrow(/not found or not owned/);
+    expect(() => service.chatActions.getRecordForAction("sa-nonexistent")).toThrow(/not found or not owned/);
   });
 
   it("rootSessionId 不匹配 → throw not found or not owned（不区分 not found vs not owned，防信息泄露）", () => {
     const record = makeRecord({ id: "sa-other", rootSessionId: "other-session" });
     store.register(record);
-    expect(() => service.getRecordForAction("sa-other")).toThrow(/not found or not owned/);
+    expect(() => service.chatActions.getRecordForAction("sa-other")).toThrow(/not found or not owned/);
   });
 });
 
@@ -157,7 +158,7 @@ describe("closeSubagent 行为分流", () => {
 
   afterEach(() => {
     service.dispose();
-    fs.rmSync(agentDir, { recursive: true, force: true });
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
   it("running + force:false + 有活进程 → 置 closeAfterRound=true（不立即终态，等轮完）", async () => {
@@ -167,7 +168,7 @@ describe("closeSubagent 行为分流", () => {
     const record = makeRecord({ status: "running" });
     store.register(record);
 
-    await service.closeSubagent(record, false);
+    await service.chatActions.closeSubagent(record, false);
 
     expect(record.closeAfterRound).toBe(true);
     expect(record.status).toBe("running"); // 仍 running
@@ -181,7 +182,7 @@ describe("closeSubagent 行为分流", () => {
     record.sessionFile = path.join(agentDir, "test.jsonl");
     store.register(record);
 
-    await service.closeSubagent(record, false);
+    await service.chatActions.closeSubagent(record, false);
 
     expect(record.status).toBe("closed");
     expect(store.getMutable(record.id)).toBeUndefined(); // archived
@@ -191,7 +192,7 @@ describe("closeSubagent 行为分流", () => {
     const record = makeRecord({ status: "running", sessionFile: path.join(agentDir, "run.jsonl") });
     store.register(record);
 
-    await service.closeSubagent(record, true);
+    await service.chatActions.closeSubagent(record, true);
 
     // v4 B-1：cancelled 折入 closed（closedReason='cancelled' 区分用户取消语义）
     expect(record.status).toBe("closed");
@@ -203,7 +204,7 @@ describe("closeSubagent 行为分流", () => {
     const record = makeRecord({ status: "closed" });
     store.register(record);
 
-    await service.closeSubagent(record, false);
+    await service.chatActions.closeSubagent(record, false);
 
     expect(record.status).toBe("closed"); // 不变
   });
@@ -223,7 +224,7 @@ describe("closeSubagent 行为分流", () => {
     expect(hasIdleTimer(record.id)).toBe(true);
 
     try {
-      await service.closeSubagent(record, false);
+      await service.chatActions.closeSubagent(record, false);
     } finally {
       disarmIdleTimer(record.id); // 断言失败路径的兜底清理
     }
@@ -242,7 +243,7 @@ describe("closeSubagent 行为分流", () => {
     record.sessionFile = path.join(agentDir, "path-b.jsonl");
     store.register(record);
 
-    await service.closeSubagent(record, false);
+    await service.chatActions.closeSubagent(record, false);
 
     expect(record.status).toBe("closed");
     expect(record.closedReason).toBe("user-close");
@@ -269,7 +270,7 @@ describe("closeSubagent 行为分流", () => {
     expect(hasIdleTimer(record.id)).toBe(true);
 
     try {
-      await service.closeSubagent(record, true);
+      await service.chatActions.closeSubagent(record, true);
     } finally {
       disarmIdleTimer(record.id); // 断言失败路径的兜底清理
     }
@@ -299,7 +300,7 @@ describe("cancelBackground CAS 抢锁（A2-1）——cancel 迟到不覆写已
 
   afterEach(() => {
     service.dispose();
-    fs.rmSync(agentDir, { recursive: true, force: true });
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
   it("record 已 closed 未 archive（doFinalizeRecord Step 0 await 窗口形态）→ cancel 返回 false，不覆写终态/不写 tombstone/不 notify/不 archive", () => {
@@ -354,7 +355,7 @@ describe("[M5] closeAfterRound 消费点挂 onRoundSettled（chatMode 轮完成
   afterEach(() => {
     service.dispose();
     _resetLifecycleState();
-    fs.rmSync(agentDir, { recursive: true, force: true });
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
   it("热路径轮完成（onRoundSettled）+ closeAfterRound=true → 消费标志终态化（closed+user-close + archive）", async () => {
@@ -428,7 +429,7 @@ describe("[C2] close 现状语义 + sessionFile 条件透传", () => {
   afterEach(() => {
     service.dispose();
     _resetLifecycleState();
-    fs.rmSync(agentDir, { recursive: true, force: true });
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
 	it("close 语义：轮次通知（含指针行）发出后 closeAfterRoundSettled 终态化 + 终态通知，两条都送达", async () => {
@@ -473,8 +474,10 @@ describe("[C2] close 现状语义 + sessionFile 条件透传", () => {
 
     // running + 无活进程（getChildByRecord mock undefined）→ isResumable 放行 →
     // 非 chatMode 映射 closed 通知，立即 flush（无其他 running background）
-    const svc = service as unknown as { notifyComplete(r: ExecutionRecord): void };
-    svc.notifyComplete(record);
+    // [D4-①] notifyComplete 已随通知簇搬至 notify-host——按轴直接构造（同 pi/store
+    // 注入，行为与经 Service 的原路径等价；dedup 集为空与单次调用断言相容）
+    createNotifyHost({ getPi: () => pi, listRunning: () => store.listRunning(), getIsIdle: () => undefined })
+      .notifyComplete(record);
 
     expect(pi.sendMessage).toHaveBeenCalledTimes(1);
     const msg = pi.sendMessage.mock.calls[0]![0] as {
@@ -493,8 +496,8 @@ describe("[C2] close 现状语义 + sessionFile 条件透传", () => {
     record.sessionFile = path.join(agentDir, "c2-chat.jsonl");
     store.register(record);
 
-    const svc = service as unknown as { notifyComplete(r: ExecutionRecord): void };
-    svc.notifyComplete(record);
+    createNotifyHost({ getPi: () => pi, listRunning: () => store.listRunning(), getIsIdle: () => undefined })
+      .notifyComplete(record);
 
     expect(pi.sendMessage).toHaveBeenCalledTimes(1);
     const msg = pi.sendMessage.mock.calls[0]![0] as {
@@ -526,7 +529,7 @@ describe("[C-4] onRoundSettled 轮次增量 + [C-1] close 终态通知", () => {
   afterEach(() => {
     service.dispose();
     _resetLifecycleState();
-    fs.rmSync(agentDir, { recursive: true, force: true });
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
   /** 真实回调链（与生产一致：agent_settled → onRoundSettled），turns 经 updateFromEvent 累积。 */
@@ -601,7 +604,7 @@ describe("[C-4] onRoundSettled 轮次增量 + [C-1] close 终态通知", () => {
       updateFromEvent(record, { type: "text_delta", delta: "LAST-ROUND-INCREMENT" });
       updateFromEvent(record, { type: "turn_end" });
       settleRound(record); // 第 1 条：轮次通知
-      await service.closeSubagent(record, false); // idle close（D2 路径②）
+      await service.chatActions.closeSubagent(record, false); // idle close（D2 路径②）
     } finally {
       disarmIdleTimer(record.id);
     }
@@ -651,7 +654,7 @@ describe("[C-4] onRoundSettled 轮次增量 + [C-1] close 终态通知", () => {
     record.sessionFile = path.join(agentDir, "oneshot-close.jsonl");
     store.register(record);
 
-    await service.closeSubagent(record, false); // resumable → closeChatIdle → notifyClosed 拒绝
+    await service.chatActions.closeSubagent(record, false); // resumable → closeChatIdle → notifyClosed 拒绝
 
     expect(record.status).toBe("closed");
     expect(pi.sendMessage).not.toHaveBeenCalled();
@@ -672,7 +675,7 @@ describe("[C-4] onRoundSettled 轮次增量 + [C-1] close 终态通知", () => {
       updateFromEvent(record, { type: "turn_end" });
       settleRound(record); // 轮终：onRoundSettled 写 record.result = "ok"
       expect(record.result).toBe("ok"); // 前提锚点：轮终真实值在位
-      await service.closeSubagent(record, false); // idle close → completeRecord + archive
+      await service.chatActions.closeSubagent(record, false); // idle close → completeRecord + archive
     } finally {
       disarmIdleTimer(record.id);
     }

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

@@ -34,7 +34,7 @@ vi.mock("../alive-store.ts", () => ({
   findForeignLiveInstance: foreignLiveSpy,
 }));
 
-vi.mock("../session-runner.ts", () => ({
+vi.mock("../engine/engines/pi/session-runner.ts", () => ({
   runSpawn: vi.fn(),
   killAllSpawnedChildren: vi.fn(),
   getChildByRecord: vi.fn(() => undefined),
@@ -63,7 +63,7 @@ function makePi(): PiLike {
 
 function setup(): { agentDir: string; service: SubagentService; store: RecordStore } {
   const agentDir = makeTmpAgentDir();
-  const modelService = new ModelConfigService({ agentDir });
+  const modelService = new ModelConfigService({ agentDir, cwd: agentDir });
   const service = new SubagentService({ cwd: agentDir, modelService });
   service.initSession({ pi: makePi(), sessionId: "root-session" });
   const store = (service as unknown as { store: RecordStore }).store;
@@ -79,7 +79,7 @@ describe("T5① child process skips orphan recovery scan", () => {
     recover: ReturnType<typeof vi.spyOn>;
     entryOnly: ReturnType<typeof vi.spyOn>;
   } => {
-    const modelService = new ModelConfigService({ agentDir });
+    const modelService = new ModelConfigService({ agentDir, cwd: agentDir });
     const svc = new SubagentService({ cwd: agentDir, modelService });
     const store = (svc as unknown as { store: RecordStore }).store;
     const recover = vi.spyOn(store, "recoverOrphanRecords").mockImplementation(() => {});
@@ -95,7 +95,7 @@ describe("T5① child process skips orphan recovery scan", () => {
   afterEach(() => {
     vi.unstubAllEnvs();
     vi.restoreAllMocks();
-    fs.rmSync(agentDir, { recursive: true, force: true });
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
   it("root process (no self-record env) runs the orphan recovery scan", () => {
@@ -120,6 +120,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());
@@ -127,7 +140,7 @@ describe("T5③ cold-lookup running candidate foreign-instance guard", () => {
 
   afterEach(() => {
     vi.restoreAllMocks();
-    fs.rmSync(agentDir, { recursive: true, force: true });
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
   const stubColdCandidate = (record: {
@@ -150,9 +163,9 @@ describe("T5③ cold-lookup running candidate foreign-instance guard", () => {
     });
     foreignLiveSpy.mockReturnValue({ pid: 4242, id: "sa-foreign", startedAt: Date.now() });
 
-    expect(() => service.getRecordForAction("sa-foreign")).toThrow(ResurrectDeniedError);
+    expect(() => service["getRecordForAction"]("sa-foreign")).toThrow(ResurrectDeniedError);
     try {
-      service.getRecordForAction("sa-foreign");
+      service["getRecordForAction"]("sa-foreign");
     } catch (err) {
       expect((err as Error).message).toContain("4242");
       expect((err as Error).message).toContain("double-write");
@@ -168,7 +181,7 @@ describe("T5③ cold-lookup running candidate foreign-instance guard", () => {
       sessionFile: "/tmp/fake-session-2.jsonl",
       rootSessionId: "root-session",
     });
-    const found = service.getRecordForAction("sa-cold");
+    const found = service["getRecordForAction"]("sa-cold");
     expect(found.id).toBe("sa-cold");
   });
 });

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/);
   });
 });