pi-ui-extend 1.0.39 → 1.0.41

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

@@ -6,7 +6,7 @@ import type {
   MessageCompressionCandidate,
   NudgeThresholds,
 } from "./pruner-types.js";
-import { extractBlockId, messageText } from "./pruner-metadata.js";
+import { messageText } from "./pruner-metadata.js";
 import { stableMessageKeys } from "./pruner-message-ids.js";
 
 function coercePercentThreshold(value: number | string | undefined, fallback: number): number {
@@ -21,23 +21,6 @@ function coercePercentThreshold(value: number | string | undefined, fallback: nu
   return parsed <= 1 ? parsed : fallback;
 }
 
-export function injectNudge(messages: any[], nudgeText: string): void {
-  messages.push({
-    role: "user",
-    content: nudgeText,
-    timestamp: Date.now(),
-  });
-}
-
-function typePriority(type: DcpNudgeType): number {
-  switch (type) {
-    case "context-strong": return 4;
-    case "context-soft": return 3;
-    case "iteration": return 2;
-    case "turn": return 1;
-  }
-}
-
 function nudgeTypeLabel(type: DcpNudgeType): string {
   switch (type) {
     case "context-strong": return "context limit (strong)";
@@ -50,45 +33,28 @@ function nudgeTypeLabel(type: DcpNudgeType): string {
 function isRealAnchorCandidate(msg: any): boolean {
   const role = msg?.role ?? "";
   if (role !== "user" && role !== "assistant") return false;
-  const text = messageText(msg);
-  if (extractBlockId(text) !== undefined) return false;
-  return true;
+  return msg?._dcpOrigin !== "block" && msg?._dcpOrigin !== "dcp-control";
 }
 
 function findAnchorMessage(messages: any[]): { msg: any; index: number; stableId: string; timestamp: number; role: string } | null {
   const stableKeys = stableMessageKeys(messages);
-  // Prefer the latest real user message: it gives the reminder direct user-like
-  // salience without creating a new synthetic message at the end of context.
+  // A reminder may only be introduced on a fresh user tail. If assistant/tool
+  // traffic already follows that user message then it has already belonged to
+  // an earlier provider prefix; editing it now would invalidate that prefix.
   for (let i = messages.length - 1; i >= 0; i--) {
     const msg = messages[i];
-    if (msg?.role !== "user" || !isRealAnchorCandidate(msg)) continue;
-    if (!Number.isFinite(msg.timestamp)) continue;
-    return {
-      msg,
-      index: i,
-      stableId: stableKeys[i]!,
-      timestamp: msg.timestamp,
-      role: msg.role,
-    };
-  }
-
-  // Fallback to assistant messages if no raw user message is present.
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const msg = messages[i];
-    if (msg?.role !== "assistant" || !isRealAnchorCandidate(msg)) continue;
-    if (!Number.isFinite(msg.timestamp)) continue;
-    return {
-      msg,
-      index: i,
-      stableId: stableKeys[i]!,
-      timestamp: msg.timestamp,
-      role: msg.role,
-    };
+    if (msg?._dcpOrigin === "dcp-control") continue;
+    if (msg?.role !== "user" || !isRealAnchorCandidate(msg) || !Number.isFinite(msg.timestamp)) return null;
+    return { msg, index: i, stableId: stableKeys[i]!, timestamp: msg.timestamp, role: msg.role };
   }
 
   return null;
 }
 
+export function hasCacheSafeNudgeCarrier(messages: any[]): boolean {
+  return findAnchorMessage(messages) !== null;
+}
+
 function anchorMatchesMessage(anchor: DcpNudgeAnchor, msg: any, stableKey: string): boolean {
   if (anchor.anchorStableId && stableKey === anchor.anchorStableId) return true;
   return msg?.timestamp === anchor.anchorTimestamp;
@@ -220,41 +186,27 @@ export function upsertNudgeAnchor(
     if (!existing || isNewerAnchor(anchor, existing)) existing = anchor;
   }
 
-  const now = Date.now();
   if (existing) {
-    // Keep the original carrier and frozen text. Moving a reminder to the
-    // newest user message would remove bytes from an old provider-cache prefix.
+    // Once published, both carrier and bytes are immutable. A later urgency
+    // increase must not rewrite an old provider prefix.
     state.nudgeAnchors = [existing];
-    const shouldUpgrade = typePriority(type) > typePriority(existing.type);
-    if (shouldUpgrade) {
-      existing.type = type;
-      existing.contextPercent = options.contextPercent ?? existing.contextPercent;
-      existing.renderedReminder = options.renderedReminder ?? existing.renderedReminder;
-      existing.updatedAt = now;
-    } else if (!existing.renderedReminder && options.renderedReminder) {
-      // One-time migration for anchors persisted before frozen rendering.
-      existing.renderedReminder = options.renderedReminder;
-    }
-    state.lastNudge = {
-      type: existing.type,
-      anchorId: existing.id,
-      anchorTimestamp: existing.anchorTimestamp,
-      anchorStableId: existing.anchorStableId,
-      contextPercent: existing.contextPercent,
-      createdAt: now,
-    };
-    return { anchor: existing, created: false, updated: shouldUpgrade };
+    return { anchor: existing, created: false, updated: false };
   }
 
-  const target = findAnchorMessage(messages);
-  if (!target) {
-    // The caller will append one synthetic tail reminder. Drop persisted
-    // anchors first so applyAnchoredNudges cannot render a second reminder.
+  if (state.nudgeAnchors.length > 0) {
     state.nudgeAnchors = [];
     state.lastNudge = undefined;
+  }
+
+  const target = findAnchorMessage(messages);
+  if (!target) {
+    // Mid-turn reminder creation is deliberately deferred rather than
+    // synthesizing an ephemeral tail message that would disappear on the next
+    // provider continuation and break prefix equality.
     return { anchor: null, created: false, updated: false };
   }
 
+  const now = Date.now();
   const anchor: DcpNudgeAnchor = {
     id: state.nextNudgeAnchorId++,
     type,
@@ -301,8 +253,7 @@ export function applyAnchoredNudges(
     }
   }
 
-  // Defensive migration for persisted pre-singleton state: render only the
-  // newest valid anchor and discard every stale predecessor.
+  // Render only the newest valid anchor and discard stale predecessors.
   state.nudgeAnchors = selected ? [selected.anchor] : [];
   const anchorSetChanged = state.nudgeAnchors.length !== priorAnchors.length ||
     state.nudgeAnchors.some((anchor, index) => anchor !== priorAnchors[index]);
@@ -312,15 +263,12 @@ export function applyAnchoredNudges(
   const reminder = selected.anchor.renderedReminder ?? render(selected.anchor);
   if (materializedReminder) selected.anchor.renderedReminder = reminder;
   const anchorMessage = messages[selected.index];
-  if (anchorMessage?.role === "assistant") {
-    messages.splice(selected.index + 1, 0, {
-      role: "user",
-      content: reminder,
-      timestamp: selected.anchor.createdAt,
-    });
-  } else {
-    appendTextToMessage(anchorMessage, reminder);
+  if (anchorMessage?.role !== "user") {
+    state.nudgeAnchors = [];
+    state.lastNudge = undefined;
+    return { rendered: false, stateChanged: true };
   }
+  appendTextToMessage(anchorMessage, reminder);
   return {
     rendered: true,
     stateChanged: anchorSetChanged || materializedReminder,

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

@@ -1,19 +1,28 @@
 import type { DcpConfig } from "./config.js";
 import type { DcpState, ToolRecord } from "./state.js";
-import { estimateMessageTokens } from "./pruner-metadata.js";
+import { preserveRawMutationHash } from "./conversation-index.js";
 
 export const EMERGENCY_CURRENT_TURN_PLACEHOLDER =
   "[Older tool output removed during current-turn context emergency; re-run the tool if exact content is needed]";
 
-// Tool outputs that must never be auto-pruned unless a future explicit user
-// action intentionally changes that policy. They mutate state or control DCP.
-const ALWAYS_PROTECTED_TOOLS = new Set(["compress", "write", "edit"]);
+// Tool outputs whose effects may mutate the workspace/process or control DCP.
+// Normalize names so provider/extension casing and aliases cannot bypass the
+// safety policy. Unknown tools are handled conservatively by autonomous
+// supersession below rather than assumed read-only.
+const ALWAYS_PROTECTED_TOOLS = new Set([
+  "compress", "write", "edit", "apply_patch", "patch",
+  "bash", "shell", "powershell", "exec", "execute",
+]);
+
+function normalizeToolName(name: string | undefined): string {
+  return (name ?? "").trim().toLowerCase().replace(/[\s-]+/g, "_");
+}
 
 function buildProtectedTools(config: DcpConfig, extra: string[] = []): Set<string> {
   return new Set([
     ...ALWAYS_PROTECTED_TOOLS,
-    ...(config.compress.protectedTools ?? []),
-    ...extra,
+    ...(config.compress.protectedTools ?? []).map(normalizeToolName),
+    ...extra.map(normalizeToolName),
   ]);
 }
 
@@ -82,38 +91,13 @@ function isProtectedByFilePattern(record: ToolRecord | undefined, config: DcpCon
   );
 }
 
-function recordForToolResult(msg: any, state: DcpState): ToolRecord | undefined {
-  if (typeof msg.toolCallId !== "string") return undefined;
-  return state.toolCalls.get(msg.toolCallId);
-}
-
-function toolNameForResult(msg: any, record: ToolRecord | undefined): string {
-  return record?.toolName ?? msg.toolName ?? "";
-}
-
-function estimateToolResultTokens(msg: any, record: ToolRecord | undefined): number {
-  return Math.max(record?.tokenEstimate ?? 0, estimateMessageTokens(msg));
-}
-
-function toolResultIsProtected(
-  msg: any,
-  record: ToolRecord | undefined,
-  config: DcpConfig,
-  extraProtectedTools: string[] = [],
-): boolean {
-  const protectedTools = buildProtectedTools(config, extraProtectedTools);
-  const toolName = toolNameForResult(msg, record);
-  if (protectedTools.has(toolName)) return true;
-  return isProtectedByFilePattern(record, config);
-}
-
 export function isToolRecordProtected(
   record: ToolRecord,
   config: DcpConfig,
   extraProtectedTools: string[] = [],
 ): boolean {
   const protectedTools = buildProtectedTools(config, extraProtectedTools);
-  if (protectedTools.has(record.toolName)) return true;
+  if (protectedTools.has(normalizeToolName(record.toolName))) return true;
   return isProtectedByFilePattern(record, config);
 }
 
@@ -138,127 +122,32 @@ export function markToolPruned(
   return !wasAlreadyPruned;
 }
 
-export function applyDeduplication(messages: any[], state: DcpState, config: DcpConfig): void {
-  if (!config.strategies.deduplication.enabled) return;
-  if (state.manualMode && !config.manualMode.automaticStrategies) return;
-
-  // fingerprint → array of toolCallIds in timestamp order
-  const fingerprintMap = new Map<string, Array<{ id: string; tokens: number }>>();
-
-  for (const msg of messages) {
-    if (msg.role !== "toolResult") continue;
-    const record = recordForToolResult(msg, state);
-    if (!record) continue;
-    if (toolResultIsProtected(msg, record, config, config.strategies.deduplication.protectedTools ?? [])) continue;
-
-    const fp = record.inputFingerprint;
-    if (!fingerprintMap.has(fp)) {
-      fingerprintMap.set(fp, []);
-    }
-    fingerprintMap.get(fp)!.push({ id: msg.toolCallId, tokens: estimateToolResultTokens(msg, record) });
-  }
-
-  // For each fingerprint with duplicates, prune all but the last
-  for (const [, ids] of fingerprintMap) {
-    if (ids.length <= 1) continue;
-    // Keep the last one; prune the rest
-    for (let i = 0; i < ids.length - 1; i++) {
-      markToolPruned(state, ids[i]!.id, "duplicate", ids[i]!.tokens);
-    }
-  }
-}
-
-/**
- * Apply error purging: mark old error tool outputs for pruning.
- * Mutates state.prunedToolIds.
- */
-export function applyErrorPurging(messages: any[], state: DcpState, config: DcpConfig): void {
-  if (!config.strategies.purgeErrors.enabled) return;
-  if (state.manualMode && !config.manualMode.automaticStrategies) return;
-
-  const turnsThreshold = config.strategies.purgeErrors.turns ?? 3;
-
-  for (const msg of messages) {
-    if (msg.role !== "toolResult") continue;
-    if (!msg.isError) continue;
-
-    const record = recordForToolResult(msg, state);
-    if (!record) continue;
-    if (toolResultIsProtected(msg, record, config, config.strategies.purgeErrors.protectedTools ?? [])) continue;
-
-    if (state.currentTurn - record.turnIndex >= turnsThreshold) {
-      markToolPruned(state, msg.toolCallId, "old-error", estimateToolResultTokens(msg, record));
-    }
-  }
-}
-
-/**
- * Policy-based autonomous tool-output pruning. This is the non-LLM half of
- * DCP: large, old, repeated, or stale discovery outputs can be replaced with
- * placeholders without waiting for the model to call `compress`.
- */
-export function applyAutoToolOutputPruning(messages: any[], state: DcpState, config: DcpConfig): void {
-  const strategy = config.strategies.autoToolPruning;
-  if (!strategy.enabled) return;
-  if (state.manualMode && !config.manualMode.automaticStrategies) return;
-
-  const maxOutputTokens = Math.max(1, strategy.maxOutputTokens ?? 2000);
-  const keepRecentTurns = Math.max(0, strategy.keepRecentTurns ?? 2);
-  const readLikeTurns = Math.max(0, strategy.readLikeTurns ?? 3);
-  const readLikeTools = new Set(strategy.readLikeTools ?? []);
-
-  for (const msg of messages) {
-    if (msg.role !== "toolResult") continue;
-    if (typeof msg.toolCallId !== "string") continue;
-
-    const record = recordForToolResult(msg, state);
-    if (!record) continue;
-    if (toolResultIsProtected(msg, record, config, strategy.protectedTools ?? [])) continue;
-
-    const ageTurns = Math.max(0, state.currentTurn - record.turnIndex);
-    const tokenEstimate = estimateToolResultTokens(msg, record);
-    const toolName = toolNameForResult(msg, record);
-
-    if (tokenEstimate > maxOutputTokens && ageTurns >= keepRecentTurns) {
-      markToolPruned(state, msg.toolCallId, "large-output", tokenEstimate);
-    } else if (readLikeTools.has(toolName) && ageTurns >= readLikeTurns) {
-      markToolPruned(state, msg.toolCallId, "stale-read", tokenEstimate);
-    }
-  }
-}
-
 function placeholderForPrunedTool(msg: any, state: DcpState): string {
   const reason = state.prunedToolReasons.get(msg.toolCallId);
-  if (reason === "duplicate") {
-    return "[Output removed to save context - duplicate tool call; latest matching result kept]";
-  }
-  if (reason === "large-output") {
-    return "[Large tool output removed to save context after it aged out of the active working set]";
-  }
-  if (reason === "stale-read") {
-    return "[Stale read/search output removed to save context; re-read if exact content is needed again]";
-  }
   if (reason === "manual-sweep") {
     return "[Output removed by /dcp sweep to save context]";
   }
   if (reason === "emergency-current-turn") {
     return EMERGENCY_CURRENT_TURN_PLACEHOLDER;
   }
-  if (reason === "old-error" || msg.isError) {
-    return "[Error output removed - tool failed more than the configured number of turns ago]";
-  }
   return "[Output removed to save context - information superseded or no longer needed]";
 }
 
 /**
  * Apply explicit tool output pruning from state.prunedToolIds.
  * Replaces content of matching toolResult messages in place.
+ *
+ * The canonical hash of the un-pruned raw message is preserved on the
+ * projection entry (runtime-only) before the body is replaced: exact mutation
+ * membership for compression blocks must bind to the raw content a later
+ * materialization pass will actually see, not to this placeholder.
  */
 export function applyToolOutputPruning(messages: any[], state: DcpState): void {
   for (const msg of messages) {
     if (msg.role !== "toolResult") continue;
     if (!state.prunedToolIds.has(msg.toolCallId)) continue;
 
+    preserveRawMutationHash(msg);
     msg.content = [
       {
         type: "text",

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

@@ -1,14 +1,10 @@
 import type { DcpConfig } from "./config.js";
 import type { DcpState } from "./state.js";
-import { applyCompressionBlocks, repairOrphanedToolPairs, syncCompressionBlocks } from "./pruner-compression-blocks.js";
+import { applyCompressionBlocks, syncCompressionBlocks } from "./pruner-compression-blocks.js";
 import { stripStaleDcpMetadataFromMessage } from "./pruner-metadata.js";
 import { injectMessageIds } from "./pruner-message-ids.js";
-import {
-  applyAutoToolOutputPruning,
-  applyDeduplication,
-  applyErrorPurging,
-  applyToolOutputPruning,
-} from "./pruner-tools.js";
+import { copyRawMutationHash } from "./conversation-index.js";
+import { applyToolOutputPruning } from "./pruner-tools.js";
 
 export type {
   CompressionCandidate,
@@ -35,6 +31,7 @@ export {
 } from "./pruner-tools.js";
 export {
   detectCompressionCandidate,
+  detectEmergencyCompressionCandidate,
   detectMessageCompressionCandidates,
   formatCompressionCandidateHint,
   formatMessageCompressionCandidateHint,
@@ -44,7 +41,7 @@ export {
   applyAnchoredNudges,
   clearDcpNudgeAnchors,
   getNudgeType,
-  injectNudge,
+  hasCacheSafeNudgeCarrier,
   nudgeTypeLabel,
   upsertNudgeAnchor,
 } from "./pruner-nudge.js";
@@ -63,7 +60,13 @@ export function applyPruning(
         typeof contentBlock === "object" && contentBlock !== null ? { ...contentBlock } : contentBlock,
       );
     }
-    return stripStaleDcpMetadataFromMessage(clone);
+    const stripped = stripStaleDcpMetadataFromMessage(clone);
+    for (const key of ["_dcpOrigin", "_dcpBlockId", "_dcpStableId"] as const) {
+      const descriptor = Object.getOwnPropertyDescriptor(m, key);
+      if (descriptor) Object.defineProperty(stripped, key, descriptor);
+    }
+    copyRawMutationHash(m, stripped);
+    return stripped;
   });
 
   // 1. Count user turns → update state.currentTurn. Do this before inserting
@@ -75,32 +78,14 @@ export function applyPruning(
   syncCompressionBlocks(msgs, state, config);
   applyCompressionBlocks(msgs, state);
 
-  // 2b. Post-compression safety net: remove any orphaned tool pairs that the
-  // expansion logic could not catch (e.g. multi-block interactions, pre-broken state).
-  repairOrphanedToolPairs(msgs);
-
-  // 3-5. Discover new automatic pruning decisions only at stable checkpoints.
-  // Rewriting an old result after every same-turn duplicate breaks provider
-  // continuation repeatedly. A new user turn or compression block already
-  // establishes a natural history boundary where one prefix rebuild is
-  // acceptable. Branches that move the turn count backwards also reopen the
-  // checkpoint instead of suppressing pruning indefinitely.
-  const newestBlockId = Math.max(0, state.nextBlockId - 1);
-  const automaticPruneCheckpoint =
-    state.currentTurn !== state.lastAutomaticPruneTurn ||
-    newestBlockId !== state.lastAutomaticPruneBlockId;
-  if (automaticPruneCheckpoint) {
-    applyDeduplication(msgs, state, config);
-    applyErrorPurging(msgs, state, config);
-    applyAutoToolOutputPruning(msgs, state, config);
-    state.lastAutomaticPruneTurn = state.currentTurn;
-    state.lastAutomaticPruneBlockId = newestBlockId;
-  }
-
-  // 6. Apply explicit tool output pruning (prunedToolIds)
+  // Existing explicit/emergency pruning decisions are replayed, but routine
+  // context construction never discovers new retroactive deletions. A new user
+  // turn must remain append-only for provider prefix caching; destructive
+  // rewrites happen only through an explicit compress/sweep boundary or the
+  // bounded emergency path.
   applyToolOutputPruning(msgs, state);
 
-  // 7. Refresh message ID snapshots and append stable distributed metadata to
+  // Refresh message ID snapshots and append stable distributed metadata to
   // user/tool-result carriers. Assistant items remain byte-stable.
   injectMessageIds(msgs, state, { config });
 

package/external/pi-tools-suite/src/dcp/recovery.ts

@@ -0,0 +1,129 @@
+import { createInputFingerprint, type DcpState, type ToolRecord } from "./state.js"
+import { estimateMessageTokens, messageText } from "./pruner-metadata.js"
+
+export interface DcpToolRecordRehydration {
+  recordsUpdated: number
+  exactArgsRestored: number
+  exactOutputsRestored: number
+}
+
+interface RawToolCall {
+  id: string
+  name: string
+  input: Record<string, unknown>
+  turnIndex: number
+  timestamp: number
+}
+
+function assistantToolCalls(message: any, turnIndex: number): RawToolCall[] {
+  if (message?.role !== "assistant" || !Array.isArray(message.content)) return []
+  const calls: RawToolCall[] = []
+  for (const part of message.content) {
+    if (!part || part.type !== "toolCall" || typeof part.id !== "string") continue
+    const name = typeof part.name === "string"
+      ? part.name
+      : typeof part.function?.name === "string"
+        ? part.function.name
+        : ""
+    const rawInput = part.input ?? part.arguments ?? part.function?.arguments
+    let input: Record<string, unknown> = {}
+    if (rawInput && typeof rawInput === "object" && !Array.isArray(rawInput)) {
+      input = rawInput as Record<string, unknown>
+    } else if (typeof rawInput === "string") {
+      try {
+        const parsed = JSON.parse(rawInput)
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) input = parsed
+      } catch {
+        // Keep opaque/non-JSON provider arguments out of structured recovery.
+      }
+    }
+    calls.push({
+      id: part.id,
+      name,
+      input,
+      turnIndex,
+      timestamp: Number.isFinite(message.timestamp) ? message.timestamp : 0,
+    })
+  }
+  return calls
+}
+
+function hasRestoredOnlyArgs(record: ToolRecord): boolean {
+  const keys = Object.keys(record.inputArgs ?? {})
+  return keys.length === 0 || (keys.length === 1 && keys[0] === "_restoredValues")
+}
+
+/**
+ * Rebuild exact, ephemeral tool metadata from the raw session branch.
+ *
+ * The journal intentionally persists only projection decisions, not tool
+ * outputs or delivery evidence. After restart this function reconstructs the
+ * tool records needed for protection/fingerprinting from raw history while
+ * leaving `providerSeenToolIds` untouched. Absence of provider evidence after
+ * restart therefore remains "unknown" and cannot authorize emergency pruning.
+ */
+export function rehydrateToolRecordsFromMessages(
+  messages: any[],
+  state: DcpState,
+): DcpToolRecordRehydration {
+  const calls = new Map<string, RawToolCall>()
+  let turnIndex = 0
+  for (const message of messages) {
+    if (message?.role === "user") turnIndex++
+    for (const call of assistantToolCalls(message, turnIndex)) calls.set(call.id, call)
+  }
+
+  let recordsUpdated = 0
+  let exactArgsRestored = 0
+  let exactOutputsRestored = 0
+  const touched = new Set<string>()
+
+  for (const message of messages) {
+    if (message?.role !== "toolResult" || typeof message.toolCallId !== "string") continue
+    const call = calls.get(message.toolCallId)
+    const text = messageText(message).trim()
+    const toolName = call?.name || (typeof message.toolName === "string" ? message.toolName : "")
+    let record = state.toolCalls.get(message.toolCallId)
+    if (!record) {
+      const inputArgs = call?.input ?? {}
+      record = {
+        toolCallId: message.toolCallId,
+        toolName,
+        inputArgs,
+        inputFingerprint: createInputFingerprint(toolName, inputArgs),
+        isError: message.isError === true,
+        turnIndex: call?.turnIndex ?? turnIndex,
+        timestamp: Number.isFinite(message.timestamp) ? message.timestamp : call?.timestamp ?? 0,
+        tokenEstimate: estimateMessageTokens(message),
+        ...(text ? { outputText: text } : {}),
+        ...(message.details !== undefined ? { outputDetails: message.details } : {}),
+      }
+      state.toolCalls.set(message.toolCallId, record)
+      if (Object.keys(inputArgs).length > 0) exactArgsRestored++
+      if (text) exactOutputsRestored++
+      touched.add(message.toolCallId)
+      continue
+    }
+    if (call && hasRestoredOnlyArgs(record) && Object.keys(call.input).length > 0) {
+      record.inputArgs = call.input
+      if (call.name) record.toolName = call.name
+      record.inputFingerprint = createInputFingerprint(record.toolName, call.input)
+      record.turnIndex = call.turnIndex
+      exactArgsRestored++
+      touched.add(message.toolCallId)
+    }
+    if (!record.outputText && text) {
+      record.outputText = text
+      exactOutputsRestored++
+      touched.add(message.toolCallId)
+    }
+    if (typeof message.toolName === "string" && message.toolName) record.toolName = message.toolName
+    if (typeof message.isError === "boolean") record.isError = message.isError
+    if (Number.isFinite(message.timestamp)) record.timestamp = message.timestamp
+    record.tokenEstimate = Math.max(record.tokenEstimate ?? 0, estimateMessageTokens(message))
+  }
+
+  recordsUpdated = touched.size
+  state.totalToolCallCount = Math.max(state.totalToolCallCount, state.toolCalls.size)
+  return { recordsUpdated, exactArgsRestored, exactOutputsRestored }
+}