pi-condense 2.5.0 → 2.6.0

package/src/commands.test.ts

@@ -6,9 +6,13 @@ const cfg = (enabled: boolean): ContextPruneConfig => ({ enabled } as ContextPru
 const cfgVisible = (enabled: boolean): ContextPruneConfig =>
   ({ enabled, showPruneStatusLine: true } as ContextPruneConfig);
 
-function captureStatus(config: ContextPruneConfig, value?: Parameters<typeof setPruneStatusWidget>[2]): string | undefined {
+function captureStatus(
+  config: ContextPruneConfig,
+  value?: Parameters<typeof setPruneStatusWidget>[2],
+  diagnostics?: Parameters<typeof setPruneStatusWidget>[3],
+): string | undefined {
   let captured: string | undefined;
-  setPruneStatusWidget({ ui: { setStatus: (_id, text) => { captured = text; } } }, config, value);
+  setPruneStatusWidget({ ui: { setStatus: (_id, text) => { captured = text; } } }, config, value, diagnostics);
   return captured;
 }
 
@@ -65,3 +69,28 @@ describe("setPruneStatusWidget", () => {
     expect(captureStatus(cfg(true))).toBeUndefined();
   });
 });
+
+describe("diagnostic counters on the status line", () => {
+  const zeroDiag = { "unresolved-range": 0, "range-id-mismatch": 0, "orphan-sweep": 0 } as const;
+  const mixedDiag = { "unresolved-range": 2, "range-id-mismatch": 0, "orphan-sweep": 1 } as const;
+
+  it("omits the diagnostic segment when all counters are zero", () => {
+    expect(pruneStatusText(cfg(true), undefined, zeroDiag)).toBe("prune: ON");
+  });
+
+  it("appends a compact segment when a counter fires, omitting zero kinds", () => {
+    const text = pruneStatusText(cfg(true), undefined, mixedDiag);
+    expect(text).toBe("prune: ON \u00b7 diag u2/o1");
+  });
+
+  it("appends the diagnostic segment to the reclaim form too", () => {
+    const text = pruneStatusText(cfg(true), { beforeChars: 368000, afterChars: 56000 }, mixedDiag);
+    expect(text).toBe("prune: ON \u00b7 92.0k->14.0k (-85%) \u00b7 diag u2/o1");
+  });
+
+  it("setPruneStatusWidget forwards the counters", () => {
+    expect(captureStatus(cfgVisible(true), undefined, { "unresolved-range": 1, "range-id-mismatch": 0, "orphan-sweep": 0 })).toBe(
+      "\u2502 prune: ON \u00b7 diag u1",
+    );
+  });
+});

package/src/commands.ts

@@ -5,6 +5,7 @@ import {
   type CapturedBatch,
   type ChainCompressionEntry,
   type FlushOptions,
+  type DiagnosticKind,
   PRUNE_ON_MODES,
   BATCHING_MODES,
   STATUS_WIDGET_ID,
@@ -57,25 +58,38 @@ class SettingsOverlay extends Container {
 
 // ── Status widget text ──────────────────────────────────────────────────────
 
-export function pruneStatusText(config: ContextPruneConfig, reclaim?: LiveReclaim): string {
+export function pruneStatusText(
+  config: ContextPruneConfig,
+  reclaim?: LiveReclaim,
+  diagnostics?: Record<DiagnosticKind, number>,
+): string {
   if (!config.enabled) return "prune: OFF";
-  if (!reclaim || reclaim.beforeChars <= 0) return "prune: ON";
+  const diag = diagnostics
+    ? [
+        diagnostics["unresolved-range"] ? `u${diagnostics["unresolved-range"]}` : "",
+        diagnostics["range-id-mismatch"] ? `m${diagnostics["range-id-mismatch"]}` : "",
+        diagnostics["orphan-sweep"] ? `o${diagnostics["orphan-sweep"]}` : "",
+      ].filter(Boolean)
+    : [];
+  const suffix = diag.length > 0 ? ` \u00b7 diag ${diag.join("/")}` : "";
+  if (!reclaim || reclaim.beforeChars <= 0) return `prune: ON${suffix}`;
   const beforeTok = Math.round(reclaim.beforeChars / 4);
   const afterTok = Math.round(reclaim.afterChars / 4);
   const reduction = Math.max(0, Math.round((1 - afterTok / beforeTok) * 100));
-  return `prune: ON \u00b7 ${formatCompactCount(beforeTok)}->${formatCompactCount(afterTok)} (-${reduction}%)`;
+  return `prune: ON \u00b7 ${formatCompactCount(beforeTok)}->${formatCompactCount(afterTok)} (-${reduction}%)${suffix}`;
 }
 
 export function setPruneStatusWidget(
   ctx: { ui: { setStatus: (id: string, text?: string) => void } },
   config: ContextPruneConfig,
   value?: LiveReclaim | string,
+  diagnostics?: Record<DiagnosticKind, number>,
 ): void {
   if (!config.showPruneStatusLine) {
     ctx.ui.setStatus(STATUS_WIDGET_ID, undefined);
     return;
   }
-  const text = typeof value === "string" ? value : pruneStatusText(config, value);
+  const text = typeof value === "string" ? value : pruneStatusText(config, value, diagnostics);
   // Leading-only separator: the footer joins extension status segments with a
   // single space, so a trailing divider collides with the next segment's leading
   // one and renders doubled. One leading bar yields single dividers between
@@ -455,6 +469,7 @@ export function registerCommands(
   getLiveReclaim: () => LiveReclaim | undefined,
   indexer: ToolCallIndexer,
   compactChains: (ctx: ExtensionCommandContext) => Promise<{ compressedEntries: ChainCompressionEntry[]; skipped: number }>,
+  getDiagnosticCounts?: () => Record<DiagnosticKind, number>,
 ): void {
   // Register the /pruner command
   pi.registerCommand("pruner", {
@@ -801,7 +816,7 @@ export function registerCommands(
             }
             currentConfig.value = newConfig;
             saveConfig(newConfig);
-            setPruneStatusWidget(ctx, newConfig, getLiveReclaim());
+            setPruneStatusWidget(ctx, newConfig, getLiveReclaim(), getDiagnosticCounts?.());
             settingsList?.invalidate();
           };
 
@@ -836,7 +851,7 @@ export function registerCommands(
           currentConfig.value = { ...currentConfig.value, enabled: true };
           saveConfig(currentConfig.value);
           ctx.ui.notify("Context pruning enabled.");
-          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim());
+          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.());
           break;
         }
 
@@ -845,7 +860,7 @@ export function registerCommands(
           currentConfig.value = { ...currentConfig.value, enabled: false };
           saveConfig(currentConfig.value);
           ctx.ui.notify("Context pruning disabled.");
-          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim());
+          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.());
           break;
         }
 
@@ -964,7 +979,7 @@ export function registerCommands(
             currentConfig.value = { ...currentConfig.value, pruneOn: modeArg as ContextPruneConfig["pruneOn"] };
           }
           saveConfig(currentConfig.value);
-          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim());
+          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.());
           break;
         }
 
@@ -1011,7 +1026,7 @@ export function registerCommands(
             // tool-result savings; but assistant-message savings (thinking + toolCall args + text)
             // are not counted at all, so the two errors partly cancel. Treat as a rough proxy.
             const droppedChars = compressedEntries.reduce((total, entry) => {
-              const records = indexer.lookupToolCalls(entry.droppedToolCallIds);
+              const records = indexer.lookupToolCalls(entry.droppedOccurrenceKeys ?? entry.droppedToolCallIds);
               return total + records.reduce((s, r) => s + r.resultText.length, 0);
             }, 0);
             const reclaimedTokens = Math.ceil(droppedChars / 4);
@@ -1061,7 +1076,7 @@ export function registerCommands(
 
           // Remove the widget and restore the normal footer status.
           clearWidget();
-          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim());
+          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.());
 
           if (!result.ok) {
             const suffix = "error" in result && result.error ? ` (${result.error})` : "";

package/src/diagnostics.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, spyOn, test } from "bun:test";
+import { DiagnosticSink } from "./diagnostics.js";
+import { CUSTOM_TYPE_DIAGNOSTIC } from "./types.js";
+
+const sinkWithLog = () => {
+  const appended: Array<{ type: string; data: any }> = [];
+  const sink = new DiagnosticSink((type, data) => appended.push({ type, data }));
+  return { sink, appended };
+};
+
+describe("DiagnosticSink", () => {
+  test("writes one session entry per distinct (kind, dedupKey)", () => {
+    const { sink, appended } = sinkWithLog();
+    sink.report("unresolved-range", "b5", "blockId=b5 start=1000 final=null");
+    expect(appended).toHaveLength(1);
+    expect(appended[0].type).toBe(CUSTOM_TYPE_DIAGNOSTIC);
+    expect(appended[0].data).toEqual({ kind: "unresolved-range", detail: "blockId=b5 start=1000 final=null" });
+  });
+
+  test("dedupes a repeated (kind, dedupKey) within the session", () => {
+    const { sink, appended } = sinkWithLog();
+    sink.report("unresolved-range", "b5", "first");
+    sink.report("unresolved-range", "b5", "second");
+    expect(appended).toHaveLength(1);
+    expect(sink.counts()["unresolved-range"]).toBe(1);
+  });
+
+  test("a different dedupKey of the same kind still reports", () => {
+    const { sink, appended } = sinkWithLog();
+    sink.report("unresolved-range", "b5", "x");
+    sink.report("unresolved-range", "b7", "y");
+    expect(appended).toHaveLength(2);
+    expect(sink.counts()["unresolved-range"]).toBe(2);
+  });
+
+  test("the same dedupKey under two different kinds both report", () => {
+    const { sink, appended } = sinkWithLog();
+    sink.report("unresolved-range", "b5", "x");
+    sink.report("range-id-mismatch", "b5", "y");
+    expect(appended).toHaveLength(2);
+    expect(appended[0].type).toBe(CUSTOM_TYPE_DIAGNOSTIC);
+    expect(appended[1].type).toBe(CUSTOM_TYPE_DIAGNOSTIC);
+    expect(sink.counts()["unresolved-range"]).toBe(1);
+    expect(sink.counts()["range-id-mismatch"]).toBe(1);
+  });
+
+  test("counts are per kind and start at zero", () => {
+    const { sink } = sinkWithLog();
+    expect(sink.counts()).toEqual({ "unresolved-range": 0, "range-id-mismatch": 0, "orphan-sweep": 0 });
+    sink.report("orphan-sweep", "a,b", "swept 2");
+    expect(sink.counts()["orphan-sweep"]).toBe(1);
+  });
+
+  test("an appendEntry failure never throws into the render path, and does not mark the key as seen", () => {
+    const spy = spyOn(console, "error").mockImplementation(() => {});
+    const sink = new DiagnosticSink(() => {
+      throw new Error("session closed");
+    });
+    expect(() => sink.report("orphan-sweep", "a", "detail")).not.toThrow();
+    expect(spy).toHaveBeenCalled();
+    expect(sink.counts()["orphan-sweep"]).toBe(0);
+    spy.mockRestore();
+  });
+
+  test("a retry of the same (kind, dedupKey) after appendEntry starts working persists and counts", () => {
+    const spy = spyOn(console, "error").mockImplementation(() => {});
+    let working = false;
+    const appended: Array<{ type: string; data: any }> = [];
+    const sink = new DiagnosticSink((type, data) => {
+      if (!working) throw new Error("session closed");
+      appended.push({ type, data });
+    });
+
+    expect(() => sink.report("orphan-sweep", "a", "detail")).not.toThrow();
+    expect(sink.counts()["orphan-sweep"]).toBe(0);
+    expect(appended).toHaveLength(0);
+
+    working = true;
+    sink.report("orphan-sweep", "a", "detail");
+    expect(sink.counts()["orphan-sweep"]).toBe(1);
+    expect(appended).toHaveLength(1);
+
+    spy.mockRestore();
+  });
+
+  test("counts() returns a snapshot; mutating it does not affect internal counters", () => {
+    const { sink } = sinkWithLog();
+    sink.report("orphan-sweep", "a", "detail");
+    const snapshot = sink.counts();
+    snapshot["orphan-sweep"] = 999;
+    expect(sink.counts()["orphan-sweep"]).toBe(1);
+  });
+
+  test("reset() zeroes all counters", () => {
+    const { sink } = sinkWithLog();
+    sink.report("unresolved-range", "b5", "x");
+    sink.report("orphan-sweep", "a", "y");
+    sink.reset();
+    expect(sink.counts()).toEqual({ "unresolved-range": 0, "range-id-mismatch": 0, "orphan-sweep": 0 });
+  });
+
+  test("reset() allows a previously-seen (kind, dedupKey) to report again", () => {
+    const { sink, appended } = sinkWithLog();
+    sink.report("unresolved-range", "b5", "first");
+    expect(appended).toHaveLength(1);
+
+    sink.reset();
+
+    sink.report("unresolved-range", "b5", "second");
+    expect(appended).toHaveLength(2);
+    expect(appended[1].data).toEqual({ kind: "unresolved-range", detail: "second" });
+    expect(sink.counts()["unresolved-range"]).toBe(1);
+  });
+});

package/src/diagnostics.ts

@@ -0,0 +1,46 @@
+import { CUSTOM_TYPE_DIAGNOSTIC } from "./types.js";
+import type { DiagnosticEntryData, DiagnosticKind } from "./types.js";
+
+/**
+ * Out-of-band diagnostic channel for prune-time degradations. Session entries
+ * only - never LLM context, so zero tokens and zero cache-prefix change.
+ * Deduped per (kind, dedupKey) so a permanently degraded condition writes one
+ * entry, not one per render.
+ */
+export class DiagnosticSink {
+  private readonly seen = new Set<string>();
+  private readonly counters: Record<DiagnosticKind, number> = {
+    "unresolved-range": 0,
+    "range-id-mismatch": 0,
+    "orphan-sweep": 0,
+  };
+
+  constructor(private readonly appendEntry: (customType: string, data?: unknown) => void) {}
+
+  report(kind: DiagnosticKind, dedupKey: string, detail: string): void {
+    const key = `${kind}:${dedupKey}`;
+    if (this.seen.has(key)) return;
+    const payload: DiagnosticEntryData = { kind, detail };
+    try {
+      this.appendEntry(CUSTOM_TYPE_DIAGNOSTIC, payload);
+    } catch (err) {
+      // The render path must never fail because bookkeeping failed.
+      console.error(`pruner: failed to persist ${kind} diagnostic:`, err);
+      return;
+    }
+    this.seen.add(key);
+    this.counters[kind]++;
+  }
+
+  counts(): Record<DiagnosticKind, number> {
+    return { ...this.counters };
+  }
+
+  /** Clears session-scoped state; call on session_start/session_tree since this sink is process-scoped, not session-scoped. */
+  reset(): void {
+    this.seen.clear();
+    for (const kind of Object.keys(this.counters) as DiagnosticKind[]) {
+      this.counters[kind] = 0;
+    }
+  }
+}

package/src/frontier.test.ts

@@ -85,6 +85,7 @@ describe("PruneFrontierTracker.reconstructFromSession", () => {
 
     const indexer = {
       isSummarized: (id: string) => id === "tc-old" || id === "tc-stub",
+      hasLegacyBareRecord: (id: string) => id === "tc-old" || id === "tc-stub",
       getShortRefForToolCallId: (id: string) => (id === "tc-stub" ? "t1" : id === "tc-old" ? "told" : undefined),
       getRecord: () => undefined,
       getChainEntries: () => [chainEntry],

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