pi-condense 2.4.3 → 2.6.0

package/src/pruner.ts

@@ -1,23 +1,26 @@
+import { createHash } from "node:crypto";
 import type { ToolCallIndexer } from "./indexer.js";
-import type { ChainCompressionConfig, ErrorPurgeConfig, ThinkingStripConfig } from "./types.js";
+import type { ChainCompressionConfig, ErrorPurgeConfig } from "./types.js";
 import { isProtected, type ProtectionConfig } from "./protected.js";
 import { applyChainCompressions } from "./chain-range-prune.js";
 import { purgeErroredArgs } from "./error-purge.js";
-import { stripOldThinking } from "./thinking-strip.js";
 import { inGraceRecoveryToolCallIds } from "./recovery-grace.js";
+import { occKey } from "./occurrence-key.js";
+import { sweepOrphanToolResults } from "./orphan-sweep.js";
+import type { DiagnosticSink } from "./diagnostics.js";
 
 /**
  * Estimate of a message array's context weight. Serializing the whole array
  * (not just visible text) is deliberate: it counts tool-call argument bodies
- * (error-purge), thinking blocks (thinking-strip), and tool-result arrays
- * (stub-replace / chain-range) so all reclaim mechanisms register.
+ * (error-purge) and tool-result arrays (stub-replace / chain-range) so all
+ * reclaim mechanisms register.
  */
 export function sizeMessages(messages: any[]): number {
   return JSON.stringify(messages).length;
 }
 
 /**
- * Transforms the `context` event message array in two passes:
+ * Transforms the `context` event message array in four phases:
  *
  * Phase 1 — stub-replace: ToolResultMessages for summarized tool calls are
  * replaced with short stubs pointing the model at `context_tree_query`.
@@ -43,11 +46,11 @@ export function sizeMessages(messages: any[]): number {
  * synthetic user message wrapping the existing per-batch summary text.
  * Only runs when `chainCompression.enabled` and chain entries exist.
  *
- * Phase 4 — thinking strip: keep `thinking` blocks only on the last
- * `keepLastTurns` assistant turns; strip them from older assistant messages
- * (preserving text + toolCall). Runs last so the window counts the assistant
- * turns that actually survive to the LLM. Only runs when
- * `thinkingStrip.enabled`.
+ * Phase 4 — orphan sweep: structural post-condition run unconditionally over
+ * the final array. Removes any toolResult whose matching toolCall id was not
+ * opened by the immediately preceding assistant turn (per-turn open set, not
+ * cumulative — see src/orphan-sweep.ts). Reference-preserving when nothing is
+ * swept, so a clean render still returns the identical input array.
  *
  * Return shape:
  *   - `pruned: true`  — at least one change happened; the returned
@@ -71,50 +74,63 @@ export function pruneMessages(
   indexer: ToolCallIndexer,
   chainCompression?: ChainCompressionConfig,
   errorPurge?: ErrorPurgeConfig,
-  thinkingStrip?: ThinkingStripConfig,
   protection?: ProtectionConfig,
   recoveryGraceTurns: number = 0,
-  thinkingBoundaryTimestamp?: number,
+  diagnostics?: DiagnosticSink,
 ): { messages: any[]; pruned: boolean; beforeChars: number; afterChars: number } {
   // Phase 1: stub-replace summarized tool results
   let pruned = false;
   const inGrace = inGraceRecoveryToolCallIds(messages, recoveryGraceTurns);
   const next = messages.map((msg) => {
-    if (msg.role === "toolResult" && indexer.isSummarized(msg.toolCallId)) {
-      const record = indexer.getRecord(msg.toolCallId);
-      // Render-time re-check: a record summarized before protectedPaths
-      // covered it is repaired here — the raw toolResult still lives in the
-      // session JSONL, so skipping the stub restores it verbatim.
-      // Dedup aliases resolve to the original record, so an alias whose own
-      // path is protected but whose original isn't stays stubbed (edge case).
-      if (protection && record && isProtected(record.toolName, record.args, protection)) {
-        return msg;
-      }
-      if (inGrace.has(msg.toolCallId)) {
-        return msg;
-      }
-      pruned = true;
-      const ref = indexer.getShortRefForToolCallId(msg.toolCallId) ?? msg.toolCallId;
-      const text = record?.spillPath
-        ? [
-            `[Oversized output spilled to file — ${record.spillBytes ?? "?"} bytes.]`,
-            `Tool: ${record.toolName}`,
-            `Preview (head):`,
-            record.resultPreview ?? "",
-            `Full output — read this file (offset/limit supported): ${record.spillPath}`,
-            `Or use context_tree_query with ref \`${ref}\`.`,
-          ].join("\n")
-        : `[Summarized in pruner summary, ref \`${ref}\`. Use context_tree_query to retrieve full output.]`;
-      return {
-        role: "toolResult",
-        toolCallId: msg.toolCallId,
-        toolName: msg.toolName,
-        content: [{ type: "text", text }],
-        isError: false,
-        timestamp: msg.timestamp,
-      };
+    if (msg.role !== "toolResult") return msg;
+
+    // Fail-closed: when the message carries a timestamp, the occurrence key
+    // is tried first. The bare id is consulted only as a fallback, and only
+    // when `hasLegacyBareRecord` confirms it is LEGACY-ONLY (no occurrence
+    // siblings) - a mixed bare+occurrence id fails closed there too, since a
+    // live result under a reused id is not the legacy one. A permissive
+    // bare-id fallback would stub a live result because an older occurrence
+    // (or the legacy record) of the same provider id was summarized.
+    const key = typeof msg.timestamp === "number" ? occKey(msg.toolCallId, msg.timestamp) : msg.toolCallId;
+    const lookupKey = indexer.isSummarized(key)
+      ? key
+      : indexer.hasLegacyBareRecord(msg.toolCallId)
+        ? msg.toolCallId
+        : undefined;
+    if (lookupKey === undefined) return msg;
+
+    const record = indexer.getRecord(lookupKey);
+    // Render-time re-check: a record summarized before protectedPaths
+    // covered it is repaired here — the raw toolResult still lives in the
+    // session JSONL, so skipping the stub restores it verbatim.
+    // Dedup aliases resolve to the original record, so an alias whose own
+    // path is protected but whose original isn't stays stubbed (edge case).
+    if (protection && record && isProtected(record.toolName, record.args, protection)) {
+      return msg;
+    }
+    if (inGrace.has(key)) {
+      return msg;
     }
-    return msg;
+    pruned = true;
+    const ref = indexer.getShortRefForToolCallId(lookupKey) ?? msg.toolCallId;
+    const text = record?.spillPath
+      ? [
+          `[Oversized output spilled to file — ${record.spillBytes ?? "?"} bytes.]`,
+          `Tool: ${record.toolName}`,
+          `Preview (head):`,
+          record.resultPreview ?? "",
+          `Full output — read this file (offset/limit supported): ${record.spillPath}`,
+          `Or use context_tree_query with ref \`${ref}\`.`,
+        ].join("\n")
+      : `[Summarized in pruner summary, ref \`${ref}\`. Use context_tree_query to retrieve full output.]`;
+    return {
+      role: "toolResult",
+      toolCallId: msg.toolCallId,
+      toolName: msg.toolName,
+      content: [{ type: "text", text }],
+      isError: false,
+      timestamp: msg.timestamp,
+    };
   });
 
   let current: any[] = pruned ? next : messages;
@@ -135,7 +151,8 @@ export function pruneMessages(
       // Prefer the cohesive LLM range summary (B) when present; fall back to the
       // per-batch concatenation for spans compressed before fusion / on failure.
       const chainSummaryText = (entry: typeof chainEntries[number]): string =>
-        entry.rangeSummaryText ?? indexer.getPerBatchSummaryTextForToolCallIds(entry.droppedToolCallIds);
+        entry.rangeSummaryText ??
+        indexer.getPerBatchSummaryTextForToolCallIds(entry.droppedOccurrenceKeys ?? entry.droppedToolCallIds);
       const blockSummaryLookup = (blockId: string): string | undefined => {
         const entry = indexer.findChainEntryByBlockId(blockId);
         if (!entry) return undefined;
@@ -147,6 +164,7 @@ export function pruneMessages(
         chainSummaryText,
         chainCompression.stripFinalAssistantThinking,
         blockSummaryLookup,
+        diagnostics,
       );
       if (compressed !== current) {
         current = compressed;
@@ -155,13 +173,25 @@ export function pruneMessages(
     }
   }
 
-  // Phase 4: thinking strip — keep thinking only on the last K assistant turns
-  if (thinkingStrip?.enabled) {
-    const afterStrip = stripOldThinking(current, thinkingStrip, thinkingBoundaryTimestamp);
-    if (afterStrip !== current) {
-      current = afterStrip;
-      pruned = true;
-    }
+  // Phase 4: orphan sweep — structural post-condition. Reference-preserving
+  // when clean, so a no-op render leaves the prompt-cache prefix untouched.
+  const swept = sweepOrphanToolResults(current);
+  if (swept.messages !== current) {
+    current = swept.messages;
+    pruned = true;
+    const sortedIds = [...swept.sweptIds].sort();
+    // Hash the id list into a short, stable dedup key instead of the raw
+    // sorted join: a growing orphan set would otherwise write ever-longer
+    // keys ("a", "a,b", "a,b,c", ...), and DiagnosticSink.seen retains every
+    // prefix forever - O(n^2) characters over a session's lifetime.
+    const dedupKey = createHash("sha1").update(sortedIds.join(",")).digest("hex").slice(0, 16);
+    const shown = sortedIds.slice(0, 5);
+    const more = sortedIds.length > shown.length ? ` ... +${sortedIds.length - shown.length} more` : "";
+    diagnostics?.report(
+      "orphan-sweep",
+      dedupKey,
+      `swept ${swept.sweptIds.length} orphan toolResult(s): ${shown.join(", ")}${more}`,
+    );
   }
 
   return pruned

package/src/query-tool.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, test } from "bun:test";
+import { registerQueryTool } from "./query-tool.js";
+import { ToolCallIndexer } from "./indexer.js";
+import type { CapturedBatch } from "./types.js";
+
+const capture = (idx: ToolCallIndexer, id: string, ts: number, text: string, turnIndex: number) => {
+  const batch: CapturedBatch = {
+    turnIndex,
+    timestamp: ts - 50,
+    assistantText: "",
+    toolCalls: [{ toolCallId: id, toolName: "bash", args: { cmd: "ls" }, resultText: text, isError: false, resultTimestamp: ts }],
+  };
+  idx.addBatch(batch, () => {});
+};
+
+const captureLegacy = (idx: ToolCallIndexer, id: string, timestamp: number, text: string, turnIndex: number) => {
+  const batch: CapturedBatch = {
+    turnIndex,
+    timestamp,
+    assistantText: "",
+    toolCalls: [{ toolCallId: id, toolName: "bash", args: { cmd: "ls" }, resultText: text, isError: false }],
+  };
+  idx.addBatch(batch, () => {});
+};
+
+// execute returns { content: [{ type: "text", text }], details } (src/query-tool.ts:73-76)
+const runTool = async (indexer: ToolCallIndexer, toolCallIds: string[]): Promise<string> => {
+  let registered: any;
+  registerQueryTool({ registerTool: (def: any) => (registered = def) } as any, indexer);
+  const result = await registered.execute("call-1", { toolCallIds }, undefined, undefined, undefined);
+  return result.content[0].text as string;
+};
+
+describe("context_tree_query occurrence handling", () => {
+  test("a bare id with two occurrences returns both blocks, chronologically", async () => {
+    const idx = new ToolCallIndexer();
+    capture(idx, "bash_23", 2150, "SECOND", 1);
+    capture(idx, "bash_23", 1150, "FIRST", 0);
+    const text = await runTool(idx, ["bash_23"]);
+    expect(text.indexOf("FIRST")).toBeGreaterThan(-1);
+    expect(text.indexOf("SECOND")).toBeGreaterThan(-1);
+    expect(text.indexOf("FIRST")).toBeLessThan(text.indexOf("SECOND"));
+    expect(text.match(/## toolRef:/g)).toHaveLength(2);
+  });
+
+  test("an occurrence key returns exactly one block", async () => {
+    const idx = new ToolCallIndexer();
+    capture(idx, "bash_23", 1150, "FIRST", 0);
+    capture(idx, "bash_23", 2150, "SECOND", 1);
+    const text = await runTool(idx, ["bash_23@2150"]);
+    expect(text.match(/## toolRef:/g)).toHaveLength(1);
+    expect(text).toContain("SECOND");
+  });
+
+  test("an unknown id still reports not-found once", async () => {
+    const idx = new ToolCallIndexer();
+    const text = await runTool(idx, ["nope"]);
+    expect(text).toContain("not found in index");
+  });
+
+  test("a single match still labels with the caller's input and has no @ suffix", async () => {
+    const idx = new ToolCallIndexer();
+    capture(idx, "bash_23", 1150, "FIRST", 0);
+    const text = await runTool(idx, ["bash_23"]);
+    expect(text.match(/## toolRef:/g)).toHaveLength(1);
+    expect(text).toContain("## toolRef: bash_23\n");
+    expect(text).not.toContain("bash_23@");
+  });
+
+  test("G5 conformance: a bare id whose collision was content-deduplicated still returns both occurrences via context_tree_query", async () => {
+    const idx = new ToolCallIndexer();
+    capture(idx, "bash_23", 1150, "SAME", 0);
+    // Same bare id, later occurrence, content-deduplicated against the original.
+    idx.registerDuplicate("bash_23@9150", "bash_23@1150", () => {});
+
+    const records = idx.getRecordsForId("bash_23");
+    expect(records).toHaveLength(2);
+
+    const text = await runTool(idx, ["bash_23"]);
+    expect(text.match(/## toolRef:/g)).toHaveLength(2);
+    expect(text).toContain("bash_23@1150");
+    expect(text).toContain("bash_23@9150");
+  });
+
+  test("G4/C1: colliding short refs each resolve to their OWN batch through the registered tool", async () => {
+    const idx = new ToolCallIndexer();
+    capture(idx, "bash_23", 1150, "FIRST", 0);
+    capture(idx, "bash_23", 2150, "SECOND", 1);
+    idx.registerSummaryRefs([
+      { shortId: "t1", toolCallId: "bash_23", resultTimestamp: 1150 },
+      { shortId: "t2", toolCallId: "bash_23", resultTimestamp: 2150 },
+    ]);
+
+    const firstText = await runTool(idx, ["t1"]);
+    expect(firstText.match(/## toolRef:/g)).toHaveLength(1);
+    expect(firstText).toContain("FIRST");
+    expect(firstText).not.toContain("SECOND");
+
+    const secondText = await runTool(idx, ["t2"]);
+    expect(secondText.match(/## toolRef:/g)).toHaveLength(1);
+    expect(secondText).toContain("SECOND");
+    expect(secondText).not.toContain("FIRST");
+  });
+
+  test("mixed legacy + new occurrence under the same bare id: legacy record labels with the bare id plus an explicit note, not a fake @legacy key", async () => {
+    const idx = new ToolCallIndexer();
+    captureLegacy(idx, "bash_23", 1000, "OLD", 0);
+    capture(idx, "bash_23", 2150, "NEW", 1);
+    const text = await runTool(idx, ["bash_23"]);
+    expect(text.match(/## toolRef:/g)).toHaveLength(2);
+    expect(text).toContain("## toolRef: bash_23\n");
+    expect(text).toContain("Occurrence: legacy (no resultTimestamp)");
+    expect(text).toContain("bash_23@2150");
+    expect(text).not.toContain("undefined");
+    expect(text).not.toContain("@legacy");
+  });
+});

package/src/query-tool.ts

@@ -5,19 +5,28 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { ToolCallIndexer } from "./indexer.js";
 import { QUERY_TOOL_NAME } from "./types.js";
 
+// Legacy records (persisted before resultTimestamp existed) have no timestamp
+// to disambiguate. Do NOT mint an `id@legacy` string: it is occurrence-key-
+// SHAPED but not a real key — parseOccKey would treat "legacy" as part of a
+// literal id, so echoing it back into context_tree_query would fail lookup.
+// Label with the bare id and call out the ambiguity in the block body instead.
+function occurrenceLabel(id: string, resultTimestamp: number | undefined): string {
+  return resultTimestamp === undefined ? id : `${id}@${resultTimestamp}`;
+}
+
 export function registerQueryTool(pi: ExtensionAPI, indexer: ToolCallIndexer): void {
   pi.registerTool({
     name: QUERY_TOOL_NAME,
     label: "Query Original Tool History",
     description:
-      "Retrieve original tool call results that have been pruned from active context. Pass the short refs listed in a pruner-summary message, e.g. context_tree_query({ toolCallIds: [\"t12\", \"t3\"] }), to get back the full original outputs.",
+      "Retrieve original tool call results that have been pruned from active context. Pass the short refs listed in a pruner-summary message, e.g. context_tree_query({ toolCallIds: [\"t12\", \"t3\"] }), to get back the full original outputs. A raw id that was reused returns every occurrence, each labelled id@timestamp.",
     promptSnippet: "Retrieve original pruned tool outputs by short ref",
     promptGuidelines: [
       "When you need the full output of a tool call that was summarized and pruned from context, use context_tree_query with the short refs listed in the relevant pruner-summary message.",
     ],
     parameters: Type.Object({
       toolCallIds: Type.Array(Type.String(), {
-        description: 'Required. One or more short refs (e.g. "t12") or raw tool call IDs from a pruner-summary message.',
+        description: 'Required. One or more short refs (e.g. "t12") or raw tool call IDs from a pruner-summary message. A reused raw id returns every occurrence, each labelled id@timestamp.',
       }),
     }),
 
@@ -26,46 +35,53 @@ export function registerQueryTool(pi: ExtensionAPI, indexer: ToolCallIndexer): v
       const blocks: string[] = [];
 
       for (const id of params.toolCallIds) {
-        const record = indexer.getRecord(id);
+        const records = indexer.getRecordsForId(id);
 
-        if (!record) {
+        if (records.length === 0) {
           blocks.push(`## toolRef: ${id}\n(not found in index — may not have been summarized yet)`);
           continue;
         }
 
-        foundRecords[id] = record;
+        for (const record of records) {
+          // A reused provider id denotes several occurrences; return all of
+          // them rather than silently picking one. `tN` refs stay 1:1.
+          const label = records.length > 1 ? occurrenceLabel(id, record.resultTimestamp) : id;
 
-        const status = record.isError ? "ERROR" : "OK";
-        const header = [
-          `## toolRef: ${id}`,
-          `Tool: ${record.toolName}`,
-          `Args: ${JSON.stringify(record.args, null, 2)}`,
-          `Status: ${status}`,
-          `Turn: ${record.turnIndex}`,
-          "",
-        ].join("\n");
+          foundRecords[label] = record;
 
-        let raw = record.resultText;
-        if (record.spillPath) {
-          try {
-            raw = await readFile(record.spillPath, "utf-8");
-          } catch (err) {
-            console.error(`context_tree_query: failed to read spilled output at ${record.spillPath}:`, err);
-            raw = record.resultPreview ?? "(spilled output unavailable — sidecar file missing)";
+          const status = record.isError ? "ERROR" : "OK";
+          const header = [
+            `## toolRef: ${label}`,
+            ...(records.length > 1 && record.resultTimestamp === undefined ? ["Occurrence: legacy (no resultTimestamp)"] : []),
+            `Tool: ${record.toolName}`,
+            `Args: ${JSON.stringify(record.args, null, 2)}`,
+            `Status: ${status}`,
+            `Turn: ${record.turnIndex}`,
+            "",
+          ].join("\n");
+
+          let raw = record.resultText;
+          if (record.spillPath) {
+            try {
+              raw = await readFile(record.spillPath, "utf-8");
+            } catch (err) {
+              console.error(`context_tree_query: failed to read spilled output at ${record.spillPath}:`, err);
+              raw = record.resultPreview ?? "(spilled output unavailable — sidecar file missing)";
+            }
           }
-        }
 
-        const t = truncateHead(raw, {
-          maxLines: DEFAULT_MAX_LINES,
-          maxBytes: DEFAULT_MAX_BYTES,
-        });
+          const t = truncateHead(raw, {
+            maxLines: DEFAULT_MAX_LINES,
+            maxBytes: DEFAULT_MAX_BYTES,
+          });
 
-        let body = t.content;
-        if (t.truncated) {
-          body += `\n[Output truncated: ${t.outputLines}/${t.totalLines} lines shown]`;
-        }
+          let body = t.content;
+          if (t.truncated) {
+            body += `\n[Output truncated: ${t.outputLines}/${t.totalLines} lines shown]`;
+          }
 
-        blocks.push(`${header}\n${body}`);
+          blocks.push(`${header}\n${body}`);
+        }
       }
 
       const combined = blocks.join("\n\n---\n\n");

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

@@ -5,7 +5,8 @@ import { compressEligible } from "./chain-compressor.js";
 import { pruneMessages } from "./pruner.js";
 import { detectChains } from "./chain-detector.js";
 import { isProtected } from "./protected.js";
-import type { ChainRange, ChainCompressionConfig, ThinkingStripConfig } from "./types.js";
+import { bareToolCallId } from "./occurrence-key.js";
+import type { ChainRange, ChainCompressionConfig } from "./types.js";
 
 // 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
@@ -185,8 +186,12 @@ describe("range compression integration", () => {
     expect(chains[0].protectedToolCallIds).toEqual(["tc2"]);
 
     // Only unprotected tc1 has a per-batch summary; tc2 is protected, no short ref.
+    // Keyed by the occurrence key detectChains actually produced for tc1's result
+    // (id + resultTimestamp), not the bare toolCallId, so this can't silently drift.
+    const tc1OccKey = chains[0].middleOccurrenceKeys!.find((k) => bareToolCallId(k) === "tc1")!;
+    expect(tc1OccKey).toBeDefined();
     indexer.registerSummaryRefs([{ shortId: "t1", toolCallId: "tc1" }]);
-    indexer.registerSummaryBody(["tc1"], "read app.ts summary");
+    indexer.registerSummaryBody([tc1OccKey], "read app.ts summary");
 
     const { compressedEntries } = await compressEligible(chains, 0, {
       indexer,
@@ -249,46 +254,4 @@ describe("range compression integration", () => {
     expect(synthetic.content[0].text).toContain("batch one body");
     expect(synthetic.content[0].text).toContain("batch two body");
   });
-
-  test("boundary strips thinking on survivors after a real phase-3 chain drop", async () => {
-    const indexer = new ToolCallIndexer();
-    const blockRefs = new BlockRefIssuer();
-    indexer.registerSummaryRefs([{ shortId: "t1", toolCallId: "tc1" }]);
-    indexer.registerSummaryBody(["tc1"], "summary of batch 1");
-
-    const chain: ChainRange = {
-      startUserTimestamp: 100,
-      middleToolCallIds: ["tc1"],
-      finalAssistantTimestamp: 400,
-    };
-    const { compressedEntries } = await compressEligible([chain], 0, {
-      indexer,
-      blockRefs,
-      appendEntry: () => {},
-      now: () => 999,
-    });
-    expect(compressedEntries).toHaveLength(1);
-
-    // A later assistant turn (ts 500) that carries thinking and sits OLDER than the boundary.
-    const messages: any[] = [
-      { role: "user", content: [{ type: "text", text: "go" }], timestamp: 100 },
-      { role: "assistant", content: [{ type: "toolCall", id: "tc1", name: "bash", arguments: {} }], timestamp: 200, usage: {}, stopReason: "tool_use" },
-      { role: "toolResult", toolCallId: "tc1", toolName: "bash", content: [{ type: "text", text: "o1" }], isError: false, timestamp: 210 },
-      { role: "assistant", content: [{ type: "text", text: "mid" }], timestamp: 400, usage: {}, stopReason: "end_turn" },
-      { role: "assistant", content: [{ type: "thinking", thinking: "old-think", thinkingSignature: "s" }, { type: "text", text: "after" }], timestamp: 500, usage: {}, stopReason: "stop" },
-    ];
-
-    const cc: ChainCompressionConfig = { enabled: true, rollingWindow: 0, stripFinalAssistantThinking: true, fuseRangeSummary: false };
-    const strip: ThinkingStripConfig = { enabled: true, keepLastTurns: 16 };
-    // Boundary 600: the ts=500 assistant is older -> its thinking must be stripped,
-    // even though phase 3 has dropped the tc1 chain from the array first.
-    const { messages: out, pruned } = pruneMessages(messages, indexer, cc, undefined, strip, undefined, 0, 600);
-    expect(pruned).toBe(true);
-    // Chain middle dropped:
-    expect(out.filter((m: any) => m.role === "toolResult")).toHaveLength(0);
-    // Surviving ts=500 assistant older than boundary 600 -> thinking stripped:
-    const late = out.find((m: any) => m.role === "assistant" && m.timestamp === 500);
-    expect(late).toBeDefined();
-    expect(late.content.some((c: any) => c.type === "thinking")).toBe(false);
-  });
 });

package/src/recovery-grace.test.ts

@@ -3,6 +3,7 @@ import { inGraceRecoveryToolCallIds } from "./recovery-grace.js";
 
 const user = () => ({ role: "user", content: [{ type: "text", text: "u" }] });
 const ctq = (id: string) => ({ role: "toolResult", toolCallId: id, toolName: "context_tree_query", content: [{ type: "text", text: "x" }] });
+const ctqAt = (id: string, timestamp: number) => ({ role: "toolResult", toolCallId: id, toolName: "context_tree_query", content: [{ type: "text", text: "x" }], timestamp });
 const bash = (id: string) => ({ role: "toolResult", toolCallId: id, toolName: "bash", content: [{ type: "text", text: "x" }] });
 
 describe("inGraceRecoveryToolCallIds", () => {
@@ -32,4 +33,16 @@ describe("inGraceRecoveryToolCallIds", () => {
     expect(set.has("t1")).toBe(false);
     expect(set.has("t2")).toBe(true);
   });
+  it("keys a timestamped recovery output by occurrence (id@timestamp), not the bare id", () => {
+    const msgs = [user(), ctqAt("reused", 100)];
+    const set = inGraceRecoveryToolCallIds(msgs, 3);
+    expect(set.has("reused@100")).toBe(true);
+    expect(set.has("reused")).toBe(false);
+  });
+  it("does not conflate two occurrences of the same reused bare id", () => {
+    const msgs = [user(), ctqAt("reused", 100), user(), user(), user(), user(), ctqAt("reused", 200)];
+    const set = inGraceRecoveryToolCallIds(msgs, 3);
+    expect(set.has("reused@100")).toBe(false);
+    expect(set.has("reused@200")).toBe(true);
+  });
 });

package/src/recovery-grace.ts

@@ -1,8 +1,16 @@
 import { QUERY_TOOL_NAME } from "./types.js";
+import { occKey } from "./occurrence-key.js";
 
 /**
- * Set of `context_tree_query` toolCallIds still inside the recovery grace
- * window, computed positionally from the message array (no stored metadata).
+ * Set of `context_tree_query` occurrence keys (or bare ids when the message
+ * carries no timestamp) still inside the recovery grace window, computed
+ * positionally from the message array (no stored metadata).
+ *
+ * Keyed by occurrence, not bare id: the pruner's fail-closed ladder in
+ * `pruneMessages` looks this set up with the SAME `occKey(id, timestamp)` it
+ * computed for the message under test, so a graced occurrence never leaks
+ * protection onto a different, later occurrence that happens to reuse the
+ * same provider id.
  *
  * A recovery output's "user-turn-group" is the count of `role === "user"`
  * messages at or before its position; its age is `nowUTG - that count`, where
@@ -26,7 +34,8 @@ export function inGraceRecoveryToolCallIds(messages: any[], graceTurns: number):
       continue;
     }
     if (m?.role === "toolResult" && m.toolName === QUERY_TOOL_NAME && typeof m.toolCallId === "string") {
-      if (nowUTG - seen <= graceTurns) result.add(m.toolCallId);
+      const key = typeof m.timestamp === "number" ? occKey(m.toolCallId, m.timestamp) : m.toolCallId;
+      if (nowUTG - seen <= graceTurns) result.add(key);
     }
   }
   return result;