pi-condense 2.5.0 → 2.6.0

package/src/summary-refs.test.ts

@@ -1,5 +1,11 @@
 import { describe, expect, test } from "bun:test";
-import { substituteInlineRefs, formatSummaryToolCallRefs, type SummaryToolCallRef } from "./summary-refs.js";
+import {
+  substituteInlineRefs,
+  formatSummaryToolCallRefs,
+  buildShortToolCallRefs,
+  normalizeSummaryToolCallRefs,
+  type SummaryToolCallRef,
+} from "./summary-refs.js";
 
 describe("substituteInlineRefs", () => {
   const refs: SummaryToolCallRef[] = [
@@ -120,3 +126,47 @@ describe("substituteInlineRefs", () => {
     }
   });
 });
+
+describe("occurrence-aware summary refs", () => {
+  test("buildShortToolCallRefs carries resultTimestamp through", () => {
+    const { refs, nextIndex } = buildShortToolCallRefs(
+      [
+        { toolCallId: "bash_23", resultTimestamp: 2150 },
+        { toolCallId: "bash_23", resultTimestamp: 3150 },
+      ],
+      5,
+    );
+    expect(refs).toEqual([
+      { shortId: "t5", toolCallId: "bash_23", resultTimestamp: 2150 },
+      { shortId: "t6", toolCallId: "bash_23", resultTimestamp: 3150 },
+    ]);
+    expect(nextIndex).toBe(7);
+  });
+
+  test("buildShortToolCallRefs omits resultTimestamp when absent", () => {
+    const { refs } = buildShortToolCallRefs([{ toolCallId: "bash_1" }], 1);
+    expect(refs).toEqual([{ shortId: "t1", toolCallId: "bash_1" }]);
+    expect("resultTimestamp" in refs[0]).toBe(false);
+  });
+
+  test("normalizeSummaryToolCallRefs preserves a numeric resultTimestamp", () => {
+    const refs = normalizeSummaryToolCallRefs({
+      toolCallRefs: [{ shortId: "t1", toolCallId: "bash_1", resultTimestamp: 1150 }],
+    });
+    expect(refs).toEqual([{ shortId: "t1", toolCallId: "bash_1", resultTimestamp: 1150 }]);
+  });
+
+  test("normalizeSummaryToolCallRefs drops a non-numeric resultTimestamp", () => {
+    const refs = normalizeSummaryToolCallRefs({
+      toolCallRefs: [{ shortId: "t1", toolCallId: "bash_1", resultTimestamp: "nope" }],
+    });
+    expect(refs).toEqual([{ shortId: "t1", toolCallId: "bash_1" }]);
+    expect("resultTimestamp" in refs[0]).toBe(false);
+  });
+
+  test("legacy toolCallIds-only details still normalize", () => {
+    expect(normalizeSummaryToolCallRefs({ toolCallIds: ["bash_1"] })).toEqual([
+      { shortId: "bash_1", toolCallId: "bash_1" },
+    ]);
+  });
+});

package/src/summary-refs.ts

@@ -1,8 +1,11 @@
 import type { CapturedBatch } from "./types.js";
+import { resultTimestampOf } from "./occurrence-key.js";
 
 export interface SummaryToolCallRef {
   shortId: string;
   toolCallId: string;
+  /** ToolResultMessage timestamp; combines with toolCallId into the occurrence key. */
+  resultTimestamp?: number;
 }
 
 export interface SummaryMessageDetailsLike {
@@ -13,12 +16,13 @@ export interface SummaryMessageDetailsLike {
 const SHORT_ID_PREFIX = "t";
 
 export function buildShortToolCallRefs(
-  toolCallIds: string[],
+  calls: { toolCallId: string; resultTimestamp?: number }[],
   startIndex: number,
 ): { refs: SummaryToolCallRef[]; nextIndex: number } {
-  const refs = toolCallIds.map((toolCallId, offset) => ({
+  const refs = calls.map((call, offset) => ({
     shortId: `${SHORT_ID_PREFIX}${startIndex + offset}`,
-    toolCallId,
+    toolCallId: call.toolCallId,
+    ...(call.resultTimestamp !== undefined ? { resultTimestamp: call.resultTimestamp } : {}),
   }));
   return { refs, nextIndex: startIndex + refs.length };
 }
@@ -33,7 +37,14 @@ export function normalizeSummaryToolCallRefs(details: unknown): SummaryToolCallR
         (ref): ref is SummaryToolCallRef =>
           !!ref && typeof ref.shortId === "string" && typeof ref.toolCallId === "string",
       )
-      .map((ref) => ({ shortId: ref.shortId, toolCallId: ref.toolCallId }));
+      .map((ref) => {
+        const resultTimestamp = resultTimestampOf((ref as any).resultTimestamp);
+        return {
+          shortId: ref.shortId,
+          toolCallId: ref.toolCallId,
+          ...(resultTimestamp !== undefined ? { resultTimestamp } : {}),
+        };
+      });
   }
 
   if (Array.isArray(raw.toolCallIds)) {

package/src/test-support.ts

@@ -0,0 +1,54 @@
+import { expect } from "bun:test";
+import { sweepOrphanToolResults } from "./orphan-sweep.js";
+import { pruneMessages } from "./pruner.js";
+import { DiagnosticSink } from "./diagnostics.js";
+
+/** Shared by chain-range-prune.test.ts and id-collision.integration.test.ts. */
+export function expectNoOrphanToolResults(messages: any[]): void {
+  let open = new Set<string>();
+  for (const m of messages) {
+    if (m.role === "assistant") {
+      open = new Set((m.content ?? []).filter((c: any) => c.type === "toolCall").map((c: any) => c.id));
+    } else if (m.role === "toolResult") {
+      expect(open.has(m.toolCallId)).toBe(true);
+      open.delete(m.toolCallId);
+    }
+  }
+}
+
+/**
+ * G4/C3: proof that the orphan sweep (src/pruner.ts Phase 4) is a net, not a
+ * crutch. Runs the real `sweepOrphanToolResults` (the exact function backing
+ * Phase 4's diagnostic) over an already-pruned message array and fails if it
+ * finds anything to sweep. Equivalent to asserting the Phase 4 diagnostic
+ * never fires for this output: `sweepOrphanToolResults` returns the input
+ * array reference and an empty `sweptIds` when nothing is orphaned, which is
+ * precisely the condition under which `pruneMessages` skips the
+ * `diagnostics?.report("orphan-sweep", ...)` call.
+ */
+export function expectZeroOrphanSweep(messages: any[]): void {
+  const { messages: swept, sweptIds } = sweepOrphanToolResults(messages);
+  expect(sweptIds).toEqual([]);
+  expect(swept).toBe(messages);
+}
+
+/**
+ * G4/C3: wraps a `pruneMessages` call with a counting `DiagnosticSink` and
+ * fails if the `orphan-sweep` diagnostic fires. For fixtures that already go
+ * through the full pruner pipeline (pruner.test.ts), this is the more direct
+ * proof than `expectZeroOrphanSweep` since it exercises the actual Phase 4
+ * call site, not just the underlying pure function.
+ */
+export function pruneWithZeroSweepAssertion(
+  messages: any[],
+  indexer: any,
+  chainCompression?: any,
+  errorPurge?: any,
+  protection?: any,
+  recoveryGraceTurns: number = 0,
+): ReturnType<typeof pruneMessages> {
+  const sink = new DiagnosticSink(() => {});
+  const result = pruneMessages(messages, indexer, chainCompression, errorPurge, protection, recoveryGraceTurns, sink);
+  expect(sink.counts()["orphan-sweep"]).toBe(0);
+  return result;
+}

package/src/tree-browser.ts

@@ -7,6 +7,7 @@ import type { ToolCallRecord } from "./types.js";
 import { CUSTOM_TYPE_SUMMARY } from "./types.js";
 import { normalizeSummaryToolCallRefs } from "./summary-refs.js";
 import type { ToolCallIndexer } from "./indexer.js";
+import { occKey } from "./occurrence-key.js";
 
 // ── Tree node types ─────────────────────────────────────────────────────────
 
@@ -119,7 +120,7 @@ export function buildPruneTree(
 
     const children: TreeNode[] = [];
     for (const ref of toolCallRefs) {
-      const record = indexer.getRecord(ref.toolCallId);
+      const record = indexer.getRecord(occKey(ref.toolCallId, ref.resultTimestamp));
       if (!record) continue;
       children.push(toolCallNode(record, 1));
     }

package/src/types.ts

@@ -10,7 +10,7 @@
  *   event.toolResults = ToolResultMessage[] (one per tool call in this turn)
  *
  * STATE MODEL (Ph1 step 3):
- *   - Runtime state: Map<toolCallId, ToolCallRecord> rebuilt on session_start
+ *   - Runtime state: Map<occurrenceKey, ToolCallRecord> rebuilt on session_start
  *   - Session metadata: pi.appendEntry("context-prune-index", IndexEntryData)
  *     stored once per summarized batch; NOT in LLM context
  *   - User config: .pi/settings.json → "contextPrune" key (JSON merge safe,
@@ -78,6 +78,22 @@ export const CUSTOM_TYPE_DEDUP_ALIAS = "context-prune-dedup-alias";
  */
 export const CUSTOM_TYPE_CHAIN = "context-prune-chain";
 
+/**
+ * Written via pi.appendEntry(CUSTOM_TYPE_DIAGNOSTIC, data) when a prune-time
+ * invariant degrades. NOT in LLM context: zero tokens, zero cache-prefix
+ * change. Deduplication is a runtime concern of the diagnostic sink
+ * (src/diagnostics.ts), which takes a caller-supplied dedup key and never
+ * persists it - the persisted entry carries only `kind` plus a freeform `detail`.
+ */
+export const CUSTOM_TYPE_DIAGNOSTIC = "context-prune-diagnostic";
+
+export type DiagnosticKind = "unresolved-range" | "range-id-mismatch" | "orphan-sweep";
+
+export interface DiagnosticEntryData {
+  kind: DiagnosticKind;
+  detail: string;
+}
+
 /** The registered name of the recovery tool (src/query-tool.ts). Shared so the
  * grace checks in pruner.ts / chain-compressor.ts cannot drift from registration. */
 export const QUERY_TOOL_NAME = "context_tree_query";
@@ -397,13 +413,22 @@ export interface ChainRange {
   /** Timestamp of the user message that opens the chain. */
   startUserTimestamp: number;
   /**
-   * All toolCallIds in the chain's middle (deduplicated).
-   * Collected from both AssistantMessage ToolCall blocks AND matching
-   * ToolResultMessages. Used to: (1) drop ToolResultMessages, (2) identify
-   * and drop middle AssistantMessages, (3) suppress per-batch summary
-   * CustomMessages whose toolCallRefs overlap.
+   * All toolCallIds in the chain's middle (deduplicated). Collected from both
+   * AssistantMessage ToolCall blocks AND matching ToolResultMessages.
+   * Identifies the chain's middle tool calls for detection, recovery-grace
+   * filtering and diagnostics. NOT used for the load-bearing indexer lookups
+   * (summary bodies, tool refs) - those maps are occurrence-keyed, so use
+   * the sibling `middleOccurrenceKeys` instead. Drops themselves are decided
+   * positionally by `resolveRange` in chain-range-prune.ts, not by these ids.
    */
   middleToolCallIds: string[];
+  /**
+   * Occurrence keys (`id@resultTimestamp`) for the chain's middle tool
+   * results, collected from the ToolResultMessages themselves. Used for
+   * indexer summary-body / toolRef lookups, which are occurrence-keyed.
+   * Optional so hand-built ChainRange fixtures need not set it.
+   */
+  middleOccurrenceKeys?: string[];
   /**
    * Subset of middleToolCallIds whose tool name ∈ protectedTools (detection-time
    * fact). The detector always emits it ([] when no protected tool ran); optional
@@ -425,12 +450,19 @@ export interface ChainCompressionEntry {
   /** Timestamp of the user message that opens the chain. Keep raw; synthetic inserted after. */
   startUserTimestamp: number;
   /**
-   * ToolCallIds of all dropped middle messages.
-   * Used at context-transform time to: drop matching ToolResultMessages,
-   * drop AssistantMessages that contain any of these as ToolCall blocks,
-   * and suppress per-batch summary messages whose toolCallRefs overlap.
+   * All toolCallIds in the chain's middle. **Diagnostic only** since the
+   * positional-range change: drops are decided by index range (see
+   * resolveRange in chain-range-prune.ts). Retained as a cross-check - a
+   * mismatch against the ids actually dropped emits `range-id-mismatch`.
    */
   droppedToolCallIds: string[];
+  /**
+   * Occurrence keys for the same calls as droppedToolCallIds. Load-bearing at
+   * render time: summaryBodies are occurrence-keyed, so the synthetic chain
+   * body is looked up by these. Absent on pre-upgrade entries, which fall back
+   * to droppedToolCallIds against their own bare-keyed summaryBodies.
+   */
+  droppedOccurrenceKeys?: string[];
   /**
    * Subset of droppedToolCallIds whose tool was user-protected. Membership is decided
    * per call by tool name (every call whose name ∈ protectedTools), not a per-id allowlist.
@@ -523,6 +555,13 @@ export interface CapturedToolCall {
   args: Record<string, unknown>;
   resultText: string;
   isError: boolean;
+  /**
+   * Timestamp of the ToolResultMessage this call was paired with. The
+   * occurrence discriminant (see src/occurrence-key.ts): provider ids repeat
+   * within a session, this does not. Optional so pre-upgrade persisted
+   * entries stay readable; absent => the record is legacy bare-id keyed.
+   */
+  resultTimestamp?: number;
   spillPath?: string;
   spillBytes?: number;
   resultPreview?: string;
@@ -565,6 +604,8 @@ export interface ToolCallRecord {
   isError: boolean;
   turnIndex: number;
   timestamp: number;
+  /** See CapturedToolCall.resultTimestamp. */
+  resultTimestamp?: number;
   /** Absolute path to the sidecar blob holding the full body (set only when the result was spilled). */
   spillPath?: string;
   /** Full byte length of the spilled body. */
@@ -603,6 +644,9 @@ export interface IndexEntryData {
 export interface DedupAliasEntryData {
   newToolCallId: string;
   originalToolCallId: string;
+  /** Occurrence timestamps for each side; absent on pre-upgrade entries. */
+  newResultTimestamp?: number;
+  originalResultTimestamp?: number;
   hash?: string;
 }
 
@@ -613,6 +657,8 @@ export interface DedupAliasEntryData {
 export interface SummaryToolCallRef {
   shortId: string;
   toolCallId: string;
+  /** ToolResultMessage timestamp; with toolCallId this forms the occurrence key. */
+  resultTimestamp?: number;
 }
 
 /**