@zhushanwen/pi-subagent-workflow 7.3.4 → 8.0.0

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

@@ -0,0 +1,337 @@
+// 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

@@ -0,0 +1,116 @@
+// 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);
+    });
+  });
+});

package/src/execution/__tests__/list-component.test.ts

@@ -36,11 +36,13 @@ function makeTheme(): ThemeLike {
   } as ThemeLike;
 }
 
-/** service stub：list-component 只调 collectRecords(limit) 单参数。
+/** service stub：list-component 只调 collectRecords(limit) 单参数 + getFullRecord（[perf]
+ *  选中项详情懒加载，mock 回 undefined → fullRecordOf 回退 light record，与旧行为一致）。
  *  与 tool-action.test.ts 同模式：部分对象直接断言为 SubagentService（duck-type）。 */
 function makeService(records: SubagentRecord[] = []): SubagentService {
   return {
     collectRecords: vi.fn(() => records),
+    getFullRecord: vi.fn(() => undefined as SubagentRecord | undefined),
   } as SubagentService;
 }
 
@@ -50,7 +52,7 @@ function makeRecord(over: Partial<SubagentRecord> = {}): SubagentRecord {
     id: "run-1",
     agent: "worker",
     task: "do the thing",
-    status: "done",
+    status: "closed",
     mode: "sync",
     startedAt: 1000,
     endedAt: 2000,
@@ -158,9 +160,10 @@ describe("SubagentsListComponent", () => {
 
   // ── hasRunning ────────────────────────────────────────
   describe("hasRunning", () => {
-    it("records 全是 done → false", () => {
+    it("records 全是 closed（终态）→ false", () => {
       const { comp } = makeComponent({
-        records: [makeRecord({ status: "done" }), makeRecord({ status: "failed" })],
+        // v4 B-1：done/failed 等旧终态已收敛为 closed（fixture 同步迁移）
+        records: [makeRecord({ status: "closed" }), makeRecord({ status: "closed" })],
       });
       expect(comp.hasRunning()).toBe(false);
     });
@@ -168,7 +171,7 @@ describe("SubagentsListComponent", () => {
     it("records 含一个 running → true", () => {
       const { comp } = makeComponent({
         records: [
-          makeRecord({ id: "a", status: "done" }),
+          makeRecord({ id: "a", status: "closed" }),
           makeRecord({ id: "b", status: "running" }),
         ],
       });
@@ -344,4 +347,55 @@ describe("SubagentsListComponent", () => {
       expect(detailJoined).toContain("session-abc.jsonl"); // sessionFile
     });
   });
+
+  // ── 帧缓存 collectRecordsFrame（TC3/IF3/DM5）──────────
+  describe("帧缓存 collectRecordsFrame", () => {
+    it("同一帧（TTL 50ms 内）hasRunning + render 只触发 1 次 service.collectRecords", () => {
+      // fake timers 已锁 Date.now()（beforeEach）→ 帧内多次消费共享同一份 records
+      const rec = makeRecord({ id: "a", status: "running" });
+      const { comp, service } = makeComponent({ records: [rec], rows: 24 });
+      expect(comp.hasRunning()).toBe(true); // 第 1 次扫描
+      comp.render(80); // buildLines 消费（帧命中，不重扫）
+      comp.handleInput("x"); // handleInput 消费（帧命中）
+      expect(vi.mocked(service.collectRecords)).toHaveBeenCalledTimes(1);
+    });
+
+    it("advance 100ms 后 TTL 过期 → 重扫（collectRecords 递增）", () => {
+      const rec = makeRecord({ id: "a", status: "running" });
+      const { comp, service } = makeComponent({ records: [rec], rows: 24 });
+      comp.render(80);
+      expect(vi.mocked(service.collectRecords)).toHaveBeenCalledTimes(1);
+      vi.advanceTimersByTime(100); // > FRAME_TTL_MS(50)
+      // 镜像 animTimer 真实序列：hasRunning（帧消费点）→ invalidate → render。
+      // hasRunning 直接走帧缓存（不经 render 行缓存），TTL 过期 → 重扫
+      expect(comp.hasRunning()).toBe(true);
+      expect(vi.mocked(service.collectRecords)).toHaveBeenCalledTimes(2);
+      comp.invalidate();
+      comp.render(80); // 重建行，但帧刚刷新（100ms 后的同一时刻）→ 不再重扫
+      expect(vi.mocked(service.collectRecords)).toHaveBeenCalledTimes(2);
+    });
+
+    it("invalidate 不清帧缓存：invalidate 后同帧 render 仍命中（不重扫）", () => {
+      // timer 序列 hasRunning → invalidate → requestRender 的共享前提：
+      // invalidate 只清渲染行缓存（cachedKey/cachedLines），帧缓存由 TTL 独立保证
+      const rec = makeRecord({ id: "a", status: "running" });
+      const { comp, service } = makeComponent({ records: [rec], rows: 24 });
+      const first = comp.render(80);
+      expect(vi.mocked(service.collectRecords)).toHaveBeenCalledTimes(1);
+      comp.invalidate();
+      const second = comp.render(80);
+      expect(second).not.toBe(first); // 渲染行缓存已清 → 重建
+      expect(vi.mocked(service.collectRecords)).toHaveBeenCalledTimes(1); // 帧缓存未清 → 不重扫
+    });
+
+    it("detailMode 渲染路径（buildDetailContent children）同帧共享：render 仍只 1 次扫描", () => {
+      // 选中项有子 record → buildDetailContent 内 children 计算消费 collectRecordsFrame
+      const parent = makeRecord({ id: "p", status: "closed" });
+      const child = makeRecord({ id: "c", parentRecordId: "p" });
+      const { comp, service } = makeComponent({ records: [parent, child], rows: 24, detailMode: true });
+      const joined = comp.render(80).join("\n");
+      expect(joined).toContain("children:");
+      expect(vi.mocked(service.collectRecords)).toHaveBeenCalledTimes(1); // buildLines + children 同帧合一
+    });
+  });
 });

package/src/execution/__tests__/list-fields.test.ts

@@ -0,0 +1,109 @@
+// src/execution/__tests__/list-fields.test.ts
+//
+// [v4 A-6] recordToListItem 字段派生单测。
+//
+// 验证 list 输出的新增字段派生正确：
+//   - parent：从 record.parentRecordId 派生（顶层 record → undefined）
+//   - resumable：从 isResumable 派生（running && 无活进程句柄）
+//   - closedReason：透传 record.closedReason（SP-4 级联关闭告知替代）
+//
+// Mock 策略：vi.mock lifecycle-predicates 的 isResumable，控制其返回值模拟「有/无
+// 活进程句柄」两种 running 子态。isResumable 真实逻辑（running && !hasLiveProcessHandle）
+// 由 lifecycle-predicates.test.ts 覆盖；本测试聚焦 recordToListItem 的字段派生与透传。
+
+import { describe, expect, it, vi } from "vitest";
+
+// mock lifecycle-predicates：控制 isResumable 返回值。
+// recordToListItem 内部 import 的 isResumable 经 vitest 自动接线拿到此 mock 版本。
+vi.mock("../../execution/lifecycle-predicates.ts", () => ({
+	isResumable: vi.fn(),
+}));
+
+import { recordToListItem } from "../../interface/subagent-actions.ts";
+import { isResumable } from "../../execution/lifecycle-predicates.ts";
+import type { ClosedReason, SubagentRecord } from "../types.ts";
+
+// ── SubagentRecord stub 工厂（最小合法 record） ──
+
+function makeRecord(over: Partial<SubagentRecord> = {}): SubagentRecord {
+	return {
+		id: "sa-test",
+		agent: "general-purpose",
+		task: "test task",
+		slug: "test-slug",
+		status: "running",
+		mode: "background",
+		startedAt: Date.now(),
+		rootSessionId: "session-main",
+		parentRecordId: undefined,
+		depth: 0,
+		endedAt: undefined,
+		turns: 0,
+		totalTokens: 0,
+		model: "test/model",
+		thinkingLevel: undefined,
+		eventLog: [],
+		displayItems: [],
+		result: undefined,
+		error: undefined,
+		sessionFile: undefined,
+		...over,
+	};
+}
+
+describe("recordToListItem — parent/resumable/closedReason (v4 A-6)", () => {
+	// ═══ parent：从 record.parentRecordId 派生 ═══
+
+	it("parent：嵌套 record（parentRecordId='sa-A'）→ parent='sa-A'", () => {
+		const rec = makeRecord({ parentRecordId: "sa-A" });
+		expect(recordToListItem(rec).parent).toBe("sa-A");
+	});
+
+	it("parent：根层 record（parentRecordId=undefined）→ parent=undefined", () => {
+		const rec = makeRecord({ parentRecordId: undefined });
+		expect(recordToListItem(rec).parent).toBeUndefined();
+	});
+
+	// ═══ resumable：isResumable 透传（mock 模拟有/无活进程句柄） ═══
+
+	it("resumable：running + 无活进程句柄（isResumable=true）→ true（B-1 续聊态）", () => {
+		vi.mocked(isResumable).mockReturnValue(true);
+		const rec = makeRecord({ status: "running" });
+		expect(recordToListItem(rec).resumable).toBe(true);
+	});
+
+	it("resumable：running + 有活进程句柄（isResumable=false）→ false（正在执行）", () => {
+		vi.mocked(isResumable).mockReturnValue(false);
+		const rec = makeRecord({ status: "running" });
+		expect(recordToListItem(rec).resumable).toBe(false);
+	});
+
+	it("resumable：closed（isResumable=false）→ false（终态不可续聊）", () => {
+		vi.mocked(isResumable).mockReturnValue(false);
+		const rec = makeRecord({ status: "closed" });
+		expect(recordToListItem(rec).resumable).toBe(false);
+	});
+
+	// ═══ closedReason：透传 record.closedReason ═══
+
+	it("closedReason：closed + closedReason='parent-fork' → 透传", () => {
+		const rec = makeRecord({
+			status: "closed",
+			closedReason: "parent-fork" as ClosedReason,
+		});
+		expect(recordToListItem(rec).closedReason).toBe("parent-fork");
+	});
+
+	it("closedReason：closed + closedReason='parent-new' → 透传（SP-4 级联关闭场景）", () => {
+		const rec = makeRecord({
+			status: "closed",
+			closedReason: "parent-new" as ClosedReason,
+		});
+		expect(recordToListItem(rec).closedReason).toBe("parent-new");
+	});
+
+	it("closedReason：running record（无 closedReason）→ undefined", () => {
+		const rec = makeRecord({ status: "running" });
+		expect(recordToListItem(rec).closedReason).toBeUndefined();
+	});
+});