pi-ui-extend 1.0.39 → 1.0.41

package/external/pi-tools-suite/src/dcp/pruner-compression-blocks.ts

@@ -1,107 +1,55 @@
 import type { DcpConfig } from "./config.js";
-import type { DcpState } from "./state.js";
-import { PASSTHROUGH_ROLES, estimateMessageTokens } from "./pruner-metadata.js";
+import { hasExactCompressionMembership, type CompressionBlock, type CompressionMember, type DcpState } from "./state.js";
+import { estimateMessageTokens } from "./pruner-metadata.js";
 import { stableMessageKeys } from "./pruner-message-ids.js";
 import { writeDcpDebugLog } from "./debug-log.js";
+import { canonicalMessageHash, rawMutationHashOf } from "./conversation-index.js";
 
 function findBoundaryIndex(messages: any[], stableId: string | undefined, timestamp: number): number {
-  const stableKeys = stableId ? stableMessageKeys(messages) : [];
-  return messages.findIndex((message, index) => {
-    if (stableId && stableKeys[index] === stableId) return true;
-    return message.timestamp === timestamp;
-  });
-}
-
-export interface ReconcileInheritedBlocksResult {
-  fittingBlockIds: number[];
-  activatedBlockIds: number[];
-  deactivatedBlockIds: number[];
+  if (stableId) {
+    const stableKeys = stableMessageKeys(messages);
+    return stableKeys.indexOf(stableId);
+  }
+  const matches = messages.flatMap((message, index) => message.timestamp === timestamp ? [index] : []);
+  return matches.length === 1 ? matches[0]! : -1;
 }
 
 /**
- * Reconcile inherited compression state with the branch that is actually
- * being sent to the provider.
- *
- * A fork can branch before the source session's newest roll-up block ends.
- * That roll-up remains active in the source sidecar, while the older block it
- * covered is inactive. Since the roll-up's end boundary is absent on the
- * fork, neither block would otherwise be applied and the whole history would
- * be sent raw. Select the widest fitting block(s) instead, while preserving an
- * explicit user decompression for the block and its covered descendants.
+ * Mutation identity of one message occurrence. A projection entry whose body
+ * DCP replaced (tool-output placeholder) legitimately stands in for its
+ * preserved raw content, so its identity is that recorded raw hash; every
+ * other message is identified by its own canonical hash. Exactness is not
+ * relaxed: the member hash must still match this identity, in order,
+ * contiguously, and any changed raw content still fails closed.
  */
-export function reconcileInheritedCompressionBlocks(
-  messages: any[],
-  state: DcpState,
-): ReconcileInheritedBlocksResult {
-  const byId = new Map(state.compressionBlocks.map((block) => [block.id, block]));
-  const fittingBlockIds = new Set<number>();
-  const descendantCache = new Map<number, Set<number>>();
-
-  for (const block of state.compressionBlocks) {
-    if (!Number.isFinite(block.startTimestamp) || !Number.isFinite(block.endTimestamp)) continue;
-    const startFound = findBoundaryIndex(messages, block.startMessageId, block.startTimestamp) !== -1;
-    const endFound = findBoundaryIndex(messages, block.endMessageId, block.endTimestamp) !== -1;
-    if (startFound && endFound) fittingBlockIds.add(block.id);
-  }
-
-  function descendantsOf(rootId: number): Set<number> {
-    const cached = descendantCache.get(rootId);
-    if (cached) return cached;
-
-    const descendants = new Set<number>();
-    const pending = [...(byId.get(rootId)?.coveredBlockIds ?? [])];
-    while (pending.length > 0) {
-      const id = pending.pop()!;
-      if (id === rootId || descendants.has(id)) continue;
-      descendants.add(id);
-      pending.push(...(byId.get(id)?.coveredBlockIds ?? []));
-    }
-    descendantCache.set(rootId, descendants);
-    return descendants;
-  }
-
-  // Decompressing a roll-up intentionally exposes its whole range. Do not
-  // unexpectedly reactivate one of its older nested summaries after a fork.
-  const suppressedByUser = new Set<number>();
-  for (const block of state.compressionBlocks) {
-    if (!block.deactivatedByUser) continue;
-    suppressedByUser.add(block.id);
-    for (const id of descendantsOf(block.id)) suppressedByUser.add(id);
-  }
+function mutationIdentity(message: any): string {
+  return rawMutationHashOf(message) ?? canonicalMessageHash(message);
+}
 
-  const eligibleBlockIds = new Set(
-    [...fittingBlockIds].filter((id) => !suppressedByUser.has(id)),
-  );
-  const coveredByFittingBlock = new Set<number>();
-  for (const id of eligibleBlockIds) {
-    for (const coveredId of descendantsOf(id)) coveredByFittingBlock.add(coveredId);
+function exactMemberSpan(messages: any[], members: CompressionMember[]): { lo: number; hi: number } | undefined {
+  const keys = stableMessageKeys(messages);
+  const lo = keys.indexOf(members[0]!.stableId);
+  if (lo < 0 || lo + members.length > messages.length) return undefined;
+  for (let offset = 0; offset < members.length; offset++) {
+    const member = members[offset]!;
+    if (keys[lo + offset] !== member.stableId || mutationIdentity(messages[lo + offset]) !== member.hash) return undefined;
   }
+  return { lo, hi: lo + members.length - 1 };
+}
 
-  const activeBlockIds = new Set(
-    [...eligibleBlockIds].filter((id) => !coveredByFittingBlock.has(id)),
-  );
-  const activatedBlockIds: number[] = [];
-  const deactivatedBlockIds: number[] = [];
-
-  for (const block of state.compressionBlocks) {
-    const shouldBeActive = activeBlockIds.has(block.id);
-    if (block.active !== shouldBeActive) {
-      if (shouldBeActive) activatedBlockIds.push(block.id);
-      else deactivatedBlockIds.push(block.id);
-    }
-    block.active = shouldBeActive;
-
-    if (block.deactivatedByUser) continue;
-    block.deactivatedReason = fittingBlockIds.has(block.id)
-      ? undefined
-      : "outside-inherited-branch";
+function exactStableIdSpan(messages: any[], members: CompressionMember[]): { lo: number; hi: number } | undefined {
+  const keys = stableMessageKeys(messages);
+  const lo = keys.indexOf(members[0]!.stableId);
+  if (lo < 0 || lo + members.length > messages.length) return undefined;
+  for (let offset = 0; offset < members.length; offset++) {
+    if (keys[lo + offset] !== members[offset]!.stableId) return undefined;
   }
+  return { lo, hi: lo + members.length - 1 };
+}
 
-  return {
-    fittingBlockIds: [...fittingBlockIds].sort((a, b) => a - b),
-    activatedBlockIds: activatedBlockIds.sort((a, b) => a - b),
-    deactivatedBlockIds: deactivatedBlockIds.sort((a, b) => a - b),
-  };
+function exactBlockSpan(messages: any[], block: CompressionBlock): { lo: number; hi: number } | undefined {
+  if (!hasExactCompressionMembership(block)) return undefined;
+  return exactMemberSpan(messages, block.mutationMembers!) ?? exactMemberSpan(messages, block.sourceMembers!);
 }
 
 
@@ -123,7 +71,35 @@ export function syncCompressionBlocks(messages: any[], state: DcpState, config:
   }
 
   for (const block of state.compressionBlocks) {
-    if (!block.active || block.deactivatedByUser) continue;
+    if (!block.active) continue;
+
+    if (!hasExactCompressionMembership(block)) {
+      block.active = false;
+      block.deactivatedReason = "invalid-exact-membership";
+      writeDcpDebugLog(config, "block.auto_deactivated", {
+        blockId: `b${block.id}`,
+        reason: block.deactivatedReason,
+        topic: block.topic,
+      });
+      continue;
+    }
+
+    // If the same exact stable sequence still exists but the recorded source
+    // and raw hashes no longer match, never widen or guess a replacement.
+    if (
+      exactStableIdSpan(messages, block.mutationMembers!) &&
+      !exactMemberSpan(messages, block.mutationMembers!) &&
+      !exactMemberSpan(messages, block.sourceMembers!)
+    ) {
+      block.active = false;
+      block.deactivatedReason = "exact-membership-mismatch";
+      writeDcpDebugLog(config, "block.auto_deactivated", {
+        blockId: `b${block.id}`,
+        reason: block.deactivatedReason,
+        topic: block.topic,
+      });
+      continue;
+    }
 
     // ── Skip the missing-origin-compress-call check ────────────────────
     // The compress tool-call that *created* this block is not the block's
@@ -178,208 +154,124 @@ export function syncCompressionBlocks(messages: any[], state: DcpState, config:
   }
 }
 
-export function applyCompressionBlocks(messages: any[], state: DcpState): any[] {
-  const activeBlocks = state.compressionBlocks
-    .filter((b) => b.active)
-    .sort((a, b) => a.startTimestamp - b.startTimestamp);
-  if (activeBlocks.length === 0) return messages;
-
-  for (const block of activeBlocks) {
-    // Skip blocks with corrupted timestamps (from pre-fix sessions)
-    if (!Number.isFinite(block.startTimestamp) || !Number.isFinite(block.endTimestamp)) continue;
-
-    // Find start and end indices by timestamp
-    const startIdx = findBoundaryIndex(messages, block.startMessageId, block.startTimestamp);
-    const endIdx = findBoundaryIndex(messages, block.endMessageId, block.endTimestamp);
-
-    if (startIdx === -1 || endIdx === -1) continue;
-
-    let lo = Math.min(startIdx, endIdx);
-    let hi = Math.max(startIdx, endIdx);
-
-    // Expand lo backward: if there is an assistant before lo whose tool_use
-    // blocks have matching tool_results inside [lo..hi], pull the entire
-    // assistant + any intermediate result messages into the range so the
-    // group is always removed atomically.
-    //
-    // Critically we must skip backward past any toolResult / bashExecution
-    // messages before lo, because an assistant with multiple tool_calls emits
-    // N consecutive result messages — the assistant itself sits further back.
-    while (lo > 0) {
-      // Walk backward past tool-result messages to find the preceding assistant
-      let scanIdx = lo - 1;
-      while (scanIdx >= 0) {
-        const r = (messages[scanIdx] as any).role as string;
-        if (r !== "toolResult" && r !== "bashExecution" && !PASSTHROUGH_ROLES.has(r)) break;
-        scanIdx--;
-      }
-      if (scanIdx < 0 || (messages[scanIdx] as any).role !== "assistant") break;
-
-      const prev = messages[scanIdx] as any;
-      const toolCallIdsInRange = new Set<string>();
-      for (let i = lo; i <= hi; i++) {
-        const m = messages[i] as any;
-        if (
-          (m.role === "toolResult" || m.role === "bashExecution") &&
-          typeof m.toolCallId === "string"
-        ) {
-          toolCallIdsInRange.add(m.toolCallId);
-        }
-      }
-      const prevContent: any[] = Array.isArray(prev.content) ? prev.content : [];
-      const hasMatchingToolCalls = prevContent.some(
-        (contentBlock: any) => contentBlock.type === "toolCall" && toolCallIdsInRange.has(contentBlock.id),
-      );
-      if (!hasMatchingToolCalls) break;
-      // Pull assistant + all intermediate result messages into the range
-      lo = scanIdx;
-    }
-
-    // Expand hi forward: for every assistant message in [lo..hi] that has
-    // tool_use blocks, include any immediately-following tool_result messages
-    // that correspond to those blocks. Loop to fixed point because expanding
-    // hi could expose more assistants in theory.
-    let prevHi: number;
-    do {
-      prevHi = hi;
-      const assistantToolCallIds = new Set<string>();
-      for (let i = lo; i <= hi; i++) {
-        const m = messages[i] as any;
-        if (m.role !== "assistant") continue;
-        const content: any[] = Array.isArray(m.content) ? m.content : [];
-        for (const contentBlock of content) {
-          if (contentBlock.type === "toolCall" && typeof contentBlock.id === "string") {
-            assistantToolCallIds.add(contentBlock.id);
-          }
-        }
-      }
-      while (hi + 1 < messages.length) {
-        const next = messages[hi + 1] as any;
-        if (
-          (next.role === "toolResult" || next.role === "bashExecution") &&
-          assistantToolCallIds.has(next.toolCallId)
-        ) {
-          hi++;
-        } else if (PASSTHROUGH_ROLES.has(next.role)) {
-          hi++;
-        } else {
-          break;
-        }
-      }
-    } while (hi !== prevHi);
-
-    // Estimate tokens removed
-    let removedTokens = 0;
-    for (let i = lo; i <= hi; i++) {
-      removedTokens += estimateMessageTokens(messages[i]);
-    }
-
-    // Remove the range (inclusive)
-    messages.splice(lo, hi - lo + 1);
-
-    // Build synthetic user message for the compressed block
-    const syntheticMsg = {
-      role: "user",
-      content: [
-        {
-          type: "text",
-          text:
-            "[Compressed section: " +
-            block.topic +
-            "]\n\n" +
-            block.summary +
-            "\n\n[dcp-block-id]: # (b" +
-            block.id +
-            ")",
-        },
-      ],
-      // anchorTimestamp is always finite (resolveAnchorTimestamp returns
-      // endTimestamp + 1 instead of Infinity), but guard against corrupted
-      // state from older sessions where Infinity/null could leak in.
-      timestamp: Number.isFinite(block.anchorTimestamp) ? block.anchorTimestamp - 0.5 : block.endTimestamp + 0.5,
-    };
+function compressedBlockText(block: CompressionBlock, label: "section" | "message"): string {
+  return [
+    `[Compressed ${label}: ${block.topic}]`,
+    "",
+    block.summary,
+    "",
+    `[dcp-block-id]: # (b${block.id})`,
+  ].join("\n");
+}
 
-    // Estimate tokens added by the summary
-    const addedTokens = estimateMessageTokens(syntheticMsg);
+/** Exact estimator cost of the synthetic v2 range replacement, including the
+ * DCP wrapper/carrier text that is not part of block.summaryTokenEstimate. */
+export function estimateCompressionBlockReplacementTokens(block: CompressionBlock): number {
+  return estimateMessageTokens({
+    role: "user",
+    content: [{ type: "text", text: compressedBlockText(block, "section") }],
+    timestamp: block.startTimestamp,
+  });
+}
 
-    // Insert the synthetic message
-    messages.push(syntheticMsg);
+function accountCompressionBlock(
+  block: CompressionBlock,
+  removedTokens: number,
+  addedTokens: number,
+  state: DcpState,
+): void {
+  if (state.accountedCompressionBlockIds.has(block.id)) return;
+  state.accountedCompressionBlockIds.add(block.id);
+  state.totalPruneCount++;
+  const rawSaved = Math.max(0, removedTokens - addedTokens);
+  const coveredSavings = (block.coveredBlockIds ?? []).reduce(
+    (sum, id) => sum + (state.compressionTokenSavings.get(id) ?? 0),
+    0,
+  );
+  state.tokensSaved = Math.max(0, state.tokensSaved + rawSaved - coveredSavings);
+  state.compressionTokenSavings.set(block.id, rawSaved);
+}
 
-    // Re-sort by timestamp
-    messages.sort((a, b) => (a.timestamp ?? 0) - (b.timestamp ?? 0));
+function preserveProjectedStableId(message: any, stableId: string | undefined): void {
+  if (!stableId || !message || typeof message !== "object") return;
+  Object.defineProperty(message, "_dcpStableId", {
+    value: stableId,
+    enumerable: false,
+    configurable: true,
+  });
+}
 
-    // Update tokens saved exactly once per compression block.
-    if (!state.accountedCompressionBlockIds.has(block.id)) {
-      state.accountedCompressionBlockIds.add(block.id);
-      state.totalPruneCount++;
-      const rawSaved = Math.max(0, removedTokens - addedTokens);
-      const coveredSavings = (block.coveredBlockIds ?? []).reduce(
-        (sum, id) => sum + (state.compressionTokenSavings.get(id) ?? 0),
-        0,
-      );
-      const adjustment = rawSaved - coveredSavings;
-      state.tokensSaved = Math.max(0, state.tokensSaved + adjustment);
-      state.compressionTokenSavings.set(block.id, rawSaved);
-    }
+function markProjectedOrigin(message: any, origin: "block" | "dcp-control", blockId?: number): void {
+  if (!message || typeof message !== "object") return;
+  Object.defineProperty(message, "_dcpOrigin", {
+    value: origin,
+    enumerable: false,
+    configurable: true,
+  });
+  if (blockId !== undefined) {
+    Object.defineProperty(message, "_dcpBlockId", {
+      value: blockId,
+      enumerable: false,
+      configurable: true,
+    });
   }
-
-  return messages;
 }
 
-/**
- * Remove orphaned toolResult/bashExecution messages whose corresponding
- * assistant toolCall was removed, and strip orphaned toolCall blocks from
- * assistant messages whose toolResult was removed.
- *
- * This is a safety net that runs after all compression blocks are applied.
- */
-export function repairOrphanedToolPairs(messages: any[]): void {
-  // 1. Build set of all toolCall IDs present in assistant messages
-  const assistantToolCallIds = new Set<string>();
-  for (const msg of messages) {
-    if (msg.role !== "assistant") continue;
-    const content: any[] = Array.isArray(msg.content) ? msg.content : [];
-    for (const contentBlock of content) {
-      if (contentBlock.type === "toolCall" && typeof contentBlock.id === "string") {
-        assistantToolCallIds.add(contentBlock.id);
-      }
-    }
-  }
+function applyExactMessageBodyBlock(messages: any[], block: CompressionBlock, state: DcpState): boolean {
+  const span = exactBlockSpan(messages, block);
+  if (!span || span.lo !== span.hi) return false;
+  const targetIndex = span.lo;
+  const target = messages[targetIndex];
+  const removedTokens = estimateMessageTokens(target);
+  const text = compressedBlockText(block, "section");
+
+  if (typeof target?.content === "string") target.content = text;
+  else target.content = [{ type: "text", text }];
+  preserveProjectedStableId(target, block.startMessageId);
+  markProjectedOrigin(target, "block", block.id);
+
+  const addedTokens = estimateMessageTokens(target);
+  accountCompressionBlock(block, removedTokens, addedTokens, state);
+  return true;
+}
 
-  // 2. Build set of all toolCallIds present in toolResult/bashExecution messages
-  const resultToolCallIds = new Set<string>();
-  for (const msg of messages) {
-    if (msg.role !== "toolResult" && msg.role !== "bashExecution") continue;
-    if (typeof msg.toolCallId === "string") {
-      resultToolCallIds.add(msg.toolCallId);
-    }
-  }
+function applyExactRangeBlock(messages: any[], block: CompressionBlock, state: DcpState): boolean {
+  const span = exactBlockSpan(messages, block);
+  if (!span) return false;
+  const { lo, hi } = span;
+  let removedTokens = 0;
+  for (let i = lo; i <= hi; i++) removedTokens += estimateMessageTokens(messages[i]);
+
+  const syntheticMsg = {
+    role: "user",
+    content: [{ type: "text", text: compressedBlockText(block, "section") }],
+    timestamp: block.startTimestamp,
+  };
+  markProjectedOrigin(syntheticMsg, "block", block.id);
+  messages.splice(lo, hi - lo + 1, syntheticMsg);
 
-  // 3. Remove orphaned toolResult/bashExecution messages (no matching assistant toolCall)
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const msg = messages[i];
-    if (msg.role !== "toolResult" && msg.role !== "bashExecution") continue;
-    if (typeof msg.toolCallId === "string" && !assistantToolCallIds.has(msg.toolCallId)) {
-      messages.splice(i, 1);
-    }
-  }
+  const addedTokens = estimateMessageTokens(syntheticMsg);
+  accountCompressionBlock(block, removedTokens, addedTokens, state);
+  return true;
+}
 
-  // 4. Strip orphaned toolCall blocks from assistant messages (no matching toolResult)
-  for (const msg of messages) {
-    if (msg.role !== "assistant") continue;
-    const content: any[] = Array.isArray(msg.content) ? msg.content : [];
-    const hasToolCalls = content.some((b: any) => b.type === "toolCall");
-    if (!hasToolCalls) continue;
+export function applyCompressionBlocks(messages: any[], state: DcpState): any[] {
+  const activeBlocks = state.compressionBlocks
+    .filter((b) => b.active)
+    .sort((a, b) => a.startTimestamp - b.startTimestamp);
+  if (activeBlocks.length === 0) return messages;
 
-    const filtered = content.filter((contentBlock: any) => {
-      if (contentBlock.type !== "toolCall") return true;
-      return typeof contentBlock.id === "string" && resultToolCallIds.has(contentBlock.id);
-    });
+  for (const block of activeBlocks) {
+    if (!hasExactCompressionMembership(block)) continue;
 
-    // Only update if we actually removed something
-    if (filtered.length !== content.length) {
-      // If the assistant has no content left at all, keep at least an empty array
-      msg.content = filtered.length > 0 ? filtered : [];
+    if (block.version === 2 && block.replacementMode === "message-body") {
+      applyExactMessageBodyBlock(messages, block, state);
+      continue;
+    }
+    if (block.version === 2 && block.replacementMode === "range") {
+      applyExactRangeBlock(messages, block, state);
     }
   }
+
+  return messages;
 }

package/external/pi-tools-suite/src/dcp/pruner-emergency.ts

@@ -1,5 +1,5 @@
 import type { DcpConfig } from "./config.js";
-import { estimateMessageTokens, extractBlockId, messageText } from "./pruner-metadata.js";
+import { estimateMessageTokens, messageText } from "./pruner-metadata.js";
 import type {
   EmergencyCurrentTurnOutput,
   EmergencyCurrentTurnSelection,
@@ -48,9 +48,7 @@ export function emergencyPressureState(
 }
 
 function isRealUserMessage(message: any): boolean {
-  if (message?.role !== "user") return false;
-  const text = messageText(message);
-  return !text.includes("<dcp-system-reminder>") && extractBlockId(text) === undefined;
+  return message?.role === "user" && message?._dcpOrigin !== "block" && message?._dcpOrigin !== "dcp-control";
 }
 
 function assistantToolCallIds(message: any): string[] {

package/external/pi-tools-suite/src/dcp/pruner-message-ids.ts

@@ -5,10 +5,11 @@ import {
   ID_ELIGIBLE_ROLES,
   PASSTHROUGH_ROLES,
   estimateMessageTokens,
-  extractBlockId,
   messageText,
   stripStaleDcpMetadataLines,
 } from "./pruner-metadata.js";
+import { buildConversationIndex, canonicalMessageHash } from "./conversation-index.js";
+import { recordCompressionProjection } from "./compression-preview.js";
 
 export interface InjectMessageIdsOptions {
   /** Config enables priority markers for message-mode candidates. */
@@ -49,6 +50,9 @@ function fallbackContentFingerprint(msg: any): string {
 }
 
 export function stableMessageId(msg: any, fallbackIndex = 0): string {
+  if (typeof msg?._dcpStableId === "string" && msg._dcpStableId.length > 0) {
+    return msg._dcpStableId;
+  }
   const candidates = [
     msg?.id,
     msg?.entryId,
@@ -67,8 +71,7 @@ export function stableMessageId(msg: any, fallbackIndex = 0): string {
     return `tool:${msg.toolCallId.trim()}`;
   }
 
-  const blockId = extractBlockId(messageText(msg));
-  if (blockId !== undefined) return `block:${blockId}`;
+  if (Number.isInteger(msg?._dcpBlockId)) return `block:${msg._dcpBlockId}`;
   if (Number.isFinite(msg?.timestamp)) {
     return `ts:${msg.timestamp}:${fallbackContentFingerprint(msg)}`;
   }
@@ -78,7 +81,7 @@ export function stableMessageId(msg: any, fallbackIndex = 0): string {
 /**
  * Return deterministic per-occurrence identities for a message sequence.
  * Session entry IDs and content-fingerprinted fallbacks are normally unique;
- * the suffix keeps byte-identical legacy messages from sharing one mNNN ID.
+ * the suffix keeps byte-identical fallback identities from sharing one mNNN ID.
  */
 export function stableMessageKeys(messages: any[]): string[] {
   const occurrences = new Map<string, number>();
@@ -172,17 +175,24 @@ export function injectMessageIds(
     const stableKey = stableKeys[messageIndex]!;
     const id = persistentMessageId(stableKey, state);
     const originalText = messageText(msg);
-    const blockId = extractBlockId(originalText);
+    const blockId = Number.isInteger(msg?._dcpBlockId) ? msg._dcpBlockId as number : undefined;
     const tokenEstimate = estimateMessageTokens(msg);
+    const toolCallIds = role === "assistant" && Array.isArray(msg.content)
+      ? msg.content
+        .filter((part: any) => part?.type === "toolCall" && typeof part.id === "string")
+        .map((part: any) => part.id as string)
+      : [];
 
     assignedIds.set(messageIndex, id);
     assignedMeta.set(messageIndex, {
       timestamp: msg.timestamp,
       stableId: stableKey,
+      contentHash: canonicalMessageHash(msg),
       role,
       blockId,
       toolCallId: typeof msg.toolCallId === "string" ? msg.toolCallId : undefined,
       toolName: typeof msg.toolName === "string" ? msg.toolName : undefined,
+      toolCallIds: toolCallIds.length > 0 ? toolCallIds : undefined,
       text: originalText,
       tokenEstimate,
       priority: priorityForMessage(tokenEstimate, options.config),
@@ -224,4 +234,6 @@ export function injectMessageIds(
 
   state.messageIdSnapshot = nextIdSnapshot;
   state.messageMetaSnapshot = nextMetaSnapshot;
+  state.conversationIndexSnapshot = buildConversationIndex(messages, stableKeys, state);
+  recordCompressionProjection(state.conversationIndexSnapshot, messages);
 }

package/external/pi-tools-suite/src/dcp/pruner-metadata.ts

@@ -76,7 +76,17 @@ export function estimateMessageTokens(msg: any): number {
       if (part && typeof part === "object") {
         if (typeof part.text === "string") total += estimateTokens(part.text);
         else if (typeof part.thinking === "string") total += estimateTokens(part.thinking);
-        else if (part.type === "image") total += 500; // rough estimate for images
+        else if (part.type === "toolCall") {
+          try {
+            // Tool calls are provider-visible context too. Counting the full
+            // serialized block keeps range-before and replacement-after on the
+            // same estimator and includes IDs, names, arguments/input, and any
+            // provider replay metadata without guessing field-by-field.
+            total += estimateTokens(JSON.stringify(part) ?? "");
+          } catch {
+            total += estimateTokens(`${part.name ?? "tool"}:${part.id ?? ""}`);
+          }
+        } else if (part.type === "image") total += 500; // rough estimate for images
       }
     }
     return total;