@zhushanwen/pi-subagent-workflow 8.5.0 → 8.7.0

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