pi-condense 2.8.0 → 2.9.0

package/src/range-compression.integration.test.ts

@@ -5,9 +5,14 @@ import { compressEligible } from "./chain-compressor.js";
 import { pruneMessages } from "./pruner.js";
 import { detectChains } from "./chain-detector.js";
 import { isProtected } from "./protected.js";
-import { bareToolCallId } from "./occurrence-key.js";
+import { bareToolCallId, occKey } from "./occurrence-key.js";
+import { expectNoOrphanToolResults } from "./test-support.js";
+import { CUSTOM_TYPE_CHAIN, CUSTOM_TYPE_INDEX } from "./types.js";
 import type { ChainRange, ChainCompressionConfig } from "./types.js";
 
+const noopDiagnostics = { report: () => {} };
+const testBackfill = { spillThreshold: 1_000_000, spillPreviewBytes: 2048, sessionDir: "/tmp", sessionId: "s1" };
+
 // End-to-end of the in-memory B path (everything except the LLM call, which is
 // the shared runSummarization already exercised live): a span's per-batch
 // summaries are fused by compressEligible, the entry lands in the real indexer's
@@ -41,6 +46,9 @@ describe("range compression integration", () => {
         fuseInputs.push(text);
         return "FUSED COHESIVE SUMMARY";
       },
+      messages: [],
+      diagnostics: noopDiagnostics,
+      backfill: testBackfill,
     });
 
     // Fusion received the concatenated per-batch summaries and stored its result.
@@ -101,6 +109,9 @@ describe("range compression integration", () => {
       blockRefs,
       appendEntry: () => {},
       now: () => 999,
+      messages: [],
+      diagnostics: noopDiagnostics,
+      backfill: testBackfill,
     });
 
     expect(compressedEntries).toHaveLength(1);
@@ -198,6 +209,9 @@ describe("range compression integration", () => {
       blockRefs,
       appendEntry: () => {},
       now: () => 999,
+      messages,
+      diagnostics: noopDiagnostics,
+      backfill: testBackfill,
     });
 
     expect(compressedEntries).toHaveLength(1);
@@ -238,7 +252,15 @@ describe("range compression integration", () => {
     indexer.registerSummaryBody(["tc2"], "batch two body");
 
     const chain: ChainRange = { startUserTimestamp: 100, middleToolCallIds: ["tc1", "tc2"], finalAssistantTimestamp: 400 };
-    await compressEligible([chain], 0, { indexer, blockRefs, appendEntry: () => {}, now: () => 1 });
+    await compressEligible([chain], 0, {
+      indexer,
+      blockRefs,
+      appendEntry: () => {},
+      now: () => 1,
+      messages: [],
+      diagnostics: noopDiagnostics,
+      backfill: testBackfill,
+    });
 
     const messages: any[] = [
       { role: "user", content: [{ type: "text", text: "go" }], timestamp: 100 },
@@ -254,4 +276,375 @@ describe("range compression integration", () => {
     expect(synthetic.content[0].text).toContain("batch one body");
     expect(synthetic.content[0].text).toContain("batch two body");
   });
+
+  test("mixed flush: one covered + one uncovered chain compress in a single compressEligible call", async () => {
+    const indexer = new ToolCallIndexer();
+    const blockRefs = new BlockRefIssuer();
+
+    // Chain A (covered): per-batch summary exists for tcA.
+    indexer.registerSummaryRefs([{ shortId: "t1", toolCallId: "tcA" }]);
+    indexer.registerSummaryBody(["tcA"], "summary of tcA");
+
+    const messages: any[] = [
+      { role: "user", content: [{ type: "text", text: "go A" }], timestamp: 100 },
+      { role: "assistant", content: [{ type: "toolCall", id: "tcA", name: "bash", arguments: {} }], timestamp: 200, usage: {}, stopReason: "tool_use" },
+      { role: "toolResult", toolCallId: "tcA", toolName: "bash", content: [{ type: "text", text: "outA" }], isError: false, timestamp: 210 },
+      { role: "assistant", content: [{ type: "text", text: "done A" }], timestamp: 400, usage: {}, stopReason: "end_turn" },
+      // Chain B (uncovered): no per-batch summary for tcB1/tcB2.
+      { role: "user", content: [{ type: "text", text: "go B" }], timestamp: 1000 },
+      { role: "assistant", content: [{ type: "toolCall", id: "tcB1", name: "bash", arguments: { cmd: "one" } }], timestamp: 1100, usage: {}, stopReason: "tool_use" },
+      { role: "toolResult", toolCallId: "tcB1", toolName: "bash", content: [{ type: "text", text: "outB1" }], isError: false, timestamp: 1110 },
+      { role: "assistant", content: [{ type: "toolCall", id: "tcB2", name: "bash", arguments: { cmd: "two" } }], timestamp: 1200, usage: {}, stopReason: "tool_use" },
+      { role: "toolResult", toolCallId: "tcB2", toolName: "bash", content: [{ type: "text", text: "outB2" }], isError: false, timestamp: 1210 },
+      { role: "assistant", content: [{ type: "text", text: "done B" }], timestamp: 1400, usage: {}, stopReason: "end_turn" },
+    ];
+
+    const chainA: ChainRange = { startUserTimestamp: 100, middleToolCallIds: ["tcA"], finalAssistantTimestamp: 400 };
+    const chainB: ChainRange = {
+      startUserTimestamp: 1000,
+      middleToolCallIds: ["tcB1", "tcB2"],
+      middleOccurrenceKeys: [occKey("tcB1", 1110), occKey("tcB2", 1210)],
+      finalAssistantTimestamp: 1400,
+    };
+
+    const { compressedEntries } = await compressEligible([chainA, chainB], 0, {
+      indexer,
+      blockRefs,
+      appendEntry: () => {},
+      now: () => 999,
+      messages,
+      diagnostics: noopDiagnostics,
+      backfill: testBackfill,
+    });
+
+    expect(compressedEntries).toHaveLength(2);
+    const entryA = compressedEntries.find((e) => e.startUserTimestamp === 100)!;
+    const entryB = compressedEntries.find((e) => e.startUserTimestamp === 1000)!;
+    expect(entryA.bodySource).toBeUndefined();
+    expect(entryB.bodySource).toBe("deterministic");
+
+    const cc: ChainCompressionConfig = { enabled: true, rollingWindow: 0, stripFinalAssistantThinking: true, fuseRangeSummary: false };
+    const { messages: out } = pruneMessages(messages, indexer, cc);
+
+    const synthetics = out.filter((m: any) => m.role === "user" && typeof m.content?.[0]?.text === "string" && m.content[0].text.startsWith("<compressed-chain"));
+    expect(synthetics).toHaveLength(2);
+    const uncoveredSynthetic = synthetics.find((s: any) => s.content[0].text.includes("Deterministic chain compression"));
+    expect(uncoveredSynthetic).toBeDefined();
+    expectNoOrphanToolResults(out);
+
+    // Covered-output identity: the presence of chain B's deterministic branch
+    // must not perturb chain A's rendering at all. Rebuild chain A alone (chain
+    // B never existed) and require byte-identical entry + rendered text.
+    const referenceIndexer = new ToolCallIndexer();
+    const referenceBlockRefs = new BlockRefIssuer();
+    referenceIndexer.registerSummaryRefs([{ shortId: "t1", toolCallId: "tcA" }]);
+    referenceIndexer.registerSummaryBody(["tcA"], "summary of tcA");
+    const referenceMessages = messages.slice(0, 4); // chain A's own span only
+    const { compressedEntries: refEntries } = await compressEligible([chainA], 0, {
+      indexer: referenceIndexer,
+      blockRefs: referenceBlockRefs,
+      appendEntry: () => {},
+      now: () => 999,
+      messages: referenceMessages,
+      diagnostics: noopDiagnostics,
+      backfill: testBackfill,
+    });
+    expect(refEntries).toHaveLength(1);
+    expect(entryA).toEqual(refEntries[0]);
+
+    const { messages: refOut } = pruneMessages(referenceMessages, referenceIndexer, cc);
+    const refSynthetic = refOut.find(
+      (m: any) => m.role === "user" && typeof m.content?.[0]?.text === "string" && m.content[0].text.startsWith("<compressed-chain"),
+    );
+    expect(refSynthetic).toBeDefined();
+    const coveredSynthetic = synthetics.find((s: any) => !s.content[0].text.includes("Deterministic chain compression"));
+    expect(coveredSynthetic).toEqual(refSynthetic);
+  });
+
+  test("recovery through backfill: an uncovered chain's raw output is recoverable via its t<N> ref", async () => {
+    const indexer = new ToolCallIndexer();
+    const blockRefs = new BlockRefIssuer();
+
+    const messages: any[] = [
+      { role: "user", content: [{ type: "text", text: "go" }], timestamp: 1000 },
+      { role: "assistant", content: [{ type: "toolCall", id: "tcB1", name: "bash", arguments: { cmd: "one" } }], timestamp: 1100, usage: {}, stopReason: "tool_use" },
+      { role: "toolResult", toolCallId: "tcB1", toolName: "bash", content: [{ type: "text", text: "outB1 raw" }], isError: false, timestamp: 1110 },
+      { role: "assistant", content: [{ type: "text", text: "done" }], timestamp: 1400, usage: {}, stopReason: "end_turn" },
+    ];
+    const chainB: ChainRange = {
+      startUserTimestamp: 1000,
+      middleToolCallIds: ["tcB1"],
+      middleOccurrenceKeys: [occKey("tcB1", 1110)],
+      finalAssistantTimestamp: 1400,
+    };
+
+    const { compressedEntries } = await compressEligible([chainB], 0, {
+      indexer,
+      blockRefs,
+      appendEntry: () => {},
+      now: () => 999,
+      messages,
+      diagnostics: noopDiagnostics,
+      backfill: testBackfill,
+    });
+
+    expect(compressedEntries).toHaveLength(1);
+    const ref = compressedEntries[0].toolRefs[0];
+    const resolved = indexer.resolveToolCallId(ref);
+    expect(resolved).toBeDefined();
+    expect(indexer.getRecord(resolved!)?.resultText).toBe("outB1 raw");
+  });
+
+  test("restart mid-failure-window: index entry persists even when the chain-entry append fails, and converges on retry", async () => {
+    const indexer = new ToolCallIndexer();
+    const blockRefs = new BlockRefIssuer();
+
+    const messages: any[] = [
+      { role: "user", content: [{ type: "text", text: "go" }], timestamp: 1000 },
+      { role: "assistant", content: [{ type: "toolCall", id: "tcB1", name: "bash", arguments: { cmd: "one" } }], timestamp: 1100, usage: {}, stopReason: "tool_use" },
+      { role: "toolResult", toolCallId: "tcB1", toolName: "bash", content: [{ type: "text", text: "outB1 raw" }], isError: false, timestamp: 1110 },
+      { role: "assistant", content: [{ type: "text", text: "done" }], timestamp: 1400, usage: {}, stopReason: "end_turn" },
+    ];
+    const chainB: ChainRange = {
+      startUserTimestamp: 1000,
+      middleToolCallIds: ["tcB1"],
+      middleOccurrenceKeys: [occKey("tcB1", 1110)],
+      finalAssistantTimestamp: 1400,
+    };
+
+    const captured: Array<{ type: string; data: unknown }> = [];
+    const flakyAppendEntry = (type: string, data?: unknown) => {
+      if (type === CUSTOM_TYPE_CHAIN) throw new Error("session write failed");
+      captured.push({ type, data });
+    };
+
+    // compressEligible does not catch chain-entry append failures itself
+    // (index.ts's caller wraps the whole call in try/catch); the throw
+    // propagates, but the index entry (with its refs) is already durable in
+    // `captured` by the time it does, per the append-before-commit ordering.
+    await expect(
+      compressEligible([chainB], 0, {
+        indexer,
+        blockRefs,
+        appendEntry: flakyAppendEntry,
+        now: () => 999,
+        messages,
+        diagnostics: noopDiagnostics,
+        backfill: testBackfill,
+      }),
+    ).rejects.toThrow("session write failed");
+
+    expect(captured.filter((c) => c.type === CUSTOM_TYPE_INDEX)).toHaveLength(1);
+    expect(captured.filter((c) => c.type === CUSTOM_TYPE_CHAIN)).toHaveLength(0);
+
+    // Rebuild a fresh indexer from exactly what got captured (simulating a restart).
+    const branch = captured.map(({ type, data }) => ({ type: "custom", customType: type, data }));
+    const rebuilt = new ToolCallIndexer();
+    rebuilt.reconstructFromSession({ sessionManager: { getBranch: () => branch } } as any);
+
+    // Re-run with an honest appendEntry: records are already indexed, so this
+    // composes-and-persists the chain entry without re-backfilling.
+    const captured2: Array<{ type: string; data: unknown }> = [];
+    const round2 = await compressEligible([chainB], 0, {
+      indexer: rebuilt,
+      blockRefs,
+      appendEntry: (type, data) => captured2.push({ type, data }),
+      now: () => 1000,
+      messages,
+      diagnostics: noopDiagnostics,
+      backfill: testBackfill,
+    });
+
+    expect(round2.compressedEntries).toHaveLength(1);
+    expect(captured2.filter((c) => c.type === CUSTOM_TYPE_INDEX)).toHaveLength(0);
+    expect(captured2.filter((c) => c.type === CUSTOM_TYPE_CHAIN)).toHaveLength(1);
+
+    // Refs are identical to round 1's - the index entry (with its refs) never
+    // got re-persisted, so round 2 reused the durable ref from round 1.
+    const round1IndexEntry = captured.find((c) => c.type === CUSTOM_TYPE_INDEX)!.data as any;
+    const round1Refs = round1IndexEntry.refs.map((r: { shortId: string }) => r.shortId);
+    expect(round2.compressedEntries[0].toolRefs).toEqual(round1Refs);
+  });
+
+  test("multi-chain compact: three uncovered chains compress in one compressEligible call", async () => {
+    const indexer = new ToolCallIndexer();
+    const blockRefs = new BlockRefIssuer();
+
+    const messages: any[] = [];
+    const chains: ChainRange[] = [];
+    for (let i = 0; i < 3; i++) {
+      const base = 1000 + i * 1000;
+      const startTs = base;
+      const callTs = base + 100;
+      const resultTs = base + 110;
+      const finalTs = base + 400;
+      const id = `tc${i}`;
+      messages.push(
+        { role: "user", content: [{ type: "text", text: `go ${i}` }], timestamp: startTs },
+        { role: "assistant", content: [{ type: "toolCall", id, name: "bash", arguments: { cmd: id } }], timestamp: callTs, usage: {}, stopReason: "tool_use" },
+        { role: "toolResult", toolCallId: id, toolName: "bash", content: [{ type: "text", text: `out ${i}` }], isError: false, timestamp: resultTs },
+        { role: "assistant", content: [{ type: "text", text: `done ${i}` }], timestamp: finalTs, usage: {}, stopReason: "end_turn" },
+      );
+      chains.push({
+        startUserTimestamp: startTs,
+        middleToolCallIds: [id],
+        middleOccurrenceKeys: [occKey(id, resultTs)],
+        finalAssistantTimestamp: finalTs,
+      });
+    }
+
+    const { compressedEntries } = await compressEligible(chains, 0, {
+      indexer,
+      blockRefs,
+      appendEntry: () => {},
+      now: () => 9999,
+      messages,
+      diagnostics: noopDiagnostics,
+      backfill: testBackfill,
+    });
+
+    expect(compressedEntries).toHaveLength(3);
+    expect(compressedEntries.every((e) => e.bodySource === "deterministic")).toBe(true);
+  });
+
+  test("fully-deduped chain: backfilled via index-membership filter (not isSummarized), compressed, pre-existing alias entries still resolve", async () => {
+    const indexer = new ToolCallIndexer();
+    const blockRefs = new BlockRefIssuer();
+
+    // Originals indexed in an earlier flush (as if summarized then).
+    indexer.addBatch(
+      {
+        turnIndex: 0,
+        timestamp: 10,
+        assistantText: "",
+        toolCalls: [
+          { toolCallId: "origA", toolName: "bash", args: {}, resultText: "SAME_A", isError: false, resultTimestamp: 20 },
+          { toolCallId: "origB", toolName: "bash", args: {}, resultText: "SAME_B", isError: false, resultTimestamp: 21 },
+        ],
+      },
+      () => {},
+    );
+    indexer.registerSummaryBody([occKey("origA", 20), occKey("origB", 21)], "summary of originals");
+    indexer.registerSummaryRefs([
+      { shortId: "t1", toolCallId: "origA", resultTimestamp: 20 },
+      { shortId: "t2", toolCallId: "origB", resultTimestamp: 21 },
+    ]);
+
+    // Pre-existing, unrelated duplicate of origA (registered before the chain
+    // under test even ran) - the control used below to prove the chain's own
+    // backfill does not disturb unrelated alias entries.
+    indexer.registerDuplicate(occKey("dup3", 30), occKey("origA", 20), () => {});
+
+    // The chain's own middle calls (tc1, tc2) were FULLY deduped by the
+    // pre-flush content-hash pass: both matched already-indexed originals,
+    // so neither was ever sent to the summarizer and neither has a direct
+    // index entry - only a dedup-alias entry pointing at origA/origB.
+    indexer.registerDuplicate(occKey("tc1", 110), occKey("origA", 20), () => {});
+    indexer.registerDuplicate(occKey("tc2", 120), occKey("origB", 21), () => {});
+
+    // isSummarized is true (dedup-alias hit) but the record is NOT in the
+    // index map directly - this is exactly the distinction the backfill
+    // filter (index membership) must honor instead of isSummarized().
+    expect(indexer.isSummarized(occKey("tc1", 110))).toBe(true);
+    expect(indexer.getIndex().has(occKey("tc1", 110))).toBe(false);
+    expect(indexer.isSummarized(occKey("tc2", 120))).toBe(true);
+    expect(indexer.getIndex().has(occKey("tc2", 120))).toBe(false);
+
+    const messages: any[] = [
+      { role: "user", content: [{ type: "text", text: "go" }], timestamp: 100 },
+      { role: "assistant", content: [{ type: "toolCall", id: "tc1", name: "bash", arguments: {} }], timestamp: 105, usage: {}, stopReason: "tool_use" },
+      { role: "toolResult", toolCallId: "tc1", toolName: "bash", content: [{ type: "text", text: "SAME_A" }], isError: false, timestamp: 110 },
+      { role: "assistant", content: [{ type: "toolCall", id: "tc2", name: "bash", arguments: {} }], timestamp: 115, usage: {}, stopReason: "tool_use" },
+      { role: "toolResult", toolCallId: "tc2", toolName: "bash", content: [{ type: "text", text: "SAME_B" }], isError: false, timestamp: 120 },
+      { role: "assistant", content: [{ type: "text", text: "done" }], timestamp: 200, usage: {}, stopReason: "end_turn" },
+    ];
+    const chain: ChainRange = {
+      startUserTimestamp: 100,
+      middleToolCallIds: ["tc1", "tc2"],
+      middleOccurrenceKeys: [occKey("tc1", 110), occKey("tc2", 120)],
+      finalAssistantTimestamp: 200,
+    };
+
+    // Zero coverage: no summary body was ever registered for tc1/tc2's own keys.
+    expect(indexer.hasPerBatchSummaryCoveringAny([occKey("tc1", 110), occKey("tc2", 120)])).toBe(false);
+
+    const { compressedEntries } = await compressEligible([chain], 0, {
+      indexer,
+      blockRefs,
+      appendEntry: () => {},
+      now: () => 1,
+      messages,
+      diagnostics: noopDiagnostics,
+      backfill: testBackfill,
+    });
+
+    expect(compressedEntries).toHaveLength(1);
+    expect(compressedEntries[0].bodySource).toBe("deterministic");
+
+    // tc1/tc2 are now directly backfilled (index-membership filter let them through).
+    expect(indexer.getRecord(occKey("tc1", 110))?.resultText).toBe("SAME_A");
+    expect(indexer.getRecord(occKey("tc2", 120))?.resultText).toBe("SAME_B");
+
+    // Pre-existing, unrelated alias entry (dup3 -> origA) still resolves unchanged.
+    expect(indexer.resolveToolCallId(occKey("dup3", 30))).toBe(occKey("origA", 20));
+    expect(indexer.getRecord(occKey("dup3", 30))?.resultText).toBe("SAME_A");
+
+    // Backfilled records never seed contentHashToOriginal - the canonical for
+    // "SAME_A"/"SAME_B" content stays origA/origB, unpoisoned by tc1/tc2.
+    expect(indexer.lookupByContent("bash", "SAME_A")).toBe(occKey("origA", 20));
+    expect(indexer.lookupByContent("bash", "SAME_B")).toBe(occKey("origB", 21));
+  });
+
+  test("protected member in an uncovered chain: excluded from backfill index+refs, relocated verbatim at render, unprotected middle dropped", async () => {
+    const indexer = new ToolCallIndexer();
+    const blockRefs = new BlockRefIssuer();
+
+    const messages: any[] = [
+      { role: "user", content: [{ type: "text", text: "go" }], timestamp: 1000 },
+      { role: "assistant", content: [{ type: "toolCall", id: "tcB1", name: "bash", arguments: { cmd: "one" } }], timestamp: 1100, usage: {}, stopReason: "tool_use" },
+      { role: "toolResult", toolCallId: "tcB1", toolName: "bash", content: [{ type: "text", text: "outB1" }], isError: false, timestamp: 1110 },
+      { role: "assistant", content: [{ type: "toolCall", id: "tcB2", name: "todowrite", arguments: {} }], timestamp: 1200, usage: {}, stopReason: "tool_use" },
+      { role: "toolResult", toolCallId: "tcB2", toolName: "todowrite", content: [{ type: "text", text: "PLAN-STATE-XYZ" }], isError: false, timestamp: 1210 },
+      { role: "assistant", content: [{ type: "text", text: "done" }], timestamp: 1400, usage: {}, stopReason: "end_turn" },
+    ];
+    const chainB: ChainRange = {
+      startUserTimestamp: 1000,
+      middleToolCallIds: ["tcB1", "tcB2"],
+      middleOccurrenceKeys: [occKey("tcB1", 1110), occKey("tcB2", 1210)],
+      finalAssistantTimestamp: 1400,
+      protectedToolCallIds: ["tcB2"],
+    };
+
+    const { compressedEntries } = await compressEligible([chainB], 0, {
+      indexer,
+      blockRefs,
+      appendEntry: () => {},
+      now: () => 999,
+      messages,
+      diagnostics: noopDiagnostics,
+      backfill: testBackfill,
+    });
+
+    expect(compressedEntries).toHaveLength(1);
+    const entry = compressedEntries[0];
+    expect(entry.bodySource).toBe("deterministic");
+
+    // (a) protected id absent from the backfilled index entry's records and from toolRefs.
+    expect(indexer.getRecord(occKey("tcB2", 1210))).toBeUndefined();
+    expect(indexer.getRecord(occKey("tcB1", 1110))).toBeDefined();
+    expect(entry.toolRefs).toHaveLength(1);
+    expect(entry.toolRefs.map((r) => indexer.resolveToolCallId(r))).not.toContain(occKey("tcB2", 1210));
+
+    // (b) + (c) render: protected relocated verbatim inside the compressed-chain block; unprotected middle dropped.
+    const cc: ChainCompressionConfig = { enabled: true, rollingWindow: 0, stripFinalAssistantThinking: true, fuseRangeSummary: false };
+    const { messages: out } = pruneMessages(messages, indexer, cc);
+    const synthetic = out.find(
+      (m: any) => m.role === "user" && typeof m.content?.[0]?.text === "string" && m.content[0].text.startsWith("<compressed-chain"),
+    );
+    expect(synthetic).toBeDefined();
+    expect(synthetic.content[0].text).toContain('<protected-output tool="todowrite">');
+    expect(synthetic.content[0].text).toContain("PLAN-STATE-XYZ");
+    expect(out.filter((m: any) => m.role === "toolResult")).toHaveLength(0);
+    expectNoOrphanToolResults(out);
+  });
 });

package/src/spill.ts

@@ -36,6 +36,24 @@ interface SpillConfig {
   dedupByContentHash: boolean;
 }
 
+interface SpillableRecord {
+  toolName: string;
+  resultText: string;
+  spillBytes?: number;
+  resultPreview?: string;
+  spillPath?: string;
+  contentHash?: string;
+}
+
+/** Mutates `record` in place: spillBytes/resultPreview/spillPath/contentHash set, resultText emptied. */
+export function applySpill(record: SpillableRecord, spillPath: string, previewBytes: number): void {
+  record.spillBytes = Buffer.byteLength(record.resultText, "utf8");
+  record.resultPreview = headPreview(record.resultText, previewBytes);
+  record.spillPath = spillPath;
+  record.contentHash = hashToolResult(record.toolName, record.resultText);
+  record.resultText = "";
+}
+
 export async function spillOversizedBatch(args: {
   batch: CapturedBatch;
   indexer: ToolCallIndexer;
@@ -52,7 +70,6 @@ export async function spillOversizedBatch(args: {
     if (tc.resultText.length < config.spillThreshold) continue;
 
     const key = occKey(tc.toolCallId, tc.resultTimestamp);
-    const hash = hashToolResult(tc.toolName, tc.resultText);
 
     if (config.dedupByContentHash) {
       const original = indexer.lookupByContent(tc.toolName, tc.resultText);
@@ -72,11 +89,7 @@ export async function spillOversizedBatch(args: {
       continue;
     }
 
-    tc.spillBytes = Buffer.byteLength(tc.resultText, "utf8");
-    tc.resultPreview = headPreview(tc.resultText, config.spillPreviewBytes);
-    tc.spillPath = path;
-    tc.contentHash = hash;
-    tc.resultText = "";
+    applySpill(tc, path, config.spillPreviewBytes);
     toIndex.push(tc);
     handled.add(tc.toolCallId);
   }

package/src/types.ts

@@ -94,7 +94,7 @@ export const CUSTOM_TYPE_DIAGNOSTIC = "context-prune-diagnostic";
  */
 export const CUSTOM_TYPE_FLUSH_METRICS = "context-prune-flush-metrics";
 
-export type DiagnosticKind = "unresolved-range" | "range-id-mismatch" | "orphan-sweep";
+export type DiagnosticKind = "unresolved-range" | "range-id-mismatch" | "orphan-sweep" | "backfill-empty";
 
 export interface DiagnosticEntryData {
   kind: DiagnosticKind;
@@ -505,6 +505,12 @@ export interface ChainCompressionEntry {
    * Absent on fusion failure / single-batch spans → renderer falls back to concat.
    */
   rangeSummaryText?: string;
+  /**
+   * "deterministic" = zero-LLM synthetic body built by the uncovered-chain
+   * backfill path (rangeSummaryText holds the stub). Absent = LLM-fused or
+   * per-batch semantics, unchanged.
+   */
+  bodySource?: "deterministic";
 }
 
 export interface ChainCompressionConfig {
@@ -640,6 +646,10 @@ export interface ToolCallRecord {
  */
 export interface IndexEntryData {
   toolCalls: ToolCallRecord[];
+  /** Entry written by backfillChainRecords: records must NOT seed contentHashToOriginal. */
+  backfilled?: true;
+  /** Refs allocated at backfill time; durable carrier for alias reconstruction. */
+  refs?: SummaryToolCallRef[];
 }
 
 /**