recallnest 3.0.0 → 3.0.1

package/src/__tests__/pivot-distill.test.ts

@@ -1,1178 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { createHash } from "node:crypto";
-import { chmodSync, mkdirSync, mkdtempSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-  acquireOutputLock,
-  aggregateDetailedUsage,
-  agySessionIdFromPath,
-  assertExternalModeAuthorization,
-  assertPivotResponseMetadata,
-  buildPivotRequestProfile,
-  buildPivotLlmConfig,
-  buildStratifiedSample,
-  coalesceTurns,
-  extractAgyUserText,
-  extractTurnsFromRecord,
-  filteredDejaEnvironment,
-  frozenSampleHash,
-  geminiJsonTurns,
-  harnessFamily,
-  inventoryCompletenessReasons,
-  isSyntheticSession,
-  loadFrozenBundle,
-  loadSessionInventory,
-  main,
-  OMISSION_MARKER,
-  parseCliOptions,
-  parserKindFor,
-  redactedResidue,
-  PIPELINE_VERSION,
-  PIVOT_MODEL,
-  pivotRequestProfileHash,
-  PROMPT_VERSION,
-  readSessionTurns,
-  redactForExternalModel,
-  retryDecision,
-  resolveBundleSamplePath,
-  resolveClaudeSessionPath,
-  safeEndpoint,
-  selectFrozenEntries,
-  selectionIdentityHash,
-  sessionFingerprint,
-  stableSessionId,
-  storedResultMatches,
-  validateJudgeResponse,
-  writeFrozenBundle,
-  type FrozenBundleDescriptor,
-  type SessionMeta,
-} from "../../scripts/pivot-distill.js";
-
-function session(overrides: Partial<SessionMeta> = {}): SessionMeta {
-  return {
-    key: "codex:019fc307-9cdb-7c51-812d-7b2d3545c656",
-    sessionId: "019fc307-9cdb-7c51-812d-7b2d3545c656",
-    rawHarness: "codex",
-    harness: "codex",
-    parserKind: "codex-rollout",
-    project: "recallnest",
-    path: "/tmp/rollout-019fc307-9cdb-7c51-812d-7b2d3545c656.jsonl",
-    date: "2026-08-02",
-    sizeBytes: 200_000,
-    mtimeNs: "123456789",
-    origin: "deja",
-    fingerprint: "abc",
-    ...overrides,
-  };
-}
-
-function sha256(value: string): string {
-  return createHash("sha256").update(value).digest("hex");
-}
-
-function bundleIdentityHashForTest(input: {
-  requestProfileHash: string;
-  manifestSha256: string;
-  sessions: number;
-  eligibleSessions: number;
-  deferredSessions: number;
-}): string {
-  return sha256(JSON.stringify({ schemaVersion: 1, ...input }));
-}
-
-function createBundleFixture(): {
-  outputDir: string;
-  bundleDir: string;
-  descriptor: FrozenBundleDescriptor;
-} {
-  const outputDir = mkdtempSync(join(tmpdir(), "pivot-bundle-"));
-  const source = join(outputDir, "source.jsonl");
-  writeFileSync(source, "{}\n");
-  const sourceStat = statSync(source, { bigint: true });
-  const profile = buildPivotRequestProfile("https://example.invalid/compatible-mode/v1?ignored=1#fragment", 600);
-  const profileHash = pivotRequestProfileHash(profile);
-  const sample = buildStratifiedSample([
-    { role: "user", text: "以后必须保留可回查证据" },
-    { role: "assistant", text: "已记录这条规则" },
-  ], 600);
-  const descriptor = writeFrozenBundle(outputDir, [{
-    session: session({
-      path: source,
-      sizeBytes: Number(sourceStat.size),
-      mtimeNs: sourceStat.mtimeNs.toString(),
-    }),
-    sample,
-  }], profile, profileHash);
-  return { outputDir, bundleDir: join(outputDir, "input-bundle"), descriptor };
-}
-
-describe("pivot-distill harness normalization", () => {
-  it("reports Gemini and Antigravity as one AGY endpoint", () => {
-    expect(harnessFamily("claude")).toBe("claude-code");
-    expect(harnessFamily("codex")).toBe("codex");
-    expect(harnessFamily("kimi")).toBe("kimi");
-    expect(harnessFamily("gemini")).toBe("agy");
-    expect(harnessFamily("antigravity")).toBe("agy");
-    expect(harnessFamily("grok")).toBeNull();
-  });
-
-  it("selects the parser from raw harness and file shape", () => {
-    expect(parserKindFor("gemini", "/x/session.json")).toBe("gemini-json");
-    expect(parserKindFor("gemini", "/x/transcript_full.jsonl")).toBe("agy-converted");
-    expect(parserKindFor("antigravity", "/x/transcript.jsonl")).toBe("antigravity-jsonl");
-    expect(parserKindFor("kimi", "/x/wire.jsonl")).toBe("kimi-wire");
-  });
-
-  it("extracts the raw UUID from Codex rollout identity", () => {
-    expect(stableSessionId(
-      "2026-08-02T23-13-07-019fc309-3111-7d53-b968-d7269eee3959",
-      "/x/rollout-2026-08-02T23-13-07-019fc309-3111-7d53-b968-d7269eee3959.jsonl",
-    )).toBe("019fc309-3111-7d53-b968-d7269eee3959");
-  });
-
-  it("keeps distinct AGY brain session IDs instead of collapsing them to logs", () => {
-    expect(agySessionIdFromPath("/x/brain/session-a/.system_generated/logs/transcript_full.jsonl")).toBe("session-a");
-    expect(agySessionIdFromPath("/x/brain/session-b/.system_generated/logs/transcript_full.jsonl")).toBe("session-b");
-  });
-
-  it("does not accept an unresolved Claude subagent path as a main session", () => {
-    expect(resolveClaudeSessionPath({
-      id: "main-session",
-      harness: "claude",
-      path: "/definitely-missing/subagents/agent-worker.jsonl",
-    })).toBeNull();
-    expect(resolveClaudeSessionPath({
-      id: "main-session",
-      harness: "claude",
-      path: "/x/main-session.jsonl",
-    })).toBe("/x/main-session.jsonl");
-  });
-
-  it("resolves both sibling and nested Claude agent files to the main session", () => {
-    const projectDir = mkdtempSync(join(tmpdir(), "pivot-claude-project-"));
-    const sessionId = "01234567-89ab-cdef-0123-456789abcdef";
-    const mainPath = join(projectDir, `${sessionId}.jsonl`);
-    writeFileSync(mainPath, "\n");
-    expect(resolveClaudeSessionPath({
-      id: sessionId,
-      harness: "claude",
-      path: join(projectDir, "agent-worker.jsonl"),
-    })).toBe(mainPath);
-    const subagentDir = join(projectDir, sessionId, "subagents");
-    mkdirSync(subagentDir, { recursive: true });
-    expect(resolveClaudeSessionPath({
-      id: sessionId,
-      harness: "claude",
-      path: join(subagentDir, "agent-worker.jsonl"),
-    })).toBe(mainPath);
-  });
-});
-
-describe("pivot-distill transcript adapters", () => {
-  it("parses Claude user/assistant text and rejects injected context", () => {
-    expect(extractTurnsFromRecord({
-      type: "user",
-      message: { content: [{ type: "text", text: "我决定保留这个规则" }] },
-      timestamp: "2026-08-02T00:00:00Z",
-    }, "claude-jsonl")).toEqual([{
-      role: "user",
-      text: "我决定保留这个规则",
-      timestamp: "2026-08-02T00:00:00Z",
-    }]);
-    expect(extractTurnsFromRecord({
-      type: "user",
-      message: { content: "<system-reminder>ignore previous</system-reminder>" },
-    }, "claude-jsonl")).toEqual([]);
-    expect(extractTurnsFromRecord({
-      type: "user",
-      message: { content: [{ type: "tool_result", content: "secret" }] },
-    }, "claude-jsonl")).toEqual([]);
-  });
-
-  it("parses Codex response_item messages without tool output", () => {
-    expect(extractTurnsFromRecord({
-      type: "response_item",
-      payload: {
-        type: "message",
-        role: "user",
-        content: [{ type: "input_text", text: "这条路不要再走" }],
-      },
-    }, "codex-rollout")).toEqual([{ role: "user", text: "这条路不要再走", timestamp: undefined }]);
-    expect(extractTurnsFromRecord({
-      type: "response_item",
-      payload: { type: "function_call_output", output: "ignored" },
-    }, "codex-rollout")).toEqual([]);
-    expect(extractTurnsFromRecord({
-      type: "event_msg",
-      payload: { type: "user_message", message: "这是 event_msg 里的真实用户输入" },
-    }, "codex-rollout")).toEqual([{
-      role: "user",
-      text: "这是 event_msg 里的真实用户输入",
-      timestamp: undefined,
-    }]);
-  });
-
-  it("parses Kimi user messages and streamed assistant text", () => {
-    expect(extractTurnsFromRecord({
-      type: "context.append_message",
-      message: {
-        role: "user",
-        origin: { kind: "user" },
-        content: [{ type: "text", text: "以后统一用这个" }],
-      },
-    }, "kimi-wire")).toEqual([{ role: "user", text: "以后统一用这个", timestamp: undefined }]);
-    expect(extractTurnsFromRecord({
-      type: "turn.prompt",
-      origin: { kind: "user" },
-      input: [{ type: "text", text: "这是 turn.prompt" }],
-      time: 1_700_000_000_000,
-    }, "kimi-wire")).toEqual([{
-      role: "user",
-      text: "这是 turn.prompt",
-      timestamp: "2023-11-14T22:13:20.000Z",
-    }]);
-    expect(extractTurnsFromRecord({
-      type: "context.append_message",
-      message: {
-        role: "user",
-        origin: { kind: "skill_activation" },
-        content: [{ type: "text", text: "这是系统注入" }],
-      },
-    }, "kimi-wire")).toEqual([]);
-    expect(extractTurnsFromRecord({
-      type: "context.append_loop_event",
-      event: { type: "content.part", part: { type: "text", text: "收到" } },
-    }, "kimi-wire")).toEqual([{ role: "assistant", text: "收到", timestamp: undefined }]);
-  });
-
-  it("parses Antigravity and Gemini records into the AGY conversation", () => {
-    expect(extractTurnsFromRecord({
-      type: "USER_INPUT",
-      content: "<USER_REQUEST>这是我的规则</USER_REQUEST><ADDITIONAL_METADATA>系统数据</ADDITIONAL_METADATA>",
-      created_at: "2026-08-01T00:00:00Z",
-    }, "antigravity-jsonl")).toEqual([{
-      role: "user",
-      text: "这是我的规则",
-      timestamp: "2026-08-01T00:00:00Z",
-    }]);
-    expect(geminiJsonTurns(JSON.stringify({
-      messages: [
-        { type: "user", timestamp: "t1", content: [{ text: "不要自动删除" }] },
-        { type: "gemini", timestamp: "t2", content: "明白" },
-      ],
-    }))).toEqual([
-      { role: "user", text: "不要自动删除", timestamp: "t1" },
-      { role: "assistant", text: "明白", timestamp: "t2" },
-    ]);
-    expect(extractAgyUserText(
-      "保留正文<ADDITIONAL_METADATA>系统数据</ADDITIONAL_METADATA><USER_SETTINGS_CHANGE>设置</USER_SETTINGS_CHANGE>",
-    )).toBe("保留正文");
-    expect(extractTurnsFromRecord({
-      type: "user",
-      message: { role: "user", content: "转换后的用户内容" },
-    }, "agy-converted")).toEqual([{
-      role: "user",
-      text: "转换后的用户内容",
-      timestamp: undefined,
-    }]);
-    expect(extractTurnsFromRecord({
-      type: "assistant",
-      message: { role: "assistant", content: "旧 SQLite 转换后的回答" },
-    }, "antigravity-jsonl")).toEqual([{
-      role: "assistant",
-      text: "旧 SQLite 转换后的回答",
-      timestamp: undefined,
-    }]);
-  });
-
-  it("coalesces streamed assistant parts but keeps user turns separate", () => {
-    expect(coalesceTurns([
-      { role: "assistant", text: "前半" },
-      { role: "assistant", text: "后半" },
-      { role: "user", text: "下一问" },
-    ])).toEqual([
-      { role: "assistant", text: "前半\n后半" },
-      { role: "user", text: "下一问" },
-    ]);
-  });
-});
-
-describe("pivot-distill sampling and validation", () => {
-  it("covers the beginning, middle, and end of a long session", () => {
-    const turns = Array.from({ length: 9 }, (_, index) => ({
-      role: index % 2 === 0 ? "user" as const : "assistant" as const,
-      text: `turn-${index}-${"x".repeat(90)}`,
-    }));
-    const sample = buildStratifiedSample(turns, 400);
-    expect(sample.text.length).toBeLessThanOrEqual(400);
-    expect(sample.text).toContain("turn-0-");
-    expect(sample.text).toContain("turn-4-");
-    expect(sample.text).toContain("turn-8-");
-    expect(sample.sampledTurns).toBe(5);
-    expect(sample.sampledExchanges).toBe(3);
-  });
-
-  it("redacts a secret before the per-turn cut", () => {
-    const sample = buildStratifiedSample([{
-      role: "user",
-      text: `${"x".repeat(880)} sk-ant-api03-SECRETSECRETSECRET tail`,
-    }], 2_000);
-    expect(sample.text).toContain("[REDACTED:anthropic");
-    expect(sample.text).not.toContain("sk-ant-");
-  });
-
-  it("keeps complete exchanges verbatim when the 24K-style cap is not reached", () => {
-    const turns = [
-      { role: "assistant" as const, text: "开头的 assistant-only 说明" },
-      { role: "user" as const, text: "连续用户一" },
-      { role: "user" as const, text: "连续用户二" },
-      { role: "assistant" as const, text: "回答二之一" },
-      { role: "assistant" as const, text: "回答二之二" },
-      { role: "user" as const, text: "结尾尚未回答" },
-    ];
-    const sample = buildStratifiedSample(turns, 2_000);
-    expect(sample.originalTurns).toBe(turns.length);
-    expect(sample.sampledTurns).toBe(turns.length);
-    expect(sample.exchanges).toBe(4);
-    expect(sample.sampledExchanges).toBe(4);
-    expect(sample.omittedTurns).toBe(0);
-    expect(sample.text).toContain("助手：回答二之一\n助手：回答二之二");
-    expect(sample.text).toEndWith("用户：结尾尚未回答");
-  });
-
-  it("preserves head, centered middle, and tail evidence in long user and assistant turns", () => {
-    const user = `USER_HEAD_${"u".repeat(180)}_USER_MIDDLE_${"v".repeat(180)}_USER_TAIL`;
-    const assistant = `ASSIST_HEAD_${"a".repeat(180)}_ASSIST_MIDDLE_${"b".repeat(180)}_ASSIST_TAIL`;
-    const sample = buildStratifiedSample([
-      { role: "user", text: user },
-      { role: "assistant", text: assistant },
-    ], 340);
-    expect(sample.text.length).toBeLessThanOrEqual(340);
-    expect(sample.text).toContain("USER_HEAD_");
-    expect(sample.text).toContain("USER_MIDDLE_");
-    expect(sample.text).toContain("USER_TAIL");
-    expect(sample.text).toContain("ASSIST_HEAD_");
-    expect(sample.text).toContain("ASSIST_MIDDLE_");
-    expect(sample.text).toContain("ASSIST_TAIL");
-    expect(sample.text).toContain(OMISSION_MARKER);
-    expect(sample.roles.user.truncatedTurns).toBe(1);
-    expect(sample.roles.assistant.truncatedTurns).toBe(1);
-    expect(sample.coverageRatio).toBeGreaterThan(0);
-    expect(sample.coverageRatio).toBeLessThan(1);
-  });
-
-  it("handles one-role sessions, multiple long turns, boundary rounding, and deterministic output", () => {
-    const turns = Array.from({ length: 6 }, (_, index) => ({
-      role: "user" as const,
-      text: `USER-${index}-HEAD-${"x".repeat(180)}-MID-${index}-${"y".repeat(180)}-TAIL-${index}`,
-    }));
-    const first = buildStratifiedSample(turns, 420);
-    const second = buildStratifiedSample(turns, 420);
-    expect(second).toEqual(first);
-    expect(first.text.length).toBeLessThanOrEqual(420);
-    expect(first.roles.assistant.turns).toBe(0);
-    expect(first.text).toContain("USER-0-HEAD");
-    expect(first.text).toContain("TAIL-5");
-    expect(first.sampledExchanges).toBeLessThan(turns.length);
-  });
-
-  it("rejects a cap too small for even one minimum exchange", () => {
-    expect(() => buildStratifiedSample([{ role: "user", text: "x".repeat(200) }], 20))
-      .toThrow("too small to preserve the required first/last exchanges");
-  });
-
-  it("redacts common transcript credentials and personal contacts before external LLM use", () => {
-    const values = [
-      { text: `DATABASE_URL=postgres://user:${"p".repeat(16)}@db.invalid/app`, secret: "p".repeat(16) },
-      { text: `Authorization: Basic ${"Q".repeat(24)}`, secret: "Q".repeat(24) },
-      { text: `Cookie: session=${"c".repeat(24)}`, secret: "c".repeat(24) },
-      {
-        text: `token=${"a".repeat(8)}.${"b".repeat(8)}.${"c".repeat(8)}`,
-        secret: `${"a".repeat(8)}.${"b".repeat(8)}.${"c".repeat(8)}`,
-      },
-      { text: "person@example.invalid", secret: "person@example.invalid" },
-      { text: "13812345678", secret: "13812345678" },
-    ];
-    for (const value of values) {
-      const result = redactForExternalModel(value.text);
-      expect(result.redacted).toBeGreaterThan(0);
-      expect(result.text).not.toContain(value.secret);
-    }
-  });
-
-  it("accepts grounded candidates and constructs controlled metadata", () => {
-    const sample = buildStratifiedSample([
-      { role: "user", text: "这条路以后不要再走" },
-      { role: "assistant", text: "已记录原因" },
-    ], 500);
-    const result = validateJudgeResponse(JSON.stringify({
-      hasPivot: true,
-      candidates: [{
-        kind: "decision",
-        text: "Alice 决定不再采用旧路线，因为它会让同一数据形成两个真相源。",
-        anchor: "这条路以后不要再走",
-        key: "拒绝双真相源",
-        evidence: ["已记录原因"],
-      }],
-    }), sample, session());
-    expect(result.hasPivot).toBeTrue();
-    expect(result.candidates[0].canonicalKey).toBe("pivot-decision-拒绝双真相源");
-    expect(result.candidates[0].proposedScope).toBe("memory:pivot");
-    expect(result.candidates[0].proposedCategory).toBe("events");
-    expect(result.candidates[0].tags).toEqual([
-      "src:019fc307",
-      "date:2026-08-02",
-      "harness:codex",
-      "raw:codex",
-    ]);
-  });
-
-  it("redactedResidue ignores placeholder shapes but catches real residue", () => {
-    // A placeholder's own word shape must not re-match the assignment rule.
-    expect(redactedResidue("session_id='[REDACTED:sensitive_assignment]'")).toBe(0);
-    // Placeholder junction with surviving context must not re-match email/uri.
-    expect(redactedResidue("clone https://[REDACTED:uri_credentials]@gitlab.com/user/repo.git")).toBe(0);
-    // Genuine residue outside placeholders still counts.
-    expect(redactedResidue("[REDACTED:email] and mail me at someone@example.com")).toBeGreaterThan(0);
-  });
-
-  it("grounds anchors and evidence that copy the rendered role labels", () => {
-    const sample = buildStratifiedSample([
-      { role: "user", text: "这条路以后不要再走" },
-      { role: "assistant", text: "已记录原因" },
-    ], 500);
-    const result = validateJudgeResponse(JSON.stringify({
-      hasPivot: true,
-      candidates: [{
-        kind: "decision",
-        text: "Alice 决定不再采用旧路线，因为它会让同一数据形成两个真相源。",
-        anchor: "用户：这条路以后不要再走",
-        key: "拒绝双真相源",
-        evidence: ["助手：已记录原因"],
-      }],
-    }), sample, session());
-    expect(result.hasPivot).toBeTrue();
-    expect(result.candidates[0].anchor).toBe("这条路以后不要再走");
-    expect(result.candidates[0].evidence).toEqual(["已记录原因"]);
-  });
-
-  it("rejects evidence that is only a bare role label", () => {
-    expect(() => validateJudgeResponse(JSON.stringify({
-      hasPivot: true,
-      candidates: [{
-        kind: "decision",
-        text: "Alice 决定不再采用旧路线，因为它会让同一数据形成两个真相源。",
-        anchor: "这条路以后不要再走",
-        key: "拒绝双真相源",
-        evidence: ["助手："],
-      }],
-    }), buildStratifiedSample([
-      { role: "user", text: "这条路以后不要再走" },
-      { role: "assistant", text: "已记录原因" },
-    ], 500), session())).toThrow("substantive");
-  });
-
-  it("keeps verbatim evidence and drops a paraphrased quote without voiding the candidate", () => {
-    const sample = buildStratifiedSample([
-      { role: "user", text: "这条路以后不要再走" },
-      { role: "assistant", text: "已记录原因" },
-    ], 500);
-    const result = validateJudgeResponse(JSON.stringify({
-      hasPivot: true,
-      candidates: [{
-        kind: "decision",
-        text: "Alice 决定不再采用旧路线，因为它会让同一数据形成两个真相源。",
-        anchor: "这条路以后不要再走",
-        key: "拒绝双真相源",
-        evidence: ["已记录原因", "助手当时总结说旧路线会造成双真相源问题"],
-      }],
-    }), sample, session());
-    expect(result.candidates[0].evidence).toEqual(["已记录原因"]);
-  });
-
-  it("drops a candidate whose stored form degrades below read-back rules", () => {
-    // "助手：好" passes raw substantive checks but stores as a single char
-    // after label stripping — the stored-form gate must reject it, and with
-    // no surviving candidate the response fails as a whole.
-    expect(() => validateJudgeResponse(JSON.stringify({
-      hasPivot: true,
-      candidates: [{
-        kind: "decision",
-        text: "Alice 决定不再采用旧路线，因为它会让同一数据形成两个真相源。",
-        anchor: "这条路以后不要再走",
-        key: "拒绝双真相源",
-        evidence: ["助手：好"],
-      }],
-    }), buildStratifiedSample([
-      { role: "user", text: "这条路以后不要再走" },
-      { role: "assistant", text: "好" },
-    ], 500), session())).toThrow("requires at least one valid candidate");
-  });
-
-  it("rejects a candidate when no evidence survives grounding", () => {
-    expect(() => validateJudgeResponse(JSON.stringify({
-      hasPivot: true,
-      candidates: [{
-        kind: "decision",
-        text: "Alice 决定不再采用旧路线，因为它会让同一数据形成两个真相源。",
-        anchor: "这条路以后不要再走",
-        key: "拒绝双真相源",
-        evidence: ["助手当时总结说旧路线会造成双真相源问题"],
-      }],
-    }), buildStratifiedSample([
-      { role: "user", text: "这条路以后不要再走" },
-      { role: "assistant", text: "已记录原因" },
-    ], 500), session())).toThrow("requires at least one grounded");
-  });
-
-  it("rejects a case that drops below two grounded evidence quotes", () => {
-    expect(() => validateJudgeResponse(JSON.stringify({
-      hasPivot: true,
-      candidates: [{
-        kind: "case",
-        text: "记录了一次问题的解决过程，包含问题定位与验证后的修复方案说明。",
-        anchor: "这条路以后不要再走",
-        key: "示例案例",
-        evidence: ["已记录原因", "这句在输入里根本不存在的概括描述"],
-      }],
-    }), buildStratifiedSample([
-      { role: "user", text: "这条路以后不要再走" },
-      { role: "assistant", text: "已记录原因" },
-    ], 500), session())).toThrow("requires at least two grounded");
-  });
-
-  it("keeps valid candidates when a sibling candidate fails validation", () => {
-    const sample = buildStratifiedSample([
-      { role: "user", text: "这条路以后不要再走" },
-      { role: "assistant", text: "已记录原因" },
-    ], 500);
-    const result = validateJudgeResponse(JSON.stringify({
-      hasPivot: true,
-      candidates: [
-        {
-          kind: "decision",
-          text: "Alice 决定不再采用旧路线，因为它会让同一数据形成两个真相源。",
-          anchor: "这条路以后不要再走",
-          key: "拒绝双真相源",
-          evidence: ["已记录原因"],
-        },
-        {
-          kind: "case",
-          text: "记录了一次问题的解决过程，包含问题定位与验证后的修复方案说明。",
-          anchor: "输入里不存在的锚点句子",
-          key: "不合格案例",
-          evidence: ["已记录原因", "这句也不存在于输入之中"],
-        },
-      ],
-    }), sample, session());
-    expect(result.candidates.length).toBe(1);
-    expect(result.candidates[0].canonicalKey).toBe("pivot-decision-拒绝双真相源");
-  });
-
-  it("still fails when no candidate survives validation", () => {
-    expect(() => validateJudgeResponse(JSON.stringify({
-      hasPivot: true,
-      candidates: [{
-        kind: "decision",
-        text: "Alice 决定不再采用旧路线，因为它会让同一数据形成两个真相源。",
-        anchor: "输入里不存在的锚点句子",
-        key: "拒绝双真相源",
-        evidence: ["已记录原因"],
-      }],
-    }), buildStratifiedSample([
-      { role: "user", text: "这条路以后不要再走" },
-      { role: "assistant", text: "已记录原因" },
-    ], 500), session())).toThrow("requires at least one valid candidate");
-  });
-
-  it("rejects hallucinated anchors and inconsistent empty verdicts", () => {
-    expect(() => validateJudgeResponse(JSON.stringify({
-      hasPivot: true,
-      candidates: [{
-        kind: "preference_rule",
-        text: "Alice 明确要求所有报告都保留证据出处，方便之后重新核对。",
-        anchor: "输入里并不存在的原话",
-        key: "保留证据",
-      }],
-    }), buildStratifiedSample([{ role: "user", text: "请保留出处" }], 500), session())).toThrow("not grounded");
-    expect(() => validateJudgeResponse(
-      JSON.stringify({ hasPivot: true, candidates: [] }),
-      buildStratifiedSample([{ role: "user", text: "请保留出处" }], 500),
-      session(),
-    )).toThrow("requires at least one");
-  });
-
-  it("enforces evidence counts by pivot kind and forbids quoting omission markers", () => {
-    const base = {
-      text: "Alice 明确改变了既有判断，并给出了可以回查的真实原因与结果。",
-      anchor: "我改主意了",
-      key: "改变判断",
-    };
-    const sample = buildStratifiedSample([
-      { role: "user", text: "我改主意了" },
-      { role: "assistant", text: "旧判断失效" },
-      { role: "assistant", text: "新方案已经验证" },
-    ], 500);
-    expect(() => validateJudgeResponse(JSON.stringify({
-      hasPivot: true,
-      candidates: [{ kind: "judgment_shift", ...base, evidence: [] }],
-    }), sample, session())).toThrow("at least one");
-    expect(() => validateJudgeResponse(JSON.stringify({
-      hasPivot: true,
-      candidates: [{ kind: "case", ...base, evidence: ["旧判断失效"] }],
-    }), sample, session())).toThrow("at least two");
-    expect(() => validateJudgeResponse(JSON.stringify({
-      hasPivot: true,
-      candidates: [{ kind: "preference_rule", ...base, anchor: `我改${OMISSION_MARKER}主意了`, evidence: [] }],
-    }), buildStratifiedSample([{ role: "user", text: `我改${OMISSION_MARKER}主意了` }], 500), session()))
-      .toThrow("omission marker");
-  });
-
-  it("requires distinct substantive evidence grounded within individual turns", () => {
-    const sample = buildStratifiedSample([
-      { role: "user", text: "部署时出现连接失败" },
-      { role: "assistant", text: "先修配置文件" },
-      { role: "assistant", text: "之后验证服务恢复" },
-    ], 500);
-    const candidate = {
-      kind: "case",
-      text: "部署连接失败的问题通过修正配置并验证服务恢复得到了解决。",
-      anchor: "部署时出现连接失败",
-      key: "部署连接修复",
-    };
-    expect(() => validateJudgeResponse(JSON.stringify({
-      hasPivot: true,
-      candidates: [{ ...candidate, evidence: ["助手：", "助手："] }],
-    }), sample, session())).toThrow(/distinct|substantive/);
-    expect(() => validateJudgeResponse(JSON.stringify({
-      hasPivot: true,
-      candidates: [{ ...candidate, evidence: ["连接失败先修配置文件", "之后验证服务恢复"] }],
-    }), sample, session())).toThrow("requires at least two grounded");
-  });
-
-  it("rejects an anchor that appears only in an assistant turn", () => {
-    expect(() => validateJudgeResponse(JSON.stringify({
-      hasPivot: true,
-      candidates: [{
-        kind: "decision",
-        text: "Alice 明确决定采用这个方案，并说明了此前方案不再继续使用。",
-        anchor: "这句话只由助手说过",
-        key: "助手冒充用户锚点",
-      }],
-    }), buildStratifiedSample([
-      { role: "user", text: "另一句话" },
-      { role: "assistant", text: "这句话只由助手说过" },
-    ], 500), session())).toThrow("user turn");
-  });
-
-  it("rejects sensitive material in a model-proposed canonical key", () => {
-    expect(() => validateJudgeResponse(JSON.stringify({
-      hasPivot: true,
-      candidates: [{
-        kind: "decision",
-        text: "Alice 明确决定采用这个方案，并说明了此前方案不再继续使用。",
-        anchor: "采用这个方案",
-        key: `token=${"s".repeat(24)}`,
-        evidence: ["采用这个方案"],
-      }],
-    }), buildStratifiedSample([{ role: "user", text: "采用这个方案" }], 500), session()))
-      .toThrow("sensitive material");
-  });
-
-  it("round-trips all four validated pivot kinds through strict stored-result checks", () => {
-    const fixture = createBundleFixture();
-    const loaded = loadFrozenBundle(
-      fixture.bundleDir,
-      fixture.descriptor.bundleHash,
-      fixture.descriptor.requestProfileHash,
-    );
-    const entry = loaded.entries[0];
-    const selectionHash = selectionIdentityHash("transport", [entry]);
-    const evidenceByKind = {
-      judgment_shift: ["已记录这条规则"],
-      decision: ["已记录这条规则"],
-      preference_rule: [],
-      case: ["以后必须保留可回查证据", "已记录这条规则"],
-    } as const;
-    for (const kind of ["judgment_shift", "decision", "preference_rule", "case"] as const) {
-      const judged = validateJudgeResponse(JSON.stringify({
-        hasPivot: true,
-        candidates: [{
-          kind,
-          text: "用户明确要求以后必须保留可回查证据，最终结果需要能够追溯到真实出处。",
-          anchor: "以后必须保留可回查证据",
-          key: `round-trip-${kind}`,
-          evidence: evidenceByKind[kind],
-        }],
-      }), entry.sample, entry.session);
-      const storedResult = {
-        schemaVersion: 1,
-        mode: "transport",
-        selectionHash,
-        outboundSampleSha256: entry.sampleSha256,
-        promptVersion: PROMPT_VERSION,
-        pipelineVersion: PIPELINE_VERSION,
-        model: PIVOT_MODEL,
-        requestProfileHash: fixture.descriptor.requestProfileHash,
-        bundleHash: fixture.descriptor.bundleHash,
-        session: entry.session,
-        status: "ok",
-        hasPivot: true,
-        candidates: judged.candidates,
-        sample: entry.sample.metrics,
-        responseChars: 100,
-        attempts: 1,
-        responseModel: PIVOT_MODEL,
-        finishReason: "stop",
-        completedAt: "2026-08-03T00:00:00.000Z",
-      };
-      expect(storedResultMatches(
-        storedResult, entry, "transport", selectionHash, PIVOT_MODEL, fixture.descriptor.bundleHash,
-        fixture.descriptor.requestProfileHash, 3,
-      )).toBeTrue();
-      if (kind === "decision") {
-        expect(storedResultMatches(
-          { ...storedResult, session: { ...entry.session, date: "2026-08-04" } },
-          entry, "transport", selectionHash, PIVOT_MODEL, fixture.descriptor.bundleHash,
-          fixture.descriptor.requestProfileHash, 3,
-        )).toBeFalse();
-        expect(storedResultMatches(
-          {
-            ...storedResult,
-            candidates: [{ ...judged.candidates[0], unexpected: "must-not-pass-through" }],
-          },
-          entry, "transport", selectionHash, PIVOT_MODEL, fixture.descriptor.bundleHash,
-          fixture.descriptor.requestProfileHash, 3,
-        )).toBeFalse();
-      }
-    }
-  });
-});
-
-describe("pivot-distill request identity and frozen bundle", () => {
-  it("builds a credential-free fixed-model request profile whose hash covers every request choice", () => {
-    const endpoint = safeEndpoint("https://user:password@example.invalid//compatible-mode/v1/?token=secret#fragment");
-    expect(endpoint).toBe("https://example.invalid/compatible-mode/v1");
-    expect(endpoint).not.toContain("password");
-    expect(endpoint).not.toContain("token=");
-    const profile = buildPivotRequestProfile(
-      "https://user:password@example.invalid/compatible-mode/v1?token=secret#fragment",
-      24_000,
-    );
-    expect(profile.model).toBe(PIVOT_MODEL);
-    expect(profile.enableThinking).toBeFalse();
-    expect(profile.responseFormat).toEqual({ type: "json_object" });
-    expect(profile.tokenLimit).toEqual({ parameter: "max_tokens", value: 1_800 });
-    expect(profile.retryPolicy).toEqual({
-      maxSessionAttempts: 3,
-      sdkMaxRetries: 0,
-      backoffMs: [250, 500],
-      maxRetryAfterMs: 5_000,
-      retryableHttpStatuses: [408, 409, 429],
-      retryableServerErrorRange: "500-599",
-    });
-    expect(profile.promptHashes.system).toHaveLength(64);
-    expect(profile.promptHashes.userTemplate).toHaveLength(64);
-    expect(profile.promptHashes.jsonSchema).toHaveLength(64);
-    const identity = pivotRequestProfileHash(profile);
-    expect(pivotRequestProfileHash({ ...profile, temperature: 0.2 })).not.toBe(identity);
-    expect(pivotRequestProfileHash({
-      ...profile,
-      sampling: { ...profile.sampling, omissionMarker: "different" },
-    })).not.toBe(identity);
-    expect(pivotRequestProfileHash({
-      ...profile,
-      retryPolicy: { ...profile.retryPolicy, sdkMaxRetries: 1 },
-    })).not.toBe(identity);
-    expect(buildPivotLlmConfig({
-      apiKey: "test-key",
-      model: "qwen-turbo",
-      baseURL: "https://user:secret@example.invalid/v1?token=hidden#fragment",
-    }, profile, 12_345)).toMatchObject({
-      baseURL: "https://example.invalid/compatible-mode/v1",
-      model: PIVOT_MODEL,
-      maxRetries: 0,
-      timeoutMs: 12_345,
-    });
-  });
-
-  it("keeps retry cost bounded and aggregates usage from every billed attempt", () => {
-    const policy = buildPivotRequestProfile("https://example.invalid/v1").retryPolicy;
-    expect(retryDecision({ status: 429, headers: { "retry-after": "0.01" } }, 1, policy))
-      .toEqual({ retry: true, delayMs: 10 });
-    expect(retryDecision({ status: 500 }, 2, policy)).toEqual({ retry: true, delayMs: 500 });
-    expect(retryDecision({ status: 401 }, 1, policy)).toEqual({ retry: false, delayMs: 0 });
-    expect(retryDecision({ status: 429 }, 3, policy)).toEqual({ retry: false, delayMs: 0 });
-    expect(aggregateDetailedUsage([
-      { promptTokens: 10, completionTokens: 2, totalTokens: 12 },
-      { promptTokens: 11, completionTokens: 3, totalTokens: 14, cachedPromptTokens: 4 },
-    ])).toEqual({
-      promptTokens: 21,
-      completionTokens: 5,
-      totalTokens: 26,
-      cachedPromptTokens: 4,
-    });
-  });
-
-  it("makes the external stage and exact outbound sample set part of report identity", () => {
-    const fixture = createBundleFixture();
-    const loaded = loadFrozenBundle(
-      fixture.bundleDir, fixture.descriptor.bundleHash, fixture.descriptor.requestProfileHash,
-    );
-    expect(selectionIdentityHash("transport", loaded.entries))
-      .not.toBe(selectionIdentityHash("regression", loaded.entries));
-    const changed = structuredClone(loaded.entries);
-    changed[0].sampleSha256 = "f".repeat(64);
-    expect(selectionIdentityHash("transport", changed))
-      .not.toBe(selectionIdentityHash("transport", loaded.entries));
-  });
-
-  it("writes 0700/0600 bundles and reloads only exact expected identities", () => {
-    const fixture = createBundleFixture();
-    expect(statSync(fixture.bundleDir).mode & 0o777).toBe(0o700);
-    expect(statSync(join(fixture.bundleDir, "bundle.json")).mode & 0o777).toBe(0o600);
-    const loaded = loadFrozenBundle(
-      fixture.bundleDir,
-      fixture.descriptor.bundleHash,
-      fixture.descriptor.requestProfileHash,
-    );
-    expect(loaded.entries).toHaveLength(1);
-    expect(loaded.entries[0].status).toBe("eligible");
-    expect(frozenSampleHash(loaded.entries[0].sample)).toBe(loaded.entries[0].sampleSha256);
-    expect(() => loadFrozenBundle(
-      fixture.bundleDir,
-      "wrong-bundle",
-      fixture.descriptor.requestProfileHash,
-    )).toThrow("unexpected bundleHash");
-    expect(() => loadFrozenBundle(
-      fixture.bundleDir,
-      fixture.descriptor.bundleHash,
-      "wrong-profile",
-    )).toThrow("unexpected requestProfileHash");
-  });
-
-  it("rejects mutated samples, duplicate session keys, and paths outside the bundle root", () => {
-    const mutated = createBundleFixture();
-    const manifestEntry = JSON.parse(readFileSync(join(mutated.bundleDir, "manifest.jsonl"), "utf8")) as {
-      sampleFile: string;
-    };
-    const samplePath = join(mutated.bundleDir, manifestEntry.sampleFile);
-    const sample = JSON.parse(readFileSync(samplePath, "utf8")) as Record<string, unknown>;
-    sample.text = `X${String(sample.text).slice(1)}`;
-    writeFileSync(samplePath, `${JSON.stringify(sample)}\n`);
-    expect(() => loadFrozenBundle(
-      mutated.bundleDir,
-      mutated.descriptor.bundleHash,
-      mutated.descriptor.requestProfileHash,
-    )).toThrow("sample grounding projection mismatch");
-
-    const mutatedMetrics = createBundleFixture();
-    const metricsEntry = JSON.parse(
-      readFileSync(join(mutatedMetrics.bundleDir, "manifest.jsonl"), "utf8"),
-    ) as { sampleFile: string };
-    const metricsPath = join(mutatedMetrics.bundleDir, metricsEntry.sampleFile);
-    const metricsSample = JSON.parse(readFileSync(metricsPath, "utf8")) as {
-      metrics: { redactions: number };
-    };
-    metricsSample.metrics.redactions += 1;
-    writeFileSync(metricsPath, `${JSON.stringify(metricsSample)}\n`);
-    expect(() => loadFrozenBundle(
-      mutatedMetrics.bundleDir,
-      mutatedMetrics.descriptor.bundleHash,
-      mutatedMetrics.descriptor.requestProfileHash,
-    )).toThrow("sample hash mismatch");
-
-    const duplicate = createBundleFixture();
-    const originalLine = readFileSync(join(duplicate.bundleDir, "manifest.jsonl"), "utf8").trim();
-    const duplicatedManifest = `${originalLine}\n${originalLine}\n`;
-    const descriptor = JSON.parse(readFileSync(join(duplicate.bundleDir, "bundle.json"), "utf8")) as FrozenBundleDescriptor;
-    descriptor.manifestSha256 = sha256(duplicatedManifest);
-    descriptor.sessions = 2;
-    descriptor.eligibleSessions = 2;
-    descriptor.deferredSessions = 0;
-    descriptor.bundleHash = bundleIdentityHashForTest({
-      requestProfileHash: descriptor.requestProfileHash,
-      manifestSha256: descriptor.manifestSha256,
-      sessions: descriptor.sessions,
-      eligibleSessions: descriptor.eligibleSessions,
-      deferredSessions: descriptor.deferredSessions,
-    });
-    writeFileSync(join(duplicate.bundleDir, "manifest.jsonl"), duplicatedManifest);
-    writeFileSync(join(duplicate.bundleDir, "bundle.json"), `${JSON.stringify(descriptor)}\n`);
-    expect(() => loadFrozenBundle(
-      duplicate.bundleDir,
-      descriptor.bundleHash,
-      descriptor.requestProfileHash,
-    )).toThrow("duplicate session key");
-
-    expect(() => resolveBundleSamplePath(duplicate.bundleDir, "/tmp/outside.json"))
-      .toThrow("must stay relative");
-    expect(() => resolveBundleSamplePath(duplicate.bundleDir, "samples/../../outside.json"))
-      .toThrow("must stay relative");
-  });
-
-  it("rejects a request profile that no longer matches the fixed prompt/body/sampling contract", () => {
-    const fixture = createBundleFixture();
-    const descriptor = JSON.parse(readFileSync(join(fixture.bundleDir, "bundle.json"), "utf8")) as FrozenBundleDescriptor;
-    descriptor.requestProfile.temperature = 0.7;
-    writeFileSync(join(fixture.bundleDir, "bundle.json"), `${JSON.stringify(descriptor)}\n`);
-    expect(() => loadFrozenBundle(
-      fixture.bundleDir,
-      fixture.descriptor.bundleHash,
-      fixture.descriptor.requestProfileHash,
-    )).toThrow("current fixed pivot contract");
-  });
-
-  it("rejects duplicate keys before bundle creation and keeps assistant-only sessions deferred", () => {
-    const outputDir = mkdtempSync(join(tmpdir(), "pivot-bundle-duplicate-"));
-    const profile = buildPivotRequestProfile("https://example.invalid/v1", 500);
-    const profileHash = pivotRequestProfileHash(profile);
-    const userSample = buildStratifiedSample([{ role: "user", text: "保留证据" }], 500);
-    expect(() => writeFrozenBundle(outputDir, [
-      { session: session(), sample: userSample },
-      { session: session(), sample: userSample },
-    ], profile, profileHash)).toThrow("duplicate session key");
-
-    const assistantOnlyDir = mkdtempSync(join(tmpdir(), "pivot-bundle-deferred-"));
-    const assistantOnly = buildStratifiedSample([{ role: "assistant", text: "只有助手内容" }], 500);
-    const descriptor = writeFrozenBundle(assistantOnlyDir, [{ session: session(), sample: assistantOnly }], profile, profileHash);
-    const loaded = loadFrozenBundle(join(assistantOnlyDir, "input-bundle"), descriptor.bundleHash, descriptor.requestProfileHash);
-    expect(loaded.entries[0].status).toBe("deferred");
-    expect(loaded.entries[0].reason).toBe("no-parseable-user-text");
-  });
-});
-
-describe("pivot-distill source enumeration and parse integrity", () => {
-  it("filters inherited DEJA variables from both inventory subprocesses", () => {
-    expect(filteredDejaEnvironment({ DEJA_HOME: "/wrong", DEJA_CONFIG: "/wrong/config", KEEP_ME: "yes" }))
-      .toEqual({ KEEP_ME: "yes" });
-  });
-
-  it("enumerates four endpoint families plus Claude Desktop and both AGY origins with a fake Deja", () => {
-    const root = mkdtempSync(join(tmpdir(), "pivot-inventory-"));
-    const sourceRoot = join(root, "sources");
-    mkdirSync(sourceRoot, { recursive: true });
-    const dejaSessions = ([
-      ["claude", "claude.jsonl"],
-      ["codex", "codex.jsonl"],
-      ["kimi", "kimi.jsonl"],
-      ["gemini", "gemini.json"],
-    ] as const).map(([harness, name], index) => {
-      const path = join(sourceRoot, name);
-      writeFileSync(path, harness === "gemini" ? "{\"messages\":[]}" : "{}\n");
-      return { id: `deja-${index}-${harness}`, harness, path, project: "test" };
-    });
-    const codexArchiveRoot = join(root, "codex-archive");
-    const claudeDesktopRoot = join(root, "desktop");
-    const agyConvertedRoot = join(root, "agy", "brain", "session-one", ".system_generated", "logs");
-    const agyArchiveRoot = join(root, "agy-archive");
-    for (const directory of [codexArchiveRoot, claudeDesktopRoot, agyConvertedRoot, agyArchiveRoot]) {
-      mkdirSync(directory, { recursive: true });
-    }
-    writeFileSync(join(codexArchiveRoot, "archive.jsonl"), "{}\n");
-    writeFileSync(join(claudeDesktopRoot, "desktop.jsonl"), "{}\n");
-    writeFileSync(join(agyConvertedRoot, "transcript_full.jsonl"), "{}\n");
-    writeFileSync(join(agyArchiveRoot, "legacy.jsonl"), "{}\n");
-    const payload = JSON.stringify({ schema_version: 2, sessions: dejaSessions });
-    const dejaBin = join(root, "fake-deja.ts");
-    writeFileSync(dejaBin, `#!/usr/bin/env bun
-if (process.env.DEJA_HOME || process.env.DEJA_CONFIG) process.exit(91);
-if (process.argv[2] === "version") console.log("deja 0.16.5");
-else console.log(${JSON.stringify(payload)});
-`);
-    chmodSync(dejaBin, 0o700);
-    const options = parseCliOptions([
-      "--deja-bin", dejaBin,
-      "--codex-archive-root", codexArchiveRoot,
-      "--claude-desktop-root", claudeDesktopRoot,
-      "--agy-converted-root", join(root, "agy"),
-      "--agy-archive-root", agyArchiveRoot,
-    ]);
-    const previousDejaHome = process.env.DEJA_HOME;
-    const previousDejaConfig = process.env.DEJA_CONFIG;
-    process.env.DEJA_HOME = "/must-not-reach-child";
-    process.env.DEJA_CONFIG = "/must-not-reach-child/config";
-    try {
-      const loaded = loadSessionInventory(options);
-      expect(loaded.missingPaths).toBe(0);
-      expect(new Set(loaded.sessions.map((item) => item.harness))).toEqual(new Set(["claude-code", "codex", "kimi", "agy"]));
-      expect(loaded.sessions.some((item) => item.origin === "claude-desktop")).toBeTrue();
-      expect(loaded.sessions.some((item) => item.origin === "agy-converted")).toBeTrue();
-      expect(loaded.sessions.some((item) => item.origin === "agy-archive")).toBeTrue();
-      expect(loaded.sessions.some((item) => item.rawHarness === "gemini")).toBeTrue();
-      expect(inventoryCompletenessReasons(loaded.sessions, loaded.missingPaths)).toEqual([]);
-      expect(inventoryCompletenessReasons(
-        loaded.sessions.filter((item) => item.origin !== "claude-desktop"), 0,
-      )).toContain("origin=claude-desktop has zero sessions");
-      expect(inventoryCompletenessReasons(
-        loaded.sessions.filter((item) => item.rawHarness !== "gemini"), 0,
-      )).toContain("rawHarness=gemini has zero sessions");
-      expect(inventoryCompletenessReasons(loaded.sessions, 1)).toContain("missingPaths=1");
-    } finally {
-      if (previousDejaHome === undefined) delete process.env.DEJA_HOME;
-      else process.env.DEJA_HOME = previousDejaHome;
-      if (previousDejaConfig === undefined) delete process.env.DEJA_CONFIG;
-      else process.env.DEJA_CONFIG = previousDejaConfig;
-    }
-  });
-
-  it("treats malformed JSONL as a bundle-blocking parse failure", async () => {
-    const root = mkdtempSync(join(tmpdir(), "pivot-malformed-"));
-    const path = join(root, "bad.jsonl");
-    writeFileSync(path, "{\"type\":\"event_msg\",\"payload\":{\"type\":\"user_message\",\"message\":\"ok\"}}\nnot-json\n");
-    await expect(readSessionTurns(session({ path, parserKind: "codex-rollout" })))
-      .rejects.toThrow("Malformed JSONL at line 2");
-  });
-});
-
-describe("pivot-distill external authorization and exact selection", () => {
-  const common = [
-    "--input-bundle", "/tmp/frozen",
-    "--bundle-hash", "bundle-hash",
-    "--request-profile-hash", "profile-hash",
-    "--allow-external-llm",
-  ];
-
-  it("requires exact transport, separate regression, and dual full authorization", () => {
-    expect(() => assertExternalModeAuthorization(parseCliOptions([
-      "--mode", "transport", ...common,
-    ]))).toThrow("exactly one");
-    expect(() => assertExternalModeAuthorization(parseCliOptions([
-      "--mode", "transport", ...common, "--session-key", "codex:one",
-    ]))).not.toThrow();
-    expect(() => assertExternalModeAuthorization(parseCliOptions([
-      "--mode", "transport", ...common,
-      "--session-key", "codex:one",
-      "--output-dir", "/tmp/frozen/results",
-    ]))).toThrow("must not be the frozen input bundle");
-    expect(() => assertExternalModeAuthorization(parseCliOptions([
-      "--mode", "regression", ...common, "--session-key", "codex:one",
-    ]))).toThrow("allow-regression-run");
-    expect(() => assertExternalModeAuthorization(parseCliOptions([
-      "--mode", "regression", ...common, "--session-key", "codex:one", "--allow-regression-run",
-    ]))).not.toThrow();
-    expect(() => assertExternalModeAuthorization(parseCliOptions([
-      "--mode", "full", ...common,
-    ]))).toThrow("allow-full-run");
-    expect(() => assertExternalModeAuthorization(parseCliOptions([
-      "--mode", "full", ...common, "--allow-full-run",
-    ]))).not.toThrow();
-  });
-
-  it("rejects truncated or wrong-model responses even if their content could parse", () => {
-    expect(() => assertPivotResponseMetadata({ finishReason: "length", responseModel: PIVOT_MODEL }))
-      .toThrow("finish_reason=length");
-    expect(() => assertPivotResponseMetadata({ finishReason: "stop", responseModel: "rolling-alias" }))
-      .toThrow("response model mismatch");
-    expect(() => assertPivotResponseMetadata({ finishReason: "stop", responseModel: PIVOT_MODEL }))
-      .not.toThrow();
-  });
-
-  it("refuses transport before any live inventory branch when authorization is missing", async () => {
-    await expect(main([
-      "--mode", "transport",
-      "--deja-bin", "/definitely/not/a/deja/binary",
-      "--output-dir", join(tmpdir(), "must-not-be-created-by-unauthorized-transport"),
-    ])).rejects.toThrow("--allow-external-llm");
-  });
-
-  it("selects one exact frozen key while full selects every eligible sample", () => {
-    const fixture = createBundleFixture();
-    const loaded = loadFrozenBundle(
-      fixture.bundleDir,
-      fixture.descriptor.bundleHash,
-      fixture.descriptor.requestProfileHash,
-    );
-    const transport = parseCliOptions([
-      "--mode", "transport",
-      "--input-bundle", fixture.bundleDir,
-      "--bundle-hash", fixture.descriptor.bundleHash,
-      "--request-profile-hash", fixture.descriptor.requestProfileHash,
-      "--session-key", loaded.entries[0].session.key,
-      "--allow-external-llm",
-    ]);
-    expect(selectFrozenEntries(loaded, transport).map((entry) => entry.session.key))
-      .toEqual([loaded.entries[0].session.key]);
-    const full = parseCliOptions([
-      "--mode", "full",
-      "--input-bundle", fixture.bundleDir,
-      "--bundle-hash", fixture.descriptor.bundleHash,
-      "--request-profile-hash", fixture.descriptor.requestProfileHash,
-      "--allow-external-llm",
-      "--allow-full-run",
-    ]);
-    expect(selectFrozenEntries(loaded, full)).toHaveLength(fixture.descriptor.eligibleSessions);
-  });
-});
-
-describe("pivot-distill resume identity and CLI", () => {
-  it("changes the stamp when content, prompt, or model changes", () => {
-    const base = {
-      harness: "codex" as const,
-      rawHarness: "codex" as const,
-      sessionId: "s1",
-      date: "2026-08-02",
-      sizeBytes: 100,
-      mtimeNs: "1",
-      promptVersion: "p1",
-      model: "m1",
-    };
-    const fingerprint = sessionFingerprint(base);
-    expect(sessionFingerprint({ ...base, sizeBytes: 101 })).not.toBe(fingerprint);
-    expect(sessionFingerprint({ ...base, promptVersion: "p2" })).not.toBe(fingerprint);
-    expect(sessionFingerprint({ ...base, model: "m2" })).not.toBe(fingerprint);
-    expect(sessionFingerprint({ ...base, rawHarness: "antigravity" })).not.toBe(fingerprint);
-    expect(sessionFingerprint({ ...base, date: "2026-08-03" })).not.toBe(fingerprint);
-    expect(sessionFingerprint({ ...base, pipelineVersion: "pipeline-v2" })).not.toBe(fingerprint);
-    expect(sessionFingerprint({ ...base, sampleSha256: "sample-v2" })).not.toBe(fingerprint);
-    expect(sessionFingerprint({ ...base, requestProfileHash: "profile-v2" })).not.toBe(fingerprint);
-  });
-
-  it("excludes synthetic digest sessions without keyword-deciding pivots", () => {
-    expect(isSyntheticSession({ path: "/private/tmp/session-digest-a/x.jsonl", project: "x" })).toBeTrue();
-    expect(isSyntheticSession({ path: "/sessions/x.jsonl", project: "digest/a" })).toBeTrue();
-    expect(isSyntheticSession({ path: "/sessions/x.jsonl", project: "recallnest" })).toBeFalse();
-  });
-
-  it("defaults to all non-synthetic sessions and parses frozen execution selectors", () => {
-    const defaults = parseCliOptions([]);
-    expect(defaults.mode).toBe("inventory");
-    expect(defaults.minSize).toBe(1);
-    const parsed = parseCliOptions([
-      "--mode", "estimate",
-      "--min-size", "200000",
-      "--limit", "12",
-      "--claude-desktop-root", "/tmp/desktop-import",
-      "--agy-archive-root", "/tmp/agy-archive",
-    ]);
-    expect(parsed.mode).toBe("estimate");
-    expect(parsed.minSize).toBe(200_000);
-    expect(parsed.limit).toBe(12);
-    expect(parsed.claudeDesktopRoot).toBe("/tmp/desktop-import");
-    expect(parsed.agyArchiveRoot).toBe("/tmp/agy-archive");
-    const transport = parseCliOptions([
-      "--mode", "transport",
-      "--input-bundle", "/tmp/bundle",
-      "--bundle-hash", "bundle",
-      "--request-profile-hash", "profile",
-      "--session-key", "codex:one",
-      "--allow-external-llm",
-    ]);
-    expect(transport.mode).toBe("transport");
-    expect(transport.sessionKeys).toEqual(["codex:one"]);
-    expect(transport.allowExternalLlm).toBeTrue();
-  });
-
-  it("rejects concurrent writers to the same output directory", () => {
-    const outputDir = mkdtempSync(join(tmpdir(), "pivot-distill-lock-"));
-    chmodSync(outputDir, 0o755);
-    const release = acquireOutputLock(outputDir);
-    expect(statSync(outputDir).mode & 0o777).toBe(0o700);
-    expect(() => acquireOutputLock(outputDir)).toThrow("already in use");
-    release();
-    const releaseAgain = acquireOutputLock(outputDir);
-    releaseAgain();
-  });
-});