@zhushanwen/pi-subagent-workflow 7.3.4 → 8.0.0

package/src/execution/__tests__/model-resolver.test.ts

@@ -190,11 +190,48 @@ describe("resolveModel — thinkingLevel resolution", () => {
     expect(r.thinkingLevel).toBe("medium");
   });
 
-  it("ctxModel path: thinkingLevel undefined when no override anywhere", () => {
+  it("ctxModel path: thinkingLevel undefined when no override and ctxModel non-reasoning", () => {
     const reg = makeRegistry([]);
+    // ctxModel（makeModel 默认 reasoning=false）无 override → 非 reasoning 不支持 thinking
     const r = resolveModel(undefined, reg, undefined, ctxModel);
     expect(r.thinkingLevel).toBeUndefined();
   });
+
+  // ── 默认 thinking 兜底：无显式指定时用「模型最高可用档」（不落 pi 默认 medium）──
+
+  it("ctxModel path: no override + reasoning model with map → highest mapped level", () => {
+    const reg = makeRegistry([]);
+    const m = makeModel({ id: "r-main", provider: "rm", reasoning: true, thinkingLevelMap: { low: 1, high: 2, xhigh: 3 } });
+    const r = resolveModel(undefined, reg, undefined, m);
+    expect(r.thinkingLevel).toBe("xhigh");
+  });
+
+  it("ctxModel path: no override + reasoning model with map containing max → max", () => {
+    const reg = makeRegistry([]);
+    const m = makeModel({ id: "r-max", provider: "rm", reasoning: true, thinkingLevelMap: { high: 2, max: 99 } });
+    const r = resolveModel(undefined, reg, undefined, m);
+    expect(r.thinkingLevel).toBe("max");
+  });
+
+  it("ctxModel path: no override + reasoning model without map → xhigh (pi-legal ceiling)", () => {
+    const reg = makeRegistry([]);
+    // 无 map 时不能用 "max"——pi 侧 model:"max" 后缀非法会导致 model 解析失败
+    const m = makeModel({ id: "r-nomap", provider: "rm", reasoning: true });
+    const r = resolveModel(undefined, reg, undefined, m);
+    expect(r.thinkingLevel).toBe("xhigh");
+  });
+
+  it("override path: no thinkingLevel param → defaults to model's highest mapped level", () => {
+    const m = makeModel({
+      id: "default-thinking",
+      provider: "dt",
+      reasoning: true,
+      thinkingLevelMap: { minimal: 1, medium: 2, high: 3 },
+    });
+    const reg = makeRegistry([m]);
+    const r = resolveModel(undefined, reg, { model: "dt/default-thinking" });
+    expect(r.thinkingLevel).toBe("high");
+  });
 });
 
 // ============================================================

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

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

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