pi-condense 2.4.3 → 2.6.0

package/src/id-collision.integration.test.ts

@@ -0,0 +1,251 @@
+import { describe, expect, test } from "bun:test";
+import { ToolCallIndexer } from "./indexer.js";
+import { pruneMessages } from "./pruner.js";
+import { detectChains } from "./chain-detector.js";
+import { compressEligible } from "./chain-compressor.js";
+import { captureUnindexedBatchesFromSession } from "./batch-capture.js";
+import { expectNoOrphanToolResults } from "./test-support.js";
+import { CUSTOM_TYPE_CHAIN, CUSTOM_TYPE_INDEX, CUSTOM_TYPE_SUMMARY } from "./types.js";
+import type { CapturedBatch } from "./types.js";
+
+const user = (ts: number, text: string) => ({ role: "user", content: [{ type: "text", text }], timestamp: ts });
+const callTurn = (ts: number, ids: string[]) => ({
+  role: "assistant",
+  content: ids.map((id) => ({ type: "toolCall", id, name: "bash", input: { cmd: id } })),
+  timestamp: ts,
+});
+const result = (ts: number, id: string, text: string) => ({
+  role: "toolResult",
+  toolCallId: id,
+  toolName: "bash",
+  content: [{ type: "text", text }],
+  isError: false,
+  timestamp: ts,
+});
+const finalTurn = (ts: number, text: string) => ({ role: "assistant", content: [{ type: "text", text }], timestamp: ts });
+
+/**
+ * The incident shape: two closeable chains, then a live turn reusing bash_23.
+ * Pre-fix, the session-wide id-set drop deleted the live `bash_23` assistant
+ * turn and left `LIVE 24` (`gauntlet_setting_24`) orphaned, which the
+ * provider rejects with a 400.
+ */
+const buildSession = () => [
+  user(1000, "1"),
+  callTurn(1100, ["bash_18"]),
+  result(1150, "bash_18", "OUT 18"),
+  finalTurn(1200, "done 1"),
+  user(2000, "2"),
+  callTurn(2100, ["bash_23"]),
+  result(2150, "bash_23", "OUT 23 first"),
+  finalTurn(2200, "done 2"),
+  user(3000, "3"),
+  callTurn(3100, ["bash_23", "gauntlet_setting_24"]),
+  result(3150, "bash_23", "LIVE 23"),
+  result(3160, "gauntlet_setting_24", "LIVE 24"),
+];
+
+const batchFor = (turnIndex: number, ts: number, id: string, resultTs: number, text: string): CapturedBatch => ({
+  turnIndex,
+  timestamp: ts,
+  assistantText: "",
+  toolCalls: [{ toolCallId: id, toolName: "bash", args: { cmd: id }, resultText: text, isError: false, resultTimestamp: resultTs }],
+});
+
+/**
+ * Indexes + summarizes the two older batches, then compresses their chains.
+ * Mirrors index.ts's live-flush ordering and keying exactly: allocate refs ->
+ * send/append the summary -> registerSummaryRefs -> addBatch ->
+ * registerSummaryBody(<keys>). `keyer` controls the shape of the ids passed
+ * to registerSummaryBody so both the production (bare-id) bug and the fixed
+ * (occurrence-key) contract can be exercised with the same helper.
+ */
+const primeIndexer = async (
+  messages: any[],
+  keyer: (r: { toolCallId: string; resultTimestamp?: number }) => string = (r) =>
+    `${r.toolCallId}@${r.resultTimestamp}`,
+) => {
+  const appended: Array<{ type: string; data: any }> = [];
+  const indexer = new ToolCallIndexer();
+  const append = (type: string, data?: unknown) => appended.push({ type, data });
+  const refsByToolCallId = new Map<string, import("./types.js").SummaryToolCallRef>();
+
+  for (const [turnIndex, spec] of [
+    [0, { id: "bash_18", ts: 1000, resultTs: 1150, text: "OUT 18" }],
+    [1, { id: "bash_23", ts: 2000, resultTs: 2150, text: "OUT 23 first" }],
+  ] as const) {
+    const batch = batchFor(turnIndex, spec.ts, spec.id, spec.resultTs, spec.text);
+    const refs = indexer.allocateSummaryRefs(batch);
+    // (send/append the summary message here in the real flush; no-op for this harness)
+    indexer.registerSummaryRefs(refs);
+    indexer.addBatch(batch, append);
+    indexer.registerSummaryBody(refs.map(keyer), `summary of ${spec.id}`);
+    for (const ref of refs) refsByToolCallId.set(ref.toolCallId, ref);
+  }
+
+  let nextBlock = 1;
+  await compressEligible(detectChains(messages), 0, {
+    indexer,
+    blockRefs: { issue: () => `b${nextBlock++}` } as any,
+    appendEntry: append,
+    now: () => 9000,
+  });
+
+  return { indexer, appended, refsByToolCallId };
+};
+
+const chainConfig = { enabled: true, rollingWindow: 0, stripFinalAssistantThinking: false, fuseRangeSummary: false } as any;
+const syntheticsOf = (messages: any[]) =>
+  messages.filter((m: any) => m.role === "user" && m.content?.[0]?.text?.startsWith("<compressed-chain"));
+
+describe("id collision, end to end", () => {
+  test("render keeps the live turn, drops both chain interiors, leaves no orphan", async () => {
+    const messages = buildSession();
+    const { indexer } = await primeIndexer(messages);
+    const out = pruneMessages(messages, indexer, chainConfig);
+
+    expect(out.pruned).toBe(true);
+    // live turn intact, both results verbatim. Synthetics also carry
+    // timestamp=compressedAt(9000) here, so they must be excluded from this
+    // filter or they'd inflate the count - see chain-range-prune.test.ts's
+    // "compressedAt kept below 3000" comment for the same caveat.
+    const liveReal = out.messages.filter(
+      (m: any) => m.timestamp >= 3000 && !(m.content?.[0]?.text ?? "").startsWith("<compressed-chain"),
+    );
+    expect(liveReal).toHaveLength(4);
+    expect(out.messages.find((m: any) => m.timestamp === 3150).content[0].text).toBe("LIVE 23");
+    expect(out.messages.find((m: any) => m.timestamp === 3160).content[0].text).toBe("LIVE 24");
+    // both chain interiors gone, one synthetic each, bodies non-empty
+    expect(out.messages.some((m: any) => m.timestamp === 1150 || m.timestamp === 2150)).toBe(false);
+    const synthetics = syntheticsOf(out.messages);
+    expect(synthetics).toHaveLength(2);
+    const bash18Synthetic = synthetics.find((s: any) => s.content[0].text.includes("summary of bash_18"));
+    const bash23Synthetic = synthetics.find((s: any) => s.content[0].text.includes("summary of bash_23"));
+    expect(bash18Synthetic).toBeDefined();
+    expect(bash23Synthetic).toBeDefined();
+    expect(bash18Synthetic).not.toBe(bash23Synthetic);
+    expect(bash18Synthetic.content[0].text).not.toContain("summary of bash_23");
+    expect(bash23Synthetic.content[0].text).not.toContain("summary of bash_18");
+    expectNoOrphanToolResults(out.messages);
+  });
+
+  // Regression for the live-flush bug (ref #8, index.ts registerSummaryBody
+  // call): production must key registerSummaryBody with the occurrence key
+  // (`id@resultTimestamp`), because hasPerBatchSummaryCoveringAny /
+  // getPerBatchSummariesForToolCallIds are always queried with occurrence
+  // keys (src/chain-compressor.ts's `lookupKeys`). Bare ids (`tc.toolCallId`)
+  // silently mismatch and every chain is skipped as "no-summary" - it only
+  // appears to work after a restart because reconstructFromSession rebuilds
+  // bodies from summary refs, which DO carry resultTimestamp. The default
+  // `keyer` on primeIndexer above pins the correct (occurrence-key) shape;
+  // this test pins the failure mode of the bare-id shape as a contrast.
+  test("live-flush occurrence-key contract: chains compress with non-empty, per-chain-distinct bodies", async () => {
+    const messages = buildSession();
+    const { indexer } = await primeIndexer(messages); // default keyer = occurrence key, i.e. the fixed index.ts contract
+    const out = pruneMessages(messages, indexer, chainConfig);
+
+    const synthetics = syntheticsOf(out.messages);
+    expect(synthetics).toHaveLength(2);
+    expect(synthetics.some((s: any) => s.content[0].text.includes("summary of bash_18"))).toBe(true);
+    expect(synthetics.some((s: any) => s.content[0].text.includes("summary of bash_23"))).toBe(true);
+    expectNoOrphanToolResults(out.messages);
+  });
+
+  test("live-flush bare-id keying bug: chains are skipped as no-summary, no synthetics emitted", async () => {
+    const messages = buildSession();
+    // Mirrors the production BUG exactly: `tc.toolCallId` with no resultTimestamp,
+    // matching index.ts's pre-fix `batch.toolCalls.map((tc) => tc.toolCallId)`.
+    const { indexer } = await primeIndexer(messages, (r) => r.toolCallId);
+    const out = pruneMessages(messages, indexer, chainConfig);
+
+    const synthetics = syntheticsOf(out.messages);
+    expect(synthetics).toHaveLength(0);
+  });
+
+  test("re-rendering the same session is deep-equal", async () => {
+    const messages = buildSession();
+    const { indexer } = await primeIndexer(messages);
+    const first = pruneMessages(messages, indexer, chainConfig);
+    const second = pruneMessages(first.messages, indexer, chainConfig);
+    expect(second.messages).toEqual(first.messages);
+    expectNoOrphanToolResults(second.messages);
+  });
+
+  test("G4/C2: a live collision batch is captured (not filtered as summarized) and separately addressable after summarization", () => {
+    // Prime the indexer with an already-summarized bash_23 occurrence.
+    const indexer = new ToolCallIndexer();
+    indexer.addBatch(
+      {
+        turnIndex: 0,
+        timestamp: 2000,
+        assistantText: "",
+        toolCalls: [{ toolCallId: "bash_23", toolName: "bash", args: {}, resultText: "OUT 23 first", isError: false, resultTimestamp: 2150 }],
+      },
+      () => {},
+    );
+    expect(indexer.isSummarized("bash_23@2150")).toBe(true);
+
+    // A NEW live occurrence of the same bare id, at a later resultTimestamp,
+    // not yet in the index.
+    const branch = [
+      { type: "message", message: user(3000, "3") },
+      { type: "message", message: callTurn(3100, ["bash_23"]) },
+      { type: "message", message: result(3150, "bash_23", "LIVE 23") },
+    ];
+
+    const batches = captureUnindexedBatchesFromSession(branch, indexer);
+    // The live occurrence must be captured, NOT skipped as already-summarized -
+    // isSummarized is asked with the occurrence key (bash_23@3150), which is
+    // distinct from the primed bash_23@2150.
+    expect(batches).toHaveLength(1);
+    expect(batches[0].toolCalls).toHaveLength(1);
+    expect(batches[0].toolCalls[0].toolCallId).toBe("bash_23");
+    expect(batches[0].toolCalls[0].resultTimestamp).toBe(3150);
+    expect(batches[0].toolCalls[0].resultText).toBe("LIVE 23");
+
+    // Capture it into the index (mirrors a successful summarization flush) and
+    // confirm both occurrences remain separately addressable.
+    indexer.addBatch(batches[0], () => {});
+    expect(indexer.getRecord("bash_23@2150")?.resultText).toBe("OUT 23 first");
+    expect(indexer.getRecord("bash_23@3150")?.resultText).toBe("LIVE 23");
+    expect(indexer.isSummarized("bash_23@3150")).toBe(true);
+  });
+
+  test("a restart-shaped rebuild reproduces both tN refs and non-empty synthetics", async () => {
+    const messages = buildSession();
+    const { appended, refsByToolCallId } = await primeIndexer(messages);
+
+    // Replay only what the session would hold: index, summary and chain entries.
+    const branch: any[] = [];
+    for (const { type, data } of appended) {
+      if (type === CUSTOM_TYPE_INDEX) branch.push({ type: "custom", customType: CUSTOM_TYPE_INDEX, data });
+      if (type === CUSTOM_TYPE_CHAIN) branch.push({ type: "custom", customType: CUSTOM_TYPE_CHAIN, data });
+    }
+    // Use the refs the flush actually allocated (via allocateSummaryRefs), not
+    // hand-picked shortIds - this proves the restart replay honors whatever
+    // numbering the flush produced instead of assuming t1/t2.
+    for (const id of ["bash_18", "bash_23"]) {
+      const ref = refsByToolCallId.get(id);
+      if (!ref) throw new Error(`primeIndexer did not allocate a ref for ${id}`);
+      branch.push({
+        type: "custom_message",
+        customType: CUSTOM_TYPE_SUMMARY,
+        content: `summary of ${id}`,
+        details: { toolCallRefs: [ref] },
+      });
+    }
+
+    const [ref18, ref23] = [refsByToolCallId.get("bash_18")!, refsByToolCallId.get("bash_23")!];
+    const rebuilt = new ToolCallIndexer();
+    rebuilt.reconstructFromSession({ sessionManager: { getBranch: () => branch } } as any);
+    expect(rebuilt.getRecord(ref18.shortId)?.resultText).toBe("OUT 18");
+    expect(rebuilt.getRecord(ref23.shortId)?.resultText).toBe("OUT 23 first");
+
+    const out = pruneMessages(buildSession(), rebuilt, chainConfig);
+    const synthetics = syntheticsOf(out.messages);
+    expect(synthetics).toHaveLength(2);
+    expect(synthetics.some((s: any) => s.content[0].text.includes("summary of bash_18"))).toBe(true);
+    expect(synthetics.some((s: any) => s.content[0].text.includes("summary of bash_23"))).toBe(true);
+    expectNoOrphanToolResults(out.messages);
+  });
+});

package/src/indexer.test.ts

@@ -0,0 +1,336 @@
+import { describe, expect, test } from "bun:test";
+import { ToolCallIndexer } from "./indexer.js";
+import { CUSTOM_TYPE_INDEX, CUSTOM_TYPE_SUMMARY, CUSTOM_TYPE_DEDUP_ALIAS } from "./types.js";
+import type { CapturedBatch } from "./types.js";
+
+const batch = (
+  turnIndex: number,
+  timestamp: number,
+  calls: { id: string; ts?: number; text: string }[],
+): CapturedBatch => ({
+  turnIndex,
+  timestamp,
+  assistantText: "",
+  toolCalls: calls.map((c) => ({
+    toolCallId: c.id,
+    toolName: "bash",
+    args: { cmd: "ls" },
+    resultText: c.text,
+    isError: false,
+    ...(c.ts !== undefined ? { resultTimestamp: c.ts } : {}),
+  })),
+});
+
+describe("occurrence keying", () => {
+  test("two batches reusing one provider id keep both records", () => {
+    const indexer = new ToolCallIndexer();
+    indexer.addBatch(batch(0, 1000, [{ id: "bash_23", ts: 1150, text: "FIRST" }]), () => {});
+    indexer.addBatch(batch(1, 2000, [{ id: "bash_23", ts: 2150, text: "SECOND" }]), () => {});
+
+    expect(indexer.getRecord("bash_23@1150")?.resultText).toBe("FIRST");
+    expect(indexer.getRecord("bash_23@2150")?.resultText).toBe("SECOND");
+  });
+
+  test("isSummarized is keyed by occurrence, so a live reused id is not summarized", () => {
+    const indexer = new ToolCallIndexer();
+    indexer.addBatch(batch(0, 1000, [{ id: "bash_23", ts: 1150, text: "FIRST" }]), () => {});
+
+    expect(indexer.isSummarized("bash_23@1150")).toBe(true);
+    expect(indexer.isSummarized("bash_23@3150")).toBe(false);
+  });
+
+  test("getRecordsForId returns every occurrence of a bare id, chronologically", () => {
+    const indexer = new ToolCallIndexer();
+    indexer.addBatch(batch(0, 2000, [{ id: "bash_23", ts: 2150, text: "SECOND" }]), () => {});
+    indexer.addBatch(batch(1, 1000, [{ id: "bash_23", ts: 1150, text: "FIRST" }]), () => {});
+
+    const records = indexer.getRecordsForId("bash_23");
+    expect(records.map((r) => r.resultText)).toEqual(["FIRST", "SECOND"]);
+  });
+
+  test("getRecordsForId on an occurrence key or short ref returns exactly one", () => {
+    const indexer = new ToolCallIndexer();
+    indexer.addBatch(batch(0, 1000, [{ id: "bash_23", ts: 1150, text: "FIRST" }]), () => {});
+    indexer.registerSummaryRefs([{ shortId: "t1", toolCallId: "bash_23", resultTimestamp: 1150 }]);
+
+    expect(indexer.getRecordsForId("bash_23@1150").map((r) => r.resultText)).toEqual(["FIRST"]);
+    expect(indexer.getRecordsForId("t1").map((r) => r.resultText)).toEqual(["FIRST"]);
+  });
+
+  test("short refs resolve per occurrence", () => {
+    const indexer = new ToolCallIndexer();
+    indexer.addBatch(batch(0, 1000, [{ id: "bash_23", ts: 1150, text: "FIRST" }]), () => {});
+    indexer.addBatch(batch(1, 2000, [{ id: "bash_23", ts: 2150, text: "SECOND" }]), () => {});
+    indexer.registerSummaryRefs([
+      { shortId: "t1", toolCallId: "bash_23", resultTimestamp: 1150 },
+      { shortId: "t2", toolCallId: "bash_23", resultTimestamp: 2150 },
+    ]);
+
+    expect(indexer.getRecord("t1")?.resultText).toBe("FIRST");
+    expect(indexer.getRecord("t2")?.resultText).toBe("SECOND");
+    expect(indexer.getShortRefForToolCallId("bash_23@2150")).toBe("t2");
+  });
+
+  test("allocateSummaryRefs mints refs carrying the occurrence timestamp", () => {
+    const indexer = new ToolCallIndexer();
+    const b = batch(0, 1000, [{ id: "bash_23", ts: 1150, text: "FIRST" }]);
+    const refs = indexer.allocateSummaryRefs(b);
+
+    expect(refs).toEqual([{ shortId: "t1", toolCallId: "bash_23", resultTimestamp: 1150 }]);
+  });
+
+  test("content dedup does not alias across batches that merely share an id", () => {
+    const indexer = new ToolCallIndexer();
+    indexer.addBatch(batch(0, 1000, [{ id: "bash_23", ts: 1150, text: "FIRST" }]), () => {});
+    indexer.addBatch(batch(1, 2000, [{ id: "bash_23", ts: 2150, text: "SECOND" }]), () => {});
+
+    // Each occurrence's content resolves to its OWN occurrence key, never
+    // to the other occurrence merely because they share a bare id.
+    expect(indexer.lookupByContent("bash", "FIRST")).toBe("bash_23@1150");
+    expect(indexer.lookupByContent("bash", "SECOND")).toBe("bash_23@2150");
+    expect(indexer.lookupByContent("bash", "UNSEEN")).toBeUndefined();
+  });
+
+  test("registerDuplicate persists both occurrence sides and reuses the short ref", () => {
+    const indexer = new ToolCallIndexer();
+    indexer.addBatch(batch(0, 1000, [{ id: "bash_23", ts: 1150, text: "SAME" }]), () => {});
+    indexer.registerSummaryRefs([{ shortId: "t1", toolCallId: "bash_23", resultTimestamp: 1150 }]);
+
+    let persisted: any;
+    indexer.registerDuplicate("bash_99@4150", "bash_23@1150", (customType, data) => {
+      persisted = { customType, data };
+    });
+
+    expect(persisted).toEqual({
+      customType: CUSTOM_TYPE_DEDUP_ALIAS,
+      data: {
+        newToolCallId: "bash_99",
+        newResultTimestamp: 4150,
+        originalToolCallId: "bash_23",
+        originalResultTimestamp: 1150,
+      },
+    });
+    expect(indexer.isSummarized("bash_99@4150")).toBe(true);
+    expect(indexer.getRecord("bash_99@4150")?.resultText).toBe("SAME");
+    expect(indexer.getShortRefForToolCallId("bash_99@4150")).toBe("t1");
+  });
+
+  test("getRecordsForId includes a dedup-alias occurrence, labelled with its own timestamp", () => {
+    const indexer = new ToolCallIndexer();
+    indexer.addBatch(batch(0, 1000, [{ id: "bash_23", ts: 1150, text: "SAME" }]), () => {});
+    // Alias shares the SAME bare id as the original but occurred later - the
+    // G5 conformance shape: a content-deduplicated collision on a reused id.
+    indexer.registerDuplicate("bash_23@9150", "bash_23@1150", () => {});
+
+    const records = indexer.getRecordsForId("bash_23");
+    expect(records).toHaveLength(2);
+    expect(records.map((r) => r.resultText)).toEqual(["SAME", "SAME"]);
+    expect(records.map((r) => r.resultTimestamp)).toEqual([1150, 9150]);
+  });
+
+  test("summary body lookups are occurrence-keyed", () => {
+    const indexer = new ToolCallIndexer();
+    indexer.registerSummaryBody(["bash_23@1150"], "summary of FIRST");
+
+    expect(indexer.hasPerBatchSummaryCoveringAny(["bash_23@1150"])).toBe(true);
+    expect(indexer.hasPerBatchSummaryCoveringAny(["bash_23@3150"])).toBe(false);
+    expect(indexer.getPerBatchSummaryTextForToolCallIds(["bash_23@1150"])).toBe("summary of FIRST");
+  });
+});
+
+describe("fail-closed asymmetry: isSummarized vs bare-id resolution", () => {
+  test("single occurrence: isSummarized on the bare id is strict-false, resolveToolCallId/getRecord fall back", () => {
+    const indexer = new ToolCallIndexer();
+    indexer.addBatch(batch(0, 1000, [{ id: "bash_23", ts: 1150, text: "FIRST" }]), () => {});
+
+    expect(indexer.isSummarized("bash_23")).toBe(false);
+    expect(indexer.resolveToolCallId("bash_23")).toBe("bash_23@1150");
+    expect(indexer.getRecord("bash_23")?.resultText).toBe("FIRST");
+  });
+
+  test("two occurrences: resolveToolCallId on the bare id is ambiguous, getRecordsForId expands both", () => {
+    const indexer = new ToolCallIndexer();
+    indexer.addBatch(batch(0, 1000, [{ id: "bash_23", ts: 1150, text: "FIRST" }]), () => {});
+    indexer.addBatch(batch(1, 2000, [{ id: "bash_23", ts: 2150, text: "SECOND" }]), () => {});
+
+    expect(indexer.resolveToolCallId("bash_23")).toBeUndefined();
+    expect(indexer.getRecordsForId("bash_23").map((r) => r.resultText)).toEqual(["FIRST", "SECOND"]);
+  });
+
+  test("mixed legacy + new occurrence under the same bare id: hasLegacyBareRecord is false (fail-closed), getRecordsForId returns both", () => {
+    const indexer = new ToolCallIndexer();
+    indexer.addBatch(batch(0, 1000, [{ id: "bash_23", text: "OLD" }]), () => {});
+    indexer.addBatch(batch(1, 2000, [{ id: "bash_23", ts: 2150, text: "NEW" }]), () => {});
+
+    // A mixed bare+occurrence id must fail closed: the pruner's legacy-bare
+    // path would otherwise stub an unrelated live occurrence with the stale
+    // legacy record (F1 regression - see pruner.test.ts).
+    expect(indexer.hasLegacyBareRecord("bash_23")).toBe(false);
+    expect(indexer.getRecordsForId("bash_23").map((r) => r.resultText)).toEqual(["OLD", "NEW"]);
+  });
+
+  test("hasLegacyBareRecord: true for pure-legacy, false for pure-occurrence, false for mixed", () => {
+    const legacyOnly = new ToolCallIndexer();
+    legacyOnly.addBatch(batch(0, 1000, [{ id: "bash_1", text: "OLD" }]), () => {});
+    expect(legacyOnly.hasLegacyBareRecord("bash_1")).toBe(true);
+
+    const occOnly = new ToolCallIndexer();
+    occOnly.addBatch(batch(0, 1000, [{ id: "bash_2", ts: 1150, text: "NEW" }]), () => {});
+    expect(occOnly.hasLegacyBareRecord("bash_2")).toBe(false);
+
+    const mixed = new ToolCallIndexer();
+    mixed.addBatch(batch(0, 1000, [{ id: "bash_3", text: "OLD" }]), () => {});
+    mixed.addBatch(batch(1, 2000, [{ id: "bash_3", ts: 2150, text: "NEW" }]), () => {});
+    expect(mixed.hasLegacyBareRecord("bash_3")).toBe(false);
+  });
+
+  test("rebuild is order-independent: a dedup alias entry appearing BEFORE its summary entry still inherits the short ref", () => {
+    const indexEntry = {
+      type: "custom",
+      customType: CUSTOM_TYPE_INDEX,
+      data: {
+        toolCalls: [
+          {
+            toolCallId: "bash_23",
+            toolName: "bash",
+            args: {},
+            resultText: "FIRST",
+            isError: false,
+            turnIndex: 0,
+            timestamp: 1000,
+            resultTimestamp: 1150,
+          },
+        ],
+      },
+    };
+    const dedupEntry = {
+      type: "custom",
+      customType: CUSTOM_TYPE_DEDUP_ALIAS,
+      data: {
+        newToolCallId: "bash_99",
+        newResultTimestamp: 4150,
+        originalToolCallId: "bash_23",
+        originalResultTimestamp: 1150,
+      },
+    };
+    const summaryEntry = {
+      type: "custom_message",
+      customType: CUSTOM_TYPE_SUMMARY,
+      content: "summary text",
+      details: {
+        toolCallRefs: [{ shortId: "t1", toolCallId: "bash_23", resultTimestamp: 1150 }],
+        toolNames: ["bash"],
+        turnIndex: 0,
+        timestamp: 1000,
+      },
+    };
+
+    const indexer = new ToolCallIndexer();
+    // dedup entry appears BEFORE the summary entry in the branch, unlike every other test here.
+    const ctx = { sessionManager: { getBranch: () => [indexEntry, dedupEntry, summaryEntry] } } as any;
+    indexer.reconstructFromSession(ctx);
+
+    expect(indexer.getShortRefForToolCallId("bash_99@4150")).toBe("t1");
+  });
+});
+
+describe("session rebuild", () => {
+  test("rebuilds occurrence records, both short refs and the dedup alias", () => {
+    const indexEntry = {
+      type: "custom",
+      customType: CUSTOM_TYPE_INDEX,
+      data: {
+        toolCalls: [
+          {
+            toolCallId: "bash_23",
+            toolName: "bash",
+            args: {},
+            resultText: "FIRST",
+            isError: false,
+            turnIndex: 0,
+            timestamp: 1000,
+            resultTimestamp: 1150,
+          },
+          {
+            toolCallId: "bash_23",
+            toolName: "bash",
+            args: {},
+            resultText: "SECOND",
+            isError: false,
+            turnIndex: 1,
+            timestamp: 2000,
+            resultTimestamp: 2150,
+          },
+        ],
+      },
+    };
+    const summaryEntry = {
+      type: "custom_message",
+      customType: CUSTOM_TYPE_SUMMARY,
+      content: "summary text",
+      details: {
+        toolCallRefs: [
+          { shortId: "t1", toolCallId: "bash_23", resultTimestamp: 1150 },
+          { shortId: "t2", toolCallId: "bash_23", resultTimestamp: 2150 },
+        ],
+        toolNames: ["bash", "bash"],
+        turnIndex: 1,
+        timestamp: 2000,
+      },
+    };
+    const dedupEntry = {
+      type: "custom",
+      customType: CUSTOM_TYPE_DEDUP_ALIAS,
+      data: {
+        newToolCallId: "bash_99",
+        newResultTimestamp: 4150,
+        originalToolCallId: "bash_23",
+        originalResultTimestamp: 1150,
+      },
+    };
+
+    const indexer = new ToolCallIndexer();
+    const ctx = { sessionManager: { getBranch: () => [indexEntry, summaryEntry, dedupEntry] } } as any;
+    indexer.reconstructFromSession(ctx);
+
+    expect(indexer.getRecord("t1")?.resultText).toBe("FIRST");
+    expect(indexer.getRecord("t2")?.resultText).toBe("SECOND");
+    expect(indexer.getRecord("bash_99@4150")?.resultText).toBe("FIRST");
+    expect(indexer.getShortRefForToolCallId("bash_99@4150")).toBe("t1");
+    expect(indexer.getPerBatchSummaryTextForToolCallIds(["bash_23@2150"])).toBe("summary text");
+  });
+
+  test("legacy entries without resultTimestamp keep bare-id keys", () => {
+    const indexEntry = {
+      type: "custom",
+      customType: CUSTOM_TYPE_INDEX,
+      data: {
+        toolCalls: [
+          {
+            toolCallId: "bash_7",
+            toolName: "bash",
+            args: {},
+            resultText: "OLD",
+            isError: false,
+            turnIndex: 0,
+            timestamp: 1000,
+          },
+        ],
+      },
+    };
+    const legacyDedupEntry = {
+      type: "custom",
+      customType: CUSTOM_TYPE_DEDUP_ALIAS,
+      data: { newToolCallId: "bash_8", originalToolCallId: "bash_7" },
+    };
+
+    const indexer = new ToolCallIndexer();
+    const ctx = { sessionManager: { getBranch: () => [indexEntry, legacyDedupEntry] } } as any;
+    indexer.reconstructFromSession(ctx);
+
+    expect(indexer.getRecord("bash_7")?.resultText).toBe("OLD");
+    expect(indexer.hasLegacyBareRecord("bash_7")).toBe(true);
+    expect(indexer.hasLegacyBareRecord("bash_23")).toBe(false);
+    expect(indexer.isSummarized("bash_8")).toBe(true);
+  });
+});