pi-ui-extend 0.1.44 → 0.1.45

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

@@ -383,11 +383,86 @@ export function resolveIdToBoundary(
   }
 
   const meta = state.messageMetaSnapshot.get(id)
-  if (meta) return { timestamp: meta.timestamp, stableId: meta.stableId }
+  if (meta) return resolveMetaBoundary(meta, field, state)
 
   const ts = state.messageIdSnapshot.get(id)
-  if (ts === undefined) throw unknownCompressionIdError(id, state)
-  return { timestamp: ts }
+  if (ts !== undefined) return { timestamp: ts }
+
+  // ── Stale mNNN fallback: direction-only clamp ────────────────────────
+  // When compression or pruning removes messages between context passes,
+  // positional mNNN IDs shift (e.g. an end boundary m145 becomes m123
+  // after 22 messages are removed).  Clamp to the closest valid ID, but
+  // ONLY in a direction that preserves the range's semantics:
+  //   - start boundary: clamp upward to the first available ID at or after
+  //     the requested number.  The start must never move backwards into
+  //     older content; if no such ID exists, the requested start is gone
+  //     and we cannot safely compress — throw.
+  //   - end boundary: clamp downward to the last available ID at or before
+  //     the requested number.  The end must never move forwards into newer
+  //     content; if no such ID exists, throw.
+  // The previous implementation fell back to the highest available ID in
+  // both "no match" cases, which could clamp e.g. m010..m010 over a
+  // snapshot of m001..m003 to a single-message block over m003 — silently
+  // compressing the wrong content.
+  const mMatch = id.match(/^m(\d+)$/i)
+  if (mMatch && state.messageIdSnapshot.size > 0) {
+    const requestedNum = parseInt(mMatch[1]!, 10)
+    const allIds = sortIds([...state.messageIdSnapshot.keys()])
+    const allNums = allIds
+      .map((mid) => {
+        const n = mid.match(/^m(\d+)$/i)
+        return n ? { id: mid, num: parseInt(n[1]!, 10) } : null
+      })
+      .filter((entry): entry is { id: string; num: number } => entry !== null)
+      .sort((a, b) => a.num - b.num)
+
+    if (allNums.length > 0) {
+      let clamped: { id: string; num: number } | undefined
+      if (field === "startTimestamp") {
+        clamped = allNums.find((entry) => entry.num >= requestedNum)
+      } else {
+        for (let i = allNums.length - 1; i >= 0; i--) {
+          if (allNums[i]!.num <= requestedNum) {
+            clamped = allNums[i]
+            break
+          }
+        }
+      }
+      if (clamped) {
+        const clampedMeta = state.messageMetaSnapshot.get(clamped.id)
+        if (clampedMeta) return resolveMetaBoundary(clampedMeta, field, state)
+        const clampedTs = state.messageIdSnapshot.get(clamped.id)
+        if (clampedTs !== undefined) return { timestamp: clampedTs }
+      }
+    }
+  }
+
+  throw unknownCompressionIdError(id, state)
+}
+
+/**
+ * Resolve a `MessageIdMeta` to a compression boundary. When the meta is a
+ * synthetic placeholder for an active compression block (`meta.blockId` is
+ * set), resolve to that block's stored boundary so the caller rolls the
+ * block up instead of nesting a new block on top of the placeholder. This
+ * matters for both exact-match and clamped mNNN IDs: a model-visible mNNN
+ * may itself represent a previously compressed section.
+ */
+function resolveMetaBoundary(
+  meta: MessageIdMeta,
+  field: "startTimestamp" | "endTimestamp",
+  state: DcpState,
+): ResolvedCompressionBoundary {
+  if (meta.blockId !== undefined) {
+    const block = state.compressionBlocks.find((b) => b.id === meta.blockId && b.active)
+    if (block) {
+      return {
+        timestamp: block[field],
+        stableId: field === "startTimestamp" ? block.startMessageId : block.endMessageId,
+      }
+    }
+  }
+  return { timestamp: meta.timestamp, stableId: meta.stableId }
 }
 
 /**

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

@@ -13,60 +13,76 @@ function findBoundaryIndex(messages: any[], stableId: string | undefined, timest
   return messages.findIndex((m, index) => messageMatchesBoundary(m, index, stableId, timestamp));
 }
 
-function collectToolCallIds(messages: any[]): Set<string> {
-  const ids = new Set<string>();
-  for (const msg of messages) {
-    if (typeof msg?.toolCallId === "string") ids.add(msg.toolCallId);
-    if (msg?.role !== "assistant" || !Array.isArray(msg.content)) continue;
-    for (const block of msg.content) {
-      if (block?.type === "toolCall" && typeof block.id === "string") ids.add(block.id);
-    }
-  }
-  return ids;
-}
 
 export function syncCompressionBlocks(messages: any[], state: DcpState, config: DcpConfig): void {
   if (state.compressionBlocks.length === 0) return;
 
-  const toolCallIds = collectToolCallIds(messages);
+  // Determine the conversation's timestamp range so we can tell whether a
+  // block's range is genuinely outside the current session history (which
+  // warrants deactivation) vs merely having its boundary messages pruned
+  // (which is normal and should NOT cause deactivation).
+  let conversationMinTs = Infinity;
+  let conversationMaxTs = -Infinity;
+  for (const msg of messages) {
+    const ts = msg?.timestamp;
+    if (typeof ts === "number" && Number.isFinite(ts)) {
+      if (ts < conversationMinTs) conversationMinTs = ts;
+      if (ts > conversationMaxTs) conversationMaxTs = ts;
+    }
+  }
 
   for (const block of state.compressionBlocks) {
     if (!block.active || block.deactivatedByUser) continue;
 
+    // ── Skip the missing-origin-compress-call check ────────────────────
+    // The compress tool-call that *created* this block is not the block's
+    // content — once the block exists the tool-call is irrelevant and will
+    // naturally be pruned by tool-output pruning, session compaction, or
+    // nested compression.  Deactivating a valid block because its creation
+    // tool-call was pruned silently loses the compressed summary and forces
+    // the original (larger) messages to be re-sent, which also invalidates
+    // the provider's prompt prefix cache.
+
+    // ── Boundary validation ────────────────────────────────────────────
+    // Only deactivate when the block's timestamp range falls entirely
+    // outside the conversation's time range, meaning the session genuinely
+    // does not contain that history (e.g. after a branch switch to a
+    // completely different conversation).  When boundary messages are merely
+    // absent because they were themselves pruned, compressed, or have
+    // fragile timestamp-based stable IDs, the block is still valid —
+    // applyCompressionBlocks already handles missing boundaries gracefully
+    // by skipping splicing when findBoundaryIndex returns -1.
     if (
-      typeof block.createdByToolCallId === "string" &&
-      state.toolCalls.has(block.createdByToolCallId) &&
-      !toolCallIds.has(block.createdByToolCallId)
+      Number.isFinite(block.startTimestamp) &&
+      Number.isFinite(block.endTimestamp) &&
+      Number.isFinite(conversationMinTs) &&
+      Number.isFinite(conversationMaxTs)
     ) {
-      block.active = false;
-      block.deactivatedReason = "missing-origin-compress-call";
-      writeDcpDebugLog(config, "block.auto_deactivated", {
-        blockId: `b${block.id}`,
-        reason: "missing-origin-compress-call",
-        topic: block.topic,
-        createdByToolCallId: block.createdByToolCallId,
-        activeBlocksAfter: state.compressionBlocks.filter((b) => b.active).length,
-      });
-      continue;
-    }
+      // Block range is entirely before or entirely after the conversation
+      const blockEntirelyOutside =
+        block.endTimestamp < conversationMinTs ||
+        block.startTimestamp > conversationMaxTs;
 
-    const hasStableBoundaries = !!block.startMessageId && !!block.endMessageId;
-    if (!hasStableBoundaries) continue;
+      if (blockEntirelyOutside) {
+        // Before deactivating, check if boundary messages can still be
+        // found by their stable ID — timestamps can change across
+        // session reloads while the underlying message persists.
+        const startFound = findBoundaryIndex(messages, block.startMessageId, block.startTimestamp) !== -1;
+        const endFound = findBoundaryIndex(messages, block.endMessageId, block.endTimestamp) !== -1;
 
-    const startIdx = findBoundaryIndex(messages, block.startMessageId, block.startTimestamp);
-    const endIdx = findBoundaryIndex(messages, block.endMessageId, block.endTimestamp);
-    if (startIdx === -1 || endIdx === -1) {
-      block.active = false;
-      block.deactivatedReason = "missing-origin-message";
-      writeDcpDebugLog(config, "block.auto_deactivated", {
-        blockId: `b${block.id}`,
-        reason: "missing-origin-message",
-        topic: block.topic,
-        missingBoundary: startIdx === -1 ? "start" : "end",
-        startMessageId: block.startMessageId,
-        endMessageId: block.endMessageId,
-        activeBlocksAfter: state.compressionBlocks.filter((b) => b.active).length,
-      });
+        if (!startFound && !endFound) {
+          block.active = false;
+          block.deactivatedReason = "outside-conversation-range";
+          writeDcpDebugLog(config, "block.auto_deactivated", {
+            blockId: `b${block.id}`,
+            reason: "outside-conversation-range",
+            topic: block.topic,
+            blockRange: [block.startTimestamp, block.endTimestamp],
+            conversationRange: [conversationMinTs, conversationMaxTs],
+            activeBlocksAfter: state.compressionBlocks.filter((b) => b.active).length,
+          });
+        }
+      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "0.1.44",
+  "version": "0.1.45",
   "private": false,
   "type": "module",
   "bin": {