acp-kernel 0.0.89 → 0.0.90-pr.420.271

package/dist/index.js

@@ -111,33 +111,45 @@ function summaryMessageId(blockId) {
 function isSummaryMessageId(id) {
   return id.startsWith(SUMMARY_ID_PREFIX);
 }
+function baseIdOf(id) {
+  const hash = id.indexOf("#");
+  return hash > 0 ? id.substring(0, hash) : id;
+}
+function isCovered(id, coveredBases) {
+  return coveredBases.has(baseIdOf(id));
+}
 function isRenderedSummaryMessage(message) {
   return isSummaryMessageId(message.id) && message.role === "system" && message.contentType === "text";
 }
 function prune(messages, state, options = {}) {
   const covered = coveredMessageIds(state);
   if (covered.size === 0) return [...messages];
+  const coveredBases = /* @__PURE__ */ new Set();
+  for (const id of covered) coveredBases.add(baseIdOf(id));
   const inject = options.injectSummaries ?? true;
   const firstUserIndex = messages.findIndex(
     (message) => message.role === "user"
   );
-  const indexById = /* @__PURE__ */ new Map();
+  const baseIndexById = /* @__PURE__ */ new Map();
   const summaryIndexById = /* @__PURE__ */ new Map();
   messages.forEach((message, index) => {
-    indexById.set(message.id, index);
+    const base = baseIdOf(message.id);
+    const existing = baseIndexById.get(base);
+    if (existing === void 0 || index < existing)
+      baseIndexById.set(base, index);
     if (isRenderedSummaryMessage(message))
       summaryIndexById.set(message.id, index);
   });
-  const anchors = inject ? collectSummaryAnchors(state, indexById, summaryIndexById) : [];
+  const anchors = inject ? collectSummaryAnchors(state, baseIndexById, summaryIndexById) : [];
   return stripOrphanedReasoning(
     stripOrphanedToolResults(
       stripOrphanedToolCalls(
-        rebuildMessages(messages, covered, firstUserIndex, anchors)
+        rebuildMessages(messages, coveredBases, firstUserIndex, anchors)
       )
     )
   );
 }
-function collectSummaryAnchors(state, indexById, summaryIndexById) {
+function collectSummaryAnchors(state, baseIndexById, summaryIndexById) {
   const anchors = [];
   for (const block of activeBlocks(state)) {
     const existingIndex = summaryIndexById.get(summaryMessageId(block.blockId));
@@ -152,7 +164,7 @@ function collectSummaryAnchors(state, indexById, summaryIndexById) {
     }
     let earliest = null;
     for (const id of block.effectiveMessageIds) {
-      const index = indexById.get(id);
+      const index = baseIndexById.get(baseIdOf(id));
       if (index !== void 0 && (earliest === null || index < earliest)) {
         earliest = index;
       }
@@ -197,7 +209,7 @@ function pairSafeAnchorIndex(messages, index) {
   }
   return safe;
 }
-function rebuildMessages(messages, covered, firstUserIndex, anchors) {
+function rebuildMessages(messages, coveredBases, firstUserIndex, anchors) {
   const safeAnchors = anchors.map((anchor) => ({
     ...anchor,
     insertAt: pairSafeAnchorIndex(messages, anchor.insertAt)
@@ -215,7 +227,7 @@ function rebuildMessages(messages, covered, firstUserIndex, anchors) {
       result.push(messages[index]);
       continue;
     }
-    if (covered.has(messages[index].id)) continue;
+    if (isCovered(messages[index].id, coveredBases)) continue;
     if (isRenderedSummaryMessage(messages[index]) && anchoredSummaryIds.has(messages[index].id))
       continue;
     result.push(messages[index]);
@@ -281,6 +293,8 @@ function stripOrphanedReasoning(messages) {
 // src/sync.ts
 function syncBlocks(messages, state) {
   const presentIds = new Set(messages.map((message) => message.id));
+  const presentBases = /* @__PURE__ */ new Set();
+  for (const message of messages) presentBases.add(baseIdOf(message.id));
   const deactivated = [];
   const result = {
     blocks: state.blocks.map((block) => ({
@@ -330,7 +344,7 @@ function syncBlocks(messages, state) {
       continue;
     }
     block.active = true;
-    const stillPresent = block.effectiveMessageIds.some((id) => presentIds.has(id)) || presentIds.has(summaryMessageId(block.blockId));
+    const stillPresent = block.effectiveMessageIds.some((id) => presentBases.has(baseIdOf(id))) || presentIds.has(summaryMessageId(block.blockId));
     if (!stillPresent) {
       block.active = false;
       deactivated.push(block.blockId);
@@ -1248,7 +1262,12 @@ function hasMediaPayload(msg) {
   if (m.rawOpenaiContent != null) return true;
   if (Array.isArray(m.rawOpenaiContentParts) && m.rawOpenaiContentParts.length > 0)
     return true;
-  if (isObjWith(m.rawAnthropicBlock, "type", "image")) return true;
+  const ab = m.rawAnthropicBlock;
+  if (isObjWith(ab, "type", "image")) return true;
+  if (isObjWith(ab, "type", "tool_result")) {
+    const content = ab.content;
+    if (Array.isArray(content)) return content.some((p) => !isObjWith(p, "type", "text"));
+  }
   const item = m.rawResponsesItem;
   if (isObjWith(item, "type", "input_image")) return true;
   if (item && typeof item === "object") {
@@ -1612,8 +1631,10 @@ function resolveBoundaries(input) {
   if (endAnchor.snapped) snappedBoundaries.push(endAnchor.snapped);
   let startIndex = startAnchor.index;
   let endIndex = endAnchor.index;
+  let reversedNote;
   if (startIndex > endIndex) {
     [startIndex, endIndex] = [endIndex, startIndex];
+    reversedNote = `note: refs were given reversed (${start.raw}\u2192${end.raw}), normalized to ${end.raw}..${start.raw}`;
   }
   const messageIds = [];
   for (let index = startIndex; index <= endIndex; index++) {
@@ -1640,7 +1661,8 @@ function resolveBoundaries(input) {
     nestedBlockIds,
     boundaryKind,
     protectedGaps,
-    snappedBoundaries
+    snappedBoundaries,
+    reversedNote
   };
 }
 function resolveAnchorIndex(boundary, state, indexByMessageId, endpoint) {
@@ -1665,6 +1687,27 @@ function resolveAnchorIndex(boundary, state, indexByMessageId, endpoint) {
         snapped: `${label}="${boundary.raw}" refers to a message already compressed into an active block \u2014 anchored to the active block covering it instead.`
       };
     }
+    const paddedRef = formatPaddedRef(boundary.numericId);
+    if (state.hiddenOrphanRefs?.includes(paddedRef)) {
+      const neighbor = snapToNeighborVisible(
+        state,
+        indexByMessageId,
+        boundary.numericId,
+        endpoint
+      );
+      if (neighbor !== null) {
+        const dir = endpoint === "start" ? "the next visible message after it" : "the previous visible message before it";
+        return {
+          index: neighbor,
+          snapped: `${label}="${boundary.raw}" is a hidden orphan compress call (no matching block) \u2014 snapped to ${dir} instead.`
+        };
+      }
+      throw new BoundaryNotFoundError(
+        "consumed",
+        endpoint,
+        `${label}="${boundary.raw}" is a hidden orphan compress call with no adjacent visible message to anchor to \u2014 run acp_status for current refs.`
+      );
+    }
     throw new BoundaryNotFoundError(
       "consumed",
       endpoint,
@@ -1741,6 +1784,26 @@ function inheritedContentIds(state, block) {
   }
   return ids;
 }
+function snapToNeighborVisible(state, indexByMessageId, refNumber, endpoint) {
+  let bestIndex = null;
+  let bestRef = null;
+  for (const [rawId, index] of indexByMessageId) {
+    const refText = state.messageRefs.byRaw[rawId];
+    if (!refText || refText === BLOCKED_REF) continue;
+    const ref = refToIndex(refText);
+    if (ref === null) continue;
+    if (endpoint === "start") {
+      if (ref > refNumber && (bestRef === null || ref < bestRef)) {
+        bestRef = ref;
+        bestIndex = index;
+      }
+    } else if (ref < refNumber && (bestRef === null || ref > bestRef)) {
+      bestRef = ref;
+      bestIndex = index;
+    }
+  }
+  return bestIndex;
+}
 function formatPaddedRef(index) {
   return `m${String(index).padStart(5, "0")}`;
 }
@@ -1771,6 +1834,214 @@ function earliestIndexOfIds(ids, indexByMessageId) {
   return earliest;
 }
 
+// src/block-map.ts
+function refNum(ref) {
+  const m = ref.match(/\d+/);
+  return m ? parseInt(m[0], 10) : 0;
+}
+var M_REF = /^m\d+$/;
+function resolveBlockSpan(block, byRaw) {
+  if (block.startRef && block.endRef && M_REF.test(block.startRef) && M_REF.test(block.endRef)) {
+    return { startRef: block.startRef, endRef: block.endRef };
+  }
+  const refs = block.effectiveMessageIds.map((id) => byRaw[id]).filter((r) => typeof r === "string" && r !== "BLOCKED");
+  if (refs.length === 0) return null;
+  const sorted = [...refs].sort((a, b) => refNum(a) - refNum(b));
+  return { startRef: sorted[0], endRef: sorted[sorted.length - 1] };
+}
+function activeBlockSpans(state) {
+  const spans = [];
+  for (const block of state.blocks) {
+    if (!block.active) continue;
+    const span = resolveBlockSpan(block, state.messageRefs.byRaw);
+    if (!span) continue;
+    spans.push({ blockId: block.blockId, tier: block.tier, ...span });
+  }
+  return spans;
+}
+function formatCreatedBlocks(state, newBlocks) {
+  const parts = [];
+  for (const block of newBlocks) {
+    const span = resolveBlockSpan(block, state.messageRefs.byRaw);
+    parts.push(
+      span ? `${block.blockId}=${span.startRef}\u2013${span.endRef}` : block.blockId
+    );
+  }
+  return parts.length > 0 ? `blocks: ${parts.join(", ")}` : "";
+}
+
+// src/decompress.ts
+function parseBlockIdArg(arg) {
+  const normalized = arg.trim().toLowerCase();
+  const refMatch = /^b0*(\d+)$/.exec(normalized);
+  if (refMatch && refMatch[1] !== void 0) return `b${refMatch[1]}`;
+  const numMatch = /^(\d+)$/.exec(normalized);
+  if (numMatch && numMatch[1] !== void 0) return `b${numMatch[1]}`;
+  return null;
+}
+function findBlocksOverlappingMessages(state, messageIds) {
+  if (messageIds.size === 0) return [];
+  const matched = [];
+  for (const block of state.blocks) {
+    if (!block.active) continue;
+    if (block.effectiveMessageIds.some((id) => messageIds.has(id))) {
+      matched.push(block);
+    }
+  }
+  return matched.sort((a, b) => numericPart(a.blockId) - numericPart(b.blockId));
+}
+function findActiveAncestor(state, blockId) {
+  const start = state.blocks.find((b) => b.blockId === blockId);
+  if (!start) return null;
+  const queue = [...start.directBlockIds];
+  const visited = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const currentId = queue.shift();
+    if (visited.has(currentId)) continue;
+    visited.add(currentId);
+    const current = state.blocks.find((b) => b.blockId === currentId);
+    if (!current) continue;
+    if (current.active) return current.blockId;
+    for (const ancestorId of current.directBlockIds) {
+      if (!visited.has(ancestorId)) queue.push(ancestorId);
+    }
+  }
+  return null;
+}
+function deactivateBlock(state, blockIds, options = {}) {
+  const targets = new Set(blockIds);
+  const updated = state.blocks.map((block) => {
+    if (!targets.has(block.blockId) || !block.active) return block;
+    return {
+      ...block,
+      active: false,
+      durationMs: block.durationMs,
+      createdAt: block.createdAt
+    };
+  });
+  let final = updated;
+  if (options.deep) {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [];
+    for (const id of blockIds) {
+      const block = updated.find((b) => b.blockId === id);
+      if (block) queue.push(...block.directBlockIds);
+    }
+    while (queue.length > 0) {
+      const id = queue.shift();
+      if (visited.has(id)) continue;
+      visited.add(id);
+      final = final.map((block) => {
+        if (block.blockId !== id) return block;
+        queue.push(...block.directBlockIds);
+        return block.active ? { ...block, active: false } : block;
+      });
+    }
+  }
+  return { ...state, blocks: final };
+}
+function buildRestoredContentPreview(messages, beforeActiveMessageIds, state) {
+  const restored = [];
+  for (const message of messages) {
+    if (!beforeActiveMessageIds.has(message.id)) continue;
+    const stillCovered = state.blocks.some(
+      (b) => b.active && b.effectiveMessageIds.includes(message.id)
+    );
+    if (!stillCovered) restored.push(message);
+  }
+  if (restored.length === 0) return { preview: "", restoredCount: 0 };
+  const lines = [];
+  let totalLength = 0;
+  const MAX_PREVIEW = 2e3;
+  const MAX_PER_MESSAGE = 200;
+  for (const message of restored) {
+    if (totalLength >= MAX_PREVIEW) break;
+    const text = message.text ?? "";
+    const truncated = text.length > MAX_PER_MESSAGE ? clampPrefix(text, MAX_PER_MESSAGE) + "..." : text;
+    const label = message.toolName && message.contentType !== "text" ? `${message.toolName}: ${truncated}` : `[${message.role}] ${truncated}`;
+    lines.push(label);
+    totalLength += label.length + 1;
+  }
+  return { preview: lines.join("\n"), restoredCount: restored.length };
+}
+function collectBlockContent(state, block, messages, options = {}) {
+  const full = options.full ?? false;
+  const targetIds = new Set(block.effectiveMessageIds);
+  if (full) {
+    const msgs = messages.filter((m) => targetIds.has(m.id));
+    if (msgs.length === 0) return { text: "", count: 0 };
+    return { text: msgs.map(formatMessage).join("\n\n"), count: msgs.length };
+  }
+  const nestedChildren = [];
+  const nestedCovered = /* @__PURE__ */ new Set();
+  for (const childId of block.directBlockIds) {
+    const child = state.blocks.find((b) => b.blockId === childId);
+    if (!child?.active) continue;
+    nestedChildren.push(child);
+    for (const id of child.effectiveMessageIds) nestedCovered.add(id);
+  }
+  const parts = [];
+  for (const child of nestedChildren) {
+    const label = child.topic ? `${child.blockId}: ${child.topic}` : child.blockId;
+    parts.push(`${SUMMARY_HEADER} \u2014 ${label}
+${child.summary}`);
+  }
+  let directCount = 0;
+  for (const m of messages) {
+    if (targetIds.has(m.id) && !nestedCovered.has(m.id)) {
+      parts.push(formatMessage(m));
+      directCount++;
+    }
+  }
+  const count = directCount + nestedChildren.length;
+  if (count === 0) return { text: "", count: 0 };
+  return { text: parts.join("\n\n"), count };
+}
+function formatMessage(message) {
+  const text = message.text ?? "";
+  if (message.toolName && message.contentType !== "text") {
+    return `[${message.role} \u2022 ${message.toolName}]
+${text}`;
+  }
+  return `[${message.role}]
+${text}`;
+}
+function numericPart(blockId) {
+  const match = /^b(\d+)$/.exec(blockId);
+  return match && match[1] !== void 0 ? Number(match[1]) : 0;
+}
+function markBlockRestoredInline(state, blockId) {
+  const existing = state.blocks.find((b) => b.blockId === blockId);
+  if (!existing) return { state, result: null };
+  const blocks = state.blocks.map(
+    (block) => block.blockId === blockId ? { ...block, restoredInline: true } : block
+  );
+  const span = resolveBlockSpan(existing, state.messageRefs.byRaw);
+  const result = {
+    restored: true,
+    blockId,
+    ...span ? { restoredStartRef: span.startRef, restoredEndRef: span.endRef } : {}
+  };
+  return { state: { ...state, blocks }, result };
+}
+function activeAncestorIds(state, blockId) {
+  const out = [];
+  const visited = /* @__PURE__ */ new Set([blockId]);
+  let frontier = [blockId];
+  while (frontier.length > 0) {
+    const next = [];
+    for (const block of state.blocks) {
+      if (visited.has(block.blockId)) continue;
+      if (!block.directBlockIds.some((id) => frontier.includes(id))) continue;
+      visited.add(block.blockId);
+      if (block.active) out.push(block.blockId);
+      next.push(block.blockId);
+    }
+    frontier = next;
+  }
+  return out;
+}
+
 // src/truncate-tools.ts
 var TRUNCATION_MARKER = "[truncated for context space]";
 var DEFAULTS = {
@@ -1955,14 +2226,26 @@ function hideConsumedCompressCalls(state, messages) {
     }
   }
   let hidden = 0;
+  const hiddenOrphanRefs = [];
+  const rememberHiddenRef = (message) => {
+    if (message.toolCallId && allBlockCallIds.has(message.toolCallId)) {
+      return;
+    }
+    const ref = state.messageRefs.byRaw[message.id];
+    if (ref && ref !== BLOCKED_REF && !hiddenOrphanRefs.includes(ref)) {
+      hiddenOrphanRefs.push(ref);
+    }
+  };
   const result = [];
   for (const message of messages) {
     if (message.toolName === "compress" && message.contentType === "tool-call" && (!message.toolCallId || !keepCallIds.has(message.toolCallId))) {
       hidden++;
+      rememberHiddenRef(message);
       continue;
     }
     if (message.contentType === "tool-result" && message.toolCallId && hiddenCallIds.has(message.toolCallId)) {
       hidden++;
+      rememberHiddenRef(message);
       continue;
     }
     if (message.toolName === "compress" && message.contentType === "tool-call" && message.toolCallId && keepCallIds.has(message.toolCallId)) {
@@ -1982,7 +2265,7 @@ function hideConsumedCompressCalls(state, messages) {
     }
     result.push(message);
   }
-  return { messages: result, hidden };
+  return { messages: result, hidden, hiddenOrphanRefs };
 }
 
 // src/absorb.ts
@@ -3632,42 +3915,6 @@ function applyMessageFilters(messages, config) {
   return { messages: working, ...tally };
 }
 
-// src/block-map.ts
-function refNum(ref) {
-  const m = ref.match(/\d+/);
-  return m ? parseInt(m[0], 10) : 0;
-}
-var M_REF = /^m\d+$/;
-function resolveBlockSpan(block, byRaw) {
-  if (block.startRef && block.endRef && M_REF.test(block.startRef) && M_REF.test(block.endRef)) {
-    return { startRef: block.startRef, endRef: block.endRef };
-  }
-  const refs = block.effectiveMessageIds.map((id) => byRaw[id]).filter((r) => typeof r === "string" && r !== "BLOCKED");
-  if (refs.length === 0) return null;
-  const sorted = [...refs].sort((a, b) => refNum(a) - refNum(b));
-  return { startRef: sorted[0], endRef: sorted[sorted.length - 1] };
-}
-function activeBlockSpans(state) {
-  const spans = [];
-  for (const block of state.blocks) {
-    if (!block.active) continue;
-    const span = resolveBlockSpan(block, state.messageRefs.byRaw);
-    if (!span) continue;
-    spans.push({ blockId: block.blockId, tier: block.tier, ...span });
-  }
-  return spans;
-}
-function formatCreatedBlocks(state, newBlocks) {
-  const parts = [];
-  for (const block of newBlocks) {
-    const span = resolveBlockSpan(block, state.messageRefs.byRaw);
-    parts.push(
-      span ? `${block.blockId}=${span.startRef}\u2013${span.endRef}` : block.blockId
-    );
-  }
-  return parts.length > 0 ? `blocks: ${parts.join(", ")}` : "";
-}
-
 // src/render-refs.ts
 function formatTokens(tokens) {
   if (tokens < 1e3) return String(tokens);
@@ -3740,6 +3987,11 @@ function createRenderRefsNode(strategy) {
 }
 var renderRefsNode = createRenderRefsNode("all");
 
+// src/message-kind.ts
+function isToolMessage(message) {
+  return message.contentType === "tool-call" || message.contentType === "tool-result";
+}
+
 // src/tool-pairs.ts
 function adjustBoundariesForToolPairs(startIndex, endIndex, messages, maxScan = 20) {
   const callIdsInRange = /* @__PURE__ */ new Set();
@@ -3944,9 +4196,6 @@ function computeIntegrityWithdrawals(messages, foldedIds) {
 function estimateTextTokens(text) {
   return Math.ceil(text.length / 4);
 }
-function isToolMessage(message) {
-  return message.contentType === "tool-call" || message.contentType === "tool-result";
-}
 function isSyntheticOrPruned(message, state) {
   if (message.text?.startsWith("[Compressed conversation section]")) return true;
   for (const block of state.blocks) {
@@ -4266,6 +4515,79 @@ function tierActionHint(config, state) {
   }
   return "";
 }
+function requestedRefoldSpan(state, spec) {
+  const nums = [];
+  for (const ref of [spec.startRef, spec.endRef]) {
+    const parsed = parseBoundary(ref);
+    if (!parsed) return null;
+    if (parsed.kind === "message") {
+      nums.push(parsed.numericId);
+      continue;
+    }
+    const block = blockById(state, `b${parsed.numericId}`);
+    if (!block) return null;
+    const span = resolveBlockSpan(block, state.messageRefs.byRaw);
+    if (!span) return null;
+    const lo = parseBoundary(span.startRef);
+    const hi = parseBoundary(span.endRef);
+    if (!lo || !hi) return null;
+    nums.push(lo.numericId, hi.numericId);
+  }
+  return { lo: Math.min(...nums), hi: Math.max(...nums) };
+}
+function evaluateRefold(state, spec) {
+  const span = requestedRefoldSpan(state, spec);
+  if (!span) return { kind: "blocked", reasons: [] };
+  const reasons = [];
+  const blocks = [];
+  for (const block of state.blocks) {
+    if (!block.active) continue;
+    const resolved = resolveBlockSpan(block, state.messageRefs.byRaw);
+    if (!resolved) {
+      reasons.push(`partially covered ${block.blockId}`);
+      continue;
+    }
+    const ownLo = parseBoundary(resolved.startRef)?.numericId;
+    const ownHi = parseBoundary(resolved.endRef)?.numericId;
+    if (ownLo === void 0 || ownHi === void 0) continue;
+    if (ownHi < span.lo || ownLo > span.hi) continue;
+    if (!block.restoredInline) {
+      reasons.push(`blocked by ${block.blockId} (not restored)`);
+      continue;
+    }
+    if (ownLo < span.lo || ownHi > span.hi) {
+      reasons.push(`partially covered ${block.blockId}`);
+      continue;
+    }
+    const blockers = activeAncestorIds(state, block.blockId).filter(
+      (ancestorId) => !blockById(state, ancestorId)?.restoredInline
+    );
+    if (blockers.length > 0) {
+      for (const id of blockers)
+        reasons.push(`blocked by ${id} (not restored)`);
+      continue;
+    }
+    blocks.push(block);
+  }
+  const uniqueReasons = [...new Set(reasons)];
+  if (uniqueReasons.length > 0)
+    return { kind: "blocked", reasons: uniqueReasons };
+  if (blocks.length > 0) return { kind: "refold", blocks };
+  return { kind: "blocked", reasons: [] };
+}
+function applyRefolds(input) {
+  validateSummaryLength(input.spec, input.config.compress);
+  const targets = new Set(input.blockIds);
+  input.state.blocks = input.state.blocks.map(
+    (block) => targets.has(block.blockId) ? {
+      ...block,
+      summary: input.spec.summary,
+      topic: input.spec.topic ?? block.topic,
+      runId: input.runId,
+      restoredInline: false
+    } : block
+  );
+}
 function createCore(ports = {}) {
   const countTokens = ports.countTokens ?? defaultCountTokens;
   function applyCompression(input) {
@@ -4275,6 +4597,7 @@ function createCore(ports = {}) {
     let tokensCompressed = 0;
     const errors = [];
     const warnings = [];
+    const notes = [];
     const protectedMessageIds = input.protectedMessageIds ?? computeProtectedRefs(
       input.messages,
       input.state,
@@ -4325,6 +4648,18 @@ function createCore(ports = {}) {
       if (resolution.status === "ok") resolvableCount++;
       else if (resolution.status === "unknown") unknownCount++;
     }
+    const refoldDecisions = /* @__PURE__ */ new Map();
+    const isRefoldCandidate = (resolution) => resolution.status === "consumed" || resolution.status === "ok" && resolution.resolved.boundaryKind !== "block" && resolution.resolved.messageIds.every(
+      (id) => preExistingCoverage.has(id)
+    );
+    for (const [spec, resolution] of classifications) {
+      if (isRefoldCandidate(resolution)) {
+        refoldDecisions.set(spec, evaluateRefold(state, spec));
+      }
+    }
+    const allRefold = input.ranges.length > 0 && unknownCount === 0 && [...classifications.entries()].every(
+      ([spec, resolution]) => isRefoldCandidate(resolution) && refoldDecisions.get(spec)?.kind === "refold"
+    );
     const rangeSpans = [];
     for (const [spec, resolution] of classifications) {
       if (resolution.status !== "ok") continue;
@@ -4363,7 +4698,7 @@ function createCore(ports = {}) {
           totalRangeChars += msg?.text?.length ?? 0;
         }
       }
-      if (!hasBlockBoundaryRange && totalRangeChars < input.config.compress.minCompressRange) {
+      if (!allRefold && !hasBlockBoundaryRange && totalRangeChars < input.config.compress.minCompressRange) {
         const diagnostics = refGateDiagnostics(
           state,
           input.ranges.length,
@@ -4372,10 +4707,50 @@ function createCore(ports = {}) {
         const firstConsumed = consumedRanges[0];
         const covering = firstConsumed ? coveringBlockIds(state, firstConsumed) : [];
         const coverDetail = covering.length > 0 ? `its content is already summarized in active block(s) ${covering.join(", ")}${covering.length === 1 ? ` \u2014 use search_context or decompress ${covering[0]} if you need details from it` : ""}` : `its refs no longer point to directly compressible content (stale block ref(s) distilled or consumed by higher-tier blocks)`;
+        const refoldReasons = [
+          ...new Set(
+            consumedRanges.flatMap((spec) => {
+              const decision = refoldDecisions.get(spec);
+              return decision?.kind === "blocked" ? decision.reasons : [];
+            })
+          )
+        ];
+        const refoldSuffix = (reasons) => reasons.length > 0 ? ` Refold blocked: ${reasons.join("; ")}. Restore the affected block(s) inline (decompress with inline:true), then recompressing the same range updates them in place` : "";
+        const refoldDetail = refoldSuffix(refoldReasons);
+        const okBlockedReasons = [
+          ...new Set(
+            [...classifications.entries()].flatMap(([spec, resolution]) => {
+              if (skipSpecs.has(spec) || resolution.status !== "ok") return [];
+              const decision = refoldDecisions.get(spec);
+              return decision?.kind === "blocked" ? decision.reasons : [];
+            })
+          )
+        ];
         const danglingRefs = consumedRanges.flatMap(
           (spec) => danglingMessageRefs(state, input.messages, spec)
         );
-        const gateMessage = resolvableCount === 0 && consumedRanges.length === 0 && unknownCount > 0 ? `None of the ${input.ranges.length} requested range(s) resolved \u2014 every ref is unknown to this session. Refs are per-session snapshots, assigned once when a message is first rendered; no compress reassigns them, so unknown refs cannot come from an earlier compress in this session. They come from a different generation: a previous session instance (switching model or upstream mid-conversation starts a fresh session whose refs restart at m00001), the generation before a native-compaction rebase (which also resets refs to m00001), or a typo. ${diagnostics} Run acp_status, then call the compress tool again using only the refs it reports.` : consumedRanges.length > 0 ? danglingRefs.length > 0 ? `Requested range(s) cannot be anchored (e.g. ${firstConsumed.startRef}..${firstConsumed.endRef}) \u2014 the refs exist in this session's ref map, but the messages they point to are no longer in the visible context and no active block covers them: the message content changed (or the message was filtered out of the view) and now carries a new ref, leaving your old refs dangling. ${diagnostics} Run acp_status, then call the compress tool again using only the refs it reports.` : `Requested range(s) already compressed (e.g. ${firstConsumed.startRef}..${firstConsumed.endRef}) \u2014 ${coverDetail}. Nothing new to compress in that window. ${diagnostics} Continue the task, or run acp_status and target one of the CURRENT compressible ranges it reports.${tierActionHint(input.config, state)}` : `Total compressible content too small (${totalRangeChars} chars across ${countedRanges} range(s), min ${input.config.compress.minCompressRange}). Combine more messages into your range(s) to meet the threshold.`;
+        let gateMessage = resolvableCount === 0 && consumedRanges.length === 0 && unknownCount > 0 ? `None of the ${input.ranges.length} requested range(s) resolved \u2014 every ref is unknown to this session. Refs are per-session snapshots, assigned once when a message is first rendered; no compress reassigns them, so unknown refs cannot come from an earlier compress in this session. They come from a different generation: a previous session instance (switching model or upstream mid-conversation starts a fresh session whose refs restart at m00001), the generation before a native-compaction rebase (which also resets refs to m00001), or a typo. ${diagnostics} Run acp_status, then call the compress tool again using only the refs it reports.` : consumedRanges.length > 0 ? danglingRefs.length > 0 ? `Requested range(s) cannot be anchored (e.g. ${firstConsumed.startRef}..${firstConsumed.endRef}) \u2014 the refs exist in this session's ref map, but the messages they point to are no longer in the visible context and no active block covers them: the message content changed (or the message was filtered out of the view) and now carries a new ref, leaving your old refs dangling. ${diagnostics} Run acp_status, then call the compress tool again using only the refs it reports.` : `Requested range(s) already compressed (e.g. ${firstConsumed.startRef}..${firstConsumed.endRef}) \u2014 ${coverDetail}${refoldDetail}. Nothing new to compress in that window. ${diagnostics} Continue the task, or run acp_status and target one of the CURRENT compressible ranges it reports.${tierActionHint(input.config, state)}` : countedRanges > 0 ? `Total compressible content too small (${totalRangeChars} chars across ${countedRanges} range(s), min ${input.config.compress.minCompressRange}). Combine more messages into your range(s) to meet the threshold.${refoldSuffix(okBlockedReasons)}` : null;
+        if (gateMessage === null) {
+          return {
+            state: input.state,
+            result: {
+              blocksCreated: 0,
+              tokensCompressed: 0,
+              errors: [...classificationErrors],
+              warnings: []
+            }
+          };
+        }
+        const reversalNotes = [];
+        for (const [spec, resolution] of classifications) {
+          if (resolution.status === "ok" && !skipSpecs.has(spec)) {
+            const note = resolution.resolved.reversedNote;
+            if (note) reversalNotes.push(note);
+          }
+        }
+        if (reversalNotes.length > 0) {
+          gateMessage += ` ${reversalNotes.join(" ")}`;
+        }
         return {
           state: input.state,
           result: {
@@ -4392,8 +4767,30 @@ function createCore(ports = {}) {
       const resolution = classifications.get(spec);
       if (resolution === void 0) continue;
       if (resolution.status === "consumed") {
+        const decision = refoldDecisions.get(spec);
+        if (decision?.kind === "refold") {
+          try {
+            applyRefolds({
+              spec,
+              state,
+              runId,
+              config: input.config,
+              blockIds: decision.blocks.map((block) => block.blockId)
+            });
+            blocksCreated += decision.blocks.length;
+          } catch (error) {
+            errors.push(
+              rangeError(
+                spec,
+                error instanceof Error ? error.message : String(error)
+              )
+            );
+          }
+          continue;
+        }
+        const reasons = decision?.kind === "blocked" ? decision.reasons : [];
         warnings.push(
-          `Skipped range (${spec.startRef}..${spec.endRef}) \u2014 already compressed (messages consumed by existing block(s)); nothing to compress.`
+          `Skipped range (${spec.startRef}..${spec.endRef}) \u2014 already compressed${reasons.length > 0 ? `: ${reasons.join("; ")}` : " (messages consumed by existing block(s))"}; nothing to compress.`
         );
         continue;
       }
@@ -4402,6 +4799,8 @@ function createCore(ports = {}) {
         continue;
       }
       warnings.push(...resolution.resolved.snappedBoundaries);
+      const note = resolution.resolved.reversedNote;
+      if (note) notes.push(note);
       try {
         const outcome = applySingleRange({
           spec,
@@ -4413,7 +4812,7 @@ function createCore(ports = {}) {
           countTokens,
           preExistingCoverage
         });
-        blocksCreated++;
+        blocksCreated += outcome.refolded ? outcome.refolded.length : 1;
         tokensCompressed += outcome.tokens;
         warnings.push(...outcome.warnings);
       } catch (error) {
@@ -4435,7 +4834,13 @@ function createCore(ports = {}) {
     }
     return {
       state,
-      result: { blocksCreated, tokensCompressed, errors, warnings }
+      result: {
+        blocksCreated,
+        tokensCompressed,
+        errors,
+        warnings,
+        ...notes.length > 0 ? { notes } : {}
+      }
     };
   }
   function processTurn(input) {
@@ -4619,7 +5024,11 @@ var hideCompressCallsNode = {
   name: "hide-compress-calls",
   run(io) {
     const hidden = hideConsumedCompressCalls(io.state, io.messages);
-    return { ...io, messages: hidden.messages };
+    return {
+      ...io,
+      messages: hidden.messages,
+      state: { ...io.state, hiddenOrphanRefs: hidden.hiddenOrphanRefs }
+    };
   }
 };
 var recommendNode = {
@@ -4877,6 +5286,21 @@ function applySingleRange(input) {
     }
   }
   if (!isBlockBoundary && filteredIds.length === 0 && consumedBlockIds.length > 0) {
+    const decision = evaluateRefold(input.state, input.spec);
+    if (decision.kind === "refold") {
+      applyRefolds({
+        spec: input.spec,
+        state: input.state,
+        runId: input.runId,
+        config: input.config,
+        blockIds: decision.blocks.map((block2) => block2.blockId)
+      });
+      return {
+        tokens: 0,
+        warnings,
+        refolded: decision.blocks.map((block2) => block2.blockId)
+      };
+    }
     const first = consumedBlockIds[0];
     const last = consumedBlockIds[consumedBlockIds.length - 1];
     throw new Error(
@@ -4957,7 +5381,15 @@ function applyPairBoundaryAdjustments(resolved, messages) {
 }
 function validateCompressionRange(input, directMessageIds, consumedBlockCount) {
   const cfg = input.config.compress;
-  const summary = input.spec.summary?.trim() ?? "";
+  validateSummaryLength(input.spec, cfg);
+  if (directMessageIds.length === 0 && consumedBlockCount === 0) {
+    throw new Error(
+      "Range contains no compressible messages \u2014 all are already covered by active blocks or protected."
+    );
+  }
+}
+function validateSummaryLength(spec, cfg) {
+  const summary = spec.summary?.trim() ?? "";
   if (summary.length === 0) {
     throw new Error(
       "Summary is empty \u2014 provide a meaningful summary of the compressed range."
@@ -4968,17 +5400,12 @@ function validateCompressionRange(input, directMessageIds, consumedBlockCount) {
       `Summary too short (${summary.length} chars, min ${cfg.minSummaryLength}). The summary must capture the compressed range's key information.`
     );
   }
-  const effectiveMax = input.spec.summaryMaxChars ?? cfg.maxSummaryLength;
+  const effectiveMax = spec.summaryMaxChars ?? cfg.maxSummaryLength;
   if (effectiveMax > 0 && summary.length > effectiveMax) {
     throw new Error(
       `Summary too long (${summary.length} chars, max ${effectiveMax}). Strip noise \u2014 keep critical paths, decisions, errors, and code references. Or pass summaryMaxChars to increase the limit \u2014 don't lose critical info just to fit.`
     );
   }
-  if (directMessageIds.length === 0 && consumedBlockCount === 0) {
-    throw new Error(
-      "Range contains no compressible messages \u2014 all are already covered by active blocks or protected."
-    );
-  }
 }
 function filterProtectedToolMessages(directMessageIds, messages, config) {
   const protectedCallIds = /* @__PURE__ */ new Set();
@@ -5219,7 +5646,7 @@ function computeContextBreakdown(messages, total, growth, countTokens) {
     const tokens = countMessageTokens(msg, count);
     if (msg.text?.startsWith("[Compressed conversation section]")) {
       summaries += tokens;
-    } else if (msg.contentType === "tool-call" || msg.contentType === "tool-result") {
+    } else if (isToolMessage(msg)) {
       tool += tokens;
     } else if (msg.role === "system") {
       system += tokens;
@@ -5251,7 +5678,8 @@ function cloneState(state) {
     nextRuleId: state.nextRuleId,
     terminalStreak: state.terminalStreak,
     nextBlockId: state.nextBlockId,
-    nextRunId: state.nextRunId
+    nextRunId: state.nextRunId,
+    hiddenOrphanRefs: state.hiddenOrphanRefs ? [...state.hiddenOrphanRefs] : void 0
   };
 }
 function scoreRelevance(block, terms) {
@@ -5521,147 +5949,6 @@ function defaultPackSources(opts) {
   return sources;
 }
 
-// src/decompress.ts
-function parseBlockIdArg(arg) {
-  const normalized = arg.trim().toLowerCase();
-  const refMatch = /^b0*(\d+)$/.exec(normalized);
-  if (refMatch && refMatch[1] !== void 0) return `b${refMatch[1]}`;
-  const numMatch = /^(\d+)$/.exec(normalized);
-  if (numMatch && numMatch[1] !== void 0) return `b${numMatch[1]}`;
-  return null;
-}
-function findBlocksOverlappingMessages(state, messageIds) {
-  if (messageIds.size === 0) return [];
-  const matched = [];
-  for (const block of state.blocks) {
-    if (!block.active) continue;
-    if (block.effectiveMessageIds.some((id) => messageIds.has(id))) {
-      matched.push(block);
-    }
-  }
-  return matched.sort((a, b) => numericPart(a.blockId) - numericPart(b.blockId));
-}
-function findActiveAncestor(state, blockId) {
-  const start = state.blocks.find((b) => b.blockId === blockId);
-  if (!start) return null;
-  const queue = [...start.directBlockIds];
-  const visited = /* @__PURE__ */ new Set();
-  while (queue.length > 0) {
-    const currentId = queue.shift();
-    if (visited.has(currentId)) continue;
-    visited.add(currentId);
-    const current = state.blocks.find((b) => b.blockId === currentId);
-    if (!current) continue;
-    if (current.active) return current.blockId;
-    for (const ancestorId of current.directBlockIds) {
-      if (!visited.has(ancestorId)) queue.push(ancestorId);
-    }
-  }
-  return null;
-}
-function deactivateBlock(state, blockIds, options = {}) {
-  const targets = new Set(blockIds);
-  const updated = state.blocks.map((block) => {
-    if (!targets.has(block.blockId) || !block.active) return block;
-    return {
-      ...block,
-      active: false,
-      durationMs: block.durationMs,
-      createdAt: block.createdAt
-    };
-  });
-  let final = updated;
-  if (options.deep) {
-    const visited = /* @__PURE__ */ new Set();
-    const queue = [];
-    for (const id of blockIds) {
-      const block = updated.find((b) => b.blockId === id);
-      if (block) queue.push(...block.directBlockIds);
-    }
-    while (queue.length > 0) {
-      const id = queue.shift();
-      if (visited.has(id)) continue;
-      visited.add(id);
-      final = final.map((block) => {
-        if (block.blockId !== id) return block;
-        queue.push(...block.directBlockIds);
-        return block.active ? { ...block, active: false } : block;
-      });
-    }
-  }
-  return { ...state, blocks: final };
-}
-function buildRestoredContentPreview(messages, beforeActiveMessageIds, state) {
-  const restored = [];
-  for (const message of messages) {
-    if (!beforeActiveMessageIds.has(message.id)) continue;
-    const stillCovered = state.blocks.some(
-      (b) => b.active && b.effectiveMessageIds.includes(message.id)
-    );
-    if (!stillCovered) restored.push(message);
-  }
-  if (restored.length === 0) return { preview: "", restoredCount: 0 };
-  const lines = [];
-  let totalLength = 0;
-  const MAX_PREVIEW = 2e3;
-  const MAX_PER_MESSAGE = 200;
-  for (const message of restored) {
-    if (totalLength >= MAX_PREVIEW) break;
-    const text = message.text ?? "";
-    const truncated = text.length > MAX_PER_MESSAGE ? clampPrefix(text, MAX_PER_MESSAGE) + "..." : text;
-    const label = message.toolName && message.contentType !== "text" ? `${message.toolName}: ${truncated}` : `[${message.role}] ${truncated}`;
-    lines.push(label);
-    totalLength += label.length + 1;
-  }
-  return { preview: lines.join("\n"), restoredCount: restored.length };
-}
-function collectBlockContent(state, block, messages, options = {}) {
-  const full = options.full ?? false;
-  const targetIds = new Set(block.effectiveMessageIds);
-  if (full) {
-    const msgs = messages.filter((m) => targetIds.has(m.id));
-    if (msgs.length === 0) return { text: "", count: 0 };
-    return { text: msgs.map(formatMessage).join("\n\n"), count: msgs.length };
-  }
-  const nestedChildren = [];
-  const nestedCovered = /* @__PURE__ */ new Set();
-  for (const childId of block.directBlockIds) {
-    const child = state.blocks.find((b) => b.blockId === childId);
-    if (!child?.active) continue;
-    nestedChildren.push(child);
-    for (const id of child.effectiveMessageIds) nestedCovered.add(id);
-  }
-  const parts = [];
-  for (const child of nestedChildren) {
-    const label = child.topic ? `${child.blockId}: ${child.topic}` : child.blockId;
-    parts.push(`${SUMMARY_HEADER} \u2014 ${label}
-${child.summary}`);
-  }
-  let directCount = 0;
-  for (const m of messages) {
-    if (targetIds.has(m.id) && !nestedCovered.has(m.id)) {
-      parts.push(formatMessage(m));
-      directCount++;
-    }
-  }
-  const count = directCount + nestedChildren.length;
-  if (count === 0) return { text: "", count: 0 };
-  return { text: parts.join("\n\n"), count };
-}
-function formatMessage(message) {
-  const text = message.text ?? "";
-  if (message.toolName && message.contentType !== "text") {
-    return `[${message.role} \u2022 ${message.toolName}]
-${text}`;
-  }
-  return `[${message.role}]
-${text}`;
-}
-function numericPart(blockId) {
-  const match = /^b(\d+)$/.exec(blockId);
-  return match && match[1] !== void 0 ? Number(match[1]) : 0;
-}
-
 // src/report.ts
 function formatTokens2(n) {
   if (!Number.isFinite(n) || n <= 0) return "0";
@@ -5686,14 +5973,16 @@ function tierLabel(block) {
 }
 function tierBreakdown(blocks, countTokens) {
   const tierTokens = {};
+  const tierCounts = {};
   for (const block of blocks) {
     tierTokens[block.tier] = (tierTokens[block.tier] ?? 0) + summaryTokensOf(block, countTokens);
+    tierCounts[block.tier] = (tierCounts[block.tier] ?? 0) + 1;
   }
   const tiers = Object.keys(tierTokens).map(Number);
   if (tiers.length <= 1) return null;
   const parts = [];
   for (const tier of [1, 2, 3]) {
-    if (tierTokens[tier]) parts.push(`T${tier}: ${formatTokens2(tierTokens[tier])}`);
+    if (tierTokens[tier]) parts.push(`T${tier}: ${formatTokens2(tierTokens[tier])} (${tierCounts[tier]} blocks)`);
   }
   return parts.join(" | ");
 }
@@ -5719,8 +6008,9 @@ function collectVisible(messages, state, countTokens) {
     const ref = refForRaw(state.messageRefs, message.id);
     if (!ref) return;
     const tokens = countMessageTokens(message, countTokens);
-    const tool = isToolMessage(message) ? message.toolName ?? (message.toolCallId ? toolCallNames.get(message.toolCallId) : void 0) ?? "tool" : "text";
-    if (tokens > 0) visible.push({ ref, tokens, tool, index });
+    const isTool = isToolMessage(message);
+    const tool = isTool ? message.toolName ?? (message.toolCallId ? toolCallNames.get(message.toolCallId) : void 0) ?? "tool" : "text";
+    if (tokens > 0) visible.push({ ref, tokens, tool, isTool, index });
   });
   return { visible, summaryTokens };
 }
@@ -5763,8 +6053,8 @@ function renderOverview(visible, summaryTokens, blocks, state, countTokens, limi
     toolTypeMap.set(message.tool, (toolTypeMap.get(message.tool) ?? 0) + message.tokens);
   }
   const topTool = [...toolTypeMap.entries()].sort((a, b) => b[1] - a[1])[0]?.[0];
-  const totalTool = visible.filter((m) => m.tool !== "text").reduce((sum, m) => sum + m.tokens, 0);
-  const totalText = visible.filter((m) => m.tool === "text").reduce((sum, m) => sum + m.tokens, 0);
+  const totalTool = visible.filter((m) => m.isTool).reduce((sum, m) => sum + m.tokens, 0);
+  const totalText = visible.filter((m) => !m.isTool).reduce((sum, m) => sum + m.tokens, 0);
   const total = summaryTokens + totalTool + totalText;
   lines.push("CONTEXT BREAKDOWN");
   lines.push(
@@ -5800,6 +6090,11 @@ function renderOverview(visible, summaryTokens, blocks, state, countTokens, limi
         `  ${block.blockId} (${tierLabel(block)})  ${formatTokens2(eff)}\u2192${formatTokens2(summaryTokensOf(block, countTokens))}  ${block.effectiveMessageIds.length} msgs  "${topic}"`
       );
     }
+    if (blocks.length > limit) {
+      lines.push(
+        `  ... and ${blocks.length - limit} more blocks not shown (scope:"compressed", limit:${blocks.length} for full list)`
+      );
+    }
   }
   lines.push("");
   lines.push(
@@ -7482,7 +7777,11 @@ function build(text) {
 }
 function docFeatures(text) {
   const hit = cache.get(text);
-  if (hit) return hit;
+  if (hit) {
+    cache.delete(text);
+    cache.set(text, hit);
+    return hit;
+  }
   const f = build(text);
   if (text.length > 0 && text.length <= capChars) {
     while (cachedChars + text.length > capChars && cache.size > 0) {
@@ -7593,8 +7892,8 @@ var hybridAlgorithm = {
   score(docs, query) {
     const bm = bm25Algorithm.score(docs, query);
     const fz = fuzzyAlgorithm.score(docs, query);
-    const maxBm = Math.max(...bm.map((r) => r.score), 1e-9);
-    const maxFz = Math.max(...fz.map((r) => r.score), 1e-9);
+    const maxBm = bm.reduce((m, r) => r.score > m ? r.score : m, 1e-9);
+    const maxFz = fz.reduce((m, r) => r.score > m ? r.score : m, 1e-9);
     const bmMap = new Map(bm.map((r) => [r.ref, r.score / maxBm]));
     const fzMap = new Map(fz.map((r) => [r.ref, r.score / maxFz]));
     return docs.map((d) => ({
@@ -7941,6 +8240,7 @@ export {
   TIER3_CONDENSE_RULES,
   VERBOSITY_LEVELS,
   VIABLE_RANGE_MIN_TOKENS,
+  activeAncestorIds,
   activeBlockSpans,
   activeBlocks,
   addRule,
@@ -7958,6 +8258,7 @@ export {
   applySectionOverrides,
   applySteeringToPrompt,
   assignRefs,
+  baseIdOf,
   blockById,
   blockDocs,
   blockVisibleInRange,
@@ -8034,6 +8335,7 @@ export {
   imageShrinksForRef,
   indexToRef,
   isAbsorbCandidate,
+  isCovered,
   isImageFullRestored,
   isMessageLatestProtected,
   isMessageProtected,
@@ -8041,6 +8343,7 @@ export {
   isRetrievedMessage,
   isStoredPlaceholderText,
   isSummaryMessageId,
+  isToolMessage,
   isValidPackName,
   jsonFoldPlugin,
   leanPack,
@@ -8050,6 +8353,7 @@ export {
   listSearchAlgorithms,
   logSelectPlugin,
   makeIO,
+  markBlockRestoredInline,
   matchSession,
   matchToolPattern,
   messageDocs,