@zhushanwen/subagent-core 0.2.0 → 0.5.1

package/src/execution/__tests__/lifecycle-manager-idle-timer-identity.test.ts

@@ -0,0 +1,117 @@
+// src/execution/__tests__/lifecycle-manager-idle-timer-identity.test.ts
+//
+// [LC-5/T6①] armIdleTimer 超时回调身份比对（按值守卫，对齐 session-runner
+// removeChildRegistration 先例）。
+//
+// 覆盖（设计 §4.3 LC-5 + §11-2）：
+//   1. 「旧 timer 已到期、回调迟到执行」与「同 recordId re-arm」精确交错 → 守卫不误删
+//      新条目（旧代码此处误删 = 新 timer 脱管、disarm 失效 → turn 中途误杀）。
+//   2. 无交错时旧 timer 到点删除自己的条目 + 后续 re-arm 正常（既有语义不回归）。
+//   3. fake timers 下「re-arm 发生在旧 timer 到期回调处置中」的同轮交错端到端：
+//      新 timer 存活、到点正常触发、Map 清理干净。
+//
+// 交错构造说明（§11-2 勘误锚点）：sinon fake clock 的同步 tick 模型在「时间推进」的
+// 同一同步流程内立即执行到期回调，不存在「已到期、回调已入队、尚未执行」的中间态
+// 暴露给 clearTimeout——纯 fake timers 无法表达 Node 真实窗口（fire 后回调入
+// macrotask 队列，clearTimeout 不可撤销）。用例 1/2 以手动排程 fake（stub setTimeout
+// 捕获回调、测试显式控制 fire 时机）精确复现该中间态；用例 3 补真实 clock 语义下的
+// 同轮交错端到端回归。
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import {
+  _resetLifecycleState,
+  armIdleTimer,
+  disarmIdleTimer,
+  hasIdleTimer,
+} from "../lifecycle-manager.ts";
+
+/** 手动排程 fake 捕获的到期回调（fire = 模拟 timer 到点，时机由用例显式控制）。 */
+let scheduled: Array<{ fire: () => void; timer: object }>;
+
+beforeEach(() => {
+  _resetLifecycleState();
+  scheduled = [];
+  // 手动排程模型：setTimeout 只登记不排程；clearTimeout no-op（「已入队回调不可撤销」
+  // 的真实语义由用例不 fire 被撤销者来表达）。
+  vi.stubGlobal(
+    "setTimeout",
+    (cb: () => void, _delay?: number) => {
+      void _delay;
+      const timer: object = {};
+      scheduled.push({ fire: cb, timer });
+      return Object.assign(timer, { unref() {} });
+    },
+  );
+  vi.stubGlobal("clearTimeout", (_t?: unknown) => {
+    void _t;
+  });
+});
+
+afterEach(() => {
+  _resetLifecycleState();
+  vi.unstubAllGlobals();
+  vi.useRealTimers();
+});
+
+describe("[LC-5] armIdleTimer 超时回调身份比对", () => {
+  it("旧 timer 到点回调迟到执行（re-arm 已覆盖条目）→ 守卫不误删新条目，disarm 仍有效", () => {
+    const onTimeoutA = vi.fn();
+    const onTimeoutB = vi.fn();
+
+    armIdleTimer("sa-x", onTimeoutA, 1000); // timerA 入手 排程表，Map: timerA
+    // re-arm（agent_settled 刷新）：disarm 旧 timer（真实 Node 中 clearTimeout 对已
+    // 入队回调无效）→ timerB 入表，Map: timerB。此后 timerA 的回调才迟到执行。
+    armIdleTimer("sa-x", onTimeoutB, 1000);
+    expect(hasIdleTimer("sa-x")).toBe(true);
+
+    scheduled[0]?.fire(); // 旧 timerA 回调迟到执行
+
+    expect(onTimeoutA).toHaveBeenCalledTimes(1); // 旧超时回调本身照常触发
+    expect(hasIdleTimer("sa-x")).toBe(true); // [核心] 新条目未被误删（旧代码此处 false = 脱管）
+
+    disarmIdleTimer("sa-x"); // B 未脱管：disarm 有效
+    expect(hasIdleTimer("sa-x")).toBe(false);
+    expect(onTimeoutB).not.toHaveBeenCalled();
+  });
+
+  it("无交错：旧 timer 到点删除自己的条目（守卫不改变既有语义），后续 re-arm 正常", () => {
+    const onTimeoutA = vi.fn();
+    const onTimeoutB = vi.fn();
+
+    armIdleTimer("sa-y", onTimeoutA, 1000);
+    expect(hasIdleTimer("sa-y")).toBe(true);
+
+    scheduled[0]?.fire(); // 正常到点：Map 中是自己 → delete → 回调
+
+    expect(onTimeoutA).toHaveBeenCalledTimes(1);
+    expect(hasIdleTimer("sa-y")).toBe(false); // 旧条目删除正常（不残留失效 entry）
+
+    armIdleTimer("sa-y", onTimeoutB, 1000); // 后续 re-arm 正常
+    expect(hasIdleTimer("sa-y")).toBe(true);
+    scheduled[1]?.fire();
+    expect(onTimeoutB).toHaveBeenCalledTimes(1);
+    expect(hasIdleTimer("sa-y")).toBe(false);
+  });
+
+  it("fake timers 同轮交错：re-arm 发生在旧 timer 到期回调处置中 → 新 timer 存活到点触发", () => {
+    vi.useFakeTimers();
+    const onTimeoutB = vi.fn();
+    const onTimeoutA = vi.fn(() => {
+      // 到期回调处置中同步 re-arm（同轮交错的 fake-timer 可达形态）
+      armIdleTimer("sa-z", onTimeoutB, 1000);
+    });
+
+    armIdleTimer("sa-z", onTimeoutA, 1000);
+    vi.advanceTimersByTime(1000); // A 到点：删自己 → onTimeoutA → re-arm B
+
+    expect(onTimeoutA).toHaveBeenCalledTimes(1);
+    expect(hasIdleTimer("sa-z")).toBe(true); // B armed，交错不丢 timer
+
+    vi.advanceTimersByTime(999);
+    expect(onTimeoutB).not.toHaveBeenCalled(); // B 从 arm 时刻重新计时
+    vi.advanceTimersByTime(1);
+    expect(onTimeoutB).toHaveBeenCalledTimes(1); // B 存活到点正常触发
+    expect(hasIdleTimer("sa-z")).toBe(false); // 触发后 Map 清理干净
+  });
+});

package/src/execution/__tests__/lifecycle-manager.test.ts

@@ -9,6 +9,15 @@
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
+// [LC-7/T7①] Mock 共享 logger：env 非法值回落默认的 warn 留痕可被断言
+//（对齐 channel-registry-handshake.test.ts 模式；vi.mock 自动 hoist 到 import 前）。
+const { loggerMock } = vi.hoisted(() => ({
+  loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+vi.mock("../../core/logger.ts", () => ({
+  getLogger: () => loggerMock,
+}));
+
 import {
   DEFAULT_IDLE_TIMEOUT_MS,
   DEFAULT_MAX_ALIVE_PROCESSES,
@@ -30,6 +39,9 @@ describe("lifecycle-manager — V2 §5.2 模块 1", () => {
   beforeEach(() => {
     vi.useFakeTimers();
     _resetLifecycleState();
+    loggerMock.debug.mockClear();
+    loggerMock.warn.mockClear();
+    loggerMock.error.mockClear();
     // [F-4 同源修复] env 隔离：「默认超时」用例依赖 XYZ_SUBAGENT_IDLE_TIMEOUT_MS
     // 未设基线（getEnvIdleTimeoutMs 会覆盖 DEFAULT），宿主 export 即假红。空串 = 未设。
     vi.stubEnv("XYZ_SUBAGENT_IDLE_TIMEOUT_MS", "");
@@ -138,6 +150,33 @@ describe("lifecycle-manager — V2 §5.2 模块 1", () => {
       expect(() => armIdleTimer("sa-env-overflow", onTimeout)).toThrowError(/2147483647/);
       expect(hasIdleTimer("sa-env-overflow")).toBe(false);
     });
+
+    // [LC-7/T7①] env 非法值回落默认不再静默：warn 留痕（env 名 + 实际值 + 生效行为）。
+    // 「以为设了极长保活、实际回落 5min」的语义漂移必须可诊断。
+    it("[LC-7] env 非法值（'30m' 非纯数字）→ 回落 DEFAULT_IDLE_TIMEOUT_MS 且 warn 留痕", () => {
+      vi.stubEnv("XYZ_SUBAGENT_IDLE_TIMEOUT_MS", "30m");
+      const onTimeout = vi.fn();
+      armIdleTimer("sa-lc7-invalid", onTimeout); // 不传 timeoutMs → env（非法）→ DEFAULT
+
+      // 生效行为 = 默认 5min（非法值没有按字面 '30m' 也不按禁用处理）
+      vi.advanceTimersByTime(DEFAULT_IDLE_TIMEOUT_MS - 1);
+      expect(onTimeout).not.toHaveBeenCalled();
+      vi.advanceTimersByTime(1);
+      expect(onTimeout).toHaveBeenCalledTimes(1);
+
+      expect(loggerMock.warn).toHaveBeenCalledTimes(1);
+      const msg = String(loggerMock.warn.mock.calls[0]?.[0] ?? "");
+      expect(msg).toContain("XYZ_SUBAGENT_IDLE_TIMEOUT_MS"); // env 变量名
+      expect(msg).toContain("30m"); // 实际值
+      expect(msg).toContain("DEFAULT_IDLE_TIMEOUT_MS"); // 生效行为：回落默认
+    });
+
+    it("[LC-7] env 未设（空串基线）→ 静默走 DEFAULT，零 warn（未配置不是异常）", () => {
+      const onTimeout = vi.fn();
+      armIdleTimer("sa-lc7-clean", onTimeout);
+      expect(hasIdleTimer("sa-lc7-clean")).toBe(true);
+      expect(loggerMock.warn).not.toHaveBeenCalled();
+    });
   });
 
   // ============================================================

package/src/execution/__tests__/lifecycle-predicates.test.ts

@@ -10,7 +10,7 @@ import {
   disarmIdleTimer,
   _resetLifecycleState,
 } from "../lifecycle-manager.ts";
-import { spawnedChildren } from "../session-runner.ts";
+import { spawnedChildren } from "../engine/engines/pi/session-runner.ts";
 import type { ChildProcess } from "node:child_process";
 import type { ExecutionRecord } from "../types.ts";
 
@@ -25,7 +25,6 @@ function makeRecord(overrides: Partial<ExecutionRecord> = {}): ExecutionRecord {
     thinkingLevel: undefined,
     mode: "background",
     task: "test",
-    slug: "test",
     startedAt: Date.now(),
     rootSessionId: "root",
     parentRecordId: undefined,

package/src/execution/__tests__/manifest-parentid.test.ts

@@ -22,7 +22,7 @@ function makeBaseManifest(overrides: Partial<ManifestRecord> = {}): ManifestReco
     id: "rec-test",
     rootSessionId: "session-main",
     agentName: "worker",
-    status: "completed",
+    status: "closed",
     createdAt: 1000,
     ...overrides,
   };
@@ -38,7 +38,7 @@ describe("ManifestStore — parentRecordId 落盘 (M3a)", () => {
   });
 
   afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
+    fs.rmSync(tmpDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
   // ── TC-m3a-new-record-parentid ──
@@ -71,7 +71,7 @@ describe("ManifestStore — parentRecordId 落盘 (M3a)", () => {
       id: "rec-old",
       rootSessionId: "session-main",
       agentName: "worker",
-      status: "completed",
+      status: "closed",
       createdAt: 2000,
       // 无 parentRecordId —— 旧版本写的
     };
@@ -104,7 +104,7 @@ describe("ManifestStore — parentRecordId 落盘 (M3a)", () => {
       id: "rec-minimal",
       rootSessionId: "session-main",
       agentName: "worker",
-      status: "completed",
+      status: "closed",
       createdAt: 3000,
     };
     fs.writeFileSync(

package/src/execution/__tests__/manifest-store-tmp-recovery.test.ts

@@ -0,0 +1,99 @@
+// src/execution/__tests__/manifest-store-tmp-recovery.test.ts
+//
+// [u-svc / T5④ / PS-13] recoverTmpFiles 循环内 per-file 容错：
+// 单个 tmp 文件操作失败（ENOENT——并发回收/外部清理抢先）只 warn + 跳过，
+// 不再中断整轮——剩余 tmp 继续处理；返回值形态不变（跳过者不计数）。
+
+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 }));
+
+// fs partial mock：unlinkSync 可按路径注错，其余转发真实实现。
+const { unlinkSyncMock } = vi.hoisted(() => ({ unlinkSyncMock: vi.fn() }));
+vi.mock("node:fs", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("node:fs")>();
+  return {
+    ...actual,
+    unlinkSync: unlinkSyncMock,
+    default: { ...actual, unlinkSync: unlinkSyncMock },
+  };
+});
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { ManifestStore } from "../manifest-store.ts";
+
+const VALID_MANIFEST = {
+  id: "sa-good",
+  rootSessionId: "root-1",
+  agentName: "general-purpose",
+  createdAt: 1,
+  status: "running",
+};
+
+describe("T5④ recoverTmpFiles per-file tolerance", () => {
+  let dir: string;
+  let store: ManifestStore;
+
+  beforeEach(async () => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), "manifest-tmp-recovery-"));
+    store = new ManifestStore(dir);
+    // 真实 unlinkSync（mock 模块对象上的 unlinkSync 已被替换，不能自引用转发）
+    const actualFs = await vi.importActual<typeof import("node:fs")>("node:fs");
+    unlinkSyncMock.mockReset();
+    unlinkSyncMock.mockImplementation((p: fs.PathLike) => actualFs.unlinkSync(p));
+    loggerMock.warn.mockClear();
+    loggerMock.error.mockClear();
+    loggerMock.debug.mockClear();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("processes remaining tmp files when one unlink fails mid-loop", async () => {
+    const actualFs = await vi.importActual<typeof import("node:fs")>("node:fs");
+    // 三个 tmp：good（合法 → promote）、stale（manifest sa-stale.json 已存在 → 删）、
+    // doomed（unlink ENOENT）
+    fs.writeFileSync(path.join(dir, "sa-good.json.tmp.111"), JSON.stringify(VALID_MANIFEST));
+    fs.writeFileSync(path.join(dir, "sa-stale.json"), JSON.stringify(VALID_MANIFEST));
+    fs.writeFileSync(path.join(dir, "sa-stale.json.tmp.222"), "{}");
+    fs.writeFileSync(path.join(dir, "sa-doomed.json.tmp.333"), "not json");
+    const doomedPath = path.join(dir, "sa-doomed.json.tmp.333");
+    unlinkSyncMock.mockImplementation((p: fs.PathLike) => {
+      if (String(p) === doomedPath) {
+        const err = new Error("ENOENT: file vanished") as NodeJS.ErrnoException;
+        err.code = "ENOENT";
+        throw err;
+      }
+      return actualFs.unlinkSync(p);
+    });
+
+    const result = await store.recoverTmpFiles();
+
+    // 整轮不中断：doomed 之外的 tmp 全部处理完
+    expect(result.recovered).toBe(1); // good promote
+    expect(result.deleted).toBe(1); // stale 删
+    // good 被提升为正式 manifest
+    expect(fs.existsSync(path.join(dir, "sa-good.json"))).toBe(true);
+    // 失败留痕（warn 级，含文件名）
+    expect(loggerMock.warn).toHaveBeenCalledWith(
+      expect.stringContaining("sa-doomed.json.tmp.333"),
+      expect.objectContaining({ detail: expect.stringContaining("ENOENT") }),
+    );
+    expect(loggerMock.warn).toHaveBeenCalledWith(expect.stringContaining("1 of 3 tmp file(s)"));
+  });
+
+  it("returns counts unchanged and no warnings when all tmp files succeed", async () => {
+    fs.writeFileSync(path.join(dir, "sa-ok.json.tmp.444"), JSON.stringify(VALID_MANIFEST));
+    const result = await store.recoverTmpFiles();
+    expect(result).toEqual({ deleted: 0, recovered: 1 });
+    expect(loggerMock.warn).not.toHaveBeenCalled();
+  });
+});

package/src/execution/__tests__/max-turns-to-watchdog-ms.test.ts

@@ -0,0 +1,113 @@
+// src/execution/__tests__/max-turns-to-watchdog-ms.test.ts
+//
+// U3（subagent-core-sink-design）：computeWatchdogMs 语义化更名 maxTurnsToWatchdogMs
+// + floor 语义文档化。本文件锚定换算纯函数语义：
+//   - floor 断言（设计 §4 S2）：maxTurnsToWatchdogMs(2) >= 1_800_000——zsw 曾自实现
+//     无 floor 版本致 maxTurns=2 被 10min 误杀（设计 §2.1 例 1），floor 是两宿主
+//     预算一致性的锚点（G1）。
+//   - 边界：0.5 轮 / 缺省（不挂 watchdog）/ 极大值。
+//
+// 纯函数换算，无 timer 参与，无需 fake timers。
+import { describe, expect, it, vi } from "vitest";
+
+// [LC-7/T7①] Mock 共享 logger：非法 env 值的 warn 留痕可被断言
+//（对齐 channel-registry-handshake.test.ts 模式；vi.mock 自动 hoist 到 import 前）。
+const { loggerMock } = vi.hoisted(() => ({
+  loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+vi.mock("../../core/logger.ts", () => ({
+  getLogger: () => loggerMock,
+}));
+
+import {
+  maxTurnsToWatchdogMs,
+  resolveSpawnWatchdogMs,
+  SPAWN_WATCHDOG_ENV,
+} from "../engine/engines/pi/session-runner.ts";
+
+const MIN_MS = 60_000;
+/** watchdog floor（session-runner WATCHDOG_FLOOR_MINUTES=30 的毫秒值）。 */
+const FLOOR_MS = 30 * MIN_MS;
+/** Node setTimeout delay 安全域上界（>2^31-1 被置 1ms 立即触发，assertSafeTimerDelay 拦截域）。 */
+const TIMER_SAFE_MAX = 2 ** 31 - 1;
+
+describe("maxTurnsToWatchdogMs（U3 watchdog 换算，floor 语义）", () => {
+  it("floor 断言（S2）：maxTurns=2 → >= 1_800_000（floor 生效，非 2×5=10min）", () => {
+    expect(maxTurnsToWatchdogMs(2)).toBeGreaterThanOrEqual(1_800_000);
+    // 精确值锚定：floor 是 max 不是「至少再加余量」
+    expect(maxTurnsToWatchdogMs(2)).toBe(FLOOR_MS);
+  });
+
+  it("0.5 轮（小数）→ floor 30min（不出现 2.5min 的短 watchdog）", () => {
+    expect(maxTurnsToWatchdogMs(0.5)).toBe(FLOOR_MS);
+  });
+
+  it("maxTurns=6 → 恰为 floor 临界（max(30min, 30min)）", () => {
+    expect(maxTurnsToWatchdogMs(6)).toBe(FLOOR_MS);
+  });
+
+  it("线性段：maxTurns=20 → 100min；maxTurns=100 → 500min（M-1 长任务不被 30min 误杀）", () => {
+    expect(maxTurnsToWatchdogMs(20)).toBe(100 * MIN_MS);
+    expect(maxTurnsToWatchdogMs(100)).toBe(500 * MIN_MS);
+  });
+
+  it("极大值 → 保持纯算术结果（> 2^31-1 溢出域；挂载前由 assertSafeTimerDelay fail-fast 拦截）", () => {
+    expect(maxTurnsToWatchdogMs(Number.MAX_SAFE_INTEGER)).toBeGreaterThan(TIMER_SAFE_MAX);
+    expect(maxTurnsToWatchdogMs(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY);
+  });
+
+  it("上层防线：换算链路入口对极大值 fail-fast（resolveSpawnWatchdogMs(Infinity) 抛出）", () => {
+    expect(() => resolveSpawnWatchdogMs(Number.POSITIVE_INFINITY)).toThrow();
+  });
+
+  it("缺省（maxTurns 未传/null 且 env 未设）→ resolveSpawnWatchdogMs 返回 undefined（不挂 watchdog）", () => {
+    // 空串与未设同义（getEnvSpawnWatchdogMs 对 falsy raw 返回 undefined）；
+    // 显式 stub 防御宿主 shell export 污染（vitest.setup.ts 已在模块加载前净化）。
+    vi.stubEnv(SPAWN_WATCHDOG_ENV, "");
+    try {
+      expect(resolveSpawnWatchdogMs(undefined)).toBeUndefined();
+      expect(resolveSpawnWatchdogMs(null)).toBeUndefined();
+    } finally {
+      vi.unstubAllEnvs();
+    }
+  });
+
+  // [LC-7/T7①] env 非法值不再静默失效：warn 留痕（env 名 + 实际值 + 生效行为）。
+  it("[LC-7] env 设非法值（'30m' 非纯数字）→ undefined（不挂 watchdog）且 warn 留痕", () => {
+    vi.stubEnv(SPAWN_WATCHDOG_ENV, "30m");
+    try {
+      expect(resolveSpawnWatchdogMs(undefined)).toBeUndefined();
+      expect(loggerMock.warn).toHaveBeenCalledTimes(1);
+      const msg = String(loggerMock.warn.mock.calls[0]?.[0] ?? "");
+      expect(msg).toContain("XYZ_SUBAGENT_SPAWN_WATCHDOG_MS"); // env 变量名
+      expect(msg).toContain("30m"); // 实际值
+      expect(msg).toContain("NOT armed"); // 生效行为：等价关闭，运维可诊断「以为有兜底、实际裸奔」
+    } finally {
+      loggerMock.warn.mockClear();
+      vi.unstubAllEnvs();
+    }
+  });
+
+  it("[LC-7] env 设 <=0 → 同样 warn 留痕（不挂 watchdog，语义与非法值一致可见）", () => {
+    vi.stubEnv(SPAWN_WATCHDOG_ENV, "-5");
+    try {
+      expect(resolveSpawnWatchdogMs(undefined)).toBeUndefined();
+      expect(loggerMock.warn).toHaveBeenCalledTimes(1);
+      expect(String(loggerMock.warn.mock.calls[0]?.[0] ?? "")).toContain("-5");
+    } finally {
+      loggerMock.warn.mockClear();
+      vi.unstubAllEnvs();
+    }
+  });
+
+  it("[LC-7] env 未设（空串）→ 静默 undefined，零 warn（未配置不是异常，不制造噪音）", () => {
+    vi.stubEnv(SPAWN_WATCHDOG_ENV, "");
+    try {
+      expect(resolveSpawnWatchdogMs(undefined)).toBeUndefined();
+      expect(loggerMock.warn).not.toHaveBeenCalled();
+    } finally {
+      loggerMock.warn.mockClear();
+      vi.unstubAllEnvs();
+    }
+  });
+});

package/src/execution/__tests__/model-resolver.test.ts

@@ -422,12 +422,12 @@ describe("ModelConfigService: ctx.model plumb-through (EA-4)", () => {
     tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "subagents-resolver-test-"));
   });
   afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
+    fs.rmSync(tmpDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
   /** 构造已 initModel 的 ModelConfigService，ctxModel 注入缓存。 */
   function makeService(ctxModel: ModelInfo | undefined, registry: ModelRegistryLike = makeRegistry([])): ModelConfigService {
-    const svc = new ModelConfigService({ agentDir: tmpDir });
+    const svc = new ModelConfigService({ agentDir: tmpDir, cwd: tmpDir });
     svc.initModel({
       modelRegistry: registry,
       sessionId: "test-session",

package/src/execution/__tests__/nested-visibility-env-propagation.test.ts

@@ -9,96 +9,28 @@
 //   TC-3d: 子进程 execute 创建的 record.rootSessionId = env 贯穿的真 ROOT
 //   TC-3e: 子进程 collectRecords 用 sessionRootId 过滤
 //
-// mock 策略与 recursive-visibility-baseline.test.ts 一致。
-
-import type { PassThrough } from "node:stream";
+// mock 策略与 recursive-visibility-baseline.test.ts 一致（已收敛
+// ./helpers/subagent-service-mocks.ts 四文件共享单源）。
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
-// ── mock modules ──
-
-vi.mock("node:child_process", async () => {
-  const { EventEmitter } = await import("node:events");
-  const { PassThrough } = await import("node:stream");
-
-  class FakeChild extends EventEmitter {
-    pid = 12345;
-    stdout = new PassThrough();
-    stderr = new PassThrough();
-    killed = false;
-    killSignal: string | undefined;
-    kill(sig?: string): boolean {
-      this.killed = true;
-      this.killSignal = sig;
-      return true;
-    }
-  }
-
-  return {
-    spawn: vi.fn(() => new FakeChild()),
-    // buildEnvBlock 用 execFile 异步取 git branch：默认 err-first 兜底（catch → branch=""）
-    execFile: vi.fn(
-      (
-        _cmd: string,
-        _args: readonly string[],
-        _opts: unknown,
-        cb: (err: Error | null, stdout?: string, stderr?: string) => void,
-      ) => cb(new Error("execFile not configured in this test")),
-    ),
-  };
-});
+import {
+  aliveStoreModule,
+  childProcessModule,
+  finalizedMarkerModule,
+  fsSyncModule,
+  manifestStoreModule,
+  tempPromptModule,
+} from "./helpers/subagent-service-mocks.ts";
 
-vi.mock("node:fs", async () => {
-  const actual = await import("node:fs");
-  return {
-    default: {
-      ...actual,
-      mkdirSync: vi.fn(),
-      existsSync: vi.fn(() => false),
-      appendFileSync: vi.fn(),
-      writeFileSync: vi.fn(),
-      readdirSync: vi.fn(() => []),
-    },
-    mkdirSync: vi.fn(),
-    existsSync: vi.fn(() => false),
-    appendFileSync: vi.fn(),
-    writeFileSync: vi.fn(),
-    readdirSync: vi.fn(() => []),
-    promises: actual.promises,
-  };
-});
-
-vi.mock("../alive-store.ts", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("../alive-store.ts")>();
-  return {
-    ...actual,
-    writeAliveMarker: vi.fn(),
-    removeAliveMarker: vi.fn(),
-  };
-});
-
-vi.mock("../finalized-marker.ts", () => ({
-  writeFinalized: vi.fn(),
-  readFinalized: vi.fn(() => false),
-}));
-
-vi.mock("../manifest-store.ts", () => {
-  class FakeManifestStore {
-    writeManifest = vi.fn(async () => {});
-    readManifest = vi.fn(async () => null);
-    listAllSync = vi.fn(() => []);
-    recoverTmpFiles = vi.fn(async () => []);
-  }
-  return { ManifestStore: vi.fn(function (_recordsDir: string) { return new FakeManifestStore(); }) };
-});
+// ── mock modules ──
 
-vi.mock("../temp-prompt.ts", () => ({
-  writePromptToTempFile: vi.fn(async (agent: string) => {
-    const safeName = agent.replace(/[^\w.-]+/g, "_");
-    return { dir: `/tmp/fake-${safeName}`, filePath: `/tmp/fake-${safeName}/prompt-${safeName}.md` };
-  }),
-  cleanupTempPrompt: vi.fn(async () => {}),
-}));
+vi.mock("node:child_process", () => childProcessModule());
+vi.mock("node:fs", async (importOriginal) => fsSyncModule(await importOriginal<typeof import("node:fs")>()));
+vi.mock("../alive-store.ts", async (importOriginal) => aliveStoreModule(await importOriginal<typeof import("../alive-store.ts")>()));
+vi.mock("../finalized-marker.ts", () => finalizedMarkerModule());
+vi.mock("../manifest-store.ts", () => manifestStoreModule());
+vi.mock("../engine/engines/pi/temp-prompt.ts", () => tempPromptModule());
 
 import { spawn } from "node:child_process";
 
@@ -119,42 +51,10 @@ const ENV_ROOT_CWD = "PI_SUBAGENT_ROOT_CWD";
 
 // ── helpers ──
 
-interface FakeChild {
-  pid: number;
-  stdout: PassThrough;
-  stderr: PassThrough;
-  killed: boolean;
-  killSignal: string | undefined;
-  kill(sig?: string): boolean;
-  emit(event: string, ...args: unknown[]): boolean;
-}
-
-function lastSpawnedChild(): FakeChild {
-  const result = mockSpawn.mock.results.at(-1);
-  if (!result) throw new Error("spawn was not called yet");
-  return result.value as FakeChild;
-}
-
 function getLastSpawnEnv(): Record<string, string | undefined> {
   return (mockSpawn.mock.calls.at(-1)?.[2]?.env as Record<string, string | undefined>) ?? {};
 }
 
-function sessionHeader(id = "env-prop-session"): Record<string, unknown> {
-  return { type: "session", id, timestamp: "2026-08-11T00-00-00-000Z", cwd: "/tmp/test" };
-}
-
-function emitStdoutLine(child: FakeChild, obj: Record<string, unknown>): void {
-  child.stdout.write(`${JSON.stringify(obj)}\n`);
-}
-
-async function driveChildToCompletion(child: FakeChild, events: Record<string, unknown>[] = []): Promise<void> {
-  emitStdoutLine(child, sessionHeader());
-  for (const e of events) emitStdoutLine(child, e);
-  child.stdout.end();
-  child.stderr.end();
-  child.emit("close", 0);
-}
-
 function makeEmptyRegistry(): ModelRegistryLike {
   return { getAvailable: () => [], find: () => undefined, hasConfiguredAuth: () => true };
 }
@@ -167,7 +67,7 @@ const ctxModel: ModelInfo = { id: "m", name: "M", provider: "p", reasoning: fals
 
 function setupService(sessionId: string, env?: Record<string, string>): SubagentService {
   const agentDir = "/tmp/env-prop-it";
-  const modelService = new ModelConfigService({ agentDir });
+  const modelService = new ModelConfigService({ agentDir, cwd: agentDir });
   modelService.initModel({
     modelRegistry: makeEmptyRegistry(),
     sessionId,
@@ -225,8 +125,8 @@ describe("TC-3: PI_SUBAGENT_ROOT_SESSION_ID env 贯穿正确", () => {
     const sessionRootId = Reflect.get(service, "sessionRootId") as string;
     expect(sessionRootId).toBe("root-main-session");
 
-    // B 的 execCtxBaseline 记录了 B 自己的身份（recordId + depth）
-    const baseline = Reflect.get(service, "execCtxBaseline") as { recordId: string; depth: number };
+    // B 的嵌套基线记录了 B 自己的身份（recordId + depth；[D3-⑤] execNesting 公共层）
+    const baseline = (Reflect.get(service, "execNesting") as { baseline(): { recordId: string; depth: number } | null }).baseline()!;
     expect(baseline.recordId).toBe("sa-a-record");
     expect(baseline.depth).toBe(1);
   });
@@ -241,6 +141,7 @@ describe("TC-3: PI_SUBAGENT_ROOT_SESSION_ID env 贯穿正确", () => {
     // execute 创建 record（模拟 B 内创建 C）
     const handle = await service.execute({
       task: "nested task",
+      slug: "test",
       ctxModel,
     });
     const store = Reflect.get(service, "store") as RecordStore;
@@ -268,6 +169,7 @@ describe("TC-3: PI_SUBAGENT_ROOT_SESSION_ID env 贯穿正确", () => {
       agent: "worker",
       model: "test/model",
       mode: "background",
+      slug: "t",
       task: "deep nested",
       startedAt: Date.now(),
       rootSessionId: "root-main-session",
@@ -277,7 +179,7 @@ describe("TC-3: PI_SUBAGENT_ROOT_SESSION_ID env 贯穿正确", () => {
     store.register(recordC);
 
     // collectRecords（不带 filter）用 this.sessionRootId 过滤
-    const viaService = service.collectRecords(100);
+    const viaService = service.queries.collectRecords(100);
     const ids = viaService.map((r) => r.id);
 
     // C 的 record 归 ROOT（rootSessionId=root-main-session），能被子进程查到

package/src/execution/__tests__/nested-visibility.test.ts

@@ -195,6 +195,7 @@ describe("TC-2: collectRecords 返回全树（含深层）", () => {
       agent: "worker",
       model: "test/model",
       mode: "background",
+      slug: "t",
       task: "task C",
       startedAt: 3000,
       rootSessionId: ROOT_SESSION,
@@ -286,6 +287,7 @@ describe("TC-2: collectRecords 返回全树（含深层）", () => {
       agent: "worker",
       model: "test/model",
       mode: "background",
+      slug: "t",
       task: "task C",
       startedAt: 3000,
       rootSessionId: ROOT_SESSION,