@zhushanwen/pi-subagent-workflow 8.6.0 → 8.8.0

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

@@ -1,287 +0,0 @@
-// src/execution/__tests__/nested-visibility-env-propagation.test.ts
-//
-// SP-8 嵌套可见性修复验证（TC-3：PI_SUBAGENT_ROOT_SESSION_ID env 贯穿）。
-//
-// 验证 env 身份贯穿机制：
-//   TC-3a: 根进程 initSession：无 env → sessionRootId = sessionId（自己是 ROOT）
-//   TC-3b: 子进程 initSession：有 env → sessionRootId = env 值（贯穿真 ROOT）
-//   TC-3c: 孙进程 initSession：env 链全程贯穿
-//   TC-3d: 子进程 execute 创建的 record.rootSessionId = env 贯穿的真 ROOT
-//   TC-3e: 子进程 collectRecords 用 sessionRootId 过滤
-//
-// mock 策略与 recursive-visibility-baseline.test.ts 一致。
-
-import type { PassThrough } from "node:stream";
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-// ── mock modules ──
-
-vi.mock("node:child_process", async () => {
-  const { EventEmitter } = await import("node:events");
-  const { PassThrough } = await import("node:stream");
-
-  class FakeChild extends EventEmitter {
-    pid = 12345;
-    stdout = new PassThrough();
-    stderr = new PassThrough();
-    killed = false;
-    killSignal: string | undefined;
-    kill(sig?: string): boolean {
-      this.killed = true;
-      this.killSignal = sig;
-      return true;
-    }
-  }
-
-  return {
-    spawn: vi.fn(() => new FakeChild()),
-    // buildEnvBlock 用 execFile 异步取 git branch：默认 err-first 兜底（catch → branch=""）
-    execFile: vi.fn(
-      (
-        _cmd: string,
-        _args: readonly string[],
-        _opts: unknown,
-        cb: (err: Error | null, stdout?: string, stderr?: string) => void,
-      ) => cb(new Error("execFile not configured in this test")),
-    ),
-  };
-});
-
-vi.mock("node:fs", async () => {
-  const actual = await import("node:fs");
-  return {
-    default: {
-      ...actual,
-      mkdirSync: vi.fn(),
-      existsSync: vi.fn(() => false),
-      appendFileSync: vi.fn(),
-      writeFileSync: vi.fn(),
-      readdirSync: vi.fn(() => []),
-    },
-    mkdirSync: vi.fn(),
-    existsSync: vi.fn(() => false),
-    appendFileSync: vi.fn(),
-    writeFileSync: vi.fn(),
-    readdirSync: vi.fn(() => []),
-    promises: actual.promises,
-  };
-});
-
-vi.mock("../alive-store.ts", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("../alive-store.ts")>();
-  return {
-    ...actual,
-    writeAliveMarker: vi.fn(),
-    removeAliveMarker: vi.fn(),
-  };
-});
-
-vi.mock("../finalized-marker.ts", () => ({
-  writeFinalized: vi.fn(),
-  readFinalized: vi.fn(() => false),
-}));
-
-vi.mock("../manifest-store.ts", () => {
-  class FakeManifestStore {
-    writeManifest = vi.fn(async () => {});
-    readManifest = vi.fn(async () => null);
-    listAllSync = vi.fn(() => []);
-    recoverTmpFiles = vi.fn(async () => []);
-  }
-  return { ManifestStore: vi.fn(function (_recordsDir: string) { return new FakeManifestStore(); }) };
-});
-
-vi.mock("../temp-prompt.ts", () => ({
-  writePromptToTempFile: vi.fn(async (agent: string) => {
-    const safeName = agent.replace(/[^\w.-]+/g, "_");
-    return { dir: `/tmp/fake-${safeName}`, filePath: `/tmp/fake-${safeName}/prompt-${safeName}.md` };
-  }),
-  cleanupTempPrompt: vi.fn(async () => {}),
-}));
-
-import { spawn } from "node:child_process";
-
-import { ModelConfigService } from "../model-config-service.ts";
-import type { ModelInfo, ModelRegistryLike } from "../model-resolver.ts";
-import type { RecordStore } from "../record-store.ts";
-import { createRecord } from "../execution-record.ts";
-import { SubagentService } from "../subagent-service.ts";
-
-const mockSpawn = vi.mocked(spawn);
-
-// ── env 名常量（与 subagent-service.ts 一致）──
-const ENV_ROOT_SESSION_ID = "PI_SUBAGENT_ROOT_SESSION_ID";
-const ENV_SELF_RECORD_ID = "PI_SUBAGENT_SELF_RECORD_ID";
-const ENV_DEPTH = "PI_SUBAGENT_DEPTH";
-const ENV_FORK_DEPTH = "PI_SUBAGENT_FORK_DEPTH";
-const ENV_ROOT_CWD = "PI_SUBAGENT_ROOT_CWD";
-
-// ── helpers ──
-
-interface FakeChild {
-  pid: number;
-  stdout: PassThrough;
-  stderr: PassThrough;
-  killed: boolean;
-  killSignal: string | undefined;
-  kill(sig?: string): boolean;
-  emit(event: string, ...args: unknown[]): boolean;
-}
-
-function lastSpawnedChild(): FakeChild {
-  const result = mockSpawn.mock.results.at(-1);
-  if (!result) throw new Error("spawn was not called yet");
-  return result.value as FakeChild;
-}
-
-function getLastSpawnEnv(): Record<string, string | undefined> {
-  return (mockSpawn.mock.calls.at(-1)?.[2]?.env as Record<string, string | undefined>) ?? {};
-}
-
-function sessionHeader(id = "env-prop-session"): Record<string, unknown> {
-  return { type: "session", id, timestamp: "2026-08-11T00-00-00-000Z", cwd: "/tmp/test" };
-}
-
-function emitStdoutLine(child: FakeChild, obj: Record<string, unknown>): void {
-  child.stdout.write(`${JSON.stringify(obj)}\n`);
-}
-
-async function driveChildToCompletion(child: FakeChild, events: Record<string, unknown>[] = []): Promise<void> {
-  emitStdoutLine(child, sessionHeader());
-  for (const e of events) emitStdoutLine(child, e);
-  child.stdout.end();
-  child.stderr.end();
-  child.emit("close", 0);
-}
-
-function makeEmptyRegistry(): ModelRegistryLike {
-  return { getAvailable: () => [], find: () => undefined, hasConfiguredAuth: () => true };
-}
-
-function makePi() {
-  return { sendMessage: vi.fn(), appendEntry: vi.fn(), events: { emit: vi.fn() } };
-}
-
-const ctxModel: ModelInfo = { id: "m", name: "M", provider: "p", reasoning: false };
-
-function setupService(sessionId: string, env?: Record<string, string>): SubagentService {
-  const agentDir = "/tmp/env-prop-it";
-  const modelService = new ModelConfigService({ agentDir });
-  modelService.initModel({
-    modelRegistry: makeEmptyRegistry(),
-    sessionId,
-    ctxModel,
-  });
-  const service = new SubagentService({
-    cwd: agentDir,
-    modelService,
-    getMainSessionFile: () => "/mock/main-session.jsonl",
-  });
-  service.initSession({ pi: makePi(), sessionId });
-  return service;
-}
-
-// ── 用例 ──
-
-describe("TC-3: PI_SUBAGENT_ROOT_SESSION_ID env 贯穿正确", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    for (const k of [ENV_ROOT_SESSION_ID, ENV_SELF_RECORD_ID, ENV_DEPTH, ENV_FORK_DEPTH, ENV_ROOT_CWD]) {
-      delete process.env[k];
-    }
-  });
-
-  afterEach(() => {
-    for (const k of [ENV_ROOT_SESSION_ID, ENV_SELF_RECORD_ID, ENV_DEPTH, ENV_FORK_DEPTH, ENV_ROOT_CWD]) {
-      delete process.env[k];
-    }
-    vi.restoreAllMocks();
-  });
-
-  it("TC-3a: 根进程 initSession：无 env → sessionRootId = sessionId（自己是 ROOT）", () => {
-    const service = setupService("root-it");
-    const sessionRootId = Reflect.get(service, "sessionRootId") as string;
-    expect(sessionRootId).toBe("root-it");
-  });
-
-  it("TC-3b: 子进程 initSession：有 env PI_SUBAGENT_ROOT_SESSION_ID → sessionRootId = env 值（贯穿真 ROOT）", () => {
-    process.env[ENV_ROOT_SESSION_ID] = "real-root-session";
-    const service = setupService("child-session");
-
-    const sessionRootId = Reflect.get(service, "sessionRootId") as string;
-    expect(sessionRootId).toBe("real-root-session"); // env 贯穿，不是 child-session
-  });
-
-  it("TC-3c: 孙进程 initSession：env 链全程贯穿，B 的 sessionRootId 仍为 ROOT", () => {
-    // 模拟 B 子进程收到的 env（A 在 spawn B 时注入）
-    process.env[ENV_ROOT_SESSION_ID] = "root-main-session";
-    process.env[ENV_SELF_RECORD_ID] = "sa-a-record";
-    process.env[ENV_DEPTH] = "1";
-
-    const service = setupService("b-session");
-
-    // B 的 sessionRootId 仍为 ROOT（env 贯穿，不被 B 自己的 sessionId 覆盖）
-    const sessionRootId = Reflect.get(service, "sessionRootId") as string;
-    expect(sessionRootId).toBe("root-main-session");
-
-    // B 的 execCtxBaseline 记录了 B 自己的身份（recordId + depth）
-    const baseline = Reflect.get(service, "execCtxBaseline") as { recordId: string; depth: number };
-    expect(baseline.recordId).toBe("sa-a-record");
-    expect(baseline.depth).toBe(1);
-  });
-
-  it("TC-3d: 子进程 execute 创建的 record.rootSessionId = env 贯穿的真 ROOT", async () => {
-    process.env[ENV_ROOT_SESSION_ID] = "root-main-session";
-    process.env[ENV_SELF_RECORD_ID] = "sa-parent";
-    process.env[ENV_DEPTH] = "1";
-
-    const service = setupService("child-session");
-
-    // execute 创建 record（模拟 B 内创建 C）
-    const handle = await service.execute({
-      task: "nested task",
-      ctxModel,
-    });
-    const store = Reflect.get(service, "store") as RecordStore;
-
-    // collectRecords 用 sessionRootId 过滤（子进程应看到 ROOT 整棵树）
-    const records = store.collectRecords(100, "all", "root-main-session");
-    const found = records.find((r) => r.id === handle.subagentId);
-
-    expect(found).toBeDefined();
-    expect(found!.rootSessionId).toBe("root-main-session"); // 指向 ROOT，不是 child-session
-    expect(found!.parentRecordId).toBe("sa-parent"); // 父链来自基线
-    expect(found!.depth).toBe(2); // 基线 depth=1 + 1 = 2
-  });
-
-  it("TC-3e: 子进程 collectRecords 用 sessionRootId 过滤（能看到 ROOT 整棵树）", () => {
-    process.env[ENV_ROOT_SESSION_ID] = "root-main-session";
-    process.env[ENV_SELF_RECORD_ID] = "sa-parent";
-    process.env[ENV_DEPTH] = "1";
-
-    const service = setupService("child-session");
-
-    // 手动注入一条 running record（避免需要真正 spawn）
-    const store = Reflect.get(service, "store") as RecordStore;
-    const recordC = createRecord("sa-c", {
-      agent: "worker",
-      model: "test/model",
-      mode: "background",
-      task: "deep nested",
-      startedAt: Date.now(),
-      rootSessionId: "root-main-session",
-      parentRecordId: "sa-parent",
-      depth: 2,
-    });
-    store.register(recordC);
-
-    // collectRecords（不带 filter）用 this.sessionRootId 过滤
-    const viaService = service.collectRecords(100);
-    const ids = viaService.map((r) => r.id);
-
-    // C 的 record 归 ROOT（rootSessionId=root-main-session），能被子进程查到
-    expect(ids).toContain("sa-c");
-    expect(viaService.find((r) => r.id === "sa-c")!.rootSessionId).toBe("root-main-session");
-  });
-});

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

@@ -1,325 +0,0 @@
-// src/execution/__tests__/nested-visibility.test.ts
-//
-// SP-8 嵌套可见性修复验证（TC-1 + TC-2：RecordStore 磁盘重建）。
-//
-// 验证全树可见性深度 ≥2 的 subagent 在 /subagents list 中可见：
-//   TC-1: 嵌套 A→B→C，B 和 C 的 rootSessionId 都指向 ROOT
-//   TC-2: collectRecords 返回全树（含深层）
-//
-// 使用真实文件系统（tmpdir + 真实 .jsonl）测试 RecordStore.collectRecords 磁盘重建。
-// TC-3（env 贯穿）见 nested-visibility-env-propagation.test.ts。
-
-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 { createRecord } from "../execution-record.ts";
-import { RecordStore } from "../record-store.ts";
-
-// ── helpers ──
-
-/**
- * 写一个最小合法的 session.jsonl（含 identity custom entry + 1 个 assistant message）。
- * 用于 collectRecords 磁盘源重建。
- */
-function writeSessionJsonl(
-  filePath: string,
-  identity: {
-    id: string;
-    agent: string;
-    mode: "background";
-    task: string;
-    startedAt: number;
-    rootSessionId?: string;
-    parentRecordId?: string;
-    depth?: number;
-    lastTs?: number;
-  },
-  assistantText = "result text",
-): void {
-  const lastTs = identity.lastTs ?? identity.startedAt + 1000;
-  const header = JSON.stringify({
-    type: "session", version: 3, id: "sess-uuid", timestamp: new Date(identity.startedAt).toISOString(), cwd: "/tmp",
-  });
-  const identityData: Record<string, unknown> = {
-    id: identity.id,
-    agent: identity.agent,
-    mode: identity.mode,
-    task: identity.task,
-    startedAt: identity.startedAt,
-  };
-  if (identity.rootSessionId !== undefined) identityData.rootSessionId = identity.rootSessionId;
-  if (identity.parentRecordId !== undefined) identityData.parentRecordId = identity.parentRecordId;
-  if (identity.depth !== undefined) identityData.depth = identity.depth;
-  const identityEntry = JSON.stringify({
-    type: "custom",
-    id: `id-${identity.id}`,
-    parentId: null,
-    timestamp: new Date(identity.startedAt).toISOString(),
-    customType: "subagent-identity",
-    data: identityData,
-  });
-  const assistantMsg = JSON.stringify({
-    type: "message",
-    id: `msg-${identity.id}`,
-    parentId: `id-${identity.id}`,
-    timestamp: new Date(lastTs).toISOString(),
-    message: {
-      role: "assistant",
-      content: [{ type: "text", text: assistantText }],
-      usage: { input: 10, output: 20, cacheRead: 0, cacheWrite: 0, totalTokens: 30, cost: { total: 0 } },
-      stopReason: "stop",
-      timestamp: lastTs,
-    },
-  });
-  fs.writeFileSync(filePath, `${header}\n${identityEntry}\n${assistantMsg}\n`, "utf-8");
-}
-
-// ============================================================
-// TC-1: 嵌套 A→B→C，B 和 C 的 rootSessionId 都指向 ROOT
-// ============================================================
-
-describe("TC-1: 嵌套 A→B→C 的 rootSessionId 全部指向 ROOT", () => {
-  let rootDir: string;
-  let tmpDir: string;
-
-  beforeEach(() => {
-    // [DS3] 两层布局：tmpDir 深一层（对齐生产 <enc> 段结构），sessions-index.json 落
-    // dirname(tmpDir)=rootDir 内随 afterEach 清理，不写 os.tmpdir() 本身。
-    rootDir = fs.mkdtempSync(path.join(os.tmpdir(), "nested-vis-tc1-"));
-    tmpDir = path.join(rootDir, "sessions");
-    fs.mkdirSync(tmpDir);
-  });
-
-  afterEach(() => {
-    fs.rmSync(rootDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
-  });
-
-  it("三层嵌套 record 的 rootSessionId 全部指向同一 ROOT（磁盘重建 + collectRecords 过滤）", () => {
-    const ROOT_SESSION = "root-session-001";
-    const store = new RecordStore(tmpDir);
-
-    // A: depth=0, parent=undefined（顶层）
-    writeSessionJsonl(path.join(tmpDir, "a.jsonl"), {
-      id: "sa-a", agent: "worker", mode: "background", task: "task A", startedAt: 1000,
-      rootSessionId: ROOT_SESSION, depth: 0,
-    });
-    // B: depth=1, parent=A（A 的子）
-    writeSessionJsonl(path.join(tmpDir, "b.jsonl"), {
-      id: "sa-b", agent: "worker", mode: "background", task: "task B", startedAt: 2000,
-      rootSessionId: ROOT_SESSION, parentRecordId: "sa-a", depth: 1,
-    });
-    // C: depth=2, parent=B（B 的子，最深层）
-    writeSessionJsonl(path.join(tmpDir, "c.jsonl"), {
-      id: "sa-c", agent: "worker", mode: "background", task: "task C", startedAt: 3000,
-      rootSessionId: ROOT_SESSION, parentRecordId: "sa-b", depth: 2,
-    });
-
-    const records = store.collectRecords(100, "all", ROOT_SESSION);
-    const ids = records.map((r) => r.id);
-
-    // 全部 3 条 record 可见
-    expect(ids).toContain("sa-a");
-    expect(ids).toContain("sa-b");
-    expect(ids).toContain("sa-c");
-    expect(records).toHaveLength(3);
-
-    // rootSessionId 全指向 ROOT
-    for (const r of records) {
-      expect(r.rootSessionId).toBe(ROOT_SESSION);
-    }
-  });
-
-  it("rootSessionId 不匹配时深层 record 被过滤（隔离防护）", () => {
-    const ROOT_SESSION = "root-session-001";
-    const OTHER_SESSION = "other-session-999";
-    const store = new RecordStore(tmpDir);
-
-    // A 归 ROOT
-    writeSessionJsonl(path.join(tmpDir, "a.jsonl"), {
-      id: "sa-a", agent: "worker", mode: "background", task: "task A", startedAt: 1000,
-      rootSessionId: ROOT_SESSION, depth: 0,
-    });
-    // B 归 OTHER（不同 session 的 subagent）
-    writeSessionJsonl(path.join(tmpDir, "b.jsonl"), {
-      id: "sa-b", agent: "worker", mode: "background", task: "task B", startedAt: 2000,
-      rootSessionId: OTHER_SESSION, depth: 1,
-    });
-
-    const records = store.collectRecords(100, "all", ROOT_SESSION);
-    const ids = records.map((r) => r.id);
-
-    // 只有 A 可见，B 被过滤
-    expect(ids).toContain("sa-a");
-    expect(ids).not.toContain("sa-b");
-  });
-});
-
-// ============================================================
-// TC-2: collectRecords 返回全树（含深层）
-// ============================================================
-
-describe("TC-2: collectRecords 返回全树（含深层）", () => {
-  let rootDir: string;
-  let tmpDir: string;
-
-  beforeEach(() => {
-    // [DS3] 两层布局：同 TC-1（sessions-index.json 落 rootDir 内随清理）。
-    rootDir = fs.mkdtempSync(path.join(os.tmpdir(), "nested-vis-tc2-"));
-    tmpDir = path.join(rootDir, "sessions");
-    fs.mkdirSync(tmpDir);
-  });
-
-  afterEach(() => {
-    fs.rmSync(rootDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
-  });
-
-  it("磁盘重建 + 内存 running 合并：全树 A→B→C 全部可见（深度 ≥2）", () => {
-    const ROOT_SESSION = "root-merge-001";
-    const store = new RecordStore(tmpDir);
-
-    // A: 磁盘终态（idle，无 sidecar → SP-2 兜底 idle）
-    writeSessionJsonl(path.join(tmpDir, "a.jsonl"), {
-      id: "sa-a", agent: "worker", mode: "background", task: "task A", startedAt: 1000,
-      rootSessionId: ROOT_SESSION, depth: 0,
-    });
-    // B: 磁盘终态（idle，无 sidecar）
-    writeSessionJsonl(path.join(tmpDir, "b.jsonl"), {
-      id: "sa-b", agent: "worker", mode: "background", task: "task B", startedAt: 2000,
-      rootSessionId: ROOT_SESSION, parentRecordId: "sa-a", depth: 1,
-    });
-    // C: 内存 running（当前正在执行）
-    const recordC = createRecord("sa-c", {
-      agent: "worker",
-      model: "test/model",
-      mode: "background",
-      task: "task C",
-      startedAt: 3000,
-      rootSessionId: ROOT_SESSION,
-      parentRecordId: "sa-b",
-      depth: 2,
-    });
-    store.register(recordC);
-
-    const records = store.collectRecords(100, "all", ROOT_SESSION);
-    const ids = records.map((r) => r.id);
-
-    // 全部 3 条可见（磁盘 A/B + 内存 C）
-    expect(ids).toContain("sa-a");
-    expect(ids).toContain("sa-b");
-    expect(ids).toContain("sa-c");
-    expect(records.length).toBeGreaterThanOrEqual(3);
-  });
-
-  it("depth 标签正确：A=0, B=1, C=2", () => {
-    const ROOT_SESSION = "root-depth-001";
-    const store = new RecordStore(tmpDir);
-
-    writeSessionJsonl(path.join(tmpDir, "a.jsonl"), {
-      id: "sa-a", agent: "worker", mode: "background", task: "task A", startedAt: 1000,
-      rootSessionId: ROOT_SESSION, depth: 0,
-    });
-    writeSessionJsonl(path.join(tmpDir, "b.jsonl"), {
-      id: "sa-b", agent: "worker", mode: "background", task: "task B", startedAt: 2000,
-      rootSessionId: ROOT_SESSION, parentRecordId: "sa-a", depth: 1,
-    });
-    writeSessionJsonl(path.join(tmpDir, "c.jsonl"), {
-      id: "sa-c", agent: "worker", mode: "background", task: "task C", startedAt: 3000,
-      rootSessionId: ROOT_SESSION, parentRecordId: "sa-b", depth: 2,
-    });
-
-    const records = store.collectRecords(100, "all", ROOT_SESSION);
-    const byId = new Map(records.map((r) => [r.id, r]));
-
-    expect(byId.get("sa-a")!.depth).toBe(0);
-    expect(byId.get("sa-b")!.depth).toBe(1);
-    expect(byId.get("sa-c")!.depth).toBe(2);
-  });
-
-  it("parentRecordId 链完整：A→(root), B→A, C→B", () => {
-    const ROOT_SESSION = "root-parent-001";
-    const store = new RecordStore(tmpDir);
-
-    writeSessionJsonl(path.join(tmpDir, "a.jsonl"), {
-      id: "sa-a", agent: "worker", mode: "background", task: "task A", startedAt: 1000,
-      rootSessionId: ROOT_SESSION, depth: 0,
-    });
-    writeSessionJsonl(path.join(tmpDir, "b.jsonl"), {
-      id: "sa-b", agent: "worker", mode: "background", task: "task B", startedAt: 2000,
-      rootSessionId: ROOT_SESSION, parentRecordId: "sa-a", depth: 1,
-    });
-    writeSessionJsonl(path.join(tmpDir, "c.jsonl"), {
-      id: "sa-c", agent: "worker", mode: "background", task: "task C", startedAt: 3000,
-      rootSessionId: ROOT_SESSION, parentRecordId: "sa-b", depth: 2,
-    });
-
-    const records = store.collectRecords(100, "all", ROOT_SESSION);
-    const byId = new Map(records.map((r) => [r.id, r]));
-
-    expect(byId.get("sa-a")!.parentRecordId).toBeUndefined(); // 顶层无父
-    expect(byId.get("sa-b")!.parentRecordId).toBe("sa-a");
-    expect(byId.get("sa-c")!.parentRecordId).toBe("sa-b");
-  });
-
-  it("statusFilter='running' 返回全树（v4 B-1：深层磁盘 idle 重建为 running）", () => {
-    const ROOT_SESSION = "root-filter-001";
-    const store = new RecordStore(tmpDir);
-
-    // 3 条磁盘 idle record（SP-2: 无 sidecar → 旧 idle，v4 B-1 重建为 running）
-    writeSessionJsonl(path.join(tmpDir, "a.jsonl"), {
-      id: "sa-a", agent: "worker", mode: "background", task: "task A", startedAt: 1000,
-      rootSessionId: ROOT_SESSION, depth: 0,
-    });
-    writeSessionJsonl(path.join(tmpDir, "b.jsonl"), {
-      id: "sa-b", agent: "worker", mode: "background", task: "task B", startedAt: 2000,
-      rootSessionId: ROOT_SESSION, parentRecordId: "sa-a", depth: 1,
-    });
-    writeSessionJsonl(path.join(tmpDir, "c.jsonl"), {
-      id: "sa-c", agent: "worker", mode: "background", task: "task C", startedAt: 3000,
-      rootSessionId: ROOT_SESSION, parentRecordId: "sa-b", depth: 2,
-    });
-
-    // C 是内存 running
-    const recordC = createRecord("sa-c", {
-      agent: "worker",
-      model: "test/model",
-      mode: "background",
-      task: "task C",
-      startedAt: 3000,
-      rootSessionId: ROOT_SESSION,
-      parentRecordId: "sa-b",
-      depth: 2,
-    });
-    store.register(recordC);
-
-    const runningRecords = store.collectRecords(100, "running", ROOT_SESSION);
-    const ids = runningRecords.map((r) => r.id);
-
-    // v4 B-1：磁盘 A/B 旧 idle 现重建为 running（idle 折入 running），与内存 C 一起返回
-    expect(ids).toHaveLength(3);
-    expect(ids).toContain("sa-a");
-    expect(ids).toContain("sa-b");
-    expect(ids).toContain("sa-c");
-  });
-
-  it("无 rootSessionFilter 时不过滤（向后兼容）", () => {
-    const store = new RecordStore(tmpDir);
-
-    writeSessionJsonl(path.join(tmpDir, "a.jsonl"), {
-      id: "sa-a", agent: "worker", mode: "background", task: "task A", startedAt: 1000,
-      rootSessionId: "root-1", depth: 0,
-    });
-    writeSessionJsonl(path.join(tmpDir, "b.jsonl"), {
-      id: "sa-b", agent: "worker", mode: "background", task: "task B", startedAt: 2000,
-      rootSessionId: "root-2", depth: 0,
-    });
-
-    // 无 filter → 全部返回
-    const records = store.collectRecords(100, "all", undefined);
-    const ids = records.map((r) => r.id);
-    expect(ids).toContain("sa-a");
-    expect(ids).toContain("sa-b");
-  });
-});