pi-condense 2.5.0 → 2.7.0

package/src/context-metrics.ts

@@ -0,0 +1,152 @@
+import { detectChains } from "./chain-detector.js";
+import { occKey, resultTimestampOf } from "./occurrence-key.js";
+import type { ContextMetricsSnapshot, PruneFrontier } from "./types.js";
+
+function charsOf(msg: any): number {
+  return JSON.stringify(msg).length;
+}
+
+function tokensOf(msg: any): number {
+  return Math.round(charsOf(msg) / 4);
+}
+
+function isTextOnlyAssistant(msg: any): boolean {
+  if (msg.role !== "assistant") return false;
+  if (!Array.isArray(msg.content)) return true;
+  return !msg.content.some((b: any) => b.type === "toolCall");
+}
+
+function toolCallBlocksOf(msg: any): { id: string; input?: unknown; arguments?: unknown }[] {
+  if (!Array.isArray(msg.content)) return [];
+  return msg.content.filter((b: any) => b.type === "toolCall");
+}
+
+function findArgsForToolCallId(branch: any[], resultIdx: number, toolCallId: string): unknown {
+  for (let i = resultIdx - 1; i >= 0; i--) {
+    const m = branch[i];
+    if (m.role !== "assistant") continue;
+    const call = toolCallBlocksOf(m).find((c) => c.id === toolCallId);
+    if (call) return (call as any).input ?? (call as any).arguments;
+  }
+  return undefined;
+}
+
+/**
+ * Pure snapshot of what the pruner cannot (yet) reclaim: thinking tokens
+ * trapped in the trailing open cycle, the largest single chain's share of
+ * the branch, and unsummarized toolResult tokens past the prune frontier.
+ */
+export function computeContextMetrics(
+  branch: any[],
+  frontier: PruneFrontier | null,
+  isSummarized: (occurrenceKey: string) => boolean,
+  isProtected: (toolName: string, args: unknown) => boolean,
+): ContextMetricsSnapshot {
+  if (branch.length === 0) {
+    return { openCycleThinkingTokens: 0, largestChainSharePct: 0, frontierGapTokens: 0 };
+  }
+
+  // ── Open segment: strictly after the last text-only assistant ──────────
+  let lastTextOnlyIdx = -1;
+  for (let i = 0; i < branch.length; i++) {
+    if (isTextOnlyAssistant(branch[i])) lastTextOnlyIdx = i;
+  }
+  const openStart = lastTextOnlyIdx + 1;
+
+  let thinkingChars = 0;
+  for (let i = openStart; i < branch.length; i++) {
+    const m = branch[i];
+    if (m.role !== "assistant" || !Array.isArray(m.content)) continue;
+    for (const block of m.content) {
+      if (block.type === "thinking") thinkingChars += JSON.stringify(block).length;
+    }
+  }
+  const openCycleThinkingTokens = Math.round(thinkingChars / 4);
+
+  // ── Largest chain share ─────────────────────────────────────────────────
+  const branchChars = branch.map(charsOf);
+  const sumChars = (start: number, end: number): number => {
+    let sum = 0;
+    for (let i = start; i <= end; i++) sum += branchChars[i];
+    return sum;
+  };
+  const totalChars = branchChars.reduce((a, b) => a + b, 0);
+
+  const chains = detectChains(branch, isProtected);
+  let largestClosedChainChars = 0;
+  for (const range of chains) {
+    const startIdx = branch.findIndex((m) => m.role === "user" && m.timestamp === range.startUserTimestamp);
+    if (startIdx === -1) continue;
+    let endIdx: number;
+    if (range.finalAssistantTimestamp !== null) {
+      endIdx = branch.findIndex(
+        (m, i) => i >= startIdx && m.role === "assistant" && m.timestamp === range.finalAssistantTimestamp,
+      );
+      if (endIdx === -1) continue;
+    } else {
+      let nextUserIdx = -1;
+      for (let i = startIdx + 1; i < branch.length; i++) {
+        if (branch[i].role === "user") {
+          nextUserIdx = i;
+          break;
+        }
+      }
+      endIdx = nextUserIdx === -1 ? branch.length - 1 : nextUserIdx - 1;
+    }
+    if (endIdx < startIdx) continue;
+    const chainChars = sumChars(startIdx, endIdx);
+    if (chainChars > largestClosedChainChars) largestClosedChainChars = chainChars;
+  }
+
+  const openSegmentChars = openStart < branch.length ? sumChars(openStart, branch.length - 1) : 0;
+  const numerator = Math.max(largestClosedChainChars, openSegmentChars);
+  const largestChainSharePct = totalChars === 0 ? 0 : Math.round((100 * numerator) / totalChars);
+
+  // ── Frontier gap ─────────────────────────────────────────────────────────
+  // Exclusion is positional: only toolResults belonging to the boundary turn's
+  // own calls (up to and including the last-attempted call) are excluded.
+  // Ids are only unique per turn (see occurrence-key.ts), so a later turn may
+  // legally reuse a bare id — its result must still count toward the gap.
+  let boundaryIdx = -1;
+  let boundaryTurnEndIdx = branch.length;
+  const boundaryExcludedIds = new Set<string>();
+  if (frontier) {
+    let counter = 0;
+    for (let i = 0; i < branch.length; i++) {
+      const m = branch[i];
+      if (m.role !== "assistant") continue;
+      const turnIdx = counter;
+      counter++;
+      if (turnIdx === frontier.lastAttemptedTurnIndex) {
+        const calls = toolCallBlocksOf(m);
+        const k = calls.findIndex((c) => c.id === frontier.lastAttemptedToolCallId);
+        if (k !== -1) {
+          boundaryIdx = i;
+          for (let j = 0; j <= k; j++) boundaryExcludedIds.add(calls[j].id);
+          for (let j = i + 1; j < branch.length; j++) {
+            if (branch[j].role === "assistant") {
+              boundaryTurnEndIdx = j;
+              break;
+            }
+          }
+        }
+        break;
+      }
+    }
+  }
+
+  let frontierGapTokens = 0;
+  const scanStart = boundaryIdx === -1 ? 0 : boundaryIdx + 1;
+  for (let i = scanStart; i < branch.length; i++) {
+    const m = branch[i];
+    if (m.role !== "toolResult") continue;
+    if (i < boundaryTurnEndIdx && boundaryExcludedIds.has(m.toolCallId)) continue;
+    const key = occKey(m.toolCallId, resultTimestampOf(m.timestamp));
+    if (isSummarized(key)) continue;
+    const args = findArgsForToolCallId(branch, i, m.toolCallId);
+    if (isProtected(m.toolName, args)) continue;
+    frontierGapTokens += tokensOf(m);
+  }
+
+  return { openCycleThinkingTokens, largestChainSharePct, frontierGapTokens };
+}

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