@zhushanwen/subagent-core 0.8.0 → 0.9.0

package/src/execution/__tests__/get-record-for-action-restart.test.ts

@@ -1,12 +1,13 @@
 // src/execution/__tests__/get-record-for-action-restart.test.ts
 //
-// [M10] getRecordForAction 跨重启磁盘重建分支测试（subagent-service.ts L933-951）。
+// [M10] getRecordForAction 跨重启磁盘重建分支测试（cold-lookup.coldLookupForAction）。
 //
 // 背景：内存 miss → collectRecords(1000,"all",undefined).find(status==="running") →
-// createRecord({chatMode: true}) → register → 回填 sessionFile/round。代码注释
-// （L946-949）自设强制约束「改动此处必须带 S3 回归场景（跨重启 message 续聊验证）」
-// ——该 S3 场景此前不存在，分支零测试。该分支含多个仅此处独有的决策：
-//   - 无条件 chatMode: true（v4 A-3 跨重启恢复入口，V3 方案 A 方向）
+// createRecord({chatMode: 持久化值}) → register → 回填 sessionFile/round。
+// [H1 U6] 原「无条件 chatMode: true」（v4 A-3）已改水合保留持久化 chatMode
+//（D4/D5：升级置位迁 Continuation revive 格 + messageHandler gate 双写点）。
+// 该分支含多个仅此处独有的决策：
+//   - chatMode 水合保留（磁盘无持久化 → false；升级在 message 链 gate 化）
 //   - rootSessionFilter 传 undefined 后置校验（异树仍 throw not owned）
 //   - sessionFile/round 从磁盘重建结果回填（round 无磁盘持久化 → undefined）
 //
@@ -25,11 +26,10 @@ const { loggerMock } = vi.hoisted(() => ({
 }));
 vi.mock("../../core/logger.ts", () => ({ getLogger: () => loggerMock }));
 
-// [W3 改写] 原 vi.mock(inproc pi 引擎目录/session-runner) 随删件消亡——deliverChatMessage 走
-// 协议 seam（registerFakePiEngine 替身；跨重启无活进程 = 引擎冷路径拒绝，续聊落
-// resumeColdRound 守卫链）。
+// [W3 改写 → H1 U6] deliverChatMessage 走协议 seam（registerFakePiEngine 替身）——
+// 每轮 = 新 run + resume 锚点，续聊守卫链归 Continuation（dispatchRoundGuarded）。
 
-import { writeFinalized } from "../finalized-marker.ts";
+import { writeFinalizedState } from "../state-marker.ts";
 import { registerFakePiEngine } from "./helpers/fake-engine-port.ts";
 import { clearEngines } from "../engine/registry.ts";
 import { ModelConfigService } from "../model-config-service.ts";
@@ -158,16 +158,17 @@ describe("[M10] getRecordForAction 跨重启磁盘重建（S3 回归场景）",
     for (const k of IDENTITY_ENV_KEYS) delete process.env[k];
   });
 
-  it("内存 miss + 磁盘 running（无 .alive）→ 重建 record：chatMode 无条件 true、sessionFile 回填、register 进内存", () => {
-    // identity entry 故意不带 chatMode 字段——证明重建分支的无条件 chatMode:true
-    //（不依赖磁盘是否记录过对话模式标志）
+  it("内存 miss + 磁盘 running（无 .alive）→ 重建 record：chatMode 水合保留（无持久化为 false，[H1 U6]）、sessionFile 回填、register 进内存", () => {
+    // identity entry 故意不带 chatMode 字段——证明重建分支只水合持久化 chatMode
+    //（[H1 U6] 无条件置位已迁 Continuation revive 格 + gate；one-shot 跨重启重建
+    // false 后经 message 链 gate 升级置位）
     const file = writeSessionJsonl(sessionsDir, { id: "sa-restart-1", rootSessionId: "root-session" });
     expect(store.getMutable("sa-restart-1")).toBeUndefined(); // 前置：内存确无
 
     const record = service.chatActions.getRecordForAction("sa-restart-1");
 
-    // [v4 A-3] 无条件 chatMode=true（跨重启恢复入口）
-    expect(record.chatMode).toBe(true);
+    // [v4 A-3 → H1 U6] 水合保留：磁盘无 chatMode → false（升级在 message 链 gate 化）
+    expect(record.chatMode).toBe(false);
     // sessionFile 从磁盘重建结果回填
     expect(record.sessionFile).toBe(file);
     // round 从 found 回填：light 磁盘重建无 round（内存态字段，跨重启不恢复）→ undefined
@@ -204,9 +205,9 @@ describe("[M10] getRecordForAction 跨重启磁盘重建（S3 回归场景）",
     expect(() => service.chatActions.getRecordForAction("sa-grand")).toThrow(/direct parent/);
   });
 
-  it(".finalized sidecar（closed 终态）不重建 → throw not found or not owned", () => {
+  it(".state sidecar（closed 终态）不重建 → throw not found or not owned", () => {
     const file = writeSessionJsonl(sessionsDir, { id: "sa-fin", rootSessionId: "root-session" });
-    writeFinalized(file); // sidecar 矩阵分支 2 → status=closed → find(status==="running") miss
+    writeFinalizedState(file); // sidecar 矩阵分支 2 → status=closed → find(status==="running") miss
 
     expect(() => service.chatActions.getRecordForAction("sa-fin")).toThrow(/not found or not owned/);
     expect(store.getMutable("sa-fin")).toBeUndefined(); // 未重建注册
@@ -221,12 +222,8 @@ describe("[M10] getRecordForAction 跨重启磁盘重建（S3 回归场景）",
   it("[review round2] worktree record 跨重启重建 → hadWorktree 标记 + 续聊被拒（行动语言）", async () => {
     clearEngines();
     const fake = registerFakePiEngine();
-    // 跨重启无活进程 → 引擎冷路径拒绝 → 续聊落 resumeColdRound 守卫链
-    fake.interactMessageResult = {
-      ok: false,
-      code: "engine_session_not_resumable",
-      message: "no live process (cold path)",
-    };
+    // [H1 U6] 每轮 = 新 run + resume 锚点（旧 interact 冷路径替身注入随 interact 面退役），
+    // 续聊守卫链归 Continuation（dispatchRoundGuarded）。
     writeSessionJsonl(sessionsDir, {
       id: "sa-wt",
       rootSessionId: "root-session",
@@ -240,7 +237,7 @@ describe("[M10] getRecordForAction 跨重启磁盘重建（S3 回归场景）",
     expect(record.worktreeHandle).toBeUndefined();
 
     // 冷路径续聊（无活进程）→ 续轮守卫拒绝，不 spawn 回落主 repo
-    await expect(service.chatActions.deliverChatMessage(record, "resume after restart", false)).rejects.toThrow(
+    await expect(service.chatActions.deliverChatMessage(record, "resume after restart")).rejects.toThrow(
       /worktree isolation.*lost when the parent process restarted/,
     );
   });
@@ -248,11 +245,6 @@ describe("[M10] getRecordForAction 跨重启磁盘重建（S3 回归场景）",
   it("[review round2] 非 worktree record 跨重启重建 → 续聊不受 worktree 守卫拦截（向后兼容）", async () => {
     clearEngines();
     const fake = registerFakePiEngine();
-    fake.interactMessageResult = {
-      ok: false,
-      code: "engine_session_not_resumable",
-      message: "no live process (cold path)",
-    };
     // identity entry 无 worktree 字段（旧文件）→ found.worktree undefined → hadWorktree false
     writeSessionJsonl(sessionsDir, { id: "sa-nowt", rootSessionId: "root-session" });
 
@@ -261,6 +253,6 @@ describe("[M10] getRecordForAction 跨重启磁盘重建（S3 回归场景）",
 
     // 冷路径续聊不被 worktree 守卫拦截（resume 正常发起；后续 spawn 编排
     // 超出本用例关注点——runSpawn 在本文件是 no-op mock）
-    await expect(service.chatActions.deliverChatMessage(record, "resume normal", false)).resolves.toBeUndefined();
+    await expect(service.chatActions.deliverChatMessage(record, "resume normal")).resolves.toBeUndefined();
   });
 });

package/src/execution/__tests__/helpers/fake-engine-port.ts

@@ -1,33 +1,27 @@
 // src/execution/__tests__/helpers/fake-engine-port.ts
 //
-// [W3 chat 域收口] SubagentService 编排层测试共享的 pi EnginePort 替身。
+// [W3 chat 域收口 → H1 U6 定形] SubagentService 编排层测试共享的 pi EnginePort 替身。
 //
-// 背景：chat 域执行链路自 W3 起经协议客户端（registry 'pi' 的 cli 形态 port——
-// RemoteEngine）发往 pi-subagent-cli 引擎进程；原 inproc 链路的测试替身
-//（vi.mock session-runner / FakeChild stdout pump）随 inproc pi 引擎目录 删除消亡。
-// 本 helper 是协议 seam 的替身单源：测试经 registerEngine("pi", fake) 注入，
-// 拿到 fake 实例后驱动 run/interact/roundLifecycle，断言协议交互。
+// 背景：会话形态轮经协议客户端（registry 'pi' 的 cli 形态 port——RemoteEngine）发往
+// pi-subagent-cli 引擎进程；原 inproc 链路的测试替身随删件消亡。本 helper 是协议 seam
+// 的替身单源：测试经 registerEngine("pi", fake) 注入，拿到 fake 实例后驱动 run，
+// 断言协议交互。
 //
 // 消费方式（与 spawn-mock.ts 同款先例）：
 //   const fake = registerFakePiEngine();
 //   await service.execute({ task: "...", conversation: true });
-//   fake.runs[0].settle({ content: "round text" });   // 模拟首轮 agent_settled 应答
-//   fake.interacts[0]                                  // interact 受理断言
+//   fake.runs[0].settle({ content: "round text" });   // 模拟 agent_settled 应答
 //
-// 形态对照（协议语义，见 pi-subagent-cli chat-session.ts）：
-//   - run 应答时点 = 首轮 agent_settled（outcome = 本轮内容非会话终态）；
-//   - interact message 受理 = { ok: true, delivered: true }；冷路径 = engine_session_not_resumable；
-//   - interact cancel = { ok: true, delivered: true }（引擎侧 SIGTERM → settle → 杀链）；
-//   - roundLifecycle 相位由测试显式驱动（idle 帧先于 run 应答帧）。
+// 形态对照（[H1] chat-run 统一终态）：每轮 = 新 run + resume 锚点（ctx.resume），
+// run 应答时点 = agent_settled（outcome = 本轮内容非会话终态）；[H1 U6] interact 面
+// 与 recordId 键路由模拟面已随 chat 域退役删除。
 
-import type { EnginePort, EngineRunResult, RunContext, ChatRoundRoute } from "../../../execution/engine/port.ts";
+import type { EnginePort, EngineRunResult, RunContext } from "../../../execution/engine/port.ts";
 import type { AgentCallOpts } from "../../../orchestration/models/types.ts";
 import type {
   AgentOutcome,
   EngineCapabilities,
   EngineHandle,
-  InteractAction,
-  InteractResult,
   ProbeReport,
   SessionView,
 } from "../../../execution/engine/types.ts";
@@ -50,7 +44,7 @@ export class FakeRun {
     });
   }
 
-  /** 模拟 run 正常应答（首轮 agent_settled 口径；outcome 缺省 = 成功空轮）。 */
+  /** 模拟 run 正常应答（agent_settled 口径；outcome 缺省 = 成功空轮）。 */
   settle(outcome: Partial<AgentOutcome> = {}): void {
     this.resolve({
       handle: {
@@ -80,44 +74,22 @@ export class FakeRun {
     this.ctx.onEvent?.(event as never);
   }
 
-  /** 模拟 host/streamDelta（runId 键——首轮）。 */
+  /** 模拟 host/streamDelta（runId 键——run 作用域路由）。 */
   emitDelta(delta: string): void {
     this.ctx.stream?.onDelta(delta);
   }
 
-  /** 模拟 host/roundLifecycle（runId 键——首轮）。 */
-  emitLifecycle(phase: Record<string, unknown>): void {
-    this.ctx.onRoundLifecycle?.({ runId: this.ctx.taskId, ...phase } as never);
-  }
-
   /** 模拟 host/handleReady（运行中句柄回填）。 */
   emitHandleReady(sessionRef: Record<string, string>, poolKey = "shared"): void {
     this.ctx.onHandleReady?.({ sessionRef, poolKey });
   }
 }
 
-/** 一次 interact 调用的捕获（action 原样记录，供断言）。 */
-export interface FakeInteractCall {
-  handle: EngineHandle;
-  action: InteractAction;
-  result: InteractResult | Promise<InteractResult>;
-}
-
 export class FakePiEnginePort implements EnginePort {
   readonly id = "pi";
 
   /** run 调用捕获（按序）。 */
   readonly runs: FakeRun[] = [];
-  /** interact 调用捕获（按序；result = 受理时返回值）。 */
-  readonly interacts: FakeInteractCall[] = [];
-  /** recordId 键路由注册捕获（recordId → 注销函数）。 */
-  readonly chatRoutes = new Map<string, ChatRoundRoute>();
-  readonly chatRouteUnregisters: string[] = [];
-
-  /** interact message 的应答形态（默认受理；测试改写为冷路径拒绝等）。 */
-  interactMessageResult: InteractResult = { ok: true, delivered: true };
-  /** interact cancel / close 的应答形态。 */
-  interactControlResult: InteractResult = { ok: true, delivered: true };
 
   capabilities(): EngineCapabilities {
     // 与 pi-subagent-cli manifest 逐位一致（gate 同步面放行 pi 全参数——V4⑤ 反向守护）。
@@ -146,37 +118,10 @@ export class FakePiEnginePort implements EnginePort {
     return captured.promise;
   }
 
-  async interact(handle: EngineHandle, action: InteractAction): Promise<InteractResult> {
-    const result = action.kind === "message" ? this.interactMessageResult : this.interactControlResult;
-    this.interacts.push({ handle, action, result });
-    return result;
-  }
-
   async read(handle: EngineHandle): Promise<SessionView> {
+    void handle;
     return { engineId: "pi", turns: [], source: "outcome-only" };
   }
-
-  registerChatRoundRoute(recordId: string, route: ChatRoundRoute): () => void {
-    this.chatRoutes.set(recordId, route);
-    return () => {
-      if (this.chatRoutes.get(recordId) === route) {
-        this.chatRoutes.delete(recordId);
-        this.chatRouteUnregisters.push(recordId);
-      }
-    };
-  }
-
-  // ── 测试驱动面（recordId 键路由——interact 续聊轮的协议回流）──
-
-  /** 向指定 record 的 chat 路由发 recordId 键 delta。 */
-  emitRecordDelta(recordId: string, delta: string): void {
-    void this.chatRoutes.get(recordId)?.onStreamDelta?.(delta);
-  }
-
-  /** 向指定 record 的 chat 路由发 recordId 键 roundLifecycle 相位。 */
-  emitRecordLifecycle(recordId: string, phase: Record<string, unknown>): void {
-    void this.chatRoutes.get(recordId)?.onRoundLifecycle?.({ recordId, ...phase } as never);
-  }
 }
 
 /** 注册替身 pi 引擎进 registry（覆盖同 id 既有注册——测试隔离自负责清理）。 */

package/src/execution/__tests__/helpers/legacy-sidecar.ts

@@ -0,0 +1,33 @@
+// src/execution/__tests__/helpers/legacy-sidecar.ts
+//
+// 兼容期旧格式终态 sidecar fixture（`.finalized` / `.cancelled`）——L4 合并后生产
+// 只写 `.state`，但读侧仍兼容旧名（存量文件不迁移）。测试需要造旧格式文件验证兼容
+// 读路径，此处是唯一 fixture 入口（格式细节单源，避免各测试散落 fs.writeFileSync）。
+//
+// 形态 = 合并前两模块的写侧逐字等价：
+//   .finalized  内容 = reason 字符串（undefined → 空文件，v8.5 前格式）
+//   .cancelled  内容 = 单行 JSON tombstone {id, status, agent, startedAt, endedAt}
+
+import * as fs from "node:fs";
+
+/** 旧 .cancelled tombstone 形态（合并前 CancelledTombstone 逐字等价）。 */
+export interface LegacyCancelledTombstone {
+  id: string;
+  status: "cancelled";
+  agent: string;
+  startedAt: number;
+  endedAt: number;
+}
+
+/** 写旧格式 `.finalized`（测试 fixture；reason 缺省 = 空文件旧格式）。 */
+export function writeLegacyFinalizedSidecar(sessionFile: string, reason?: string): void {
+  fs.writeFileSync(`${sessionFile}.finalized`, reason ?? "", "utf-8");
+}
+
+/** 写旧格式 `.cancelled`（测试 fixture；完整 tombstone 形态）。 */
+export function writeLegacyCancelledSidecar(
+  sessionFile: string,
+  meta: LegacyCancelledTombstone,
+): void {
+  fs.writeFileSync(`${sessionFile}.cancelled`, `${JSON.stringify(meta)}\n`, "utf-8");
+}

package/src/execution/__tests__/helpers/subagent-service-mocks.ts

@@ -88,11 +88,15 @@ export function aliveStoreModule(actual: typeof import("../../alive-store.ts"))
   };
 }
 
-/** ../finalized-marker.ts mock 模块（避免真实 fs 写 sidecar）。 */
-export function finalizedMarkerModule() {
+/** ../state-marker.ts mock 模块（避免真实 fs 写 sidecar；读侧恒「无终态标记」，
+ *  对齐原 finalized-marker mock 的 no-finalized 语义）。 */
+export function stateMarkerModule() {
   return {
-    writeFinalized: vi.fn(),
-    readFinalized: vi.fn(() => false),
+    writeFinalizedState: vi.fn(),
+    writeCancelledState: vi.fn(),
+    readStateMarker: vi.fn(() => undefined),
+    statStateStamp: vi.fn(() => null),
+    STATE_SIDECAR_EXT: ".state",
   };
 }
 
@@ -107,7 +111,7 @@ export function manifestStoreModule() {
     writeManifest = vi.fn(async () => {});
     readManifest = vi.fn(async () => null);
     listAllSync = vi.fn(() => []);
-    recoverTmpFiles = vi.fn(async () => []);
+    sweepTmpFiles = vi.fn(async () => 0);
   }
   return { ManifestStore: vi.fn(function (_recordsDir: string) { return new FakeManifestStore(); }) };
 }

package/src/execution/__tests__/idle-gc.test.ts

@@ -4,6 +4,10 @@
 // 只归档不补注销（archive 不发 pending:unregister——注销统一交对账 sweep）、
 // WorkflowRun store 纳入（startedAt 锚终态化 + save）。fake timers 推进 GC
 // interval；RecordStore 用 mkdtemp 自建目录 + pi=null（archive 纯内存，零磁盘写）。
+//
+// [U2b / C1] markIdleArchived 归口：归档时 `.alive` 写权声明同步 release（D3a
+// release 出口②）——S6 验收锚点链的单元级断言（fake clock 推进 30 天 → 归档 →
+// marker 已删 → fork-from 探针放行 → 接管 acquire 重声明）。
 
 import * as fs from "node:fs";
 import * as os from "node:os";
@@ -11,6 +15,7 @@ import * as path from "node:path";
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
+import { findForeignLiveInstance } from "../alive-store.ts";
 import { createRecord } from "../execution-record.ts";
 import { startIdleGc } from "../idle-gc.ts";
 import { RecordStore } from "../record-store.ts";
@@ -53,6 +58,61 @@ function makeRecord(id: string, overrides: Partial<ExecutionRecord> = {}): Execu
   return record;
 }
 
+describe("idle-GC 归口 markIdleArchived（U2b/C1——D3a release 出口②闭环链，S6 锚点）", () => {
+  it("fake clock 推进 30 天 → 归档 + `.alive` 已删 + fork-from 探针放行 + 接管 acquire 重声明（闭环链）", async () => {
+    const store = makeStore();
+    const sessionFile = path.join(tmpDir, "lease-session.jsonl");
+    fs.writeFileSync(sessionFile, "{}\n", "utf-8");
+    const rec = makeRecord("bg-lease", {
+      startedAt: Date.now() - 31 * DAY_MS,
+      idleSince: Date.now() - 31 * DAY_MS,
+      sessionFile,
+    });
+    store.register(rec);
+    // 持有期声明在位（模拟 spawn 侧 acquireWriteLease 已声明写权的 resumable record）。
+    store.acquireWriteLease(sessionFile, rec.id);
+    expect(fs.existsSync(`${sessionFile}.alive`)).toBe(true);
+
+    stop = startIdleGc(store);
+    await vi.advanceTimersByTimeAsync(GC_INTERVAL_MS + 1);
+
+    // ① 归档生效（内存移除——record 磁盘仍 running 可接管，非终态化）。
+    expect(store.getMutable("bg-lease")).toBeUndefined();
+    // ② marker 已删（release 生效——归档 = 放弃持有 = 放弃写权声明）。
+    expect(fs.existsSync(`${sessionFile}.alive`)).toBe(false);
+    // ③ fork-from 放行：探针无 marker 即无声明，不再被残留声明拦。
+    expect(findForeignLiveInstance(sessionFile)).toBeUndefined();
+    // ④ message 接管 acquire 重声明：接管时统一 acquireWriteLease（接管链经
+    //    markResurrected 的 acquire-first，本处以 store 内部 acquire 动作直驱同语义）。
+    store.acquireWriteLease(sessionFile, "bg-lease");
+    const marker = JSON.parse(fs.readFileSync(`${sessionFile}.alive`, "utf-8")) as {
+      pid: number;
+      id: string;
+    };
+    expect(marker).toMatchObject({ pid: process.pid, id: "bg-lease" });
+    // 重声明后探针对本进程仍放行（self-pid 排除——自有声明不构成 foreign）。
+    expect(findForeignLiveInstance(sessionFile)).toBeUndefined();
+  });
+
+  it("锚窗内的 record 不归档且 `.alive` 不 release（无早释）", async () => {
+    const store = makeStore();
+    const sessionFile = path.join(tmpDir, "lease-fresh.jsonl");
+    fs.writeFileSync(sessionFile, "{}\n", "utf-8");
+    const rec = makeRecord("bg-hold", {
+      startedAt: Date.now() - 1 * DAY_MS,
+      sessionFile,
+    });
+    store.register(rec);
+    store.acquireWriteLease(sessionFile, rec.id);
+
+    stop = startIdleGc(store);
+    await vi.advanceTimersByTimeAsync(GC_INTERVAL_MS + 1);
+
+    expect(store.getMutable("bg-hold")).toBeDefined();
+    expect(fs.existsSync(`${sessionFile}.alive`)).toBe(true);
+  });
+});
+
 describe("idle-gc record 锚扩展（W4）", () => {
   it("无 idleSince 的 resumable record 以 startedAt 为锚：超 30 天归档", async () => {
     const store = makeStore();

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