@zhushanwen/subagent-core 0.7.1 → 0.9.0

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

@@ -1,10 +1,8 @@
-// lifecycle-manager 单测 —— V2 §5.2 模块 1（进程生命周期管理）五项职责。
+// lifecycle-manager 单测 —— V2 §5.2 模块 1 现存唯一职责（idle timer）。原职责 2/3/4
+// 骨架未接线、职责 5 activate 互斥无生产调用方，已随简化清扫删除。
 //
 // 测试策略：
-//   - idle timer / ceiling LRU 用 vi.useFakeTimers() + advanceTimersByTime（同时 mock
-//     Date.now()，让 lastTouched 时间戳可控）。
-//   - activate 互斥锁是纯 Promise 链（无 timer），用 advanceTimersByTimeAsync(0)
-//     flush microtask 验证串行化。
+//   - idle timer 用 vi.useFakeTimers() + advanceTimersByTime。
 //   - 每个用例 beforeEach 调 _resetLifecycleState() 隔离模块级单例状态。
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
@@ -20,19 +18,10 @@ vi.mock("../../core/logger.ts", () => ({
 
 import {
   DEFAULT_IDLE_TIMEOUT_MS,
-  DEFAULT_MAX_ALIVE_PROCESSES,
   _resetLifecycleState,
-  acquireActivateLock,
   armIdleTimer,
   disarmIdleTimer,
-  evictIfOverCeiling,
-  getActiveProcessCount,
   hasIdleTimer,
-  reapAllAliveProcesses,
-  registerActiveProcess,
-  scanOrphanProcesses,
-  touchActiveProcess,
-  unregisterActiveProcess,
 } from "../lifecycle-manager.ts";
 
 describe("lifecycle-manager — V2 §5.2 模块 1", () => {
@@ -179,244 +168,4 @@ describe("lifecycle-manager — V2 §5.2 模块 1", () => {
     });
   });
 
-  // ============================================================
-  // 职责 2：全局 ceiling（LRU 挤出）
-  // ============================================================
-  describe("职责2 全局 ceiling", () => {
-    it("register 超过上限时 evictIfOverCeiling 挤出最久空闲", () => {
-      registerActiveProcess("sa-1"); // 最早
-      vi.advanceTimersByTime(10);
-      registerActiveProcess("sa-2");
-      vi.advanceTimersByTime(10);
-      registerActiveProcess("sa-3"); // 超限（size=3 > ceiling=2）
-      expect(getActiveProcessCount()).toBe(3);
-
-      const evicted: string[] = [];
-      evictIfOverCeiling((id) => evicted.push(id), 2);
-
-      expect(evicted).toEqual(["sa-1"]); // lastTouched 最老的被挤出
-      expect(getActiveProcessCount()).toBe(2);
-    });
-
-    it("不超过上限时 evictIfOverCeiling 不挤出", () => {
-      registerActiveProcess("sa-1");
-      registerActiveProcess("sa-2");
-
-      const evicted: string[] = [];
-      evictIfOverCeiling((id) => evicted.push(id), 5);
-
-      expect(evicted).toEqual([]);
-      expect(getActiveProcessCount()).toBe(2);
-    });
-
-    it("touch 更新 LRU：被 touch 的不再是挤出候选", () => {
-      registerActiveProcess("sa-1");
-      vi.advanceTimersByTime(10);
-      registerActiveProcess("sa-2");
-      vi.advanceTimersByTime(10);
-      touchActiveProcess("sa-1"); // sa-1 变最新 → sa-2 变最老
-
-      const evicted: string[] = [];
-      evictIfOverCeiling((id) => evicted.push(id), 1);
-
-      expect(evicted).toEqual(["sa-2"]); // sa-2 最久未 touch，被挤出
-    });
-
-    it("touch 不存在的 record 为 no-op（不隐式创建）", () => {
-      expect(() => touchActiveProcess("never-registered")).not.toThrow();
-      expect(getActiveProcessCount()).toBe(0);
-    });
-
-    it("unregister 清理活进程集合", () => {
-      registerActiveProcess("sa-1");
-      registerActiveProcess("sa-2");
-      unregisterActiveProcess("sa-1");
-      expect(getActiveProcessCount()).toBe(1);
-    });
-
-    it("挤出时连带 disarm 被挤 record 的 idle timer", () => {
-      registerActiveProcess("sa-1");
-      armIdleTimer("sa-1", vi.fn(), 1000);
-      registerActiveProcess("sa-2");
-      vi.advanceTimersByTime(10);
-      registerActiveProcess("sa-3"); // sa-1 最老，将被挤出
-
-      evictIfOverCeiling(() => {
-        /* kill */
-      }, 2);
-
-      expect(hasIdleTimer("sa-1")).toBe(false); // 挤出 cascade disarm
-    });
-
-    it("unregister 连带 disarm idle timer（进程终态 timer 不残留）", () => {
-      registerActiveProcess("sa-1");
-      armIdleTimer("sa-1", vi.fn(), 1000);
-      unregisterActiveProcess("sa-1");
-      expect(hasIdleTimer("sa-1")).toBe(false);
-    });
-
-    it("默认上限 = DEFAULT_MAX_ALIVE_PROCESSES（不传 maxAlive）", () => {
-      for (let i = 0; i < DEFAULT_MAX_ALIVE_PROCESSES; i++) {
-        registerActiveProcess(`sa-${i}`);
-        vi.advanceTimersByTime(1); // 保证 lastTouched 严格递增
-      }
-      registerActiveProcess("sa-over"); // 超限
-      const evicted: string[] = [];
-      evictIfOverCeiling((id) => evicted.push(id)); // 用默认上限
-
-      expect(evicted).toEqual(["sa-0"]); // 默认上限下挤出最早
-      expect(getActiveProcessCount()).toBe(DEFAULT_MAX_ALIVE_PROCESSES);
-    });
-
-    it("大幅超限时 while 循环挤出多个直到 ≤ ceiling", () => {
-      for (let i = 0; i < 5; i++) {
-        registerActiveProcess(`sa-${i}`);
-        vi.advanceTimersByTime(1);
-      }
-      const evicted: string[] = [];
-      evictIfOverCeiling((id) => evicted.push(id), 2);
-
-      expect(evicted).toEqual(["sa-0", "sa-1", "sa-2"]); // 挤出 3 个（5-2），按 LRU
-    });
-  });
-
-  // ============================================================
-  // 职责 3：shutdown 收割
-  // ============================================================
-  describe("职责3 shutdown 收割", () => {
-    it("reapAllAliveProcesses 遍历活进程调 killFn 并返回列表", () => {
-      registerActiveProcess("sa-1");
-      registerActiveProcess("sa-2");
-
-      const killed: string[] = [];
-      const reaped = reapAllAliveProcesses((id) => killed.push(id));
-
-      expect(killed).toHaveLength(2);
-      expect(killed).toEqual(expect.arrayContaining(["sa-1", "sa-2"]));
-      expect(reaped).toEqual(expect.arrayContaining(["sa-1", "sa-2"]));
-      expect(getActiveProcessCount()).toBe(0);
-    });
-
-    it("reap 后 idle timer 已 disarm（advance 不再触发）", () => {
-      registerActiveProcess("sa-1");
-      const onTimeout = vi.fn();
-      armIdleTimer("sa-1", onTimeout, 1000);
-
-      reapAllAliveProcesses(() => {
-        /* kill */
-      });
-      vi.advanceTimersByTime(10000);
-
-      expect(onTimeout).not.toHaveBeenCalled(); // timer 已被 reap 清理
-    });
-
-    it("无活进程时 reapAll 返回空列表", () => {
-      const reaped = reapAllAliveProcesses(() => {
-        /* kill */
-      });
-      expect(reaped).toEqual([]);
-    });
-  });
-
-  // ============================================================
-  // 职责 4：孤儿扫描
-  // ============================================================
-  describe("职责4 孤儿扫描", () => {
-    it("pid 存活 + 不在活进程集合 = 孤儿", () => {
-      registerActiveProcess("sa-active"); // 在集合内
-      const records = [
-        { id: "sa-active", pid: 100 },
-        { id: "sa-orphan", pid: 200 }, // pid 活但不在集合 → 孤儿
-        { id: "sa-dead", pid: 300 }, // pid 不活 → 非孤儿
-        { id: "sa-nopid" }, // 无 pid → 非孤儿
-      ];
-
-      const orphans = scanOrphanProcesses(records, (pid) => pid === 100 || pid === 200);
-
-      expect(orphans).toEqual(["sa-orphan"]);
-    });
-
-    it("pid 不存活 = 非孤儿", () => {
-      const records = [{ id: "sa-1", pid: 999 }];
-      const orphans = scanOrphanProcesses(records, () => false); // 全不活
-      expect(orphans).toEqual([]);
-    });
-
-    it("在活进程集合内 = 非孤儿（即使 pid 活）", () => {
-      registerActiveProcess("sa-1");
-      const records = [{ id: "sa-1", pid: 100 }];
-      const orphans = scanOrphanProcesses(records, () => true);
-      expect(orphans).toEqual([]);
-    });
-
-    it("无 pid 的 record 不视为孤儿", () => {
-      const records = [
-        { id: "sa-1" },
-        { id: "sa-2", sessionFile: "/x.jsonl" },
-      ];
-      const orphans = scanOrphanProcesses(records, () => true);
-      expect(orphans).toEqual([]);
-    });
-
-    it("扫描是只读（不改活进程集合）", () => {
-      registerActiveProcess("sa-1");
-      scanOrphanProcesses([{ id: "sa-2", pid: 200 }], () => true);
-      expect(getActiveProcessCount()).toBe(1); // 集合不变
-    });
-  });
-
-  // ============================================================
-  // 职责 5：activate 互斥锁
-  // ============================================================
-  describe("职责5 activate 互斥锁", () => {
-    it("首次 acquire 立即 resolve 返回 release 函数", async () => {
-      const release = await acquireActivateLock("sa-1");
-      expect(typeof release).toBe("function");
-      release();
-    });
-
-    it("并发 acquire 同一 recordId 串行化：第二次等首次 release", async () => {
-      const release1 = await acquireActivateLock("sa-1");
-
-      let secondResolved = false;
-      const secondPromise = acquireActivateLock("sa-1").then((r) => {
-        secondResolved = true;
-        return r;
-      });
-
-      await vi.advanceTimersByTimeAsync(0); // flush microtask
-      expect(secondResolved).toBe(false); // 还在等首次 release
-
-      release1();
-      await vi.advanceTimersByTimeAsync(0); // flush microtask
-      expect(secondResolved).toBe(true);
-
-      const release2 = await secondPromise;
-      release2();
-    });
-
-    it("不同 recordId 不互斥（各自独立链）", async () => {
-      const release1 = await acquireActivateLock("sa-1");
-
-      let secondResolved = false;
-      acquireActivateLock("sa-2").then((r) => {
-        secondResolved = true;
-        r();
-      });
-
-      await vi.advanceTimersByTimeAsync(0); // flush microtask
-      expect(secondResolved).toBe(true); // sa-2 不被 sa-1 阻塞
-
-      release1();
-    });
-
-    it("release 后同 recordId 可再次 acquire", async () => {
-      const r1 = await acquireActivateLock("sa-1");
-      r1();
-
-      const r2 = await acquireActivateLock("sa-1");
-      expect(typeof r2).toBe("function");
-      r2();
-    });
-  });
 });

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

@@ -1,8 +1,14 @@
 // src/execution/__tests__/manifest-store-tmp-recovery.test.ts
 //
-// [u-svc / T5④ / PS-13] recoverTmpFiles 循环内 per-file 容错：
-// 单个 tmp 文件操作失败（ENOENT——并发回收/外部清理抢先）只 warn + 跳过，
-// 不再中断整轮——剩余 tmp 继续处理；返回值形态不变（跳过者不计数）。
+// [U4c / G3] tmp 恢复退役（D6）：sweepTmpFiles 语义 = 全部 tmp **静默删除**——
+// manifest 已是可丢可重建缓存（权威 = `.state`，重建 = RecordStore.rebuildIndexes），
+// promote 半写 tmp 的恢复语义失效。断言面：
+//   - 合法 JSON 的 tmp（旧 promote 分支 2 形态）也删——promote 退役的核心锚点；
+//   - manifest 已存在时的陈旧 tmp（旧分支 1 形态）删；
+//   - 非法 JSON 的 tmp（旧分支 3 形态）删；
+//   - 返回删除计数（promote 退役后无恢复形态；公开转发链 recoverManifestTmpFiles 签名不变）；
+//   - [T5④ / PS-13] per-file 容错保留：单个 tmp 删除失败（ENOENT——并发回收/外部
+//     清理抢先）只 warn + 跳过，不再中断整轮。
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
@@ -36,7 +42,7 @@ const VALID_MANIFEST = {
   status: "running",
 };
 
-describe("T5④ recoverTmpFiles per-file tolerance", () => {
+describe("[U4c/G3] sweepTmpFiles 静默删除（promote 语义失效；H4/U5 更名收口）", () => {
   let dir: string;
   let store: ManifestStore;
 
@@ -57,15 +63,32 @@ describe("T5④ recoverTmpFiles per-file tolerance", () => {
     fs.rmSync(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
-  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）
+  it("合法 tmp + manifest 缺失（旧 promote 形态）→ 删而非提升（promote 退役锚点）", async () => {
     fs.writeFileSync(path.join(dir, "sa-good.json.tmp.111"), JSON.stringify(VALID_MANIFEST));
+    const result = await store.sweepTmpFiles();
+    // 重建源 = `.state` + rebuildIndexes——半写 tmp 不再被复活成「看似权威」的索引
+    expect(result).toBe(1);
+    expect(fs.existsSync(path.join(dir, "sa-good.json"))).toBe(false);
+    expect(fs.existsSync(path.join(dir, "sa-good.json.tmp.111"))).toBe(false);
+    expect(loggerMock.warn).not.toHaveBeenCalled();
+  });
+
+  it("manifest 已存在 + 非法 JSON tmp → 全删，幸存 manifest 不动", async () => {
     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");
+    fs.writeFileSync(path.join(dir, "sa-junk.json.tmp.333"), "not json");
+    const result = await store.sweepTmpFiles();
+    expect(result).toBe(2);
+    expect(fs.existsSync(path.join(dir, "sa-stale.json"))).toBe(true);
+    expect(fs.existsSync(path.join(dir, "sa-stale.json.tmp.222"))).toBe(false);
+    expect(fs.existsSync(path.join(dir, "sa-junk.json.tmp.333"))).toBe(false);
+  });
+
+  it("per-file 容错保留：单个 unlink ENOENT 只 warn 跳过，不中断整轮", async () => {
+    const actualFs = await vi.importActual<typeof import("node:fs")>("node:fs");
+    fs.writeFileSync(path.join(dir, "sa-a.json.tmp.444"), "not json");
+    fs.writeFileSync(path.join(dir, "sa-doomed.json.tmp.555"), "not json");
+    const doomedPath = path.join(dir, "sa-doomed.json.tmp.555");
     unlinkSyncMock.mockImplementation((p: fs.PathLike) => {
       if (String(p) === doomedPath) {
         const err = new Error("ENOENT: file vanished") as NodeJS.ErrnoException;
@@ -75,25 +98,23 @@ describe("T5④ recoverTmpFiles per-file tolerance", () => {
       return actualFs.unlinkSync(p);
     });
 
-    const result = await store.recoverTmpFiles();
+    const result = await store.sweepTmpFiles();
 
-    // 整轮不中断：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);
+    // 整轮不中断：doomed 之外的 tmp 处理完
+    expect(result).toBe(1);
+    expect(fs.existsSync(path.join(dir, "sa-a.json.tmp.444"))).toBe(false);
     // 失败留痕（warn 级，含文件名）
     expect(loggerMock.warn).toHaveBeenCalledWith(
-      expect.stringContaining("sa-doomed.json.tmp.333"),
+      expect.stringContaining("sa-doomed.json.tmp.555"),
       expect.objectContaining({ detail: expect.stringContaining("ENOENT") }),
     );
-    expect(loggerMock.warn).toHaveBeenCalledWith(expect.stringContaining("1 of 3 tmp file(s)"));
+    expect(loggerMock.warn).toHaveBeenCalledWith(expect.stringContaining("1 of 2 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 });
+  it("无 tmp 残留 → 零副作用零告警", async () => {
+    fs.writeFileSync(path.join(dir, "sa-quiescent.json"), JSON.stringify(VALID_MANIFEST));
+    const result = await store.sweepTmpFiles();
+    expect(result).toBe(0);
     expect(loggerMock.warn).not.toHaveBeenCalled();
   });
 });

package/src/execution/__tests__/model-config-service.test.ts

@@ -0,0 +1,111 @@
+// src/execution/__tests__/model-config-service.test.ts
+//
+// [H3/R5 测试归位] ModelConfigService 自有域测试文件。本文件用例自
+// subagent-service.test.ts「ModelConfigService ctxModel 缓存」describe 整块迁入
+//（用例名与断言零改动，纯移动——被测主体是 ModelConfigService 模块而非
+// SubagentService，按被测主体归属原则从 God-class 级测试文件拆出）。
+//
+// ============================================================
+// ModelConfigService ctxModel 缓存(renderCall 标题行 model 显示的核心)
+// ============================================================
+//
+// [HISTORICAL] 99f20da1e 后 renderCall 拿不到主 agent model(ToolRenderContext 无 model),
+// resolveModel 第三层拗错→降级不显示 model。修复:session_start 缓存 ctxModel,
+// resolveModel 第三参默认用缓存。此测试验证该透传链路。
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { ModelConfigService } from "../model-config-service.ts";
+import type { ModelInfo, ModelRegistryLike } from "../model-resolver.ts";
+
+// ── 工具:建临时 agentDir + 真实 ModelConfigService（自 subagent-service.test.ts 迁移段自持副本）──
+
+function makeTmpAgentDir(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagents-test-"));
+  return dir;
+}
+
+function makeModelService(agentDir: string): ModelConfigService {
+  return new ModelConfigService({ agentDir, cwd: agentDir });
+}
+
+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/);
+  });
+});

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

@@ -17,7 +17,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import {
   aliveStoreModule,
   childProcessModule,
-  finalizedMarkerModule,
+  stateMarkerModule,
   fsSyncModule,
   manifestStoreModule,
 } from "./helpers/subagent-service-mocks.ts";
@@ -29,7 +29,7 @@ import { clearEngines } from "../engine/registry.ts";
 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("../state-marker.ts", () => stateMarkerModule());
 vi.mock("../manifest-store.ts", () => manifestStoreModule());
 
 import { spawn } from "node:child_process";
@@ -101,7 +101,9 @@ describe("TC-3: PI_SUBAGENT_ROOT_SESSION_ID env 贯穿正确", () => {
 
   it("TC-3a: 根进程 initSession：无 env → sessionRootId = sessionId（自己是 ROOT）", () => {
     const service = setupService("root-it");
-    const sessionRootId = Reflect.get(service, "sessionRootId") as string;
+    // [R1 深绑改写] sessionRootId 随域 #2 聚合迁入 SessionBaselines，深绑路径改为
+    // service → baselines 聚合实例（断言对象与强度不变，路径对齐终态结构）。
+    const sessionRootId = (Reflect.get(service, "baselines") as { sessionRootId: string | null }).sessionRootId as string;
     expect(sessionRootId).toBe("root-it");
   });
 
@@ -109,7 +111,8 @@ describe("TC-3: PI_SUBAGENT_ROOT_SESSION_ID env 贯穿正确", () => {
     process.env[ENV_ROOT_SESSION_ID] = "real-root-session";
     const service = setupService("child-session");
 
-    const sessionRootId = Reflect.get(service, "sessionRootId") as string;
+    // [R1 深绑改写] 同上：sessionRootId 经 baselines 聚合路径读取。
+    const sessionRootId = (Reflect.get(service, "baselines") as { sessionRootId: string | null }).sessionRootId as string;
     expect(sessionRootId).toBe("real-root-session"); // env 贯穿，不是 child-session
   });
 
@@ -122,11 +125,12 @@ describe("TC-3: PI_SUBAGENT_ROOT_SESSION_ID env 贯穿正确", () => {
     const service = setupService("b-session");
 
     // B 的 sessionRootId 仍为 ROOT（env 贯穿，不被 B 自己的 sessionId 覆盖）
-    const sessionRootId = Reflect.get(service, "sessionRootId") as string;
+    // [R1 深绑改写] 同上：sessionRootId / execNesting 经 baselines 聚合路径读取。
+    const sessionRootId = (Reflect.get(service, "baselines") as { sessionRootId: string | null }).sessionRootId as string;
     expect(sessionRootId).toBe("root-main-session");
 
     // B 的嵌套基线记录了 B 自己的身份（recordId + depth；[D3-⑤] execNesting 公共层）
-    const baseline = (Reflect.get(service, "execNesting") as { baseline(): { recordId: string; depth: number } | null }).baseline()!;
+    const baseline = ((Reflect.get(service, "baselines") as { execNesting: { baseline(): { recordId: string; depth: number } | null } }).execNesting).baseline()!;
     expect(baseline.recordId).toBe("sa-a-record");
     expect(baseline.depth).toBe(1);
   });

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

@@ -13,11 +13,23 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import { createRecord } from "../execution-record.ts";
 import { RecordStore } from "../record-store.ts";
 
+// [Gate A teardown 稳定性] no-op 掉索引落盘。根因：collectRecords 扫描尾的
+// flushIndexAfterScan（record-store.ts）fire-and-forget saveIndex（tmp+fsync+rename
+// 异步 fs），满载下该 promise 可能在本文件 teardown 之后才 settle，其失败分支经
+// logger.warn → console.warn 上报 vitest（rpc onUserConsoleLog 在途）——worker 关闭
+// rpc 时在途调用被 reject 为 EnvironmentTeardownError（0 断言失败，纯 teardown 时序）。
+// 本文件用一次性 tmpdir、断言不观察索引文件，落盘与否无观察者——no-op 消除在途 IO
+// 链，任何负载下确定；loadIndex 等其余导出保留原实现（磁盘重建语义不变）。
+vi.mock("../sessions-index.ts", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("../sessions-index.ts")>()),
+  saveIndex: async () => {},
+}));
+
 // ── helpers ──
 
 /**

package/src/execution/__tests__/notify-ledger.test.ts

@@ -917,6 +917,47 @@ describe("createNotifier — ledger 四步接线（U2）", () => {
     notifier.dispose();
   });
 
+  it("dedupKey 显式覆盖 notifyId（drain 丢弃通知独立身份）：同轮失败通知 key 不互吞，同 key 重放仍幂等；缺省回退 `id` / `id:round` 不变", () => {
+    const ledgerMock = makeLedgerHost();
+    const notifierHost = makeNotifierHost();
+    // 桥接：ledger sendDelivery → notifier host.sendMessage（模拟 index.ts 装配）
+    ledgerMock.host.sendDelivery = (message) => {
+      notifierHost.sendMessage(message, { triggerTurn: true });
+      if (ledgerMock.deliverPersists.value) {
+        ledgerMock.sessionEntries.push({
+          type: "custom_message",
+          customType: message.customType,
+          content: message.content,
+          display: message.display,
+          details: message.details,
+        });
+      }
+    };
+    bindNotifyLedgerHost(ledgerMock.host);
+
+    const notifier = createNotifier(notifierHost);
+    // 场景复刻（conversation-continuation drain 丢弃修复）：同 id 同轮——失败单发缺省
+    // key `id:round`，丢弃通知 dedupKey `id:round:drain-drop` → 两条都写账送达（修复
+    // 前丢弃通知沿用缺省 key 被幂等吞，「队列消息被丢」反馈永不可达）。
+    const failedRound = { id: "sa-drain", status: "closed" as const, outcome: "failed" as const, agent: "w", round: 1, startedAt: 1, endedAt: 2 };
+    notifier.notify({ ...failedRound, error: "round did not complete: crash" });
+    notifier.notify({ ...failedRound, error: "queued message could not be dispatched", dedupKey: "sa-drain:1:drain-drop" });
+    // 同 dedupKey 重放 = 同一显式反馈 → 幂等吞（去重语义保留，非全量放行）
+    notifier.notify({ ...failedRound, error: "dropped again", dedupKey: "sa-drain:1:drain-drop" });
+
+    expect(notifierHost.sentMessages).toHaveLength(2);
+    expect(notifierHost.sentMessages[0]?.details).toMatchObject({ notifyId: "sa-drain:1" });
+    expect(notifierHost.sentMessages[1]?.details).toMatchObject({ notifyId: "sa-drain:1:drain-drop" });
+
+    // 缺省回退（dedupKey 未设）：无 round → 裸 id（notifyClosed 终态通知消费形态），
+    // 与 `id:round` / `id:round:drain-drop` 互不吞——key 空间三形态互斥
+    notifier.notify({ ...failedRound, round: undefined, error: "closed" });
+    expect(notifierHost.sentMessages).toHaveLength(3);
+    expect(notifierHost.sentMessages[2]?.details).toMatchObject({ notifyId: "sa-drain" });
+
+    notifier.dispose();
+  });
+
   it("ledger 未 bind 时退回内核路径（向后兼容，options 仍单通道 triggerTurn）", () => {
     const notifierHost = makeNotifierHost();
     const notifier = createNotifier(notifierHost);
@@ -982,7 +1023,7 @@ describe("createNotifier — ledger 四步接线（U2）", () => {
 // ─── MF-5: settled 监听单例化 ──────────────────────────────
 //
 // 回归背景：index.ts:428-430 每次 session_start 注册新 pi.on("agent_settled")
-// handler，旧实例 dispose 只置标志不移除物理监听（pi 0.84.1 on() 无 off）——
+// handler，旧实例 dispose 只置标志不移除物理监听（pi 0.84.4 on() 无 off）——
 // 长会话 N 次切换累积 N 个死 handler。修复：bind 路径首次注册模块级单例
 // handler（settledEdgeDispatch），后续 bind 只换 boundLedger 引用。