@zhushanwen/pi-subagent-workflow 8.5.0 → 8.7.0

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

@@ -1,211 +0,0 @@
-// acquireActivateLock 30s 超时兜底单测 —— v4-lifecycle-convergence.md §3.3 A-2。
-//
-// 验证：前序 holder 持锁不 release（崩溃/死锁模拟）时，waiter
-//   - 等待 29999ms 仍 pending（未误伤正常排队）
-//   - 到 30001ms 抛含恢复指引的超时错误（'activation timed out' + 'retry action: message'）
-//
-// 测试策略：纯 Promise 链 + setTimeout 超时，用 vi.useFakeTimers() 控时，
-// advanceTimersByTimeAsync 同时推进 fake timer 与 microtask flush。
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import {
-  _getActivateLockTailCountForTest,
-  _resetLifecycleState,
-  acquireActivateLock,
-} from "../lifecycle-manager.ts";
-
-describe("acquireActivateLock 30s 超时兜底 (v4 A-2)", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    _resetLifecycleState();
-  });
-
-  afterEach(() => {
-    _resetLifecycleState();
-    vi.useRealTimers();
-  });
-
-  it("waiter 等待 29999ms 仍 pending；到 30001ms 抛含恢复指引的超时错误", async () => {
-    // 第一个 holder 持锁后不 release（模拟崩溃/死锁）
-    await acquireActivateLock("sa-stuck");
-
-    // 第二个 waiter 必然排队（前序未 release）
-    let errMsg: string | null = null;
-    let gotRelease: (() => void) | null = null;
-    const waiter = acquireActivateLock("sa-stuck")
-      .then((release) => {
-        gotRelease = release;
-      })
-      .catch((err: unknown) => {
-        errMsg = err instanceof Error ? err.message : String(err);
-      });
-
-    // flush microtask：waiter 进入 prev.then 等待链
-    await vi.advanceTimersByTimeAsync(0);
-    expect(gotRelease).toBe(null); // 尚未拿到锁
-    expect(errMsg).toBe(null);
-
-    // 29999ms：未满 30s，waiter 仍 pending
-    await vi.advanceTimersByTimeAsync(29999);
-    expect(gotRelease).toBe(null);
-    expect(errMsg).toBe(null);
-
-    // 再推进 2ms（累计 30001ms）：超时 timer 触发 → reject
-    await vi.advanceTimersByTimeAsync(2);
-    await waiter;
-
-    // 超时：未拿到锁，抛含恢复指引的错误
-    expect(gotRelease).toBe(null);
-    expect(errMsg).not.toBe(null);
-    expect(errMsg).toContain("activation timed out");
-    expect(errMsg).toContain("retry action: message");
-    expect(errMsg).toContain("sa-stuck");
-  });
-
-  it("首次 acquire（无前序 holder）立即返回 release，不触发超时", async () => {
-    // 首次 acquire：prev=Promise.resolve()，立即 resolve，timer 被 clearTimeout 取消
-    const release = await acquireActivateLock("sa-fresh");
-    expect(typeof release).toBe("function");
-
-    // 推进远超 30s，不应有任何未捕获的超时 reject（timer 已清除）
-    await vi.advanceTimersByTimeAsync(60000);
-    release();
-  });
-
-  it("[review 修复] 超时后前序 release → 链可推进：二次 acquire 立即获锁（锁链不瘫痪）", async () => {
-    // 瘫痪路径回归：waiter 超时 reject 后，若其 current 永久 pending，tail 永久
-    // pending → 前序 release 后后续 acquire 也只能 30s 超时（只能重启恢复）。
-    // 修复后超时回调 resolve 自身 current 放行链尾：release1 后 tail settle，
-    // 二次 acquire 的 prev 已 settle → 立即拿到 releaseFn。
-    const release1 = await acquireActivateLock("sa-recover");
-
-    let waiterErr: string | null = null;
-    const waiter = acquireActivateLock("sa-recover").catch((err: unknown) => {
-      waiterErr = err instanceof Error ? err.message : String(err);
-    });
-    await vi.advanceTimersByTimeAsync(0); // waiter 挂链
-    await vi.advanceTimersByTimeAsync(30001); // 超时 reject（+ 超时放行链尾）
-    await waiter;
-    expect(waiterErr).toContain("activation timed out");
-
-    release1(); // 前序释放 → tail settle（current 已被超时放行 resolve）
-    await vi.advanceTimersByTimeAsync(0); // flush microtask 链
-
-    // 二次 acquire：prev 是已 settle 的 tail → 立即拿到锁，不等 30s
-    const release2 = await acquireActivateLock("sa-recover");
-    expect(typeof release2).toBe("function");
-    release2();
-    await vi.advanceTimersByTimeAsync(0);
-  });
-
-  it("[review 修复] 前序持续持锁时超时不放行后续 waiter 提前获锁（互斥保持）", async () => {
-    // 超时放行只 resolve 自身 current（tail 仍等 prev）；前序未 release 时，
-    // 新 acquire 依然排队等待，不会与前序 holder 形成双写者。
-    const release1 = await acquireActivateLock("sa-mutex");
-
-    const waiter1 = acquireActivateLock("sa-mutex").catch(() => {});
-    await vi.advanceTimersByTimeAsync(30001); // waiter1 超时放行自身 current
-    await waiter1;
-
-    // 前序仍持锁：新 acquire 的 prev（= waiter1 的 tail）等待 release1，不提前获锁
-    let gotRelease2 = false;
-    const waiter2 = acquireActivateLock("sa-mutex").then(() => {
-      gotRelease2 = true;
-    });
-    await vi.advanceTimersByTimeAsync(0);
-    expect(gotRelease2).toBe(false); // 未提前获锁
-
-    release1();
-    await vi.advanceTimersByTimeAsync(0);
-    await waiter2; // release1 后链推进，waiter2 获锁
-    expect(gotRelease2).toBe(true);
-  });
-
-  it("[review 修复] 超时者对称自清：前序 release 推进链尾后 Map 条目回收；前序持锁期间不提前删", async () => {
-    // round2 INFO 残留：超时者 releaseFn 永不被调用，原实现条目滞留 Map 直到下次
-    // 同 recordId acquire 覆盖。修复后挂 tail 尾部自清——tail settle（前序已
-    // release）时回收；tail pending（前序仍持锁）时回调不执行，条目保留（后续
-    // acquire 仍排队等待，互斥不被破坏）。
-    const release1 = await acquireActivateLock("sa-timeout-gc");
-
-    const waiter = acquireActivateLock("sa-timeout-gc").catch(() => {});
-    await vi.advanceTimersByTimeAsync(0); // waiter 挂链，Map 链尾已覆盖为 waiter 的 tail
-    expect(_getActivateLockTailCountForTest()).toBe(1);
-
-    await vi.advanceTimersByTimeAsync(30001); // 超时：reject + settleCurrent + tail.then 自清排队
-    await waiter;
-    // 前序仍持锁 → tail 仍 pending → 自清回调未执行 → 条目仍在
-    expect(_getActivateLockTailCountForTest()).toBe(1);
-
-    release1(); // 前序释放 → tail settle → 自清回调执行（identity 匹配，无新 waiter）
-    await vi.advanceTimersByTimeAsync(0);
-    expect(_getActivateLockTailCountForTest()).toBe(0);
-  });
-});
-
-describe("activateLockTails tail-identity 自清（release 后回收）", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    _resetLifecycleState();
-  });
-
-  afterEach(() => {
-    _resetLifecycleState();
-    vi.useRealTimers();
-  });
-
-  it("W3TC14: 无 waiter 时 release 后 Map 空 + release 后可再次 acquire", async () => {
-    const release = await acquireActivateLock("sa-gc");
-    // 自清新增的 test-only 观察点：acquire 后 Map 有 1 条链尾
-    expect(_getActivateLockTailCountForTest()).toBe(1);
-
-    release();
-    // 自清经 queueMicrotask 异步执行——advanceTimersByTimeAsync(0) flush microtask
-    await vi.advanceTimersByTimeAsync(0);
-    // 无 waiter：Map 中链尾即本链尾，identity 匹配 → delete 回收
-    expect(_getActivateLockTailCountForTest()).toBe(0);
-
-    // release 后可再次 acquire：prev 回落 Promise.resolve()，立即 resolve 返回 release
-    const release2 = await acquireActivateLock("sa-gc");
-    expect(typeof release2).toBe("function");
-    release2();
-    await vi.advanceTimersByTimeAsync(0);
-    expect(_getActivateLockTailCountForTest()).toBe(0);
-  });
-
-  it("W3TC15: 有 waiter 排队不删、最后释放者回收；不同 recordId 链独立", async () => {
-    const release1 = await acquireActivateLock("sa-q");
-
-    // 发起 acquire#2 同 recordId（不 await，.then 捕获 release2）
-    let release2: (() => void) | null = null;
-    const waiter = acquireActivateLock("sa-q").then((r) => {
-      release2 = r;
-    });
-    // #2 进入等待链——此刻 Map 链尾已被 #2 覆盖
-    await vi.advanceTimersByTimeAsync(0);
-
-    release1();
-    await vi.advanceTimersByTimeAsync(0);
-    // ES7 核心：waiter 的链尾仍在——identity 不匹配不删
-    expect(_getActivateLockTailCountForTest()).toBe(1);
-
-    // acquire#2 在 release1 后正常 resolve（等待链不被 delete 破坏——waiter 持
-    // acquire 时刻捕获的 prev Promise 引用而非 Map 查询）
-    await waiter;
-    expect(typeof release2).toBe("function");
-
-    // 另一 recordId 独立链：同时持有时各自独立计数
-    const releaseA = await acquireActivateLock("sa-a");
-    expect(_getActivateLockTailCountForTest()).toBe(2); // sa-q + sa-a
-
-    release2!();
-    await vi.advanceTimersByTimeAsync(0);
-    // 最后释放者回收：release2 的 identity 匹配 → sa-q 条目回收，sa-a 仍在
-    expect(_getActivateLockTailCountForTest()).toBe(1);
-
-    releaseA();
-    await vi.advanceTimersByTimeAsync(0);
-    expect(_getActivateLockTailCountForTest()).toBe(0);
-  });
-});

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

@@ -1,337 +0,0 @@
-// lifecycle-manager 单测 —— V2 §5.2 模块 1（进程生命周期管理）五项职责。
-//
-// 测试策略：
-//   - idle timer / ceiling LRU 用 vi.useFakeTimers() + advanceTimersByTime（同时 mock
-//     Date.now()，让 lastTouched 时间戳可控）。
-//   - activate 互斥锁是纯 Promise 链（无 timer），用 advanceTimersByTimeAsync(0)
-//     flush microtask 验证串行化。
-//   - 每个用例 beforeEach 调 _resetLifecycleState() 隔离模块级单例状态。
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-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", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    _resetLifecycleState();
-  });
-
-  afterEach(() => {
-    _resetLifecycleState();
-    vi.useRealTimers();
-  });
-
-  // ============================================================
-  // 职责 1：idle timer
-  // ============================================================
-  describe("职责1 idle timer", () => {
-    it("arm 后到 timeoutMs 触发 onTimeout（边界：差 1ms 不触发）", () => {
-      const onTimeout = vi.fn();
-      armIdleTimer("sa-1", onTimeout, 1000);
-
-      expect(hasIdleTimer("sa-1")).toBe(true);
-      vi.advanceTimersByTime(999);
-      expect(onTimeout).not.toHaveBeenCalled();
-
-      vi.advanceTimersByTime(1);
-      expect(onTimeout).toHaveBeenCalledTimes(1);
-      // 触发后自动从 Map 移除（不残留失效 entry）
-      expect(hasIdleTimer("sa-1")).toBe(false);
-    });
-
-    it("disarm 后不再触发 onTimeout", () => {
-      const onTimeout = vi.fn();
-      armIdleTimer("sa-1", onTimeout, 1000);
-      disarmIdleTimer("sa-1");
-
-      expect(hasIdleTimer("sa-1")).toBe(false);
-      vi.advanceTimersByTime(5000);
-      expect(onTimeout).not.toHaveBeenCalled();
-    });
-
-    it("disarm 不存在的 record 为 no-op（不抛错）", () => {
-      expect(() => disarmIdleTimer("never-armed")).not.toThrow();
-    });
-
-    it("重复 arm 刷新 timer：旧 timer 作废、重新计时", () => {
-      const onTimeout = vi.fn();
-      armIdleTimer("sa-1", onTimeout, 1000);
-      vi.advanceTimersByTime(500); // 过了 500ms
-
-      armIdleTimer("sa-1", onTimeout, 1000); // 刷新：重新计 1000ms
-      vi.advanceTimersByTime(999);
-      expect(onTimeout).not.toHaveBeenCalled(); // 旧 timer 已作废，新的还没到
-
-      vi.advanceTimersByTime(1);
-      expect(onTimeout).toHaveBeenCalledTimes(1);
-    });
-
-    it("默认超时 = DEFAULT_IDLE_TIMEOUT_MS", () => {
-      const onTimeout = vi.fn();
-      armIdleTimer("sa-1", onTimeout); // 不传 timeoutMs
-
-      vi.advanceTimersByTime(DEFAULT_IDLE_TIMEOUT_MS - 1);
-      expect(onTimeout).not.toHaveBeenCalled();
-
-      vi.advanceTimersByTime(1);
-      expect(onTimeout).toHaveBeenCalledTimes(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__/lifecycle-predicates.test.ts

@@ -1,116 +0,0 @@
-// lifecycle-predicates 单测（v4 B-1）。
-// 验证 isIdle/isResumable/hasLiveProcessHandle 在两态收敛后的判定逻辑。
-// 依赖 lifecycle-manager 模块级 idleTimers 与 session-runner.spawnedChildren（单例 Map），
-// beforeEach 重置隔离。
-
-import { describe, it, expect, beforeEach } from "vitest";
-
-import {
-  armIdleTimer,
-  disarmIdleTimer,
-  _resetLifecycleState,
-} from "../lifecycle-manager.ts";
-import { spawnedChildren } from "../session-runner.ts";
-import type { ChildProcess } from "node:child_process";
-import type { ExecutionRecord } from "../types.ts";
-
-import { hasLiveProcessHandle, isIdle, isResumable } from "../lifecycle-predicates.ts";
-
-/** 构造最小 ExecutionRecord（status 默认 running）。 */
-function makeRecord(overrides: Partial<ExecutionRecord> = {}): ExecutionRecord {
-  return {
-    id: "sa-test",
-    agent: "general-purpose",
-    model: "test/model",
-    thinkingLevel: undefined,
-    mode: "background",
-    task: "test",
-    slug: "test",
-    startedAt: Date.now(),
-    rootSessionId: "root",
-    parentRecordId: undefined,
-    depth: 0,
-    status: "running",
-    turns: [],
-    turnCount: 0,
-    totalTokens: 0,
-    lastError: undefined,
-    round: 0,
-    endedAt: undefined,
-    result: undefined,
-    error: undefined,
-    agentResult: undefined,
-    controller: undefined,
-    ...overrides,
-  } as ExecutionRecord;
-}
-
-/** 构造最小 ChildProcess fake（hasLiveProcessHandle 只读 .killed）。 */
-function fakeChild(killed: boolean): ChildProcess {
-  // 测试 fake：被测代码仅读 .killed，其余字段不可达，用 unknown 中转满足 Map 类型。
-  return { killed } as unknown as ChildProcess;
-}
-
-describe("lifecycle-predicates (v4 B-1)", () => {
-  beforeEach(() => {
-    _resetLifecycleState();
-    spawnedChildren.clear();
-  });
-
-  describe("isIdle (= hasIdleTimer)", () => {
-    it("armed idle timer → true", () => {
-      const rec = makeRecord();
-      armIdleTimer(rec.id, () => {});
-      expect(isIdle(rec)).toBe(true);
-    });
-
-    it("no idle timer → false", () => {
-      expect(isIdle(makeRecord())).toBe(false);
-    });
-
-    it("disarmed timer → false", () => {
-      const rec = makeRecord();
-      armIdleTimer(rec.id, () => {});
-      disarmIdleTimer(rec.id);
-      expect(isIdle(rec)).toBe(false);
-    });
-  });
-
-  describe("hasLiveProcessHandle", () => {
-    it("no child in map → false", () => {
-      expect(hasLiveProcessHandle("sa-test")).toBe(false);
-    });
-
-    it("child present and not killed → true", () => {
-      spawnedChildren.set("sa-test", fakeChild(false));
-      expect(hasLiveProcessHandle("sa-test")).toBe(true);
-    });
-
-    it("child present but killed → false", () => {
-      spawnedChildren.set("sa-test", fakeChild(true));
-      expect(hasLiveProcessHandle("sa-test")).toBe(false);
-    });
-  });
-
-  describe("isResumable (= running && !hasLiveProcessHandle)", () => {
-    it("running + no live process → true (Path B / 跨重启)", () => {
-      expect(isResumable(makeRecord({ status: "running" }))).toBe(true);
-    });
-
-    it("running + live process → false (Path A 保活 / 正在执行)", () => {
-      const rec = makeRecord({ status: "running" });
-      spawnedChildren.set(rec.id, fakeChild(false));
-      expect(isResumable(rec)).toBe(false);
-    });
-
-    it("closed + no live process → false (终态不可 resume)", () => {
-      expect(isResumable(makeRecord({ status: "closed" }))).toBe(false);
-    });
-
-    it("closed + live process → false (终态优先)", () => {
-      const rec = makeRecord({ status: "closed" });
-      spawnedChildren.set(rec.id, fakeChild(false));
-      expect(isResumable(rec)).toBe(false);
-    });
-  });
-});