pi-ui-extend 1.0.37 → 1.0.39

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

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import type { DcpState, MessageIdMeta } from "./state.js";
 import type { DcpConfig } from "./config.js";
 import {
@@ -6,6 +7,7 @@ import {
   estimateMessageTokens,
   extractBlockId,
   messageText,
+  stripStaleDcpMetadataLines,
 } from "./pruner-metadata.js";
 
 export interface InjectMessageIdsOptions {
@@ -13,6 +15,39 @@ export interface InjectMessageIdsOptions {
   config?: DcpConfig;
 }
 
+const ID_CARRIER_ROLES = new Set(["user", "toolResult", "bashExecution"]);
+
+function canonicalContentForStableId(msg: any): unknown {
+  if (!Array.isArray(msg?.content)) {
+    if (msg?.role === "assistant") return msg?.content ?? "";
+    return stripStaleDcpMetadataLines(typeof msg?.content === "string" ? msg.content : "");
+  }
+
+  if (msg?.role === "assistant") return msg.content;
+
+  return msg.content.flatMap((block: any) => {
+    if (!block || typeof block !== "object") return [block];
+    if (typeof block.text === "string") {
+      const text = stripStaleDcpMetadataLines(block.text);
+      return text.length > 0 ? [{ ...block, text }] : [];
+    }
+    if (typeof block.thinking === "string") {
+      const thinking = stripStaleDcpMetadataLines(block.thinking);
+      return thinking.length > 0 ? [{ ...block, thinking }] : [];
+    }
+    return [block];
+  });
+}
+
+function fallbackContentFingerprint(msg: any): string {
+  return createHash("sha256")
+    .update(String(msg?.role ?? ""))
+    .update("\u0000")
+    .update(JSON.stringify(canonicalContentForStableId(msg)))
+    .digest("hex")
+    .slice(0, 20);
+}
+
 export function stableMessageId(msg: any, fallbackIndex = 0): string {
   const candidates = [
     msg?.id,
@@ -32,10 +67,29 @@ export function stableMessageId(msg: any, fallbackIndex = 0): string {
     return `tool:${msg.toolCallId.trim()}`;
   }
 
-  if (Number.isFinite(msg?.timestamp)) return `ts:${msg.timestamp}`;
+  const blockId = extractBlockId(messageText(msg));
+  if (blockId !== undefined) return `block:${blockId}`;
+  if (Number.isFinite(msg?.timestamp)) {
+    return `ts:${msg.timestamp}:${fallbackContentFingerprint(msg)}`;
+  }
   return `idx:${fallbackIndex}`;
 }
 
+/**
+ * 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.
+ */
+export function stableMessageKeys(messages: any[]): string[] {
+  const occurrences = new Map<string, number>();
+  return messages.map((message, index) => {
+    const base = stableMessageId(message, index);
+    const occurrence = (occurrences.get(base) ?? 0) + 1;
+    occurrences.set(base, occurrence);
+    return occurrence === 1 ? base : `${base}#${occurrence}`;
+  });
+}
+
 function priorityForMessage(tokenEstimate: number, config: DcpConfig | undefined): "low" | "medium" | "high" {
   const settings = config?.compress?.messageMode;
   const mediumTokens = Math.max(1, settings?.mediumTokens ?? 500);
@@ -46,140 +100,128 @@ function priorityForMessage(tokenEstimate: number, config: DcpConfig | undefined
   return "low";
 }
 
-function messageIdIndex(id: string): number | undefined {
-  const match = /^m(\d+)$/.exec(id);
-  if (!match) return undefined;
-  const index = Number.parseInt(match[1]!, 10);
-  return Number.isFinite(index) ? index : undefined;
-}
-
-function summarizeMessageIds(ids: string[]): string {
-  if (ids.length === 0) return "none";
-
-  const ranges: string[] = [];
-  let start = ids[0]!;
-  let previous = ids[0]!;
-  let previousIndex = messageIdIndex(previous);
-
-  const flush = () => {
-    const startIndex = messageIdIndex(start);
-    const endIndex = messageIdIndex(previous);
-    if (
-      startIndex !== undefined &&
-      endIndex !== undefined &&
-      endIndex - startIndex >= 2
-    ) {
-      ranges.push(`${start}..${previous}`);
-    } else if (start === previous) {
-      ranges.push(start);
-    } else {
-      ranges.push(start, previous);
-    }
-  };
-
-  for (let i = 1; i < ids.length; i++) {
-    const id = ids[i]!;
-    const index = messageIdIndex(id);
-    if (previousIndex !== undefined && index === previousIndex + 1) {
-      previous = id;
-      previousIndex = index;
-      continue;
-    }
+function persistentMessageId(stableKey: string, state: DcpState): string {
+  const existing = state.messageIdsByStableId.get(stableKey);
+  if (existing) return existing;
 
-    flush();
-    start = id;
-    previous = id;
-    previousIndex = index;
-  }
-
-  flush();
-  return ranges.join(", ");
+  const id = `m${String(state.nextMessageId++).padStart(3, "0")}`;
+  state.messageIdsByStableId.set(stableKey, id);
+  return id;
 }
 
-function compactPriorityHint(ids: string[], state: DcpState): string | undefined {
-  const high: string[] = [];
-  const medium: string[] = [];
-  const blocks: string[] = [];
-
-  for (const id of ids) {
-    const meta = state.messageMetaSnapshot.get(id);
-    if (!meta) continue;
-    if (meta.priority === "high") high.push(id);
-    else if (meta.priority === "medium") medium.push(id);
-    if (meta.blockId !== undefined) blocks.push(`${id}=b${meta.blockId}`);
-  }
-
-  const parts: string[] = [];
-  if (high.length > 0) parts.push(`high=${summarizeMessageIds(high)}`);
-  if (medium.length > 0) parts.push(`medium=${summarizeMessageIds(medium)}`);
-  if (blocks.length > 0) parts.push(`blocks=${blocks.join(",")}`);
-  return parts.length > 0 ? `Hints: ${parts.join("; ")}` : undefined;
+function carrierSelfLabel(role: string): string {
+  if (role === "toolResult") return "this tool result";
+  if (role === "bashExecution") return "this bash result";
+  return "this user message";
 }
 
-export function buildMessageIdControlText(state: DcpState): string | undefined {
-  const ids = [...state.messageIdSnapshot.keys()];
-  if (ids.length === 0) return undefined;
-
-  const hint = compactPriorityHint(ids, state);
-
+function buildCarrierControlText(
+  precedingAssistantIds: string[],
+  ownId: string,
+  ownRole: string,
+  blockId: number | undefined,
+): string {
+  const assignments = [
+    ...precedingAssistantIds.map((id) => `${id}=preceding assistant message`),
+    `${ownId}=${carrierSelfLabel(ownRole)}`,
+  ];
   return [
     "<dcp-message-ids>",
-    "DCP metadata for the preceding conversation messages. IDs follow current message order; use only these IDs with compress; do not quote/output.",
-    `Current raw message IDs: ${summarizeMessageIds(ids)}${ids.length > 2 ? ` (${ids.length} messages)` : ""}`,
-    ...(hint ? [hint] : []),
+    `Stable DCP IDs (use with compress; do not quote/output): ${assignments.join("; ")}`,
+    ...(blockId === undefined ? [] : [`Active compressed block alias: b${blockId}`]),
     "</dcp-message-ids>",
   ].join("\n");
 }
 
+function appendControlToCarrier(message: any, controlText: string): void {
+  const suffix = `\n\n${controlText}`;
+  if (typeof message.content === "string") {
+    message.content += suffix;
+    return;
+  }
+  if (Array.isArray(message.content)) {
+    message.content = [...message.content, { type: "text", text: suffix }];
+    return;
+  }
+  message.content = [{ type: "text", text: controlText }];
+}
+
+/**
+ * Build the current addressability snapshot and distribute immutable ID
+ * metadata over append-only user/tool-result carriers. Assistant messages are
+ * never modified: provider-signed reasoning and function-call items must replay
+ * byte-for-byte for Responses continuation.
+ */
 export function injectMessageIds(
   messages: any[],
   state: DcpState,
   options: InjectMessageIdsOptions = {},
 ): void {
-  // Rebuild into local maps and assign once at the end, so readers (compress
-  // tool, candidates, provider payload builder) never observe a transiently
-  // empty snapshot mid-rebuild. The previous clear()-then-set loop exposed a
-  // window where any concurrent reader saw `messageIdSnapshot` as empty,
-  // which surfaced to the model as `Current raw message IDs: none`.
-  const nextIdSnapshot = new Map<string, number>()
-  const nextMetaSnapshot = new Map<string, MessageIdMeta>()
-
-  let counter = 1;
+  const nextIdSnapshot = new Map<string, number>();
+  const nextMetaSnapshot = new Map<string, MessageIdMeta>();
+  const stableKeys = stableMessageKeys(messages);
+  const assignedIds = new Map<number, string>();
+  const assignedMeta = new Map<number, MessageIdMeta>();
 
   for (let messageIndex = 0; messageIndex < messages.length; messageIndex++) {
     const msg = messages[messageIndex];
-    const role: string = msg.role ?? "";
-
-    // Skip PI-internal passthrough messages
-    if (PASSTHROUGH_ROLES.has(role)) continue;
-    // Skip non-eligible roles
-    if (!ID_ELIGIBLE_ROLES.has(role)) continue;
-
-    const id = "m" + String(counter).padStart(3, "0");
-    counter++;
+    const role: string = msg?.role ?? "";
+    if (PASSTHROUGH_ROLES.has(role) || !ID_ELIGIBLE_ROLES.has(role)) continue;
+    if (!Number.isFinite(msg?.timestamp)) continue;
 
+    const stableKey = stableKeys[messageIndex]!;
+    const id = persistentMessageId(stableKey, state);
     const originalText = messageText(msg);
     const blockId = extractBlockId(originalText);
     const tokenEstimate = estimateMessageTokens(msg);
-    const priority = priorityForMessage(tokenEstimate, options.config);
-    const rawStableId = stableMessageId(msg, messageIndex);
-
-    if (msg.timestamp !== undefined) {
-      nextIdSnapshot.set(id, msg.timestamp);
-      nextMetaSnapshot.set(id, {
-        timestamp: msg.timestamp,
-        stableId: rawStableId,
-        role,
-        blockId,
-        toolCallId: typeof msg.toolCallId === "string" ? msg.toolCallId : undefined,
-        toolName: typeof msg.toolName === "string" ? msg.toolName : undefined,
-        text: originalText,
-        tokenEstimate,
-        priority,
-      });
+
+    assignedIds.set(messageIndex, id);
+    assignedMeta.set(messageIndex, {
+      timestamp: msg.timestamp,
+      stableId: stableKey,
+      role,
+      blockId,
+      toolCallId: typeof msg.toolCallId === "string" ? msg.toolCallId : undefined,
+      toolName: typeof msg.toolName === "string" ? msg.toolName : undefined,
+      text: originalText,
+      tokenEstimate,
+      priority: priorityForMessage(tokenEstimate, options.config),
+    });
+  }
+
+  const publish = (messageIndex: number): void => {
+    const id = assignedIds.get(messageIndex);
+    const meta = assignedMeta.get(messageIndex);
+    if (!id || !meta) return;
+    nextIdSnapshot.set(id, meta.timestamp);
+    nextMetaSnapshot.set(id, meta);
+  };
+  const pendingAssistantIndexes: number[] = [];
+  for (let messageIndex = 0; messageIndex < messages.length; messageIndex++) {
+    const message = messages[messageIndex];
+    const role: string = message?.role ?? "";
+    const id = assignedIds.get(messageIndex);
+    if (!id) continue;
+
+    if (role === "assistant") {
+      pendingAssistantIndexes.push(messageIndex);
+      continue;
     }
+    if (!ID_CARRIER_ROLES.has(role)) continue;
+
+    for (const pendingIndex of pendingAssistantIndexes) publish(pendingIndex);
+    publish(messageIndex);
+    const pendingAssistantIds = pendingAssistantIndexes
+      .map((pendingIndex) => assignedIds.get(pendingIndex))
+      .filter((pendingId): pendingId is string => pendingId !== undefined);
+    const blockId = assignedMeta.get(messageIndex)?.blockId;
+    appendControlToCarrier(
+      message,
+      buildCarrierControlText(pendingAssistantIds, id, role, blockId),
+    );
+    pendingAssistantIndexes.length = 0;
   }
 
-  state.messageIdSnapshot = nextIdSnapshot
-  state.messageMetaSnapshot = nextMetaSnapshot
+  state.messageIdSnapshot = nextIdSnapshot;
+  state.messageMetaSnapshot = nextMetaSnapshot;
 }

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

@@ -182,7 +182,7 @@ export function extractMessageId(text: string): string | undefined {
   )?.[1];
 }
 
-function stripStaleDcpMetadataLines(text: string): string {
+export function stripStaleDcpMetadataLines(text: string): string {
   if (!text.includes("<dcp-") && !text.includes("[dcp-")) return text;
 
   const lines = text.split("\n");
@@ -238,21 +238,29 @@ function stripStaleDcpMetadataLines(text: string): string {
 
 function stripStaleDcpMetadataFromAssistantBlock(block: any): any | undefined {
   if (!block || typeof block !== "object") return block;
-  const next = { ...block };
+  const textCanChange = typeof block.text === "string" &&
+    (block.text.includes("<dcp-") || block.text.includes("[dcp-"));
+  const thinkingCanChange = typeof block.thinking === "string" &&
+    (block.thinking.includes("<dcp-") || block.thinking.includes("[dcp-"));
+  if (!textCanChange && !thinkingCanChange) return block;
+
+  let next = block;
   let touched = false;
 
-  if (typeof next.text === "string") {
-    const stripped = stripStaleDcpMetadataLines(next.text);
-    if (stripped !== next.text) {
+  if (typeof block.text === "string") {
+    const stripped = stripStaleDcpMetadataLines(block.text);
+    if (stripped !== block.text) {
+      next = { ...next };
       touched = true;
       next.text = stripped;
       delete next.textSignature;
     }
   }
 
-  if (typeof next.thinking === "string") {
-    const stripped = stripStaleDcpMetadataLines(next.thinking);
-    if (stripped !== next.thinking) {
+  if (typeof block.thinking === "string") {
+    const stripped = stripStaleDcpMetadataLines(block.thinking);
+    if (stripped !== block.thinking) {
+      if (!touched) next = { ...next };
       touched = true;
       next.thinking = stripped;
       delete next.thinkingSignature;
@@ -265,20 +273,23 @@ function stripStaleDcpMetadataFromAssistantBlock(block: any): any | undefined {
 }
 
 export function stripStaleDcpMetadataFromAssistantMessage(message: any): any {
-  if (!message || typeof message !== "object" || message.role !== "assistant") return message;
-  return stripStaleDcpMetadataFromMessage(message);
+  return message;
 }
 
 export function stripStaleDcpMetadataFromMessage(message: any): any {
   if (!message || typeof message !== "object") return message;
+  // Assistant content may contain provider-signed reasoning, text, or tool-call
+  // items. Even DCP-looking text must replay byte-for-byte once persisted.
+  if (message.role === "assistant") return message;
   if (typeof message.content === "string") {
-    return { ...message, content: stripStaleDcpMetadataLines(message.content) };
+    const stripped = stripStaleDcpMetadataLines(message.content);
+    return stripped === message.content ? message : { ...message, content: stripped };
   }
   if (!Array.isArray(message.content)) return message;
-  return {
-    ...message,
-    content: message.content
-      .map(stripStaleDcpMetadataFromAssistantBlock)
-      .filter((block: any) => block !== undefined),
-  };
+  const content = message.content
+    .map(stripStaleDcpMetadataFromAssistantBlock)
+    .filter((block: any) => block !== undefined);
+  const unchanged = content.length === message.content.length &&
+    content.every((block: any, index: number) => block === message.content[index]);
+  return unchanged ? message : { ...message, content };
 }

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

@@ -7,7 +7,7 @@ import type {
   NudgeThresholds,
 } from "./pruner-types.js";
 import { extractBlockId, messageText } from "./pruner-metadata.js";
-import { stableMessageId } from "./pruner-message-ids.js";
+import { stableMessageKeys } from "./pruner-message-ids.js";
 
 function coercePercentThreshold(value: number | string | undefined, fallback: number): number {
   if (typeof value === "number") return Number.isFinite(value) ? value : fallback;
@@ -56,6 +56,7 @@ function isRealAnchorCandidate(msg: any): boolean {
 }
 
 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.
   for (let i = messages.length - 1; i >= 0; i--) {
@@ -65,7 +66,7 @@ function findAnchorMessage(messages: any[]): { msg: any; index: number; stableId
     return {
       msg,
       index: i,
-      stableId: stableMessageId(msg, i),
+      stableId: stableKeys[i]!,
       timestamp: msg.timestamp,
       role: msg.role,
     };
@@ -79,7 +80,7 @@ function findAnchorMessage(messages: any[]): { msg: any; index: number; stableId
     return {
       msg,
       index: i,
-      stableId: stableMessageId(msg, i),
+      stableId: stableKeys[i]!,
       timestamp: msg.timestamp,
       role: msg.role,
     };
@@ -88,8 +89,8 @@ function findAnchorMessage(messages: any[]): { msg: any; index: number; stableId
   return null;
 }
 
-function anchorMatchesMessage(anchor: DcpNudgeAnchor, msg: any, index: number): boolean {
-  if (anchor.anchorStableId && stableMessageId(msg, index) === anchor.anchorStableId) return true;
+function anchorMatchesMessage(anchor: DcpNudgeAnchor, msg: any, stableKey: string): boolean {
+  if (anchor.anchorStableId && stableKey === anchor.anchorStableId) return true;
   return msg?.timestamp === anchor.anchorTimestamp;
 }
 
@@ -207,34 +208,33 @@ export function upsertNudgeAnchor(
   messages: any[],
   state: DcpState,
   type: DcpNudgeType,
-  options: { contextPercent?: number } = {},
+  options: { contextPercent?: number; renderedReminder?: string } = {},
 ): { anchor: DcpNudgeAnchor | null; created: boolean; updated: boolean } {
-  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.
-    state.nudgeAnchors = [];
-    state.lastNudge = undefined;
-    return { anchor: null, created: false, updated: false };
-  }
-
-  const key = `${target.stableId}|${target.timestamp}`;
+  const stableKeys = stableMessageKeys(messages);
   let existing: DcpNudgeAnchor | null = null;
   for (const anchor of state.nudgeAnchors) {
-    const anchorKey = `${anchor.anchorStableId ?? ""}|${anchor.anchorTimestamp}`;
-    if (anchorKey !== key) continue;
+    const stillPresent = messages.some((message, index) =>
+      isRealAnchorCandidate(message) && anchorMatchesMessage(anchor, message, stableKeys[index]!),
+    );
+    if (!stillPresent) continue;
     if (!existing || isNewerAnchor(anchor, existing)) existing = anchor;
   }
 
   const now = Date.now();
   if (existing) {
-    // Older sidecars may contain several anchors. Keep only the anchor for the
-    // current target so every subsequent context pass has singleton state.
+    // Keep the original carrier and frozen text. Moving a reminder to the
+    // newest user message would remove bytes from an old provider-cache prefix.
     state.nudgeAnchors = [existing];
     const shouldUpgrade = typePriority(type) > typePriority(existing.type);
-    if (shouldUpgrade) existing.type = type;
-    existing.updatedAt = now;
-    existing.contextPercent = options.contextPercent ?? existing.contextPercent;
+    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,
@@ -246,6 +246,15 @@ export function upsertNudgeAnchor(
     return { anchor: existing, created: false, updated: shouldUpgrade };
   }
 
+  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.
+    state.nudgeAnchors = [];
+    state.lastNudge = undefined;
+    return { anchor: null, created: false, updated: false };
+  }
+
   const anchor: DcpNudgeAnchor = {
     id: state.nextNudgeAnchorId++,
     type,
@@ -254,6 +263,7 @@ export function upsertNudgeAnchor(
     anchorRole: target.role,
     turnIndex: state.currentTurn,
     contextPercent: options.contextPercent,
+    renderedReminder: options.renderedReminder,
     createdAt: now,
     updatedAt: now,
   };
@@ -275,12 +285,16 @@ export function applyAnchoredNudges(
   messages: any[],
   state: DcpState,
   render: (anchor: DcpNudgeAnchor) => string,
-): void {
-  if (state.nudgeAnchors.length === 0) return;
+): { rendered: boolean; stateChanged: boolean } {
+  if (state.nudgeAnchors.length === 0) return { rendered: false, stateChanged: false };
 
+  const stableKeys = stableMessageKeys(messages);
+  const priorAnchors = state.nudgeAnchors;
   let selected: { anchor: DcpNudgeAnchor; index: number } | null = null;
   for (const anchor of state.nudgeAnchors) {
-    const index = messages.findIndex((msg, messageIndex) => anchorMatchesMessage(anchor, msg, messageIndex));
+    const index = messages.findIndex((msg, messageIndex) =>
+      anchorMatchesMessage(anchor, msg, stableKeys[messageIndex]!),
+    );
     if (index === -1) continue;
     if (!selected || isNewerAnchor(anchor, selected.anchor)) {
       selected = { anchor, index };
@@ -290,7 +304,27 @@ export function applyAnchoredNudges(
   // Defensive migration for persisted pre-singleton state: render only the
   // newest valid anchor and discard every stale predecessor.
   state.nudgeAnchors = selected ? [selected.anchor] : [];
-  if (selected) appendTextToMessage(messages[selected.index], render(selected.anchor));
+  const anchorSetChanged = state.nudgeAnchors.length !== priorAnchors.length ||
+    state.nudgeAnchors.some((anchor, index) => anchor !== priorAnchors[index]);
+  if (!selected) return { rendered: false, stateChanged: anchorSetChanged };
+
+  const materializedReminder = selected.anchor.renderedReminder === undefined;
+  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);
+  }
+  return {
+    rendered: true,
+    stateChanged: anchorSetChanged || materializedReminder,
+  };
 }
 
 export function clearDcpNudgeAnchors(state: DcpState): number {

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

@@ -1,7 +1,7 @@
 import type { DcpConfig } from "./config.js";
 import type { DcpState } from "./state.js";
 import { applyCompressionBlocks, repairOrphanedToolPairs, syncCompressionBlocks } from "./pruner-compression-blocks.js";
-import { stripStaleDcpMetadataFromAssistantMessage } from "./pruner-metadata.js";
+import { stripStaleDcpMetadataFromMessage } from "./pruner-metadata.js";
 import { injectMessageIds } from "./pruner-message-ids.js";
 import {
   applyAutoToolOutputPruning,
@@ -63,7 +63,7 @@ export function applyPruning(
         typeof contentBlock === "object" && contentBlock !== null ? { ...contentBlock } : contentBlock,
       );
     }
-    return stripStaleDcpMetadataFromAssistantMessage(clone);
+    return stripStaleDcpMetadataFromMessage(clone);
   });
 
   // 1. Count user turns → update state.currentTurn. Do this before inserting
@@ -79,21 +79,29 @@ export function applyPruning(
   // expansion logic could not catch (e.g. multi-block interactions, pre-broken state).
   repairOrphanedToolPairs(msgs);
 
-  // 3. Apply deduplication
-  applyDeduplication(msgs, state, config);
-
-  // 4. Apply error purging
-  applyErrorPurging(msgs, state, config);
-
-  // 5. Apply autonomous policy pruning for old/large/stale tool outputs
-  applyAutoToolOutputPruning(msgs, state, config);
+  // 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)
   applyToolOutputPruning(msgs, state);
 
-  // 7. Refresh message ID snapshots used by the compress tool. Markers are
-  // never injected into provider-visible content; the before_provider_request
-  // hook delivers the id map as a hidden control payload.
+  // 7. Refresh message ID snapshots and append stable distributed metadata to
+  // user/tool-result carriers. Assistant items remain byte-stable.
   injectMessageIds(msgs, state, { config });
 
   // 8. state.messageIdSnapshot/messageMetaSnapshot are already updated by injectMessageIds