acp-kernel 0.0.83 → 0.0.84

package/dist/index.js

@@ -16,7 +16,7 @@ import {
   resolvePrompts,
   thinkingTokenValue,
   viableRanges
-} from "./chunk-VPRKYTHW.js";
+} from "./chunk-6RNVHY67.js";
 import {
   activeBlocks,
   advanceSurvival,
@@ -26,7 +26,7 @@ import {
   coveredMessageIds,
   createInitialState,
   highestActiveTier
-} from "./chunk-5TQA7ZQM.js";
+} from "./chunk-MXL3G3BN.js";
 
 // src/refs.ts
 var REF_WIDTH = 5;
@@ -372,9 +372,29 @@ function defaultConfig(modelContextLimit, overrides = {}) {
     absorb: {
       enabled: false,
       toolName: "absorb",
-      minToolTokens: 1e3,
+      // Raised 1000 → 4000 (issue #352): lossless CCR takes over large-result
+      // handling; absorb's forced distillation only fires above the new bar.
+      minToolTokens: 4e3,
       contextThresholdPct: 0,
       excludeTools: []
+    },
+    crush: {
+      enabled: false,
+      minReduction: 0.1
+    },
+    imageCompression: {
+      enabled: false,
+      minTokens: 512,
+      maxDimension: 1280,
+      quality: 80,
+      format: "webp"
+    },
+    ccr: {
+      enabled: false,
+      toolName: "acp_retrieve",
+      minToolTokens: 4e3,
+      excludeTools: [],
+      maxHeadChars: 96
     }
   };
   return {
@@ -384,7 +404,10 @@ function defaultConfig(modelContextLimit, overrides = {}) {
     nudge: { ...base.nudge, ...overrides.nudge },
     truncate: { ...base.truncate, ...overrides.truncate },
     compress: { ...base.compress, ...overrides.compress },
-    absorb: overrides.absorb ? { ...base.absorb, ...overrides.absorb } : base.absorb
+    absorb: overrides.absorb ? { ...base.absorb, ...overrides.absorb } : base.absorb,
+    crush: overrides.crush ? { ...base.crush, ...overrides.crush } : base.crush,
+    imageCompression: overrides.imageCompression ? { ...base.imageCompression, ...overrides.imageCompression } : base.imageCompression,
+    ccr: overrides.ccr ? { ...base.ccr, ...overrides.ccr } : base.ccr
   };
 }
 function validateConfig(config) {
@@ -439,470 +462,84 @@ function validateConfig(config) {
       errors.push("rules.maxRuleChars must be >= 1");
     }
   }
-  return errors;
-}
-
-// src/boundaries.ts
-var MESSAGE_REF_PATTERN = /^m0*(\d{1,5})$/;
-var BLOCK_REF_PATTERN = /^b(\d{1,9})$/;
-function parseBoundary(ref) {
-  const normalized = ref.trim().toLowerCase();
-  const messageMatch = MESSAGE_REF_PATTERN.exec(normalized);
-  if (messageMatch) {
-    const numericId = Number(messageMatch[1]);
-    if (numericId >= 1 && numericId <= 99999) {
-      return { kind: "message", numericId, raw: normalized };
+  if (config.crush) {
+    if (!Number.isFinite(config.crush.minReduction) || config.crush.minReduction <= 0 || config.crush.minReduction > 1) {
+      errors.push("crush.minReduction must be in (0, 1]");
     }
-  }
-  const blockMatch = BLOCK_REF_PATTERN.exec(normalized);
-  if (blockMatch) {
-    const numericId = Number(blockMatch[1]);
-    if (numericId >= 1) return { kind: "block", numericId, raw: normalized };
-  }
-  return null;
-}
-var BoundaryNotFoundError = class extends Error {
-  code = "BOUNDARY_NOT_FOUND";
-  kind;
-  endpoint;
-  constructor(kind, endpoint, message) {
-    super(message);
-    this.name = "BoundaryNotFoundError";
-    this.code = "BOUNDARY_NOT_FOUND";
-    this.kind = kind;
-    this.endpoint = endpoint;
-  }
-};
-function resolveBoundaries(input) {
-  const start = parseBoundary(input.startRef);
-  const end = parseBoundary(input.endRef);
-  if (!start || !end) {
-    throw new Error(
-      `Invalid boundary ref(s): startId="${input.startRef}", endId="${input.endRef}". Use mNNNNN or bN.`
-    );
-  }
-  const indexByMessageId = /* @__PURE__ */ new Map();
-  input.messages.forEach(
-    (message, index) => indexByMessageId.set(message.id, index)
-  );
-  let snappedBoundaries = [];
-  const startAnchor = resolveAnchorIndex(
-    start,
-    input.state,
-    indexByMessageId,
-    "start"
-  );
-  if (startAnchor.snapped) snappedBoundaries.push(startAnchor.snapped);
-  const endAnchor = resolveAnchorIndex(
-    end,
-    input.state,
-    indexByMessageId,
-    "end"
-  );
-  if (endAnchor.snapped) snappedBoundaries.push(endAnchor.snapped);
-  let startIndex = startAnchor.index;
-  let endIndex = endAnchor.index;
-  if (startIndex > endIndex) {
-    [startIndex, endIndex] = [endIndex, startIndex];
-  }
-  const messageIds = [];
-  for (let index = startIndex; index <= endIndex; index++) {
-    const message = input.messages[index];
-    if (message && !isRenderedSummaryMessage(message))
-      messageIds.push(message.id);
-  }
-  const boundaryKind = start.kind === "block" || end.kind === "block" ? "block" : "message";
-  const nestedBlockIds = [];
-  const nestedSeen = /* @__PURE__ */ new Set();
-  for (const block of activeBlocks(input.state)) {
-    if (blockVisibleInRange(block, indexByMessageId, startIndex, endIndex)) {
-      if (!nestedSeen.has(block.blockId)) {
-        nestedSeen.add(block.blockId);
-        nestedBlockIds.push(block.blockId);
+    if (config.crush.strategies) {
+      for (const [id, ov] of Object.entries(config.crush.strategies)) {
+        if (!ov || typeof ov !== "object" || Array.isArray(ov)) {
+          errors.push(`crush.strategies.${id} must be an object`);
+          continue;
+        }
+        if (ov.enabled !== void 0 && typeof ov.enabled !== "boolean") {
+          errors.push(`crush.strategies.${id}.enabled must be a boolean`);
+        }
+        if (ov.excludeTools !== void 0 && (!Array.isArray(ov.excludeTools) || ov.excludeTools.some((t) => typeof t !== "string"))) {
+          errors.push(
+            `crush.strategies.${id}.excludeTools must be a string array`
+          );
+        }
       }
     }
   }
-  const protectedGaps = [];
-  return {
-    startIndex,
-    endIndex,
-    messageIds,
-    nestedBlockIds,
-    boundaryKind,
-    protectedGaps,
-    snappedBoundaries
-  };
-}
-function resolveAnchorIndex(boundary, state, indexByMessageId, endpoint) {
-  const label = endpoint === "start" ? "startId" : "endId";
-  if (boundary.kind === "message") {
-    const rawId = state.messageRefs.byRef[boundary.raw] ?? state.messageRefs.byRef[formatPaddedRef(boundary.numericId)];
-    if (!rawId) {
-      throw new BoundaryNotFoundError(
-        "unknown",
-        endpoint,
-        `${label}="${boundary.raw}" does not exist in this session (typo or wrong session) \u2014 run acp_status for current refs.`
-      );
+  if (config.imageCompression) {
+    const ic = config.imageCompression;
+    if (ic.minTokens !== void 0 && (!Number.isFinite(ic.minTokens) || ic.minTokens < 0)) {
+      errors.push("imageCompression.minTokens must be finite and >= 0");
     }
-    const index = indexByMessageId.get(rawId);
-    if (index !== void 0) {
-      return { index, snapped: null };
+    if (ic.maxDimension !== void 0 && (!Number.isInteger(ic.maxDimension) || ic.maxDimension < 16)) {
+      errors.push("imageCompression.maxDimension must be an integer >= 16");
     }
-    const owner2 = activeOwnerAnchor(state, [rawId], indexByMessageId);
-    if (owner2 !== null) {
-      return {
-        index: owner2,
-        snapped: `${label}="${boundary.raw}" refers to a message already compressed into an active block \u2014 anchored to the active block covering it instead.`
-      };
+    if (ic.quality !== void 0 && (!Number.isFinite(ic.quality) || ic.quality < 1 || ic.quality > 100)) {
+      errors.push("imageCompression.quality must be in [1, 100]");
     }
-    throw new BoundaryNotFoundError(
-      "consumed",
-      endpoint,
-      `${label}="${boundary.raw}" not found in visible context (likely consumed by an existing block).`
-    );
-  }
-  const block = blockById(state, `b${boundary.numericId}`);
-  if (!block) {
-    throw new BoundaryNotFoundError(
-      "unknown",
-      endpoint,
-      `${label}="b${boundary.numericId}" does not exist in this session (typo or wrong session) \u2014 run acp_status for current refs.`
-    );
-  }
-  if (block.active) {
-    const anchor = visibleBlockAnchor(block, indexByMessageId);
-    if (anchor !== null) {
-      return { index: anchor, snapped: null };
+    if (ic.format !== void 0 && ic.format !== "webp" && ic.format !== "jpeg" && ic.format !== "png") {
+      errors.push('imageCompression.format must be "webp", "jpeg", or "png"');
     }
   }
-  const owner = activeOwnerAnchor(
-    state,
-    block.effectiveMessageIds,
-    indexByMessageId
-  );
-  if (owner !== null) {
-    return {
-      index: owner,
-      snapped: `${label}="b${boundary.numericId}" was consumed by a higher-tier block \u2014 anchored to the active block covering its content instead.`
-    };
-  }
-  if (!block.active) {
-    throw new BoundaryNotFoundError(
-      "consumed",
-      endpoint,
-      `${label}="b${boundary.numericId}" not found in visible context (block distilled/consumed by a higher-tier block).`
-    );
-  }
-  throw new BoundaryNotFoundError(
-    "consumed",
-    endpoint,
-    `${label}="b${boundary.numericId}" is an active block but none of its content (raw messages or rendered summary) is visible in the current context \u2014 run acp_status to verify.`
-  );
-}
-function activeOwnerAnchor(state, ownedIds, indexByMessageId) {
-  if (ownedIds.length === 0) return null;
-  const owned = new Set(ownedIds);
-  let best = null;
-  for (const block of state.blocks) {
-    if (!block.active) continue;
-    const inherited = inheritedContentIds(state, block);
-    let ownsInherited = false;
-    for (const id of owned) {
-      if (inherited.has(id)) {
-        ownsInherited = true;
-        break;
-      }
+  if (config.ccr) {
+    if (config.ccr.enabled && !config.ccr.toolName) {
+      errors.push("ccr.toolName must be a non-empty string when enabled");
     }
-    if (!ownsInherited) continue;
-    const anchor = visibleBlockAnchor(block, indexByMessageId);
-    if (anchor === null) continue;
-    if (best === null || anchor < best) {
-      best = anchor;
+    if (!Number.isFinite(config.ccr.minToolTokens) || config.ccr.minToolTokens < 0) {
+      errors.push("ccr.minToolTokens must be >= 0");
+    }
+    if (!Number.isFinite(config.ccr.maxHeadChars) || config.ccr.maxHeadChars < 0) {
+      errors.push("ccr.maxHeadChars must be >= 0");
     }
   }
-  return best;
+  return errors;
 }
-function inheritedContentIds(state, block) {
-  const ids = /* @__PURE__ */ new Set();
-  for (const childId of block.directBlockIds) {
-    const child = blockById(state, childId);
-    if (!child) continue;
-    for (const id of child.effectiveMessageIds) ids.add(id);
+
+// src/surface-config.ts
+function applySectionOverrides(sections, overrides) {
+  const out = [];
+  for (const [key, text] of sections) {
+    const o = overrides?.[key];
+    if (o === null) continue;
+    out.push(typeof o === "string" ? o : text);
   }
-  return ids;
-}
-function formatPaddedRef(index) {
-  return `m${String(index).padStart(5, "0")}`;
-}
-function visibleBlockAnchor(block, indexByMessageId) {
-  const summaryIndex = indexByMessageId.get(summaryMessageId(block.blockId));
-  if (summaryIndex !== void 0) return summaryIndex;
-  return earliestIndexOfIds(block.effectiveMessageIds, indexByMessageId);
+  return out;
 }
-function blockVisibleInRange(block, indexByMessageId, startIndex, endIndex) {
-  const summaryIndex = indexByMessageId.get(summaryMessageId(block.blockId));
-  if (summaryIndex !== void 0 && summaryIndex >= startIndex && summaryIndex <= endIndex) {
-    return true;
-  }
-  const rawIndex = earliestIndexOfIds(
-    block.effectiveMessageIds,
-    indexByMessageId
-  );
-  return rawIndex !== null && rawIndex >= startIndex && rawIndex <= endIndex;
+function cloneWithDescriptions(schema, overrides) {
+  if (Object.keys(overrides).length === 0) return schema;
+  return cloneNode(schema, overrides);
 }
-function earliestIndexOfIds(ids, indexByMessageId) {
-  let earliest = null;
-  for (const id of ids) {
-    const index = indexByMessageId.get(id);
-    if (index !== void 0 && (earliest === null || index < earliest)) {
-      earliest = index;
+function cloneNode(node, overrides) {
+  if (Array.isArray(node)) return node.map((item) => cloneNode(item, overrides));
+  if (node && typeof node === "object") {
+    const out = {};
+    for (const [name, value] of Object.entries(node)) {
+      const cloned = cloneNode(value, overrides);
+      if (Object.hasOwn(overrides, name) && cloned && typeof cloned === "object" && !Array.isArray(cloned)) {
+        cloned.description = overrides[name];
+      }
+      out[name] = cloned;
     }
+    return out;
   }
-  return earliest;
-}
-
-// src/truncate-tools.ts
-var TRUNCATION_MARKER = "[truncated for context space]";
-var DEFAULTS = {
-  minOutputTokens: 1e3,
-  keepPrefixChars: 2e3,
-  keepSuffixChars: 2e3,
-  protectRecentMessages: 3
-};
-function truncateLargeToolOutputs(messages, tokenCount, config, countTokens, options = {}) {
-  const opts = { ...DEFAULTS, ...options };
-  const limit = config.modelContextLimit;
-  if (limit <= 0 || tokenCount < config.truncate.threshold * limit) {
-    return { messages, truncatedCount: 0, savedTokens: 0, candidatesFound: 0 };
-  }
-  const protectedIndex = messages.length - opts.protectRecentMessages;
-  const findCandidates = (predicate) => {
-    const found = [];
-    for (let i = 0; i < protectedIndex; i++) {
-      const message = messages[i];
-      if (!predicate(message)) continue;
-      const text = message.text ?? "";
-      if (text.length === 0 || text.includes(TRUNCATION_MARKER)) continue;
-      if (countTokens(text) < opts.minOutputTokens) continue;
-      found.push(message);
-    }
-    return found.sort(
-      (a, b) => countTokens(b.text ?? "") - countTokens(a.text ?? "")
-    );
-  };
-  const toolResults = findCandidates((m) => m.contentType === "tool-result");
-  const textMessages = options.includeTextMessages ? findCandidates(
-    (m) => m.contentType === "text" && (m.role === "user" || m.role === "assistant") && !isRenderedSummaryMessage(m) && !m.text?.startsWith(SUMMARY_HEADER)
-  ) : [];
-  const candidatesFound = toolResults.length + textMessages.length;
-  let truncatedCount = 0;
-  let savedTokens = 0;
-  let remaining = tokenCount;
-  const targetTokens = config.truncate.threshold * limit * 0.9;
-  const replacements = /* @__PURE__ */ new Map();
-  const applyTo = (candidates) => {
-    for (const candidate of candidates) {
-      if (remaining <= targetTokens) break;
-      const original = candidate.text ?? "";
-      const tokens = countTokens(original);
-      if (original.length <= opts.keepPrefixChars + opts.keepSuffixChars) {
-        continue;
-      }
-      const prefix = clampPrefix(original, opts.keepPrefixChars);
-      const suffix = clampWindow(original, original.length - opts.keepSuffixChars, original.length);
-      const replacement = `${prefix}
-
-...${TRUNCATION_MARKER} \u2014 original ~${tokens} tokens]...
-
-${suffix}`;
-      replacements.set(candidate.id, replacement);
-      truncatedCount++;
-      remaining -= tokens - countTokens(replacement);
-      savedTokens += tokens - countTokens(replacement);
-    }
-  };
-  applyTo(toolResults);
-  applyTo(textMessages);
-  if (replacements.size === 0) {
-    return { messages, truncatedCount: 0, savedTokens: 0, candidatesFound };
-  }
-  return {
-    messages: messages.map(
-      (m) => replacements.has(m.id) ? { ...m, text: replacements.get(m.id) } : m
-    ),
-    truncatedCount,
-    savedTokens,
-    candidatesFound
-  };
-}
-
-// src/hide-consumed.ts
-var KEEP_LAST_ORPHANED = 2;
-function rangeKey(startRef, endRef) {
-  return `${startRef}::${endRef}`;
-}
-function parseCallText(text) {
-  const raw = text ?? "";
-  const start = raw.indexOf("{");
-  if (start < 0) return null;
-  let parsed;
-  try {
-    parsed = JSON.parse(raw.slice(start));
-  } catch {
-    return null;
-  }
-  if (!parsed || typeof parsed !== "object") return null;
-  const obj = parsed;
-  let content = null;
-  let contentWasString = false;
-  if (Array.isArray(obj.content)) {
-    content = obj.content;
-  } else if (typeof obj.content === "string") {
-    contentWasString = true;
-    try {
-      const inner = JSON.parse(obj.content);
-      if (Array.isArray(inner)) content = inner;
-    } catch {
-      content = null;
-    }
-  }
-  if (!content || content.length === 0) return null;
-  return { prefix: raw.slice(0, start), obj, content, contentWasString };
-}
-function rewriteCompressText(text, liveKeys) {
-  const parsed = parseCallText(text);
-  if (!parsed) return null;
-  const { prefix, obj, content, contentWasString } = parsed;
-  const kept = content.filter((entry) => {
-    if (!entry || typeof entry !== "object") return false;
-    const e = entry;
-    const s = typeof e.startId === "string" ? e.startId : typeof e.messageId === "string" ? e.messageId : "";
-    const end = typeof e.endId === "string" ? e.endId : typeof e.messageId === "string" ? e.messageId : "";
-    return liveKeys.has(rangeKey(s, end));
-  });
-  if (kept.length === 0) return null;
-  return prefix + serializeCompacted(obj, kept, contentWasString).text;
-}
-var SUMMARY_STUB_CHARS = 200;
-function compactEntry(entry) {
-  if (!entry || typeof entry !== "object") return entry;
-  const e = entry;
-  if (typeof e.summary !== "string" || e.summary.length <= SUMMARY_STUB_CHARS) return entry;
-  return { ...e, summary: `${clampPrefix(e.summary, SUMMARY_STUB_CHARS - 1)}\u2026` };
-}
-function serializeCompacted(obj, content, contentWasString) {
-  let changed = false;
-  const compacted = content.map((entry) => {
-    const out = compactEntry(entry);
-    if (out !== entry) changed = true;
-    return out;
-  });
-  const outContent = contentWasString ? JSON.stringify(compacted) : compacted;
-  return { text: JSON.stringify({ ...obj, content: outContent }), changed };
-}
-function compactCompressText(text) {
-  const parsed = parseCallText(text);
-  if (!parsed) return null;
-  const { prefix, obj, content, contentWasString } = parsed;
-  const { text: out, changed } = serializeCompacted(obj, content, contentWasString);
-  return changed ? prefix + out : null;
-}
-function hideConsumedCompressCalls(state, messages) {
-  const allBlockCallIds = /* @__PURE__ */ new Set();
-  const activeCallIds = /* @__PURE__ */ new Set();
-  const liveRangeKeysByCallId = /* @__PURE__ */ new Map();
-  const legacyLiveByCallId = /* @__PURE__ */ new Set();
-  for (const block of state.blocks) {
-    if (!block.compressCallId) continue;
-    allBlockCallIds.add(block.compressCallId);
-    if (!block.active) continue;
-    activeCallIds.add(block.compressCallId);
-    if (block.startRef === void 0 || block.endRef === void 0) {
-      legacyLiveByCallId.add(block.compressCallId);
-      continue;
-    }
-    let keys = liveRangeKeysByCallId.get(block.compressCallId);
-    if (!keys) {
-      keys = /* @__PURE__ */ new Set();
-      liveRangeKeysByCallId.set(block.compressCallId, keys);
-    }
-    keys.add(rangeKey(block.startRef, block.endRef));
-  }
-  const lastOrphanedCallIds = [];
-  for (let i = messages.length - 1; i >= 0 && lastOrphanedCallIds.length < KEEP_LAST_ORPHANED; i--) {
-    const message = messages[i];
-    if (message.toolName !== "compress" || message.contentType !== "tool-call") continue;
-    const callId = message.toolCallId;
-    if (callId && !allBlockCallIds.has(callId)) {
-      lastOrphanedCallIds.push(callId);
-    }
-  }
-  const keepCallIds = /* @__PURE__ */ new Set([...activeCallIds, ...lastOrphanedCallIds]);
-  const hiddenCallIds = /* @__PURE__ */ new Set();
-  for (const message of messages) {
-    if (message.toolName === "compress" && message.contentType === "tool-call" && (!message.toolCallId || !keepCallIds.has(message.toolCallId))) {
-      if (message.toolCallId) hiddenCallIds.add(message.toolCallId);
-    }
-  }
-  let hidden = 0;
-  const result = [];
-  for (const message of messages) {
-    if (message.toolName === "compress" && message.contentType === "tool-call" && (!message.toolCallId || !keepCallIds.has(message.toolCallId))) {
-      hidden++;
-      continue;
-    }
-    if (message.contentType === "tool-result" && message.toolCallId && hiddenCallIds.has(message.toolCallId)) {
-      hidden++;
-      continue;
-    }
-    if (message.toolName === "compress" && message.contentType === "tool-call" && message.toolCallId && keepCallIds.has(message.toolCallId)) {
-      const liveKeys = liveRangeKeysByCallId.get(message.toolCallId);
-      if (liveKeys && liveKeys.size > 0 && !legacyLiveByCallId.has(message.toolCallId)) {
-        const rewritten = rewriteCompressText(message.text, liveKeys);
-        if (rewritten !== null) {
-          result.push({ ...message, text: rewritten });
-          continue;
-        }
-      }
-      const compacted = compactCompressText(message.text);
-      if (compacted !== null) {
-        result.push({ ...message, text: compacted });
-        continue;
-      }
-    }
-    result.push(message);
-  }
-  return { messages: result, hidden };
-}
-
-// src/surface-config.ts
-function applySectionOverrides(sections, overrides) {
-  const out = [];
-  for (const [key, text] of sections) {
-    const o = overrides?.[key];
-    if (o === null) continue;
-    out.push(typeof o === "string" ? o : text);
-  }
-  return out;
-}
-function cloneWithDescriptions(schema, overrides) {
-  if (Object.keys(overrides).length === 0) return schema;
-  return cloneNode(schema, overrides);
-}
-function cloneNode(node, overrides) {
-  if (Array.isArray(node)) return node.map((item) => cloneNode(item, overrides));
-  if (node && typeof node === "object") {
-    const out = {};
-    for (const [name, value] of Object.entries(node)) {
-      const cloned = cloneNode(value, overrides);
-      if (Object.hasOwn(overrides, name) && cloned && typeof cloned === "object" && !Array.isArray(cloned)) {
-        cloned.description = overrides[name];
-      }
-      out[name] = cloned;
-    }
-    return out;
-  }
-  return node;
+  return node;
 }
 function applyAcpToolOverrides(tools, overrides) {
   if (!overrides) return [...tools];
@@ -942,6 +579,7 @@ var SEARCH_CONTEXT_TOOL_NAME = "search_context";
 var ACP_STATUS_TOOL_NAME = "acp_status";
 var ACP_CACHE_TOOL_NAME = "acp_cache";
 var ABSORB_TOOL_NAME = "absorb";
+var IMAGE_FULL_TOOL_NAME = "image_full";
 var ACP_TEXT_OPEN = "<acp_compress>";
 var ACP_TEXT_CLOSE = "</acp_compress>";
 var ACP_STATUS_OPEN = "<acp_status>";
@@ -1475,6 +1113,67 @@ var ABSORB_TOOL_GOOGLE = {
   description: ABSORB_TOOL_DESCRIPTION,
   parameters: ABSORB_PARAMETERS
 };
+var IMAGE_FULL_TOOL_DESCRIPTION = 'Restore original-resolution images for a previously downscaled message. Call when you cannot read details (text, colors, alignment) in a reduced image: pass the message ref ("mNNNNN") from the [Downscaled screenshots] note. Full resolution applies for the rest of this session.';
+var IMAGE_FULL_PARAMETERS = {
+  type: "object",
+  properties: {
+    ref: {
+      type: "string",
+      description: "mNNNNN ref of the message whose image(s) should be restored to full resolution"
+    }
+  },
+  required: ["ref"]
+};
+var RETRIEVE_TOOL_NAME = "acp_retrieve";
+var RETRIEVE_TOOL_DESCRIPTION = "Retrieve the full original text of a stored tool result. REQUIRED when you need details from a placeholder that starts with \u{1F4E6} [acp-stored #mNNNNN: pass its ref. Returns the exact original text; the placeholder stays in context. Unknown refs return not-found.";
+var RETRIEVE_PARAMETERS = {
+  type: "object",
+  properties: {
+    ref: {
+      type: "string",
+      description: "mNNNNN ref shown in the \u{1F4E6} [acp-stored placeholder"
+    }
+  },
+  required: ["ref"]
+};
+var IMAGE_FULL_TOOL = {
+  name: IMAGE_FULL_TOOL_NAME,
+  description: IMAGE_FULL_TOOL_DESCRIPTION,
+  input_schema: IMAGE_FULL_PARAMETERS
+};
+var IMAGE_FULL_TOOL_OPENAI = {
+  type: "function",
+  function: {
+    name: IMAGE_FULL_TOOL_NAME,
+    description: IMAGE_FULL_TOOL_DESCRIPTION,
+    parameters: IMAGE_FULL_PARAMETERS
+  }
+};
+var IMAGE_FULL_TOOL_RESPONSES = {
+  type: "function",
+  name: IMAGE_FULL_TOOL_OPENAI.function.name,
+  description: IMAGE_FULL_TOOL_OPENAI.function.description,
+  parameters: IMAGE_FULL_TOOL_OPENAI.function.parameters
+};
+var RETRIEVE_TOOL = {
+  name: RETRIEVE_TOOL_NAME,
+  description: RETRIEVE_TOOL_DESCRIPTION,
+  input_schema: RETRIEVE_PARAMETERS
+};
+var RETRIEVE_TOOL_OPENAI = {
+  type: "function",
+  function: {
+    name: RETRIEVE_TOOL_NAME,
+    description: RETRIEVE_TOOL_DESCRIPTION,
+    parameters: RETRIEVE_PARAMETERS
+  }
+};
+var RETRIEVE_TOOL_RESPONSES = {
+  type: "function",
+  name: RETRIEVE_TOOL_NAME,
+  description: RETRIEVE_TOOL_DESCRIPTION,
+  parameters: RETRIEVE_PARAMETERS
+};
 
 // src/protected.ts
 var ALWAYS_PROTECTED_TOOLS = ["compress", "acp_rule"];
@@ -1552,223 +1251,2268 @@ function isMessageLatestProtected(msg, latest) {
   return false;
 }
 
-// src/absorb.ts
-var ABSORB_PROMPT_MARKER = "[ACP absorb]";
-var DEFAULT_ABSORB_CONFIG = {
+// src/content-store.ts
+import { createHash } from "crypto";
+function createContentStore() {
+  return { version: 1, byHash: {}, byRef: {} };
+}
+function hashContent(text) {
+  return createHash("sha256").update(text, "utf8").digest("hex");
+}
+function storeOriginal(store, spec) {
+  if (!spec.ref || store.byRef[spec.ref]) return store;
+  const hash = hashContent(spec.text);
+  const entry = {
+    hash,
+    rawId: spec.rawId,
+    kind: spec.kind,
+    tokens: spec.tokens,
+    chars: spec.text.length,
+    head: spec.head
+  };
+  if (spec.toolName !== void 0) entry.toolName = spec.toolName;
+  const byHash = store.byHash[hash] === void 0 ? { ...store.byHash, [hash]: spec.text } : store.byHash;
+  return { ...store, byHash, byRef: { ...store.byRef, [spec.ref]: entry } };
+}
+function retrieveByRef(store, ref) {
+  const entry = store.byRef[ref];
+  if (!entry) return { ok: false, reason: "not-found" };
+  const text = store.byHash[entry.hash];
+  if (text === void 0) return { ok: false, reason: "not-found" };
+  return { ok: true, text, entry };
+}
+function hasStoredRef(store, ref) {
+  return store.byRef[ref] !== void 0;
+}
+function contentStoreStats(store) {
+  let totalChars = 0;
+  for (const text of Object.values(store.byHash)) totalChars += text.length;
+  return {
+    entries: Object.keys(store.byRef).length,
+    uniqueContents: Object.keys(store.byHash).length,
+    totalChars
+  };
+}
+
+// src/ccr.ts
+var RETRIEVE_TOOL_NAME2 = "acp_retrieve";
+var DEFAULT_CCR_CONFIG = {
   enabled: false,
-  toolName: ABSORB_TOOL_NAME,
-  minToolTokens: 1e3,
-  contextThresholdPct: 0,
-  excludeTools: []
+  toolName: RETRIEVE_TOOL_NAME2,
+  minToolTokens: 4e3,
+  excludeTools: [],
+  maxHeadChars: 96
 };
-function resolveAbsorbConfig(config) {
-  return { ...DEFAULT_ABSORB_CONFIG, ...config.absorb ?? {} };
+function resolveCcrConfig(config) {
+  return { ...DEFAULT_CCR_CONFIG, ...config.ccr };
+}
+var STORED_PLACEHOLDER_MARKER = "[acp-stored";
+var RETRIEVED_ID_PREFIX = "acp_retrieved_";
+var KIND_LABELS = {
+  bash: "shell output",
+  shell: "shell output",
+  exec: "shell output",
+  execute_command: "shell output",
+  run: "shell output",
+  terminal: "shell output",
+  read: "file read",
+  read_file: "file read",
+  cat: "file read",
+  open: "file read",
+  grep: "search output",
+  rg: "search output",
+  search: "search output",
+  glob: "search output",
+  find: "search output",
+  webfetch: "web fetch",
+  web_fetch: "web fetch",
+  fetch: "web fetch",
+  curl: "web fetch"
+};
+function classifyKind(toolName) {
+  if (!toolName) return "tool result";
+  return KIND_LABELS[toolName.toLowerCase()] ?? "tool result";
+}
+function groupThousands(value) {
+  return String(Math.max(0, Math.round(value))).replace(
+    /\B(?=(\d{3})+(?!\d))/g,
+    ","
+  );
 }
-function formatTokenCount(tokens) {
-  if (tokens < 1e3) return String(tokens);
-  if (tokens < 1e4) return (tokens / 1e3).toFixed(1) + "K";
-  return Math.round(tokens / 1e3) + "K";
+function normalizeHead(text, maxChars) {
+  const singleLine = (text || "").replace(/\s+/g, " ").trim();
+  if (singleLine.length <= maxChars) return singleLine;
+  return singleLine.slice(0, maxChars) + "\u2026";
 }
-function buildAbsorbPrompt(ref, tokens, toolName = ABSORB_TOOL_NAME) {
-  return `${ABSORB_PROMPT_MARKER} This tool result (~${formatTokenCount(tokens)} tokens) will be REMOVED from context. Your IMMEDIATE next action: call ${toolName}({ ref: "${ref}", summary: "..." }) \u2014 summary = distilled essentials only (outcome, key values, exact paths:lines, error text verbatim, decisions). Afterwards work from your summary; do NOT re-run this tool. If the result contains nothing you need, call ${toolName} with summary "(nothing needed)".`;
+var COMMAND_FIELDS = ["command", "cmd", "script", "query", "path", "url"];
+function extractCommand(toolCallText, maxChars) {
+  if (!toolCallText) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(toolCallText);
+  } catch {
+    return void 0;
+  }
+  if (typeof parsed !== "object" || parsed === null) return void 0;
+  const record = parsed;
+  for (const field of COMMAND_FIELDS) {
+    const value = record[field];
+    if (typeof value === "string" && value.trim().length > 0) {
+      const normalized = value.replace(/\s+/g, " ").trim();
+      return normalized.length <= maxChars ? normalized : normalized.slice(0, maxChars) + "\u2026";
+    }
+  }
+  return void 0;
 }
-function buildAbsorbSystemPrompt(toolName = ABSORB_TOOL_NAME) {
-  return `INSTANT TOOL-RESULT ABSORPTION (${toolName})
-
-Some tool results end with a ${ABSORB_PROMPT_MARKER} instruction. When you see one, your IMMEDIATE next action must be calling ${toolName}({ ref, summary }) \u2014 distill that tool result's essentials into summary: outcome, key values, exact paths:lines, error text verbatim, decisions. The original output is then removed from context; your ${toolName} summary becomes the only durable record of it, so distill carefully. Never call another tool or answer the user before absorbing a marked result. Do not re-run the original tool afterwards \u2014 work from your summary. ${toolName} calls are ordinary context: the regular compression system may fold them later like any other message.`;
+function buildStoredPlaceholder(input) {
+  const title = input.command ?? input.head;
+  const titlePart = title ? ` \`${title}\`` : "";
+  return `\u{1F4E6} ${STORED_PLACEHOLDER_MARKER} #${input.ref} \xB7 ${input.kind} \xB7 ${groupThousands(input.tokens)} tok]${titlePart}
+   \u2192 ${input.retrieveToolName}("${input.ref}") returns the full text`;
 }
-function isAcpOrConfiguredTool(toolName, cfg) {
-  if (!toolName) return false;
-  if (toolName === cfg.toolName) return true;
-  return ACP_TOOL_NAMES.has(toolName);
+var LEADING_TAG_RE = new RegExp("^\\x3cacp [^>]*>[^\\x3c]*\\x3c\\/acp>\\n?");
+function stripLeadingTag(text) {
+  return text.replace(LEADING_TAG_RE, "");
 }
-function isAbsorbCandidate(msg, config, latest) {
-  if (msg.contentType !== "tool-result" || !msg.toolCallId) return false;
-  const cfg = resolveAbsorbConfig(config);
-  if (isAcpOrConfiguredTool(msg.toolName, cfg)) return false;
-  if (isMessageProtected(msg, config)) return false;
-  if (latest && isMessageLatestProtected(msg, latest)) return false;
-  for (const pattern of cfg.excludeTools) {
-    if (msg.toolName && matchToolPattern(msg.toolName, pattern)) return false;
-  }
-  return true;
+function isStoredPlaceholderText(text) {
+  return stripLeadingTag(text).includes(STORED_PLACEHOLDER_MARKER);
 }
-function hideAbsorbedMessages(messages, state) {
-  const records = state.absorbed ?? [];
-  if (records.length === 0) return messages;
-  const hidden = /* @__PURE__ */ new Set();
-  for (const record of records) {
-    if (record.callMessageId) hidden.add(record.callMessageId);
-    if (record.resultMessageId) hidden.add(record.resultMessageId);
-  }
-  return messages.filter((msg) => !hidden.has(msg.id));
+function retrievedMessageId(ref) {
+  return RETRIEVED_ID_PREFIX + ref;
 }
-function appendAbsorbPrompts(messages, state, config, tokenCount, countTokens) {
-  const cfg = resolveAbsorbConfig(config);
-  if (!cfg.enabled) return { messages, promptedCount: 0 };
-  const limit = config.modelContextLimit;
-  if (cfg.contextThresholdPct > 0 && limit > 0 && tokenCount < cfg.contextThresholdPct * limit) {
-    return { messages, promptedCount: 0 };
+function isRetrievedMessage(message) {
+  return message.id.startsWith(RETRIEVED_ID_PREFIX) && message.role === "system" && message.contentType === "text";
+}
+function buildRetrievalInjection(ref, entry, text) {
+  const header = `[acp-retrieved #${ref} \xB7 ${entry.kind} \xB7 ${groupThousands(entry.tokens)} tok]`;
+  return {
+    ackText: `retrieved ${ref}: ${groupThousands(entry.tokens)} tok (${entry.chars} chars)`,
+    injection: {
+      id: retrievedMessageId(ref),
+      role: "system",
+      contentType: "text",
+      text: `${header}
+${text}`
+    }
+  };
+}
+function applyRetrieve(input) {
+  const ref = input.ref.trim();
+  const found = retrieveByRef(input.store, ref);
+  if (!found.ok) {
+    return {
+      ok: false,
+      reason: "not-found",
+      ackText: `retrieve ${ref}: not found \u2014 no stored original for this ref`
+    };
   }
-  const absorbedIds = /* @__PURE__ */ new Set();
-  for (const record of state.absorbed ?? []) {
-    if (record.resultMessageId) absorbedIds.add(record.resultMessageId);
+  const built = buildRetrievalInjection(ref, found.entry, found.text);
+  return {
+    ok: true,
+    text: found.text,
+    ackText: built.ackText,
+    injection: built.injection,
+    entry: found.entry
+  };
+}
+function storeLargeResults(input) {
+  const cfg = resolveCcrConfig(input.config);
+  if (!cfg.enabled)
+    return { messages: input.messages, store: input.store, storedCount: 0 };
+  let current = input.store;
+  let storedCount = 0;
+  const callById = /* @__PURE__ */ new Map();
+  for (const message of input.messages) {
+    if (message.contentType === "tool-call" && message.toolCallId) {
+      callById.set(message.toolCallId, message);
+    }
   }
-  let promptedCount = 0;
-  const latest = collectLatestProtected(messages, config);
-  const out = messages.map((msg) => {
-    if (!isAbsorbCandidate(msg, config, latest)) return msg;
-    if (absorbedIds.has(msg.id)) return msg;
-    const text = msg.text ?? "";
-    if (text.includes(ABSORB_PROMPT_MARKER)) return msg;
-    const tokens = countTokens(text);
-    if (tokens < cfg.minToolTokens) return msg;
-    const ref = refForRaw(state.messageRefs, msg.id);
-    if (!ref || ref === BLOCKED_REF) return msg;
-    promptedCount++;
+  const updated = input.messages.map((message) => {
+    if (message.contentType !== "tool-result") return message;
+    const text = message.text ?? "";
+    if (text.length === 0) return message;
+    if (isStoredPlaceholderText(text)) return message;
+    if (!message.toolCallId) return message;
+    const toolName = message.toolName;
+    if (toolName && (ACP_TOOL_NAMES.has(toolName) || toolName === cfg.toolName)) {
+      return message;
+    }
+    if (toolName && cfg.excludeTools.some((pattern) => matchToolPattern(toolName, pattern))) {
+      return message;
+    }
+    if (isMessageProtected(message, input.config)) return message;
+    const tokens = input.countTokens(text);
+    if (tokens < cfg.minToolTokens) return message;
+    const ref = refForRaw(input.state.messageRefs, message.id);
+    if (!ref || ref === BLOCKED_REF) return message;
+    if (hasStoredRef(current, ref)) return message;
+    const kind = classifyKind(toolName);
+    const head = normalizeHead(text, cfg.maxHeadChars);
+    const command = extractCommand(
+      callById.get(message.toolCallId)?.text,
+      cfg.maxHeadChars
+    );
+    current = storeOriginal(current, {
+      ref,
+      rawId: message.id,
+      text,
+      kind,
+      toolName,
+      tokens,
+      head
+    });
+    storedCount += 1;
     return {
-      ...msg,
-      text: text + "\n\n" + buildAbsorbPrompt(ref, tokens, cfg.toolName)
+      ...message,
+      text: buildStoredPlaceholder({
+        ref,
+        kind,
+        tokens,
+        head,
+        command,
+        retrieveToolName: cfg.toolName
+      })
     };
   });
-  return { messages: out, promptedCount };
+  return { messages: updated, store: current, storedCount };
 }
-function parseAbsorbInput(input, callId, onWarn) {
-  let obj = null;
-  if (typeof input === "string") {
-    try {
-      const parsed = JSON.parse(input);
-      if (parsed && typeof parsed === "object") {
-        obj = parsed;
-      }
-    } catch {
-      obj = null;
+var ccrStoreNode = {
+  name: "ccr-store",
+  enabled: (_io, ctx) => resolveCcrConfig(ctx.config).enabled,
+  run(io, ctx) {
+    const applied = storeLargeResults({
+      messages: io.messages,
+      state: io.state,
+      store: ctx.contentStore,
+      config: ctx.config,
+      countTokens: ctx.countTokens
+    });
+    const effect = {
+      store: applied.store,
+      storedCount: applied.storedCount
+    };
+    const stats = applied.storedCount > 0 ? {
+      ...io.state.stats,
+      storedCount: (io.state.stats.storedCount ?? 0) + applied.storedCount
+    } : io.state.stats;
+    return {
+      ...io,
+      messages: applied.messages,
+      state: stats === io.state.stats ? io.state : { ...io.state, stats },
+      effects: { ...io.effects, ccr: effect }
+    };
+  }
+};
+function storeCoveredOriginals(store, messages, state, blockIds, countTokens, maxHeadChars = DEFAULT_CCR_CONFIG.maxHeadChars) {
+  const covered = /* @__PURE__ */ new Set();
+  for (const block of state.blocks) {
+    if (!block.active || !blockIds.includes(block.blockId)) continue;
+    for (const id of block.effectiveMessageIds) covered.add(id);
+  }
+  let current = store;
+  for (const message of messages) {
+    if (!covered.has(message.id)) continue;
+    if (message.contentType === "reasoning") continue;
+    const text = stripLeadingTag(message.text ?? "");
+    if (text.length === 0) continue;
+    const ref = refForRaw(state.messageRefs, message.id);
+    if (!ref || ref === BLOCKED_REF) continue;
+    if (isStoredPlaceholderText(text) && hasStoredRef(current, ref)) continue;
+    current = storeOriginal(current, {
+      ref,
+      rawId: message.id,
+      text,
+      kind: classifyKind(message.toolName),
+      toolName: message.toolName,
+      tokens: countTokens(text),
+      head: normalizeHead(text, maxHeadChars)
+    });
+  }
+  return current;
+}
+function noteRetrieval(state) {
+  return {
+    ...state,
+    stats: {
+      ...state.stats,
+      retrievalCount: (state.stats.retrievalCount ?? 0) + 1
+    }
+  };
+}
+
+// src/boundaries.ts
+var MESSAGE_REF_PATTERN = /^m0*(\d{1,5})$/;
+var BLOCK_REF_PATTERN = /^b(\d{1,9})$/;
+function parseBoundary(ref) {
+  const normalized = ref.trim().toLowerCase();
+  const messageMatch = MESSAGE_REF_PATTERN.exec(normalized);
+  if (messageMatch) {
+    const numericId = Number(messageMatch[1]);
+    if (numericId >= 1 && numericId <= 99999) {
+      return { kind: "message", numericId, raw: normalized };
     }
-  } else if (input && typeof input === "object") {
-    obj = input;
   }
-  if (!obj) {
-    onWarn?.(`[acp-absorb-input] rejected: not an object (${typeof input})`);
-    return null;
+  const blockMatch = BLOCK_REF_PATTERN.exec(normalized);
+  if (blockMatch) {
+    const numericId = Number(blockMatch[1]);
+    if (numericId >= 1) return { kind: "block", numericId, raw: normalized };
   }
-  const ref = pickString(obj, "ref", "messageId", "of");
-  const summary = pickString(obj, "summary", "content");
-  if (typeof ref !== "string" || typeof summary !== "string") {
-    onWarn?.(
-      `[acp-absorb-input] rejected: need ref (string) + summary (string); keys: ${Object.keys(obj).join(",")}`
+  return null;
+}
+var BoundaryNotFoundError = class extends Error {
+  code = "BOUNDARY_NOT_FOUND";
+  kind;
+  endpoint;
+  constructor(kind, endpoint, message) {
+    super(message);
+    this.name = "BoundaryNotFoundError";
+    this.code = "BOUNDARY_NOT_FOUND";
+    this.kind = kind;
+    this.endpoint = endpoint;
+  }
+};
+function resolveBoundaries(input) {
+  const start = parseBoundary(input.startRef);
+  const end = parseBoundary(input.endRef);
+  if (!start || !end) {
+    throw new Error(
+      `Invalid boundary ref(s): startId="${input.startRef}", endId="${input.endRef}". Use mNNNNN or bN.`
     );
-    return null;
   }
+  const indexByMessageId = /* @__PURE__ */ new Map();
+  input.messages.forEach(
+    (message, index) => indexByMessageId.set(message.id, index)
+  );
+  let snappedBoundaries = [];
+  const startAnchor = resolveAnchorIndex(
+    start,
+    input.state,
+    indexByMessageId,
+    "start"
+  );
+  if (startAnchor.snapped) snappedBoundaries.push(startAnchor.snapped);
+  const endAnchor = resolveAnchorIndex(
+    end,
+    input.state,
+    indexByMessageId,
+    "end"
+  );
+  if (endAnchor.snapped) snappedBoundaries.push(endAnchor.snapped);
+  let startIndex = startAnchor.index;
+  let endIndex = endAnchor.index;
+  if (startIndex > endIndex) {
+    [startIndex, endIndex] = [endIndex, startIndex];
+  }
+  const messageIds = [];
+  for (let index = startIndex; index <= endIndex; index++) {
+    const message = input.messages[index];
+    if (message && !isRenderedSummaryMessage(message) && !isRetrievedMessage(message))
+      messageIds.push(message.id);
+  }
+  const boundaryKind = start.kind === "block" || end.kind === "block" ? "block" : "message";
+  const nestedBlockIds = [];
+  const nestedSeen = /* @__PURE__ */ new Set();
+  for (const block of activeBlocks(input.state)) {
+    if (blockVisibleInRange(block, indexByMessageId, startIndex, endIndex)) {
+      if (!nestedSeen.has(block.blockId)) {
+        nestedSeen.add(block.blockId);
+        nestedBlockIds.push(block.blockId);
+      }
+    }
+  }
+  const protectedGaps = [];
   return {
-    ref: ref.trim(),
-    summary,
-    ...callId ? { absorbCallId: callId } : {}
+    startIndex,
+    endIndex,
+    messageIds,
+    nestedBlockIds,
+    boundaryKind,
+    protectedGaps,
+    snappedBoundaries
   };
 }
-function pickString(obj, ...keys) {
-  for (const key of keys) {
-    const value = obj[key];
-    if (typeof value === "string") return value;
-  }
-  return void 0;
+function resolveAnchorIndex(boundary, state, indexByMessageId, endpoint) {
+  const label = endpoint === "start" ? "startId" : "endId";
+  if (boundary.kind === "message") {
+    const rawId = state.messageRefs.byRef[boundary.raw] ?? state.messageRefs.byRef[formatPaddedRef(boundary.numericId)];
+    if (!rawId) {
+      throw new BoundaryNotFoundError(
+        "unknown",
+        endpoint,
+        `${label}="${boundary.raw}" does not exist in this session (typo or wrong session) \u2014 run acp_status for current refs.`
+      );
+    }
+    const index = indexByMessageId.get(rawId);
+    if (index !== void 0) {
+      return { index, snapped: null };
+    }
+    const owner2 = activeOwnerAnchor(state, [rawId], indexByMessageId);
+    if (owner2 !== null) {
+      return {
+        index: owner2,
+        snapped: `${label}="${boundary.raw}" refers to a message already compressed into an active block \u2014 anchored to the active block covering it instead.`
+      };
+    }
+    throw new BoundaryNotFoundError(
+      "consumed",
+      endpoint,
+      `${label}="${boundary.raw}" not found in visible context (likely consumed by an existing block).`
+    );
+  }
+  const block = blockById(state, `b${boundary.numericId}`);
+  if (!block) {
+    throw new BoundaryNotFoundError(
+      "unknown",
+      endpoint,
+      `${label}="b${boundary.numericId}" does not exist in this session (typo or wrong session) \u2014 run acp_status for current refs.`
+    );
+  }
+  if (block.active) {
+    const anchor = visibleBlockAnchor(block, indexByMessageId);
+    if (anchor !== null) {
+      return { index: anchor, snapped: null };
+    }
+  }
+  const owner = activeOwnerAnchor(
+    state,
+    block.effectiveMessageIds,
+    indexByMessageId
+  );
+  if (owner !== null) {
+    return {
+      index: owner,
+      snapped: `${label}="b${boundary.numericId}" was consumed by a higher-tier block \u2014 anchored to the active block covering its content instead.`
+    };
+  }
+  if (!block.active) {
+    throw new BoundaryNotFoundError(
+      "consumed",
+      endpoint,
+      `${label}="b${boundary.numericId}" not found in visible context (block distilled/consumed by a higher-tier block).`
+    );
+  }
+  throw new BoundaryNotFoundError(
+    "consumed",
+    endpoint,
+    `${label}="b${boundary.numericId}" is an active block but none of its content (raw messages or rendered summary) is visible in the current context \u2014 run acp_status to verify.`
+  );
+}
+function activeOwnerAnchor(state, ownedIds, indexByMessageId) {
+  if (ownedIds.length === 0) return null;
+  const owned = new Set(ownedIds);
+  let best = null;
+  for (const block of state.blocks) {
+    if (!block.active) continue;
+    const inherited = inheritedContentIds(state, block);
+    let ownsInherited = false;
+    for (const id of owned) {
+      if (inherited.has(id)) {
+        ownsInherited = true;
+        break;
+      }
+    }
+    if (!ownsInherited) continue;
+    const anchor = visibleBlockAnchor(block, indexByMessageId);
+    if (anchor === null) continue;
+    if (best === null || anchor < best) {
+      best = anchor;
+    }
+  }
+  return best;
+}
+function inheritedContentIds(state, block) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const childId of block.directBlockIds) {
+    const child = blockById(state, childId);
+    if (!child) continue;
+    for (const id of child.effectiveMessageIds) ids.add(id);
+  }
+  return ids;
+}
+function formatPaddedRef(index) {
+  return `m${String(index).padStart(5, "0")}`;
+}
+function visibleBlockAnchor(block, indexByMessageId) {
+  const summaryIndex = indexByMessageId.get(summaryMessageId(block.blockId));
+  if (summaryIndex !== void 0) return summaryIndex;
+  return earliestIndexOfIds(block.effectiveMessageIds, indexByMessageId);
+}
+function blockVisibleInRange(block, indexByMessageId, startIndex, endIndex) {
+  const summaryIndex = indexByMessageId.get(summaryMessageId(block.blockId));
+  if (summaryIndex !== void 0 && summaryIndex >= startIndex && summaryIndex <= endIndex) {
+    return true;
+  }
+  const rawIndex = earliestIndexOfIds(
+    block.effectiveMessageIds,
+    indexByMessageId
+  );
+  return rawIndex !== null && rawIndex >= startIndex && rawIndex <= endIndex;
+}
+function earliestIndexOfIds(ids, indexByMessageId) {
+  let earliest = null;
+  for (const id of ids) {
+    const index = indexByMessageId.get(id);
+    if (index !== void 0 && (earliest === null || index < earliest)) {
+      earliest = index;
+    }
+  }
+  return earliest;
+}
+
+// src/truncate-tools.ts
+var TRUNCATION_MARKER = "[truncated for context space]";
+var DEFAULTS = {
+  minOutputTokens: 1e3,
+  keepPrefixChars: 2e3,
+  keepSuffixChars: 2e3,
+  protectRecentMessages: 3
+};
+function truncateLargeToolOutputs(messages, tokenCount, config, countTokens, options = {}) {
+  const opts = { ...DEFAULTS, ...options };
+  const limit = config.modelContextLimit;
+  if (limit <= 0 || tokenCount < config.truncate.threshold * limit) {
+    return { messages, truncatedCount: 0, savedTokens: 0, candidatesFound: 0 };
+  }
+  const protectedIndex = messages.length - opts.protectRecentMessages;
+  const findCandidates = (predicate) => {
+    const found = [];
+    for (let i = 0; i < protectedIndex; i++) {
+      const message = messages[i];
+      if (!predicate(message)) continue;
+      const text = message.text ?? "";
+      if (text.length === 0 || text.includes(TRUNCATION_MARKER)) continue;
+      if (countTokens(text) < opts.minOutputTokens) continue;
+      found.push(message);
+    }
+    return found.sort(
+      (a, b) => countTokens(b.text ?? "") - countTokens(a.text ?? "")
+    );
+  };
+  const toolResults = findCandidates((m) => m.contentType === "tool-result");
+  const textMessages = options.includeTextMessages ? findCandidates(
+    (m) => m.contentType === "text" && (m.role === "user" || m.role === "assistant") && !isRenderedSummaryMessage(m) && !m.text?.startsWith(SUMMARY_HEADER)
+  ) : [];
+  const candidatesFound = toolResults.length + textMessages.length;
+  let truncatedCount = 0;
+  let savedTokens = 0;
+  let remaining = tokenCount;
+  const targetTokens = config.truncate.threshold * limit * 0.9;
+  const replacements = /* @__PURE__ */ new Map();
+  const applyTo = (candidates) => {
+    for (const candidate of candidates) {
+      if (remaining <= targetTokens) break;
+      const original = candidate.text ?? "";
+      const tokens = countTokens(original);
+      if (original.length <= opts.keepPrefixChars + opts.keepSuffixChars) {
+        continue;
+      }
+      const prefix = clampPrefix(original, opts.keepPrefixChars);
+      const suffix = clampWindow(original, original.length - opts.keepSuffixChars, original.length);
+      const replacement = `${prefix}
+
+...${TRUNCATION_MARKER} \u2014 original ~${tokens} tokens]...
+
+${suffix}`;
+      replacements.set(candidate.id, replacement);
+      truncatedCount++;
+      remaining -= tokens - countTokens(replacement);
+      savedTokens += tokens - countTokens(replacement);
+    }
+  };
+  applyTo(toolResults);
+  applyTo(textMessages);
+  if (replacements.size === 0) {
+    return { messages, truncatedCount: 0, savedTokens: 0, candidatesFound };
+  }
+  return {
+    messages: messages.map(
+      (m) => replacements.has(m.id) ? { ...m, text: replacements.get(m.id) } : m
+    ),
+    truncatedCount,
+    savedTokens,
+    candidatesFound
+  };
+}
+
+// src/hide-consumed.ts
+var KEEP_LAST_ORPHANED = 2;
+function rangeKey(startRef, endRef) {
+  return `${startRef}::${endRef}`;
+}
+function parseCallText(text) {
+  const raw = text ?? "";
+  const start = raw.indexOf("{");
+  if (start < 0) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw.slice(start));
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const obj = parsed;
+  let content = null;
+  let contentWasString = false;
+  if (Array.isArray(obj.content)) {
+    content = obj.content;
+  } else if (typeof obj.content === "string") {
+    contentWasString = true;
+    try {
+      const inner = JSON.parse(obj.content);
+      if (Array.isArray(inner)) content = inner;
+    } catch {
+      content = null;
+    }
+  }
+  if (!content || content.length === 0) return null;
+  return { prefix: raw.slice(0, start), obj, content, contentWasString };
+}
+function rewriteCompressText(text, liveKeys) {
+  const parsed = parseCallText(text);
+  if (!parsed) return null;
+  const { prefix, obj, content, contentWasString } = parsed;
+  const kept = content.filter((entry) => {
+    if (!entry || typeof entry !== "object") return false;
+    const e = entry;
+    const s = typeof e.startId === "string" ? e.startId : typeof e.messageId === "string" ? e.messageId : "";
+    const end = typeof e.endId === "string" ? e.endId : typeof e.messageId === "string" ? e.messageId : "";
+    return liveKeys.has(rangeKey(s, end));
+  });
+  if (kept.length === 0) return null;
+  return prefix + serializeCompacted(obj, kept, contentWasString).text;
+}
+var SUMMARY_STUB_CHARS = 200;
+function compactEntry(entry) {
+  if (!entry || typeof entry !== "object") return entry;
+  const e = entry;
+  if (typeof e.summary !== "string" || e.summary.length <= SUMMARY_STUB_CHARS) return entry;
+  return { ...e, summary: `${clampPrefix(e.summary, SUMMARY_STUB_CHARS - 1)}\u2026` };
+}
+function serializeCompacted(obj, content, contentWasString) {
+  let changed = false;
+  const compacted = content.map((entry) => {
+    const out = compactEntry(entry);
+    if (out !== entry) changed = true;
+    return out;
+  });
+  const outContent = contentWasString ? JSON.stringify(compacted) : compacted;
+  return { text: JSON.stringify({ ...obj, content: outContent }), changed };
+}
+function compactCompressText(text) {
+  const parsed = parseCallText(text);
+  if (!parsed) return null;
+  const { prefix, obj, content, contentWasString } = parsed;
+  const { text: out, changed } = serializeCompacted(obj, content, contentWasString);
+  return changed ? prefix + out : null;
+}
+function hideConsumedCompressCalls(state, messages) {
+  const allBlockCallIds = /* @__PURE__ */ new Set();
+  const activeCallIds = /* @__PURE__ */ new Set();
+  const liveRangeKeysByCallId = /* @__PURE__ */ new Map();
+  const legacyLiveByCallId = /* @__PURE__ */ new Set();
+  for (const block of state.blocks) {
+    if (!block.compressCallId) continue;
+    allBlockCallIds.add(block.compressCallId);
+    if (!block.active) continue;
+    activeCallIds.add(block.compressCallId);
+    if (block.startRef === void 0 || block.endRef === void 0) {
+      legacyLiveByCallId.add(block.compressCallId);
+      continue;
+    }
+    let keys = liveRangeKeysByCallId.get(block.compressCallId);
+    if (!keys) {
+      keys = /* @__PURE__ */ new Set();
+      liveRangeKeysByCallId.set(block.compressCallId, keys);
+    }
+    keys.add(rangeKey(block.startRef, block.endRef));
+  }
+  const lastOrphanedCallIds = [];
+  for (let i = messages.length - 1; i >= 0 && lastOrphanedCallIds.length < KEEP_LAST_ORPHANED; i--) {
+    const message = messages[i];
+    if (message.toolName !== "compress" || message.contentType !== "tool-call") continue;
+    const callId = message.toolCallId;
+    if (callId && !allBlockCallIds.has(callId)) {
+      lastOrphanedCallIds.push(callId);
+    }
+  }
+  const keepCallIds = /* @__PURE__ */ new Set([...activeCallIds, ...lastOrphanedCallIds]);
+  const hiddenCallIds = /* @__PURE__ */ new Set();
+  for (const message of messages) {
+    if (message.toolName === "compress" && message.contentType === "tool-call" && (!message.toolCallId || !keepCallIds.has(message.toolCallId))) {
+      if (message.toolCallId) hiddenCallIds.add(message.toolCallId);
+    }
+  }
+  let hidden = 0;
+  const result = [];
+  for (const message of messages) {
+    if (message.toolName === "compress" && message.contentType === "tool-call" && (!message.toolCallId || !keepCallIds.has(message.toolCallId))) {
+      hidden++;
+      continue;
+    }
+    if (message.contentType === "tool-result" && message.toolCallId && hiddenCallIds.has(message.toolCallId)) {
+      hidden++;
+      continue;
+    }
+    if (message.toolName === "compress" && message.contentType === "tool-call" && message.toolCallId && keepCallIds.has(message.toolCallId)) {
+      const liveKeys = liveRangeKeysByCallId.get(message.toolCallId);
+      if (liveKeys && liveKeys.size > 0 && !legacyLiveByCallId.has(message.toolCallId)) {
+        const rewritten = rewriteCompressText(message.text, liveKeys);
+        if (rewritten !== null) {
+          result.push({ ...message, text: rewritten });
+          continue;
+        }
+      }
+      const compacted = compactCompressText(message.text);
+      if (compacted !== null) {
+        result.push({ ...message, text: compacted });
+        continue;
+      }
+    }
+    result.push(message);
+  }
+  return { messages: result, hidden };
+}
+
+// src/absorb.ts
+var ABSORB_PROMPT_MARKER = "[ACP absorb]";
+var DEFAULT_ABSORB_CONFIG = {
+  enabled: false,
+  toolName: ABSORB_TOOL_NAME,
+  // Raised 1000 → 4000 (issue #352): lossless CCR takes over large-result
+  // handling; absorb's forced distillation only fires above the new bar.
+  minToolTokens: 4e3,
+  contextThresholdPct: 0,
+  excludeTools: []
+};
+function resolveAbsorbConfig(config) {
+  return { ...DEFAULT_ABSORB_CONFIG, ...config.absorb ?? {} };
+}
+function formatTokenCount(tokens) {
+  if (tokens < 1e3) return String(tokens);
+  if (tokens < 1e4) return (tokens / 1e3).toFixed(1) + "K";
+  return Math.round(tokens / 1e3) + "K";
+}
+function buildAbsorbPrompt(ref, tokens, toolName = ABSORB_TOOL_NAME) {
+  return `${ABSORB_PROMPT_MARKER} This tool result (~${formatTokenCount(tokens)} tokens) will be REMOVED from context. Your IMMEDIATE next action: call ${toolName}({ ref: "${ref}", summary: "..." }) \u2014 summary = distilled essentials only (outcome, key values, exact paths:lines, error text verbatim, decisions). Afterwards work from your summary; do NOT re-run this tool. If the result contains nothing you need, call ${toolName} with summary "(nothing needed)".`;
+}
+function buildAbsorbSystemPrompt(toolName = ABSORB_TOOL_NAME) {
+  return `INSTANT TOOL-RESULT ABSORPTION (${toolName})
+
+Some tool results end with a ${ABSORB_PROMPT_MARKER} instruction. When you see one, your IMMEDIATE next action must be calling ${toolName}({ ref, summary }) \u2014 distill that tool result's essentials into summary: outcome, key values, exact paths:lines, error text verbatim, decisions. The original output is then removed from context; your ${toolName} summary becomes the only durable record of it, so distill carefully. Never call another tool or answer the user before absorbing a marked result. Do not re-run the original tool afterwards \u2014 work from your summary. ${toolName} calls are ordinary context: the regular compression system may fold them later like any other message.`;
+}
+function isAcpOrConfiguredTool(toolName, cfg) {
+  if (!toolName) return false;
+  if (toolName === cfg.toolName) return true;
+  return ACP_TOOL_NAMES.has(toolName);
+}
+function isAbsorbCandidate(msg, config, latest) {
+  if (msg.contentType !== "tool-result" || !msg.toolCallId) return false;
+  if (isStoredPlaceholderText(msg.text ?? "")) return false;
+  const cfg = resolveAbsorbConfig(config);
+  if (isAcpOrConfiguredTool(msg.toolName, cfg)) return false;
+  if (isMessageProtected(msg, config)) return false;
+  if (latest && isMessageLatestProtected(msg, latest)) return false;
+  for (const pattern of cfg.excludeTools) {
+    if (msg.toolName && matchToolPattern(msg.toolName, pattern)) return false;
+  }
+  return true;
+}
+function hideAbsorbedMessages(messages, state) {
+  const records = state.absorbed ?? [];
+  if (records.length === 0) return messages;
+  const hidden = /* @__PURE__ */ new Set();
+  for (const record of records) {
+    if (record.callMessageId) hidden.add(record.callMessageId);
+    if (record.resultMessageId) hidden.add(record.resultMessageId);
+  }
+  return messages.filter((msg) => !hidden.has(msg.id));
+}
+function appendAbsorbPrompts(messages, state, config, tokenCount, countTokens) {
+  const cfg = resolveAbsorbConfig(config);
+  if (!cfg.enabled) return { messages, promptedCount: 0 };
+  const limit = config.modelContextLimit;
+  if (cfg.contextThresholdPct > 0 && limit > 0 && tokenCount < cfg.contextThresholdPct * limit) {
+    return { messages, promptedCount: 0 };
+  }
+  const absorbedIds = /* @__PURE__ */ new Set();
+  for (const record of state.absorbed ?? []) {
+    if (record.resultMessageId) absorbedIds.add(record.resultMessageId);
+  }
+  let promptedCount = 0;
+  const latest = collectLatestProtected(messages, config);
+  const out = messages.map((msg) => {
+    if (!isAbsorbCandidate(msg, config, latest)) return msg;
+    if (absorbedIds.has(msg.id)) return msg;
+    const text = msg.text ?? "";
+    if (text.includes(ABSORB_PROMPT_MARKER)) return msg;
+    const tokens = countTokens(text);
+    if (tokens < cfg.minToolTokens) return msg;
+    const ref = refForRaw(state.messageRefs, msg.id);
+    if (!ref || ref === BLOCKED_REF) return msg;
+    promptedCount++;
+    return {
+      ...msg,
+      text: text + "\n\n" + buildAbsorbPrompt(ref, tokens, cfg.toolName)
+    };
+  });
+  return { messages: out, promptedCount };
+}
+function parseAbsorbInput(input, callId, onWarn) {
+  let obj = null;
+  if (typeof input === "string") {
+    try {
+      const parsed = JSON.parse(input);
+      if (parsed && typeof parsed === "object") {
+        obj = parsed;
+      }
+    } catch {
+      obj = null;
+    }
+  } else if (input && typeof input === "object") {
+    obj = input;
+  }
+  if (!obj) {
+    onWarn?.(`[acp-absorb-input] rejected: not an object (${typeof input})`);
+    return null;
+  }
+  const ref = pickString(obj, "ref", "messageId", "of");
+  const summary = pickString(obj, "summary", "content");
+  if (typeof ref !== "string" || typeof summary !== "string") {
+    onWarn?.(
+      `[acp-absorb-input] rejected: need ref (string) + summary (string); keys: ${Object.keys(obj).join(",")}`
+    );
+    return null;
+  }
+  return {
+    ref: ref.trim(),
+    summary,
+    ...callId ? { absorbCallId: callId } : {}
+  };
+}
+function pickString(obj, ...keys) {
+  for (const key of keys) {
+    const value = obj[key];
+    if (typeof value === "string") return value;
+  }
+  return void 0;
+}
+function applyAbsorb(input) {
+  const countTokens = input.countTokens ?? ((text) => Math.ceil(text.length / 4));
+  const summary = input.summary?.trim() ?? "";
+  if (!summary) {
+    return {
+      state: input.state,
+      ok: false,
+      resultText: "absorb failed: summary is empty \u2014 provide the distilled key info of the tool result."
+    };
+  }
+  const cfg = resolveAbsorbConfig(input.config);
+  const rawId = rawForRef(input.state.messageRefs, input.ref.trim());
+  if (!rawId) {
+    return {
+      state: input.state,
+      ok: false,
+      resultText: `absorb failed: ref ${input.ref} does not exist in this session (it may be hidden, already compressed, or stale).`
+    };
+  }
+  const existing = (input.state.absorbed ?? []).find(
+    (record2) => record2.resultMessageId === rawId
+  );
+  if (existing) {
+    return {
+      state: input.state,
+      ok: true,
+      resultText: `already absorbed (${input.ref}) \u2014 no change.`
+    };
+  }
+  const target = input.messages.find((m) => m.id === rawId);
+  if (!target) {
+    return {
+      state: input.state,
+      ok: false,
+      resultText: `absorb failed: ref ${input.ref} is not visible in this session (hidden or compressed).`
+    };
+  }
+  if (target.contentType !== "tool-result") {
+    return {
+      state: input.state,
+      ok: false,
+      resultText: `absorb failed: ref ${input.ref} is a ${target.contentType}, not a tool result.`
+    };
+  }
+  if (isAcpOrConfiguredTool(target.toolName, cfg)) {
+    return {
+      state: input.state,
+      ok: false,
+      resultText: `absorb failed: ${target.toolName} is an ACP-managed tool result \u2014 it is not absorbable.`
+    };
+  }
+  if (isMessageProtected(target, input.config) || isMessageLatestProtected(
+    target,
+    collectLatestProtected(input.messages, input.config)
+  )) {
+    return {
+      state: input.state,
+      ok: false,
+      resultText: `absorb failed: ${target.toolName} is a protected tool \u2014 its results must stay visible.`
+    };
+  }
+  if (!target.toolCallId) {
+    return {
+      state: input.state,
+      ok: false,
+      resultText: `absorb failed: ref ${input.ref} has no tool-call id \u2014 cannot pair it for hiding.`
+    };
+  }
+  const call = input.messages.find(
+    (m) => m.contentType === "tool-call" && m.toolCallId === target.toolCallId
+  );
+  const tokens = countTokens(target.text ?? "");
+  const summaryTokens = countTokens(summary);
+  const record = {
+    toolCallId: target.toolCallId,
+    callMessageId: call?.id ?? "",
+    resultMessageId: target.id,
+    ...input.absorbCallId ? { absorbCallId: input.absorbCallId } : {},
+    summary,
+    tokensReclaimed: tokens,
+    createdAt: Date.now()
+  };
+  const state = {
+    ...input.state,
+    absorbed: [...input.state.absorbed ?? [], record],
+    stats: {
+      ...input.state.stats,
+      absorbedTokens: (input.state.stats.absorbedTokens ?? 0) + tokens
+    }
+  };
+  const bloat = summaryTokens >= tokens && tokens > 0 ? ` WARNING: your summary (~${formatTokenCount(summaryTokens)} tokens) is not smaller than the original (~${formatTokenCount(tokens)} tokens) \u2014 distill harder next time.` : "";
+  return {
+    state,
+    ok: true,
+    resultText: `absorbed ${input.ref} (~${formatTokenCount(tokens)} tokens \u2192 summary ~${formatTokenCount(summaryTokens)}). The original tool output is now hidden; your summary is the durable record.${bloat}`
+  };
+}
+
+// src/crush.ts
+var DEFAULT_CRUSH_CONFIG = {
+  enabled: false,
+  minReduction: 0.1
+};
+var MAX_INPUT_CHARS = 2e6;
+var MAX_DEPTH = 12;
+var MAX_FOLDS = 1e3;
+var RUN_MIN = 4;
+var HOIST_MIN = 4;
+var CODE_KEEP_RATIO = 0.97;
+var CRUSH_KEY = "__acp_crush";
+function isPlainObject(v) {
+  if (typeof v !== "object" || v === null || Array.isArray(v)) return false;
+  const p = Object.getPrototypeOf(v);
+  return p === null || p === Object.prototype;
+}
+function classifyCrushText(text) {
+  const trimmed = text.trim();
+  if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]"))
+    return "json";
+  if (detectLanguage(text) !== null) return "code";
+  return "log";
+}
+function crushText(text, options = {}) {
+  const countTokens = options.countTokens ?? defaultCountTokens;
+  const minReduction = options.minReduction ?? DEFAULT_CRUSH_CONFIG.minReduction;
+  const meta = options.meta ?? {};
+  if (text.length === 0 || text.length > MAX_INPUT_CHARS) return null;
+  const rawTok = countTokens(text);
+  if (rawTok <= 0) return null;
+  const kind = classifyCrushText(text);
+  const wanted = options.plugins ?? registeredPlugins();
+  for (const plugin of wanted) {
+    let res;
+    try {
+      if (!Array.isArray(plugin.kinds) || !plugin.kinds.includes(kind))
+        continue;
+      res = plugin.run(text, meta);
+    } catch {
+      continue;
+    }
+    if (!res || typeof res.text !== "string" || res.text === "" || res.text === text)
+      continue;
+    const newTok = countTokens(res.text);
+    const reduction = (rawTok - newTok) / rawTok;
+    if (reduction < minReduction) continue;
+    if (kind === "log" && res.lossy && !errorLinesSurvive(text, res.text))
+      continue;
+    const out = {
+      text: res.text,
+      strategy: plugin.id,
+      lossy: res.lossy
+    };
+    if (res.stats) out.stats = res.stats;
+    return out;
+  }
+  return null;
+}
+function canonOf(v, cache2) {
+  if (!isPlainObject(v) && !Array.isArray(v))
+    return JSON.stringify(v) ?? "null";
+  const key = v;
+  const hit = cache2.get(key);
+  if (hit !== void 0) return hit;
+  let s;
+  if (Array.isArray(v)) {
+    s = `[${v.map((e) => canonOf(e, cache2)).join(",")}]`;
+  } else {
+    const entries = Object.entries(v).map(([k, val]) => `${JSON.stringify(k)}:${canonOf(val, cache2)}`).sort();
+    s = `{${entries.join(",")}}`;
+  }
+  cache2.set(key, s);
+  return s;
+}
+function strLen(v) {
+  return JSON.stringify(v).length;
+}
+function compactValue(v, depth, stats, cache2) {
+  if (depth > MAX_DEPTH || stats.folds >= MAX_FOLDS) return v;
+  if (Array.isArray(v)) return compactArray(v, depth, stats, cache2);
+  if (isPlainObject(v)) {
+    let changed = false;
+    const out = {};
+    for (const [k, val] of Object.entries(v)) {
+      const nv = compactValue(val, depth + 1, stats, cache2);
+      out[k] = nv;
+      if (nv !== val) changed = true;
+    }
+    return changed ? out : v;
+  }
+  return v;
+}
+function compactArray(arr, depth, stats, cache2) {
+  const n = arr.length;
+  if (n < RUN_MIN && n < HOIST_MIN)
+    return arr.map((e) => compactValue(e, depth + 1, stats, cache2));
+  if (stats.folds >= MAX_FOLDS) return arr;
+  const plainStats = { folds: 0 };
+  const plain = arr.map((e) => compactValue(e, depth + 1, plainStats, cache2));
+  let winner = plain;
+  let winnerLen = strLen(plain);
+  let winnerFolds = plainStats.folds;
+  if (n >= RUN_MIN) {
+    const rf = buildRunFold(arr, depth, cache2);
+    if (rf && rf.len < winnerLen) {
+      winner = rf.value;
+      winnerLen = rf.len;
+      winnerFolds = rf.folds;
+    }
+  }
+  if (n >= HOIST_MIN && arr.every((e) => isPlainObject(e))) {
+    const hc = buildConstHoist(arr, depth, cache2);
+    if (hc && hc.len < winnerLen) {
+      winner = hc.value;
+      winnerLen = hc.len;
+      winnerFolds = hc.folds;
+    }
+  }
+  stats.folds += winnerFolds;
+  return winner;
+}
+function isRunMarker(v) {
+  return isPlainObject(v) && v[CRUSH_KEY] === "identical-run";
+}
+function buildRunFold(arr, depth, cache2) {
+  const n = arr.length;
+  const canon = arr.map((e) => canonOf(e, cache2));
+  const segs = [];
+  let runs = 0;
+  let i = 0;
+  while (i < n) {
+    let j = i;
+    while (j + 1 < n && canon[j + 1] === canon[i]) j++;
+    const runLen = j - i + 1;
+    if (runLen >= RUN_MIN) {
+      segs.push({ [CRUSH_KEY]: "identical-run", count: runLen, item: arr[i] });
+      runs++;
+    } else {
+      for (let k = i; k <= j; k++) segs.push(arr[k]);
+    }
+    i = j + 1;
+  }
+  if (runs === 0) return null;
+  const inner = { folds: 0 };
+  const final = segs.map(
+    (s) => isRunMarker(s) ? { ...s, item: compactValue(s.item, depth + 1, inner, cache2) } : compactValue(s, depth + 1, inner, cache2)
+  );
+  return { value: final, len: strLen(final), folds: runs + inner.folds };
+}
+function buildConstHoist(arr, depth, cache2) {
+  const n = arr.length;
+  const keys = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const e of arr) {
+    for (const k of Object.keys(e)) {
+      if (!seen.has(k)) {
+        seen.add(k);
+        keys.push(k);
+      }
+    }
+  }
+  const first = arr[0];
+  if (!first) return null;
+  const constKeys = [];
+  for (const k of keys) {
+    if (!(k in first)) continue;
+    const c0 = canonOf(first[k], cache2);
+    let constant = true;
+    for (let i = 1; i < n; i++) {
+      const row = arr[i];
+      if (!(k in row) || canonOf(row[k], cache2) !== c0) {
+        constant = false;
+        break;
+      }
+    }
+    if (constant) constKeys.push(k);
+  }
+  if (constKeys.length === 0) return null;
+  const constSet = new Set(constKeys);
+  const constObj = {};
+  for (const k of constKeys) constObj[k] = first[k];
+  const items = arr.map((e) => {
+    const o = {};
+    for (const [k, v] of Object.entries(e)) {
+      if (!constSet.has(k)) o[k] = v;
+    }
+    return o;
+  });
+  const hasVarying = items.some((o) => Object.keys(o).length > 0);
+  const inner = { folds: 0 };
+  const env = {
+    [CRUSH_KEY]: "rows",
+    rows: n,
+    const: compactValue(constObj, depth + 1, inner, cache2)
+  };
+  if (hasVarying)
+    env.items = items.map((it) => compactValue(it, depth + 1, inner, cache2));
+  const len = strLen(env);
+  if (len >= strLen(arr)) return null;
+  return { value: env, len, folds: 1 + inner.folds };
+}
+function crushJson(text) {
+  const parsed = JSON.parse(text);
+  const cache2 = /* @__PURE__ */ new Map();
+  const stats = { folds: 0 };
+  const out = compactValue(parsed, 0, stats, cache2);
+  if (stats.folds === 0) return null;
+  const s = JSON.stringify(out);
+  return s.length < text.length ? s : null;
+}
+function detectLanguage(text) {
+  const sample = text.split(/\r?\n/).slice(0, 300);
+  let py = 0;
+  let js = 0;
+  for (const line of sample) {
+    if (/^\s*#!.*python/.test(line)) py += 4;
+    if (/^\s*(async\s+)?def\s+\w/.test(line) || /^\s*class\s+\w/.test(line))
+      py += 2;
+    if (/\bfrom\s+['"]/.test(line) || /^\s*import\s+['"]/.test(line)) js += 2;
+    else if (/^\s*(import|from)\s+[A-Za-z_]\w*/.test(line)) py += 1;
+    if (/^\s*(function\b|const\s|let\s|var\s)/.test(line)) js += 2;
+    if (/=>/.test(line)) js += 1;
+    if (/^\s*(public|private|protected|static|final|void|return)\b/.test(line))
+      js += 1;
+    if (/;\s*$/.test(line) && line.trim().length > 0) js += 1;
+    if (/\bself\./.test(line) || /^\s*(elif|except|yield)\b/.test(line))
+      py += 1;
+    if (/\bconsole\.log\b|\brequire\s*\(|module\.exports|\bawait\s/.test(line))
+      js += 1;
+  }
+  const MARGIN = 1.5;
+  if (py >= 3 && py > js * MARGIN) return "python";
+  if (js >= 4 && js > py * MARGIN) return "js";
+  return null;
+}
+function finalizeTrimmed(original, emitted) {
+  if (emitted.length >= original.split(/\r?\n/).length) return null;
+  const out = emitted.join("\n") + (original.endsWith("\n") ? "\n" : "");
+  return out.length < original.length * CODE_KEEP_RATIO ? out : null;
+}
+function trimPython(text) {
+  const lines = text.split(/\r?\n/);
+  const emitted = [];
+  let pending = 0;
+  const flush = () => {
+    if (pending > 0) {
+      emitted.push(
+        `# [acp-crush: elided ${pending} line${pending === 1 ? "" : "s"}]`
+      );
+      pending = 0;
+    }
+  };
+  let state = "code";
+  let quote = "";
+  let isDocstring = false;
+  let blankRun = 0;
+  let atModuleStart = true;
+  let pendingDefClass = false;
+  let docstringSlot = false;
+  const classifySig = (codePart) => {
+    const t = codePart.trim();
+    if (/^(async\s+)?(def|class)\b/.test(t)) pendingDefClass = true;
+    if (t.endsWith(":")) {
+      docstringSlot = pendingDefClass;
+      pendingDefClass = false;
+    } else if (t.length > 0 && !t.startsWith("@")) {
+      docstringSlot = false;
+    }
+    atModuleStart = false;
+  };
+  for (let li = 0; li < lines.length; li++) {
+    const line = lines[li];
+    if (state === "triple") {
+      const close = findTripleClose(line, quote);
+      if (close === -1) {
+        if (isDocstring) pending++;
+        else emitted.push(line);
+        continue;
+      }
+      state = "code";
+      const rest = line.slice(close + 3).trim();
+      if (rest.length > 0) {
+        flush();
+        emitted.push(line);
+        classifySig(rest);
+      } else {
+        if (isDocstring) pending++;
+        else emitted.push(line);
+      }
+      isDocstring = false;
+      docstringSlot = false;
+      pendingDefClass = false;
+      atModuleStart = false;
+      blankRun = 0;
+      continue;
+    }
+    if (line.trim().length === 0) {
+      blankRun++;
+      if (blankRun >= 3) {
+        flush();
+        emitted.push("");
+        blankRun = 1;
+      }
+      continue;
+    }
+    if (li === 0 && line.startsWith("#!")) {
+      flush();
+      emitted.push(line);
+      blankRun = 0;
+      continue;
+    }
+    const m = line.match(/^\s*("""|''')/);
+    if (m) {
+      flush();
+      const q = m[1];
+      const opensHere = line.indexOf(q);
+      const closeOnSameLine = findTripleClose(line.slice(opensHere + 3), q);
+      if (closeOnSameLine !== -1) {
+        const restAfter = line.slice(opensHere + 3 + closeOnSameLine + 3).trim();
+        if (restAfter.length > 0) {
+          emitted.push(line);
+          classifySig(restAfter);
+        } else if (atModuleStart || docstringSlot) {
+          pending++;
+          atModuleStart = false;
+          docstringSlot = false;
+          pendingDefClass = false;
+        } else {
+          emitted.push(line);
+        }
+        blankRun = 0;
+        continue;
+      }
+      state = "triple";
+      quote = q;
+      isDocstring = atModuleStart || docstringSlot;
+      atModuleStart = false;
+      docstringSlot = false;
+      if (!isDocstring) emitted.push(line);
+      blankRun = 0;
+      continue;
+    }
+    const probe = findCommentOrTriple(line);
+    if (probe.kind === "comment-full") {
+      pending++;
+      continue;
+    }
+    if (probe.kind === "triple-mid") {
+      flush();
+      state = "triple";
+      quote = probe.quote;
+      isDocstring = false;
+      emitted.push(line);
+      classifySig(line.slice(0, probe.idx));
+      blankRun = 0;
+      continue;
+    }
+    flush();
+    emitted.push(line);
+    classifySig(line);
+    blankRun = 0;
+  }
+  if (state === "triple") return null;
+  flush();
+  return finalizeTrimmed(text, emitted);
+}
+function findTripleClose(line, quote) {
+  let i = 0;
+  while (i < line.length) {
+    if (line[i] === "\\") {
+      i += 2;
+      continue;
+    }
+    if (line.startsWith(quote, i)) return i;
+    i++;
+  }
+  return -1;
+}
+function findCommentOrTriple(line) {
+  let i = 0;
+  let inStr = null;
+  while (i < line.length) {
+    const c = line[i];
+    if (inStr) {
+      if (c === "\\") i += 2;
+      else if (c === inStr) inStr = null;
+      else i++;
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      inStr = c;
+      i++;
+      continue;
+    }
+    if (c === "#") {
+      return {
+        kind: line.slice(0, i).trim().length === 0 ? "comment-full" : "none",
+        idx: i,
+        quote: ""
+      };
+    }
+    if (line.startsWith('"""', i) || line.startsWith("'''", i)) {
+      return { kind: "triple-mid", idx: i, quote: line.slice(i, i + 3) };
+    }
+    i++;
+  }
+  return { kind: "none", idx: -1, quote: "" };
+}
+function scanTemplateRest(line, from, st) {
+  let m = st.mode;
+  let q = st.quote;
+  let d = st.depth;
+  let i = from;
+  while (i < line.length) {
+    const c = line[i];
+    if (m === "str") {
+      if (c === "\\") i += 2;
+      else if (c === q) m = "expr";
+      else i++;
+      continue;
+    }
+    if (m === "expr") {
+      if (c === "'" || c === '"') {
+        q = c;
+        m = "str";
+        i++;
+        continue;
+      }
+      if (c === "`")
+        return {
+          mode: m,
+          quote: q,
+          depth: d,
+          closed: false,
+          bail: true,
+          consumed: 0
+        };
+      if (c === "{") d++;
+      else if (c === "}") {
+        d--;
+        if (d === 0) m = "tpl";
+      }
+      i++;
+      continue;
+    }
+    if (c === "\\") {
+      i += 2;
+      continue;
+    }
+    if (c === "`")
+      return {
+        mode: "tpl",
+        quote: "",
+        depth: 0,
+        closed: true,
+        bail: false,
+        consumed: i - from + 1
+      };
+    if (c === "$" && line[i + 1] === "{") {
+      m = "expr";
+      d = 1;
+      i += 2;
+      continue;
+    }
+    i++;
+  }
+  return {
+    mode: m,
+    quote: q,
+    depth: d,
+    closed: false,
+    bail: false,
+    consumed: 0
+  };
+}
+function regexAllowedAfter(prev) {
+  if (prev === null) return true;
+  if (/[A-Za-z0-9_]/.test(prev)) return false;
+  return !".'\"`) ]".includes(prev);
+}
+function prevSigChar(line, i) {
+  for (let j = i - 1; j >= 0; j--) {
+    const c = line[j];
+    if (c === " " || c === "	") continue;
+    return c;
+  }
+  return null;
+}
+function scanRegexLiteral(line, i) {
+  let j = i + 1;
+  let inClass = false;
+  while (j < line.length) {
+    const c = line[j];
+    if (c === "\\") {
+      j += 2;
+      continue;
+    }
+    if (inClass) {
+      if (c === "]") inClass = false;
+    } else if (c === "[") {
+      inClass = true;
+    } else if (c === "/") {
+      let f = j + 1;
+      while (f < line.length && /[a-z]/i.test(line[f])) f++;
+      return f;
+    }
+    j++;
+  }
+  return null;
+}
+function scanJsCodeLine(line) {
+  let i = 0;
+  let inStr = null;
+  while (i < line.length) {
+    const c = line[i];
+    if (inStr) {
+      if (c === "\\") i += 2;
+      else if (c === inStr) inStr = null;
+      else i++;
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      inStr = c;
+      i++;
+      continue;
+    }
+    if (c === "`") {
+      const r = scanTemplateRest(line, i, { mode: "tpl", quote: "", depth: 0 });
+      if (r.bail) return { kind: "code", bail: true };
+      if (!r.closed)
+        return {
+          kind: "template-open",
+          tmpl: { mode: r.mode, quote: r.quote, depth: r.depth }
+        };
+      i += r.consumed;
+      continue;
+    }
+    if (c === "/") {
+      const nxt = line[i + 1];
+      if (nxt === "/") {
+        return {
+          kind: line.slice(0, i).trim().length === 0 ? "comment-full" : "code"
+        };
+      }
+      if (nxt !== "*") {
+        if (regexAllowedAfter(prevSigChar(line, i))) {
+          const end = scanRegexLiteral(line, i);
+          if (end !== null) {
+            i = end;
+            continue;
+          }
+        }
+        i++;
+        continue;
+      }
+      const close = line.indexOf("*/", i + 2);
+      const before = line.slice(0, i).trim().length > 0;
+      if (close === -1)
+        return { kind: before ? "block-open-mid" : "block-open-only" };
+      const rest = line.slice(close + 2).trim();
+      if (rest.length === 0) return { kind: before ? "code" : "comment-full" };
+      i = close + 2;
+      continue;
+    }
+    i++;
+  }
+  return { kind: "code" };
+}
+function trimJsTs(text) {
+  const lines = text.split(/\r?\n/);
+  const emitted = [];
+  let pending = 0;
+  const flush = () => {
+    if (pending > 0) {
+      emitted.push(
+        `// [acp-crush: elided ${pending} line${pending === 1 ? "" : "s"}]`
+      );
+      pending = 0;
+    }
+  };
+  let state = "code";
+  let tmpl = { mode: "tpl", quote: "", depth: 0 };
+  let blankRun = 0;
+  for (const line of lines) {
+    if (state === "block") {
+      const close = line.indexOf("*/");
+      if (close === -1) {
+        pending++;
+        continue;
+      }
+      state = "code";
+      if (line.slice(close + 2).trim().length === 0) pending++;
+      else {
+        flush();
+        emitted.push(line);
+      }
+      blankRun = 0;
+      continue;
+    }
+    if (state === "template") {
+      const r = scanTemplateRest(line, 0, tmpl);
+      if (r.bail) return null;
+      tmpl = { mode: r.mode, quote: r.quote, depth: r.depth };
+      if (r.closed) state = "code";
+      emitted.push(line);
+      blankRun = 0;
+      continue;
+    }
+    if (line.trim().length === 0) {
+      blankRun++;
+      if (blankRun >= 3) {
+        flush();
+        emitted.push("");
+        blankRun = 1;
+      }
+      continue;
+    }
+    const scan = scanJsCodeLine(line);
+    if (scan.bail) return null;
+    if (scan.kind === "comment-full") {
+      pending++;
+      continue;
+    }
+    if (scan.kind === "block-open-only") {
+      pending++;
+      state = "block";
+      continue;
+    }
+    if (scan.kind === "block-open-mid") {
+      flush();
+      state = "block";
+      emitted.push(line);
+      blankRun = 0;
+      continue;
+    }
+    if (scan.kind === "template-open") {
+      flush();
+      state = "template";
+      tmpl = scan.tmpl ?? { mode: "tpl", quote: "", depth: 0 };
+      emitted.push(line);
+      blankRun = 0;
+      continue;
+    }
+    flush();
+    emitted.push(line);
+    blankRun = 0;
+  }
+  if (state !== "code") return null;
+  flush();
+  return finalizeTrimmed(text, emitted);
+}
+function crushCode(text) {
+  const lang = detectLanguage(text);
+  if (lang === null) return null;
+  if (lang === "python") return trimPython(text);
+  return trimJsTs(text);
+}
+var LOG_MIN_LINES = 50;
+var LOG_MAX_TOTAL_LINES = 100;
+var LOG_MAX_ERRORS = 20;
+var LOG_ERROR_CONTEXT = 3;
+var LOG_MAX_WARNINGS = 5;
+var LOG_MAX_STACK_TRACES = 3;
+var LOG_STACK_MAX_LINES = 20;
+var LOG_TRACE_HEAD_FRAMES = 3;
+var LOG_TRACE_APP_FRAMES = 5;
+var LOG_CLASSIFIED_GATE = 5;
+var LOG_SUMMARY_GATE = 3;
+var LEVEL_PATTERNS = [
+  ["error", /\b(ERROR|FATAL|CRITICAL)\b/i],
+  ["fail", /\b(FAIL|FAILED)\b/i],
+  ["warn", /\b(WARN|WARNING)\b/i],
+  ["info", /\bINFO\b/i],
+  ["debug", /\bDEBUG\b/i],
+  ["trace", /\bTRACE\b/i]
+];
+function classifyLevel(line) {
+  for (const [level, re] of LEVEL_PATTERNS) {
+    if (re.test(line)) return level;
+  }
+  return "unknown";
+}
+function isLogSummaryLine(line) {
+  if (line.startsWith("===") || line.startsWith("---")) return true;
+  let d = 0;
+  while (d < line.length && line.charCodeAt(d) >= 48 && line.charCodeAt(d) <= 57)
+    d++;
+  if (d > 0 && line[d] === " ") {
+    const rest = line.slice(d + 1);
+    if (rest.startsWith("passed") || rest.startsWith("failed") || rest.startsWith("skipped") || rest.startsWith("error") || rest.startsWith("warning"))
+      return true;
+  }
+  for (const prefix of [
+    "Test ",
+    "Tests ",
+    "Tests:",
+    "Test:",
+    "Suite ",
+    "Suites ",
+    "Suites:",
+    "Suite:"
+  ]) {
+    if (line.startsWith(prefix)) {
+      const m = line.slice(prefix.length).match(/\S/);
+      if (m !== null && m[0].charCodeAt(0) >= 48 && m[0].charCodeAt(0) <= 57)
+        return true;
+    }
+  }
+  if (line.startsWith("TOTAL") || line.startsWith("Total") || line.startsWith("Summary"))
+    return true;
+  for (const prefix of ["Build", "Compile", "Test"]) {
+    if (line.startsWith(prefix) && (line.includes("succeeded") || line.includes("failed") || line.includes("complete")))
+      return true;
+  }
+  return false;
+}
+function isDigitChar(c) {
+  return c >= "0" && c <= "9";
+}
+function isAsciiAlnum(c) {
+  const n = c.charCodeAt(0);
+  return n >= 97 && n <= 122 || n >= 65 && n <= 90 || n >= 48 && n <= 57;
+}
+function hasLineColSuffix(s) {
+  for (let i = 0; i + 1 < s.length; i++) {
+    if (s[i] === ":" && isDigitChar(s[i + 1])) {
+      let j = i + 1;
+      while (j < s.length && isDigitChar(s[j])) j++;
+      if (j + 1 < s.length && s[j] === ":" && isDigitChar(s[j + 1]))
+        return true;
+    }
+  }
+  return false;
+}
+function isPythonFileFrame(s) {
+  return s.startsWith('File "') && s.includes('", line ') && s.length > 0 && isDigitChar(s[s.length - 1]);
+}
+function isJsAtFrame(s) {
+  return s.startsWith("at ") && s.includes("(") && s.includes(")") && hasLineColSuffix(s);
+}
+function isJavaAtFrame(s) {
+  if (!s.startsWith("at ") || !s.includes("(")) return false;
+  const open = s.indexOf("(");
+  const body = s.slice(3, open);
+  if (body.length === 0) return false;
+  for (const c of body) {
+    if (!(isAsciiAlnum(c) || c === "." || c === "_" || c === "$" || c === "/"))
+      return false;
+  }
+  return true;
+}
+function isRustPanicOpener(s) {
+  return s.startsWith("thread '") && s.includes("panicked at");
+}
+function isGoroutineHeader(line) {
+  if (!line.startsWith("goroutine ")) return false;
+  const rest = line.slice(10);
+  let d = 0;
+  while (d < rest.length && isDigitChar(rest[d])) d++;
+  return d > 0 && rest.slice(d).startsWith(" [");
+}
+function isGoPanicOpener(line) {
+  return line.startsWith("panic: ") || line.startsWith("fatal error: ") || isGoroutineHeader(line);
+}
+function isGoFileFrame(line) {
+  return line.startsWith("	") && line.includes(".go:") && line.includes(" +0x");
+}
+function isGoCallFrame(line) {
+  if (line.startsWith("created by ")) return true;
+  if (line.startsWith(" ") || line.startsWith("	") || !line.endsWith(")"))
+    return false;
+  const open = line.indexOf("(");
+  if (open === -1) return false;
+  const symbol = line.slice(0, open);
+  if (symbol.length === 0 || !symbol.includes(".")) return false;
+  for (const c of symbol) {
+    if (!(isAsciiAlnum(c) || c === "." || c === "_" || c === "/" || c === "*"))
+      return false;
+  }
+  return true;
+}
+function isDotnetFrame(s) {
+  return s.startsWith("at ") && s.includes(") in ") && s.includes(":line ");
+}
+function isDotnetExceptionHead(trimmed) {
+  const colon = trimmed.indexOf(":");
+  if (colon === -1) return false;
+  const head = trimmed.slice(0, colon);
+  if (!head.endsWith("Exception") || !head.includes(".")) return false;
+  for (const c of head) {
+    if (!(isAsciiAlnum(c) || c === "." || c === "_" || c === "`" || c === "+"))
+      return false;
+  }
+  return true;
+}
+function isRustBacktraceFrame(s) {
+  const t = s.trimStart();
+  let i = 0;
+  while (i < t.length && isDigitChar(t[i])) i++;
+  if (i === 0 || t[i] !== ":") return false;
+  i++;
+  while (i < t.length && t[i] === " ") i++;
+  const rest = t.slice(i);
+  if (!rest.startsWith("0x")) return false;
+  let h = 0;
+  for (const c of rest.slice(2)) {
+    if (c >= "0" && c <= "9" || c >= "a" && c <= "f" || c >= "A" && c <= "F")
+      h++;
+    else break;
+  }
+  return h > 0;
+}
+function isJavaMoreSummary(trimmed) {
+  if (!trimmed.startsWith("... ")) return false;
+  const rest = trimmed.slice(4);
+  let d = 0;
+  while (d < rest.length && isDigitChar(rest[d])) d++;
+  return d > 0 && rest.slice(d).trim() === "more";
+}
+function traceFlavorFor(line) {
+  const t = line.trimStart();
+  if (t.startsWith("Traceback (most recent call last)") || isPythonFileFrame(t))
+    return "py";
+  if (t.startsWith("Unhandled exception.") || isDotnetFrame(t)) return "dotnet";
+  if (isJsAtFrame(t)) return "js";
+  if (isJavaAtFrame(t)) return "java";
+  if (t.startsWith("--> ") && hasLineColSuffix(t)) return "rust-error";
+  if (isRustPanicOpener(t) || t.startsWith("stack backtrace:") || isRustBacktraceFrame(line))
+    return "rust-backtrace";
+  if (isGoPanicOpener(line)) return "go-panic";
+  return null;
+}
+function traceTerminates(flavor, line, linesSoFar) {
+  const t = line.trimStart();
+  switch (flavor) {
+    case "py": {
+      const indentedOrBlank = line.startsWith(" ") || line.startsWith("	") || line.length === 0;
+      const continuation = t.startsWith("Traceback") || t.startsWith("File ") || t.startsWith("During handling") || t.startsWith("The above exception");
+      if (indentedOrBlank || continuation) return false;
+      return !(t.length > 0 && t[0] >= "A" && t[0] <= "Z");
+    }
+    case "js":
+      return !t.startsWith("at ") && line.length !== 0;
+    case "java": {
+      const chain = t.startsWith("Caused by:") || t.startsWith("Suppressed:") || isJavaMoreSummary(t);
+      return !t.startsWith("at ") && !chain && line.length !== 0;
+    }
+    case "dotnet": {
+      if (line.length === 0) return false;
+      const continues = t.startsWith("at ") || t.startsWith("--->") || t.startsWith("--- End of") || isDotnetExceptionHead(t);
+      return !continues;
+    }
+    case "rust-error":
+      return !t.startsWith("--> ") && line.length !== 0;
+    case "rust-backtrace": {
+      if (line.length === 0 || linesSoFar === 1) return false;
+      const isFrame = t.length > 0 && isDigitChar(t[0]);
+      const continuation = line.startsWith(" ") || line.startsWith("	") || t.startsWith("stack backtrace:") || t.startsWith("note: run with");
+      return !isFrame && !continuation;
+    }
+    case "go-panic": {
+      if (line.length === 0) return false;
+      const continues = line.startsWith("	") || isGoroutineHeader(line) || isGoCallFrame(line) || line.startsWith("panic: ") || line.startsWith("fatal error: ") || line.startsWith("[signal ");
+      return !continues;
+    }
+  }
+}
+function scoreLogLine(l) {
+  const base = l.level === "error" || l.level === "fail" ? 1 : l.level === "warn" ? 0.5 : l.level === "info" || l.level === "unknown" ? 0.1 : l.level === "debug" ? 0.05 : 0.02;
+  return Math.min(base + (l.isStack ? 0.3 : 0) + (l.isSummary ? 0.4 : 0), 1);
+}
+function parseLogLines(lines) {
+  const out = new Array(lines.length);
+  let active = null;
+  let traceLines = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const entry = {
+      i,
+      content: line,
+      level: classifyLevel(line),
+      isStack: false,
+      isSummary: isLogSummaryLine(line),
+      score: 0
+    };
+    if (active !== null) {
+      const flavor = active;
+      if (traceLines >= LOG_STACK_MAX_LINES || traceTerminates(flavor, line, traceLines)) {
+        const capHit = traceLines >= LOG_STACK_MAX_LINES;
+        active = null;
+        traceLines = 0;
+        const nf = traceFlavorFor(line);
+        if (nf !== null) {
+          active = nf;
+          traceLines = 1;
+          entry.isStack = true;
+        } else if (capHit && !traceTerminates(flavor, line, 2)) {
+          active = flavor;
+          traceLines = 1;
+          entry.isStack = true;
+        }
+      } else {
+        entry.isStack = true;
+        traceLines++;
+      }
+    } else {
+      const f = traceFlavorFor(line);
+      if (f !== null) {
+        active = f;
+        traceLines = 1;
+        entry.isStack = true;
+      }
+    }
+    entry.score = scoreLogLine(entry);
+    out[i] = entry;
+  }
+  return out;
+}
+function selectWithFirstLast(arr, maxCount) {
+  if (arr.length <= maxCount) return arr.slice();
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (l) => {
+    if (seen.add(l.i)) out.push(l);
+  };
+  push(arr[0]);
+  push(arr[arr.length - 1]);
+  if (out.length < maxCount) {
+    const byScore = arr.slice().sort((a, b) => b.score - a.score || a.i - b.i);
+    for (const l of byScore) {
+      if (!seen.has(l.i)) {
+        push(l);
+        if (out.length >= maxCount) break;
+      }
+    }
+  }
+  return out;
+}
+function normalizeForDedupe(content) {
+  let splitAt = content.length;
+  for (let i = 0; i < content.length; i++) {
+    if (content[i] === ":" || content[i] === "=") {
+      splitAt = i;
+      break;
+    }
+  }
+  const suffix = content.slice(splitAt).replace(/\d+/g, "N").replace(/0x[0-9a-fA-F]+/g, "ADDR").replace(/\/[\w/]+\//g, "/PATH/");
+  return content.slice(0, splitAt) + suffix;
+}
+var RUNTIME_FRAME_PREFIXES = [
+  "at java.",
+  "at jdk.",
+  "at sun.",
+  "at javax.",
+  "at scala.",
+  "at System.",
+  "at Microsoft.",
+  "runtime.",
+  "created by runtime."
+];
+var RUNTIME_FRAME_MARKERS = [
+  "site-packages/",
+  "/usr/lib/python",
+  "lib/python3.",
+  "node:internal/",
+  "node_modules/",
+  "(internal/",
+  "core::",
+  "std::",
+  "alloc::",
+  "rust_begin_unwind",
+  "__rust_",
+  "/rustc/",
+  "/usr/local/go/src/",
+  "/libexec/src/runtime/"
+];
+function isFrameLine(content) {
+  const t = content.trimStart();
+  return t.startsWith("at ") || t.startsWith('File "') && t.includes('", line ') || isRustBacktraceFrame(content) || isGoFileFrame(content) || isGoCallFrame(content);
+}
+function isChainHeadLine(content) {
+  const t = content.trimStart();
+  return t.startsWith("Caused by:") || t.startsWith("Suppressed:") || t.startsWith("... ") || t.startsWith("--->") || t.startsWith("--- End of") || t.startsWith("During handling") || t.startsWith("The above exception");
+}
+function isRuntimeFrame(content) {
+  const t = content.trimStart();
+  return RUNTIME_FRAME_PREFIXES.some((p) => t.startsWith(p)) || RUNTIME_FRAME_MARKERS.some((m) => content.includes(m));
+}
+function collapseTraceFrames(stack, headFrames, appFrames) {
+  const kept = [];
+  const dropped = /* @__PURE__ */ new Set();
+  let framesSeen = 0;
+  let appKept = 0;
+  let runStart = -1;
+  let runLen = 0;
+  let prevDropped = false;
+  const flushRun = () => {
+    if (runStart !== -1) {
+      kept.push({
+        i: runStart,
+        content: `      [... ${runLen} frames collapsed]`,
+        level: "unknown",
+        isStack: true,
+        isSummary: false,
+        score: 0.8
+      });
+      runStart = -1;
+      runLen = 0;
+    }
+  };
+  for (const line of stack) {
+    if (isFrameLine(line.content) && !isChainHeadLine(line.content)) {
+      framesSeen++;
+      const runtime = isRuntimeFrame(line.content);
+      const keep = framesSeen <= headFrames || !runtime && appKept < appFrames;
+      if (keep) {
+        if (!runtime) appKept++;
+        flushRun();
+        kept.push(line);
+        prevDropped = false;
+      } else {
+        if (runStart === -1) runStart = line.i;
+        runLen++;
+        dropped.add(line.i);
+        prevDropped = true;
+      }
+    } else if (prevDropped && (line.content.startsWith(" ") || line.content.startsWith("	")) && !isChainHeadLine(line.content)) {
+      runLen++;
+      dropped.add(line.i);
+    } else {
+      flushRun();
+      kept.push(line);
+      prevDropped = false;
+    }
+  }
+  flushRun();
+  return { kept, dropped };
 }
-function applyAbsorb(input) {
-  const countTokens = input.countTokens ?? ((text) => Math.ceil(text.length / 4));
-  const summary = input.summary?.trim() ?? "";
-  if (!summary) {
-    return {
-      state: input.state,
-      ok: false,
-      resultText: "absorb failed: summary is empty \u2014 provide the distilled key info of the tool result."
-    };
+function selectLogLines(all) {
+  const errors = [];
+  const fails = [];
+  const warnings = [];
+  const summaries = [];
+  const stacks = [];
+  let current = [];
+  for (const l of all) {
+    if (l.level === "error") errors.push(l);
+    else if (l.level === "fail") fails.push(l);
+    else if (l.level === "warn") warnings.push(l);
+    if (l.isStack) current.push(l);
+    else if (current.length > 0) {
+      stacks.push(current);
+      current = [];
+    }
+    if (l.isSummary) summaries.push(l);
+  }
+  if (current.length > 0) stacks.push(current);
+  const selected = /* @__PURE__ */ new Map();
+  for (const l of selectWithFirstLast(errors, LOG_MAX_ERRORS))
+    selected.set(l.i, l);
+  for (const l of selectWithFirstLast(fails, LOG_MAX_ERRORS))
+    selected.set(l.i, l);
+  const seenWarn = /* @__PURE__ */ new Set();
+  const dedupedWarnings = [];
+  for (const w of warnings) {
+    const key = normalizeForDedupe(w.content);
+    if (!seenWarn.has(key)) {
+      seenWarn.add(key);
+      dedupedWarnings.push(w);
+    }
+  }
+  for (const w of dedupedWarnings.slice(0, LOG_MAX_WARNINGS))
+    selected.set(w.i, w);
+  for (const stack of stacks.slice(0, LOG_MAX_STACK_TRACES)) {
+    if (stack.length > LOG_STACK_MAX_LINES) {
+      const collapsed = collapseTraceFrames(
+        stack,
+        LOG_TRACE_HEAD_FRAMES,
+        LOG_TRACE_APP_FRAMES
+      );
+      for (const i of collapsed.dropped) selected.delete(i);
+      for (const l of collapsed.kept.slice(0, LOG_STACK_MAX_LINES))
+        selected.set(l.i, l);
+    } else {
+      for (const l of stack) selected.set(l.i, l);
+    }
   }
-  const cfg = resolveAbsorbConfig(input.config);
-  const rawId = rawForRef(input.state.messageRefs, input.ref.trim());
-  if (!rawId) {
-    return {
-      state: input.state,
-      ok: false,
-      resultText: `absorb failed: ref ${input.ref} does not exist in this session (it may be hidden, already compressed, or stale).`
-    };
+  for (const s of summaries) selected.set(s.i, s);
+  for (const idx of Array.from(selected.keys())) {
+    const lo = Math.max(0, idx - LOG_ERROR_CONTEXT);
+    const hi = Math.min(all.length, idx + LOG_ERROR_CONTEXT + 1);
+    for (let i = lo; i < hi; i++) {
+      if (i !== idx && !selected.has(i)) selected.set(i, all[i]);
+    }
   }
-  const existing = (input.state.absorbed ?? []).find(
-    (record2) => record2.resultMessageId === rawId
+  let ordered = Array.from(selected.values());
+  if (ordered.length > LOG_MAX_TOTAL_LINES) {
+    ordered.sort((a, b) => b.score - a.score || a.i - b.i);
+    ordered = ordered.slice(0, LOG_MAX_TOTAL_LINES);
+    ordered.sort((a, b) => a.i - b.i);
+  }
+  return ordered;
+}
+function formatLogOutput(selected, all) {
+  const count = (lv) => all.reduce((n, l) => l.level === lv ? n + 1 : n, 0);
+  const output = selected.map((l) => l.content);
+  const omitted = all.length - selected.length;
+  if (omitted > 0) {
+    const parts = [];
+    const e = count("error");
+    const f = count("fail");
+    const w = count("warn");
+    const inf = count("info");
+    if (e > 0) parts.push(`${e} ERROR`);
+    if (f > 0) parts.push(`${f} FAIL`);
+    if (w > 0) parts.push(`${w} WARN`);
+    if (inf > 0) parts.push(`${inf} INFO`);
+    if (parts.length > 0)
+      output.push(`[${omitted} lines omitted: ${parts.join(", ")}]`);
+  }
+  return output.join("\n");
+}
+var LOG_FORMAT_TABLE = [
+  [
+    "pytest",
+    [
+      "=== FAILURES",
+      "=== ERRORS",
+      "=== test session",
+      "=== short test summary",
+      "PASSED [",
+      "FAILED [",
+      "ERROR [",
+      "SKIPPED [",
+      "collected "
+    ]
+  ],
+  ["npm", ["npm ERR!", "npm WARN", "npm info", "npm http"]],
+  ["cargo", ["Compiling ", "Finished ", "Running ", "warning: ", "error[E"]],
+  ["jest", ["PASS ", "FAIL ", "Test Suites:"]],
+  ["make", ["make[", "make:", "gcc ", "g++ ", "clang "]]
+];
+function detectLogFormat(lines) {
+  const sample = lines.slice(0, 100);
+  let best = "generic";
+  let bestScore = 0;
+  for (const [name, pats] of LOG_FORMAT_TABLE) {
+    let score = 0;
+    for (const line of sample) {
+      if (pats.some((p) => line.includes(p))) score++;
+    }
+    if (score > bestScore) {
+      bestScore = score;
+      best = name;
+    }
+  }
+  return best;
+}
+function crushLog(text) {
+  const lines = text.split(/\r?\n/);
+  if (lines.length < LOG_MIN_LINES) return null;
+  let classified = 0;
+  let summaries = 0;
+  let traces = 0;
+  for (const line of lines) {
+    const lv = classifyLevel(line);
+    if (lv !== "unknown") classified++;
+    if (isLogSummaryLine(line)) summaries++;
+    if (traceFlavorFor(line) !== null) traces++;
+  }
+  if (!(classified >= LOG_CLASSIFIED_GATE || traces >= 1 || summaries >= LOG_SUMMARY_GATE || detectLogFormat(lines) !== "generic"))
+    return null;
+  const parsed = parseLogLines(lines);
+  const selected = selectLogLines(parsed);
+  if (selected.length >= lines.length) return null;
+  const out = formatLogOutput(selected, parsed);
+  if (out.length >= text.length) return null;
+  return out;
+}
+function errorLinesSurvive(input, output) {
+  const kept = new Set(
+    output.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0)
   );
-  if (existing) {
-    return {
-      state: input.state,
-      ok: true,
-      resultText: `already absorbed (${input.ref}) \u2014 no change.`
-    };
+  for (const line of input.split(/\r?\n/)) {
+    const level = classifyLevel(line);
+    if (level !== "error" && level !== "fail") continue;
+    const t = line.trim();
+    if (t.length > 0 && !kept.has(t)) return false;
   }
-  const target = input.messages.find((m) => m.id === rawId);
-  if (!target) {
-    return {
-      state: input.state,
-      ok: false,
-      resultText: `absorb failed: ref ${input.ref} is not visible in this session (hidden or compressed).`
-    };
+  return true;
+}
+var jsonFoldPlugin = {
+  id: "json-fold",
+  kinds: ["json"],
+  run(text) {
+    const out = crushJson(text);
+    return out ? { text: out, lossy: false } : null;
   }
-  if (target.contentType !== "tool-result") {
-    return {
-      state: input.state,
-      ok: false,
-      resultText: `absorb failed: ref ${input.ref} is a ${target.contentType}, not a tool result.`
-    };
+};
+var codeTrimPlugin = {
+  id: "code-trim",
+  kinds: ["code"],
+  run(text) {
+    const out = crushCode(text);
+    return out ? { text: out, lossy: true } : null;
   }
-  if (isAcpOrConfiguredTool(target.toolName, cfg)) {
-    return {
-      state: input.state,
-      ok: false,
-      resultText: `absorb failed: ${target.toolName} is an ACP-managed tool result \u2014 it is not absorbable.`
-    };
+};
+var logSelectPlugin = {
+  id: "log-select",
+  kinds: ["log"],
+  run(text) {
+    const out = crushLog(text);
+    return out ? { text: out, lossy: true } : null;
   }
-  if (isMessageProtected(target, input.config) || isMessageLatestProtected(
-    target,
-    collectLatestProtected(input.messages, input.config)
-  )) {
-    return {
-      state: input.state,
-      ok: false,
-      resultText: `absorb failed: ${target.toolName} is a protected tool \u2014 its results must stay visible.`
-    };
+};
+var builtInPlugins = [
+  jsonFoldPlugin,
+  codeTrimPlugin,
+  logSelectPlugin
+];
+var crushRegistry = /* @__PURE__ */ new Map();
+for (const p of builtInPlugins) crushRegistry.set(p.id, p);
+function registerCrushPlugin(def) {
+  crushRegistry.set(def.id, def);
+}
+function unregisterCrushPlugin(id) {
+  crushRegistry.delete(id);
+}
+function listCrushPlugins() {
+  return Array.from(crushRegistry.values()).map((p) => ({
+    id: p.id,
+    kinds: p.kinds
+  }));
+}
+function resetCrushPlugins() {
+  crushRegistry.clear();
+  for (const p of builtInPlugins) crushRegistry.set(p.id, p);
+}
+function registeredPlugins() {
+  return Array.from(crushRegistry.values());
+}
+function resolveCrushConfig(config) {
+  return { ...DEFAULT_CRUSH_CONFIG, ...config.crush ?? {} };
+}
+function effectivePlugins(crush, meta) {
+  const toolName = meta.toolName;
+  return registeredPlugins().filter((p) => {
+    const ov = crush.strategies?.[p.id];
+    if (ov?.enabled === false) return false;
+    if (toolName && ov?.excludeTools?.some((pat) => matchToolPattern(toolName, pat)))
+      return false;
+    return true;
+  });
+}
+function evaluateToolResult(input) {
+  const { absorb, crush, tokenCount, modelContextLimit, meta = {} } = input;
+  const countTokens = input.countTokens ?? defaultCountTokens;
+  const text = input.text;
+  const rawTokens = countTokens(text);
+  if (absorb.contextThresholdPct > 0 && modelContextLimit > 0 && tokenCount < absorb.contextThresholdPct * modelContextLimit) {
+    return { kind: "skip", text, rawTokens };
   }
-  if (!target.toolCallId) {
-    return {
-      state: input.state,
-      ok: false,
-      resultText: `absorb failed: ref ${input.ref} has no tool-call id \u2014 cannot pair it for hiding.`
-    };
+  if (rawTokens < absorb.minToolTokens) {
+    return { kind: "skip", text, rawTokens };
   }
-  const call = input.messages.find(
-    (m) => m.contentType === "tool-call" && m.toolCallId === target.toolCallId
-  );
-  const tokens = countTokens(target.text ?? "");
-  const summaryTokens = countTokens(summary);
-  const record = {
-    toolCallId: target.toolCallId,
-    callMessageId: call?.id ?? "",
-    resultMessageId: target.id,
-    ...input.absorbCallId ? { absorbCallId: input.absorbCallId } : {},
-    summary,
-    tokensReclaimed: tokens,
-    createdAt: Date.now()
-  };
-  const state = {
-    ...input.state,
-    absorbed: [...input.state.absorbed ?? [], record],
-    stats: {
-      ...input.state.stats,
-      absorbedTokens: (input.state.stats.absorbedTokens ?? 0) + tokens
-    }
-  };
-  const bloat = summaryTokens >= tokens && tokens > 0 ? ` WARNING: your summary (~${formatTokenCount(summaryTokens)} tokens) is not smaller than the original (~${formatTokenCount(tokens)} tokens) \u2014 distill harder next time.` : "";
+  const out = crushText(text, {
+    minReduction: crush.minReduction,
+    countTokens,
+    meta,
+    plugins: effectivePlugins(crush, meta)
+  });
+  if (!out) return { kind: "distill", text, rawTokens };
+  const newTokens = countTokens(out.text);
   return {
-    state,
-    ok: true,
-    resultText: `absorbed ${input.ref} (~${formatTokenCount(tokens)} tokens \u2192 summary ~${formatTokenCount(summaryTokens)}). The original tool output is now hidden; your summary is the durable record.${bloat}`
+    kind: newTokens < absorb.minToolTokens ? "crushed" : "distill",
+    text: out.text,
+    rawTokens,
+    newTokens,
+    reduction: (rawTokens - newTokens) / rawTokens,
+    strategy: out.strategy,
+    lossy: out.lossy
   };
 }
+function applyCrushToMessages(messages, config, tokenCount, countTokens) {
+  const absorb = resolveAbsorbConfig(config);
+  const crush = resolveCrushConfig(config);
+  let crushedCount = 0;
+  let distilledCount = 0;
+  let changed = false;
+  const out = [];
+  for (const msg of messages) {
+    if (!isAbsorbCandidate(msg, config)) {
+      out.push(msg);
+      continue;
+    }
+    const text = msg.text ?? "";
+    const markerAt = text.indexOf(ABSORB_PROMPT_MARKER);
+    const payload = markerAt >= 0 ? text.slice(0, markerAt) : text;
+    const ev = evaluateToolResult({
+      text: payload,
+      absorb,
+      crush,
+      tokenCount,
+      modelContextLimit: config.modelContextLimit,
+      meta: { toolName: msg.toolName },
+      countTokens
+    });
+    if (ev.kind === "skip") {
+      out.push(msg);
+      continue;
+    }
+    changed = true;
+    if (ev.kind === "crushed") crushedCount++;
+    else distilledCount++;
+    out.push({ ...msg, text: ev.text });
+  }
+  return { messages: changed ? out : messages, crushedCount, distilledCount };
+}
 
 // src/filter/registry.ts
 var registry = /* @__PURE__ */ new Map();
@@ -2684,10 +4428,12 @@ function createCore(ports = {}) {
         `[acp-kernel] Config validation warnings: ${configErrors.join("; ")}. Thresholds may not fire correctly.`
       );
     }
+    const contentStore = input.contentStore ?? createContentStore();
     const ctx = {
       config: input.config,
       tokenCount: input.tokenCount,
-      countTokens
+      countTokens,
+      contentStore
     };
     const initial = {
       messages: input.messages,
@@ -2697,14 +4443,19 @@ function createCore(ports = {}) {
     const strategy = input.renderTags ?? "all";
     const nodes = buildNodes(strategy);
     const result = runPipeline(nodes, initial, ctx);
+    const ccrEffect = result.effects.ccr;
     return {
       messages: result.messages,
       state: result.state,
       nudge: result.effects.nudge,
       terminalEscape: result.effects.terminalEscape,
-      truncationSkipped: result.effects.truncationSkipped
+      truncationSkipped: result.effects.truncationSkipped,
+      contentStore: ccrEffect?.store ?? contentStore
     };
   }
+  function retrieve(store, ref) {
+    return applyRetrieve({ store, ref });
+  }
   function decompress(blockId, state) {
     return blockById(state, blockId);
   }
@@ -2724,7 +4475,12 @@ function createCore(ports = {}) {
       activeBlocks: active.length,
       totalBlocks: state.blocks.length,
       tokensCompressed: state.stats.tokensCompressed,
-      breakdown: { active: active.length, total: state.blocks.length }
+      breakdown: {
+        active: active.length,
+        total: state.blocks.length,
+        storedMessages: state.stats.storedCount ?? 0,
+        retrievals: state.stats.retrievalCount ?? 0
+      }
     };
   }
   function defaultNodes() {
@@ -2735,7 +4491,9 @@ function createCore(ports = {}) {
       assignRefsNode,
       syncBlocksNode,
       pruneNode,
+      ccrStoreNode,
       absorbHideNode,
+      crushNode,
       absorbPromptNode,
       filterNode,
       hideCompressCallsNode,
@@ -2748,6 +4506,7 @@ function createCore(ports = {}) {
   }
   return {
     processTurn,
+    retrieve,
     applyCompression,
     defaultNodes,
     decompress,
@@ -2764,7 +4523,9 @@ var assignRefsNode = {
     const refResult = assignRefs(io.messages, {
       existing: io.state.messageRefs,
       nextIndex: highestUsedIndex(io.state.messageRefs) + 1,
-      isProtected: protectedFn
+      isProtected: protectedFn,
+      // Ephemeral retrieval injections never consume a ref slot.
+      shouldSkip: (m) => m.id.startsWith(RETRIEVED_ID_PREFIX)
     });
     return { ...io, state: { ...io.state, messageRefs: refResult.map } };
   }
@@ -2808,6 +4569,27 @@ var absorbPromptNode = {
     };
   }
 };
+var crushNode = {
+  name: "crush",
+  enabled: (_io, ctx) => ctx.config.crush?.enabled === true && ctx.config.absorb?.enabled === true,
+  run(io, ctx) {
+    const applied = applyCrushToMessages(
+      io.messages,
+      ctx.config,
+      ctx.tokenCount,
+      ctx.countTokens
+    );
+    return {
+      ...io,
+      messages: applied.messages,
+      effects: {
+        ...io.effects,
+        crushCount: applied.crushedCount,
+        crushDistilledCount: applied.distilledCount
+      }
+    };
+  }
+};
 var filterNode = {
   name: "filter",
   enabled: (_io, ctx) => !!ctx.config.messageFilters?.enabled && listMessageFilters().length > 0,
@@ -4744,6 +6526,294 @@ function formatRulesList(rules) {
   return rules.map((rule, i) => `${i + 1}. [${rule.id}] ${rule.text}`).join("\n");
 }
 
+// src/image-compress.ts
+var DEFAULT_IMAGE_COMPRESSION_CONFIG = {
+  enabled: false,
+  minTokens: 512,
+  maxDimension: 1280,
+  quality: 80,
+  format: "webp"
+};
+function resolveImageCompressionConfig(config) {
+  return { ...DEFAULT_IMAGE_COMPRESSION_CONFIG, ...config.imageCompression ?? {} };
+}
+var PIXEL_IMAGE_FALLBACK_TOKENS = 16384;
+var TILE_EDGE = 512;
+var TILE_SHORT_SIDE = 768;
+var TILE_MAX_EDGE = 2048;
+function byteAt(b, off) {
+  return b[off] ?? 0;
+}
+function u16be(b, off) {
+  return byteAt(b, off) << 8 | byteAt(b, off + 1);
+}
+function u16le(b, off) {
+  return byteAt(b, off) | byteAt(b, off + 1) << 8;
+}
+function u32be(b, off) {
+  return (byteAt(b, off) << 24 | byteAt(b, off + 1) << 16 | byteAt(b, off + 2) << 8 | byteAt(b, off + 3)) >>> 0;
+}
+function i32le(b, off) {
+  return byteAt(b, off) | byteAt(b, off + 1) << 8 | byteAt(b, off + 2) << 16 | byteAt(b, off + 3) << 24;
+}
+function parseImageDimensions(bytes) {
+  const b = bytes;
+  if (b.length < 10) return void 0;
+  if (b[0] === 137 && b[1] === 80 && b[2] === 78 && b[3] === 71) {
+    if (b.length < 24) return void 0;
+    const w = u32be(b, 16);
+    const h = u32be(b, 20);
+    return w > 0 && h > 0 ? { width: w, height: h } : void 0;
+  }
+  if (b[0] === 71 && b[1] === 73 && b[2] === 70) {
+    const w = u16le(b, 6);
+    const h = u16le(b, 8);
+    return w > 0 && h > 0 ? { width: w, height: h } : void 0;
+  }
+  if (b.length >= 26 && b[0] === 66 && b[1] === 77) {
+    const w = i32le(b, 18);
+    const h = Math.abs(i32le(b, 22));
+    return w > 0 && h > 0 ? { width: w, height: h } : void 0;
+  }
+  if (b.length >= 20 && b[0] === 82 && b[1] === 73 && b[2] === 70 && b[3] === 70 && b[8] === 87 && b[9] === 69 && b[10] === 66 && b[11] === 80) {
+    if (b[12] === 86 && b[13] === 80 && b[14] === 56 && b[15] === 88) {
+      if (b.length < 30) return void 0;
+      const w = byteAt(b, 24) | byteAt(b, 25) << 8 | byteAt(b, 26) << 16;
+      const h = byteAt(b, 27) | byteAt(b, 28) << 8 | byteAt(b, 29) << 16;
+      return w > 0 && h > 0 ? { width: w + 1, height: h + 1 } : void 0;
+    }
+    if (b[12] === 86 && b[13] === 80 && b[14] === 56 && b[15] === 76) {
+      if (b.length < 25) return void 0;
+      if (b[20] !== 47) return void 0;
+      const w = ((byteAt(b, 22) & 63) << 8 | byteAt(b, 21)) + 1;
+      const h = (byteAt(b, 24) & 15) << 10 | byteAt(b, 23) << 2 | (byteAt(b, 22) & 192) >> 6;
+      return w > 0 && h > 0 ? { width: w, height: h + 1 } : void 0;
+    }
+    if (b[12] === 86 && b[13] === 80 && b[14] === 56 && b[15] === 32) {
+      if (b.length < 30) return void 0;
+      if (b[23] !== 157 || b[24] !== 1 || b[25] !== 42) return void 0;
+      const w = u16le(b, 26) & 16383;
+      const h = u16le(b, 28) & 16383;
+      return w > 0 && h > 0 ? { width: w, height: h } : void 0;
+    }
+    return void 0;
+  }
+  if (b[0] === 255 && b[1] === 216) {
+    let off = 2;
+    while (off + 4 <= b.length) {
+      if (b[off] !== 255) {
+        off += 1;
+        continue;
+      }
+      const marker = byteAt(b, off + 1);
+      if (marker === 216 || marker === 1 || marker >= 208 && marker <= 217) {
+        off += 2;
+        continue;
+      }
+      if (marker === 218) break;
+      const segLen = u16be(b, off + 2);
+      if (segLen < 2) break;
+      if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
+        if (off + 9 > b.length) break;
+        const h = u16be(b, off + 5);
+        const w = u16be(b, off + 7);
+        if (w > 0 && h > 0) return { width: w, height: h };
+        break;
+      }
+      off += 2 + segLen;
+    }
+  }
+  return void 0;
+}
+var HEADER_SCAN_CHARS = 64;
+var JPEG_SCAN_CHARS = 35e4;
+function parseImageDimensionsFromBase64(b64) {
+  if (typeof b64 !== "string" || b64.length === 0) return void 0;
+  const head = parseImageDimensions(Buffer.from(b64.slice(0, HEADER_SCAN_CHARS), "base64"));
+  if (head) return head;
+  if (b64.startsWith("/9j/") && b64.length > HEADER_SCAN_CHARS) {
+    return parseImageDimensions(Buffer.from(b64.slice(0, JPEG_SCAN_CHARS), "base64"));
+  }
+  return void 0;
+}
+function pixelTileEstimate(width, height) {
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+    return PIXEL_IMAGE_FALLBACK_TOKENS;
+  }
+  let sw = width;
+  let sh = height;
+  const shortSide = Math.min(sw, sh);
+  if (shortSide > 0 && shortSide < TILE_SHORT_SIDE) {
+    const s = TILE_SHORT_SIDE / shortSide;
+    sw *= s;
+    sh *= s;
+  }
+  const longSide = Math.max(sw, sh);
+  if (longSide > TILE_MAX_EDGE) {
+    const s = TILE_MAX_EDGE / longSide;
+    sw *= s;
+    sh *= s;
+  }
+  const tiles = Math.ceil(sw / TILE_EDGE) * Math.ceil(sh / TILE_EDGE);
+  return 85 + 170 * tiles;
+}
+function estimateImageTokens(meta) {
+  const billing = meta.billing ?? "bytes";
+  if (billing === "bytes") return Math.ceil(meta.base64Length / 4);
+  const w = meta.width;
+  const h = meta.height;
+  if (w && h) return pixelTileEstimate(w, h);
+  if (meta.base64) {
+    const dims = parseImageDimensionsFromBase64(meta.base64);
+    if (dims) return pixelTileEstimate(dims.width, dims.height);
+  }
+  return PIXEL_IMAGE_FALLBACK_TOKENS;
+}
+function createHeuristicClassifier(options = {}) {
+  const aspectRatioMin = options.aspectRatioMin ?? 1.4;
+  const aspectRatioMax = options.aspectRatioMax ?? 2.6;
+  const minShortSide = options.minShortSide ?? 720;
+  return {
+    name: "heuristic-v1",
+    isScreenshotLike(meta) {
+      const w = meta.width;
+      const h = meta.height;
+      if (!w || !h || w <= 0 || h <= 0) return false;
+      const shortSide = Math.min(w, h);
+      if (shortSide < minShortSide) return false;
+      const ratio = Math.max(w, h) / shortSide;
+      return ratio >= aspectRatioMin && ratio <= aspectRatioMax;
+    }
+  };
+}
+var DEFAULT_SCREENSHOT_CLASSIFIER = createHeuristicClassifier();
+function decideImageRoute(meta, config, classifier = DEFAULT_SCREENSHOT_CLASSIFIER) {
+  const cfg = resolveImageCompressionConfig(config);
+  const estimatedTokens = estimateImageTokens(meta);
+  if (!cfg.enabled) return { action: "pass", reason: "disabled", estimatedTokens };
+  if (!meta.mediaType.startsWith("image/")) {
+    return { action: "pass", reason: "not-an-image", estimatedTokens };
+  }
+  if (estimatedTokens < cfg.minTokens) {
+    return { action: "pass", reason: "below-min-tokens", estimatedTokens };
+  }
+  if (!classifier.isScreenshotLike(meta)) {
+    return { action: "pass", reason: "not-screenshot-like", estimatedTokens };
+  }
+  return {
+    action: "downsample",
+    reason: "downsample",
+    estimatedTokens,
+    recipe: { maxDimension: cfg.maxDimension, quality: cfg.quality, format: cfg.format }
+  };
+}
+var IMAGE_FULL_FAILURE_MARKER = "[image_full FAILED:";
+function buildImageFullSystemNote(count) {
+  return `[Downscaled screenshots: ${count} image(s) were reduced before entering context. If you cannot read details (text, colors, alignment) in a reduced image, call ${IMAGE_FULL_TOOL_NAME} with that message's ref ("mNNNNN") to restore the original resolution.]`;
+}
+function parseImageFullInput(input, callId, onWarn) {
+  let obj = null;
+  if (typeof input === "string") {
+    try {
+      const parsed = JSON.parse(input);
+      if (parsed && typeof parsed === "object") obj = parsed;
+    } catch {
+      obj = null;
+    }
+  } else if (input && typeof input === "object") {
+    obj = input;
+  }
+  if (!obj) {
+    onWarn?.(`[acp-image-full-input] rejected: not an object (${typeof input})`);
+    return null;
+  }
+  let ref;
+  for (const key of ["ref", "messageId", "of"]) {
+    const value = obj[key];
+    if (typeof value === "string") {
+      ref = value;
+      break;
+    }
+  }
+  if (typeof ref !== "string") {
+    onWarn?.(
+      `[acp-image-full-input] rejected: need ref (string); keys: ${Object.keys(obj).join(",")}`
+    );
+    return null;
+  }
+  const trimmed = ref.trim();
+  if (!trimmed) {
+    onWarn?.("[acp-image-full-input] rejected: ref is empty");
+    return null;
+  }
+  return { ref: trimmed, ...callId ? { callId } : {} };
+}
+function recordImageShrink(state, record) {
+  const bytesSaved = Math.max(0, record.originalBytes - record.shrunkBytes);
+  const tokensSaved = Math.max(0, record.tokensBefore - record.tokensAfter);
+  return {
+    ...state,
+    imageShrinks: [...state.imageShrinks ?? [], record],
+    stats: {
+      ...state.stats,
+      imagesShrunk: (state.stats.imagesShrunk ?? 0) + 1,
+      imageBytesSaved: (state.stats.imageBytesSaved ?? 0) + bytesSaved,
+      imageTokensSaved: (state.stats.imageTokensSaved ?? 0) + tokensSaved
+    }
+  };
+}
+function isImageFullRestored(state, ref) {
+  return (state.imageFullRestored ?? []).includes(ref);
+}
+function imageShrinksForRef(state, ref) {
+  return (state.imageShrinks ?? []).filter((r) => r.ref === ref);
+}
+function applyImageFull(input) {
+  const cfg = resolveImageCompressionConfig(input.config);
+  const ref = input.ref.trim();
+  if (!cfg.enabled) {
+    return {
+      state: input.state,
+      ok: false,
+      resultText: `${IMAGE_FULL_FAILURE_MARKER} image compression is disabled in this session \u2014 no image was ever downscaled]`
+    };
+  }
+  const rawId = rawForRef(input.state.messageRefs, ref);
+  if (!rawId) {
+    return {
+      state: input.state,
+      ok: false,
+      resultText: `${IMAGE_FULL_FAILURE_MARKER} ref ${ref} does not exist in this session]`
+    };
+  }
+  if (isImageFullRestored(input.state, ref)) {
+    return {
+      state: input.state,
+      ok: true,
+      resultText: `already restored (${ref}) \u2014 full resolution stays in effect for the rest of this session.`
+    };
+  }
+  const shrinks = imageShrinksForRef(input.state, ref);
+  if (shrinks.length === 0) {
+    return {
+      state: input.state,
+      ok: false,
+      resultText: `${IMAGE_FULL_FAILURE_MARKER} no downscaled image is recorded for ${ref} \u2014 it was passed through untouched or never carried an image]`
+    };
+  }
+  return {
+    state: {
+      ...input.state,
+      imageFullRestored: [...input.state.imageFullRestored ?? [], ref]
+    },
+    ok: true,
+    resultText: `restored original-resolution image(s) for ${ref} (${shrinks.length} image${shrinks.length === 1 ? "" : "s"}); full resolution applies for the rest of this session.`
+  };
+}
+function resetImageFullState(state) {
+  return { ...state, imageFullRestored: [], imageShrinks: [] };
+}
+
 // src/parse-compress-input.ts
 function parseCompressArgs(input, opts) {
   const callId = opts?.callId;
@@ -5272,7 +7342,8 @@ function rebuildCompressionState(state, messages, config, ports = {}) {
   const core = createCore({ countTokens: ports.countTokens ?? defaultCountTokens });
   const refResult = assignRefs(messages, {
     existing: state.messageRefs,
-    nextIndex: highestUsedIndex(state.messageRefs) + 1
+    nextIndex: highestUsedIndex(state.messageRefs) + 1,
+    shouldSkip: (m) => m.id.startsWith(RETRIEVED_ID_PREFIX)
   });
   let working = { ...state, messageRefs: refResult.map };
   const invocations = collectCompressInvocations(messages);
@@ -5636,6 +7707,129 @@ function makePreview(text, query, len) {
   const suffix = end < text.length ? "\u2026" : "";
   return prefix + clampWindow(text, start, end).trim() + suffix;
 }
+
+// src/output-steering.ts
+function classifyTurn(messages) {
+  if (messages.length === 0) return "unknown";
+  const last = messages[messages.length - 1];
+  if (!last || last.role !== "user") return "unknown";
+  if (typeof last.text === "string")
+    return last.text.trim() ? "new_user_ask" : "unknown";
+  const blocks = last.blocks;
+  if (!Array.isArray(blocks) || blocks.length === 0) return "unknown";
+  let sawToolResult = false;
+  let sawError = false;
+  for (const b of blocks) {
+    if (!b) return "unknown";
+    switch (b.kind) {
+      case "tool_result":
+        sawToolResult = true;
+        if (b.isError === true) sawError = true;
+        break;
+      case "text":
+      case "image":
+      case "document":
+        return "new_user_ask";
+      default:
+        return "unknown";
+    }
+  }
+  if (sawError) return "error_continuation";
+  if (sawToolResult) return "mechanical_continuation";
+  return "unknown";
+}
+var MIN_VERBOSITY_LEVEL = 0;
+var MAX_VERBOSITY_LEVEL = 4;
+var DEFAULT_VERBOSITY_LEVEL = 2;
+var VERBOSITY_LEVELS = {
+  1: "Skip preamble and postamble. Do not announce what you are about to do or recap what you just did; start with the substance.",
+  2: "Skip preamble and postamble; start with the substance. Never restate code, file contents, diffs, or tool output that already appear in this conversation \u2014 reference them by path and line instead. After a tool call succeeds, continue without narrating the result.",
+  3: "Skip preamble and postamble. Never restate code, file contents, diffs, or tool output already in this conversation \u2014 cite the exact file path and line or symbol instead, always; a reference that omits the location is not a reference. Give conclusions only; omit rationale unless the user asks why. Prefer the smallest edit over rewriting whole files. Keep prose to the minimum needed to be unambiguous. Never drop anything the turn or task needs to be correct, including negations (not, never, no, only, except) \u2014 shorten how you say it, not what you say. Use full prose for destructive or irreversible actions, security warnings, and any multi-step sequence where brevity would create ambiguity.",
+  4: "Minimum tokens. Fragments fine. No preamble, no postamble, no restating context, no rationale. Answer, smallest-possible edits, nothing else. Never drop anything the turn or task needs to be correct, including negations (not, never, no, only, except). Use full prose for destructive or irreversible actions, security warnings, and any multi-step sequence where brevity would create ambiguity."
+};
+function verbosityDirective(level) {
+  if (!Number.isInteger(level)) return null;
+  return VERBOSITY_LEVELS[level] ?? null;
+}
+var DEFAULT_STEERING_SENTINEL = "<acp_output_steering>";
+function renderSteeringBlock(level, sentinel = DEFAULT_STEERING_SENTINEL) {
+  const text = verbosityDirective(level);
+  if (text === null) return null;
+  return `${sentinel}
+${text}
+</${sentinel.slice(1)}`;
+}
+function applySteeringToPrompt(existing, block, sentinel = DEFAULT_STEERING_SENTINEL) {
+  const suffix = `</${sentinel.slice(1)}`;
+  const start = existing.indexOf(sentinel);
+  if (start >= 0) {
+    const found = existing.indexOf(suffix, start);
+    const end = found < 0 ? existing.length : found + suffix.length;
+    const prefix = existing.slice(0, start).replace(/\s+$/, "");
+    const tail = existing.slice(end).replace(/^\n+/, "");
+    const parts = [prefix, block, tail].filter((p) => p.length > 0);
+    const updated2 = parts.join("\n\n");
+    return { updated: updated2, changed: updated2 !== existing };
+  }
+  const trimmed = existing.trim();
+  const updated = trimmed.length > 0 ? `${existing.replace(/\s+$/, "")}
+
+${block}` : block;
+  return { updated, changed: updated !== existing };
+}
+var EFFORT_LADDER = [
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh"
+];
+function clampEffortToFloor(current, floor = "low") {
+  if (typeof current !== "string") return null;
+  const ci = EFFORT_LADDER.indexOf(current);
+  if (ci === -1) return null;
+  const fi = EFFORT_LADDER.indexOf(floor);
+  return ci > fi ? floor : null;
+}
+var DEFAULT_OUTPUT_STEERING_CONFIG = {
+  enabled: false,
+  verbosityLevel: DEFAULT_VERBOSITY_LEVEL,
+  effortRouting: true
+};
+function resolveVerbosityLevel(v) {
+  if (typeof v === "number" && Number.isInteger(v) && v >= MIN_VERBOSITY_LEVEL && v <= MAX_VERBOSITY_LEVEL) {
+    return { level: v };
+  }
+  const level = DEFAULT_OUTPUT_STEERING_CONFIG.verbosityLevel;
+  if (v === void 0) return { level };
+  return {
+    level,
+    warning: `[config] outputSteering.verbosityLevel must be an integer ${MIN_VERBOSITY_LEVEL}-${MAX_VERBOSITY_LEVEL}; got ${JSON.stringify(v)} \u2014 falling back to ${level}`
+  };
+}
+function resolveOutputSteeringConfig(v) {
+  if (!v || typeof v !== "object" || Array.isArray(v)) {
+    return { config: DEFAULT_OUTPUT_STEERING_CONFIG, warnings: [] };
+  }
+  const obj = v;
+  const lvl = resolveVerbosityLevel(obj.verbosityLevel);
+  return {
+    config: {
+      enabled: obj.enabled === true,
+      verbosityLevel: lvl.level,
+      effortRouting: obj.effortRouting !== false
+    },
+    warnings: lvl.warning ? [lvl.warning] : []
+  };
+}
+function decideOutputSteering(messages, config = DEFAULT_OUTPUT_STEERING_CONFIG) {
+  const turnKind = classifyTurn(messages);
+  return {
+    turnKind,
+    verbosityLevel: config.enabled ? config.verbosityLevel : 0,
+    lowerEffort: config.enabled && config.effortRouting && turnKind === "mechanical_continuation"
+  };
+}
 export {
   ABSORB_PROMPT_MARKER,
   ABSORB_TOOL,
@@ -5684,10 +7878,33 @@ export {
   DECOMPRESS_TOOL_RESPONSES,
   DEFAULT_ABSORB_CONFIG,
   DEFAULT_ALGORITHM,
+  DEFAULT_CCR_CONFIG,
+  DEFAULT_CRUSH_CONFIG,
+  DEFAULT_IMAGE_COMPRESSION_CONFIG,
+  DEFAULT_OUTPUT_STEERING_CONFIG,
   DEFAULT_ROLE_WEIGHTS,
   DEFAULT_RULE_LIMITS,
+  DEFAULT_SCREENSHOT_CLASSIFIER,
+  DEFAULT_STEERING_SENTINEL,
+  DEFAULT_VERBOSITY_LEVEL,
+  EFFORT_LADDER,
   HOW_TO_COMPRESS_RULES,
+  IMAGE_FULL_FAILURE_MARKER,
+  IMAGE_FULL_TOOL,
+  IMAGE_FULL_TOOL_DESCRIPTION,
+  IMAGE_FULL_TOOL_NAME,
+  IMAGE_FULL_TOOL_OPENAI,
+  IMAGE_FULL_TOOL_RESPONSES,
   LEAN_HOW_TO_COMPRESS,
+  MAX_VERBOSITY_LEVEL,
+  MIN_VERBOSITY_LEVEL,
+  PIXEL_IMAGE_FALLBACK_TOKENS,
+  RETRIEVED_ID_PREFIX,
+  RETRIEVE_TOOL,
+  RETRIEVE_TOOL_DESCRIPTION,
+  RETRIEVE_TOOL_NAME,
+  RETRIEVE_TOOL_OPENAI,
+  RETRIEVE_TOOL_RESPONSES,
   RULES_USAGE_PROMPT,
   RULE_TOOL_NAME,
   SEARCH_CONTEXT_TOOL,
@@ -5695,9 +7912,11 @@ export {
   SEARCH_CONTEXT_TOOL_NAME,
   SEARCH_CONTEXT_TOOL_OPENAI,
   SEARCH_CONTEXT_TOOL_RESPONSES,
+  STORED_PLACEHOLDER_MARKER,
   SUMMARY_HEADER,
   TIER2_DISTILL_RULES,
   TIER3_CONDENSE_RULES,
+  VERBOSITY_LEVELS,
   VIABLE_RANGE_MIN_TOKENS,
   activeBlockSpans,
   activeBlocks,
@@ -5709,8 +7928,12 @@ export {
   appendAbsorbPrompts,
   applyAbsorb,
   applyAcpToolOverrides,
+  applyCrushToMessages,
+  applyImageFull,
   applyMessageFilters,
+  applyRetrieve,
   applySectionOverrides,
+  applySteeringToPrompt,
   assignRefs,
   blockById,
   blockDocs,
@@ -5721,26 +7944,41 @@ export {
   buildCompressHybridSystemPrompt,
   buildCompressSystemPrompt,
   buildCompressTextSystemPrompt,
+  buildImageFullSystemNote,
   buildRecap,
   buildRestoredContentPreview,
+  buildRetrievalInjection,
   buildStatusReport,
+  buildStoredPlaceholder,
   builtinSource,
+  ccrStoreNode,
+  clampEffortToFloor,
+  classifyCrushText,
+  classifyKind,
+  classifyTurn,
   clearDocFeatures,
   clearMessageFilters,
   clearRules,
   cloneWithDescriptions,
+  codeTrimPlugin,
   collectBlockContent,
   collectLatestProtected,
   computeFoldEconomics,
+  contentStoreStats,
   countMessageTokens,
   coveredMessageIds,
   createBpeTokenizer,
+  createContentStore,
   createCore,
   createDirPackSource,
+  createHeuristicClassifier,
   createInitialState,
   createPackResolver,
   createRenderRefsNode,
+  crushText,
   deactivateBlock,
+  decideImageRoute,
+  decideOutputSteering,
   decomposeSample,
   defaultConfig,
   defaultCountTokens,
@@ -5750,7 +7988,10 @@ export {
   docCacheInfo,
   docFeatures,
   emptyRefMap,
+  estimateImageTokens,
   estimateTokensFast,
+  evaluateToolResult,
+  extractCommand,
   findActiveAncestor,
   findBlocksOverlappingMessages,
   formatCacheReport,
@@ -5760,35 +8001,52 @@ export {
   formatRulesList,
   getMessageFilter,
   getSearchAlgorithm,
+  hasStoredRef,
+  hashContent,
   hideAbsorbedMessages,
   hideConsumedCompressCalls,
   highestActiveTier,
   highestUsedIndex,
+  imageShrinksForRef,
   indexToRef,
   isAbsorbCandidate,
+  isImageFullRestored,
   isMessageLatestProtected,
   isMessageProtected,
   isRenderedSummaryMessage,
+  isRetrievedMessage,
+  isStoredPlaceholderText,
   isSummaryMessageId,
   isValidPackName,
+  jsonFoldPlugin,
   leanPack,
+  listCrushPlugins,
   listMessageFilters,
   listRules,
   listSearchAlgorithms,
+  logSelectPlugin,
   makeIO,
   matchSession,
   matchToolPattern,
   messageDocs,
+  normalizeHead,
+  noteRetrieval,
   parseAbsorbInput,
   parseBlockIdArg,
   parseBoundary,
   parseCompressArgs,
   parseCompressInput,
+  parseImageDimensions,
+  parseImageDimensionsFromBase64,
+  parseImageFullInput,
+  pixelTileEstimate,
   prune,
   rawForRef,
   rebuildCompressionState,
+  recordImageShrink,
   refForRaw,
   refToIndex,
+  registerCrushPlugin,
   registerMessageFilter,
   registerSearchAlgorithm,
   removeRule,
@@ -5796,23 +8054,38 @@ export {
   renderMessage2 as renderMessage,
   renderNudgeText,
   renderRefsNode,
+  renderSteeringBlock,
   renderVisibleRefs,
+  resetCrushPlugins,
+  resetImageFullState,
   resolveAbsorbConfig,
   resolveBlockSpan,
   resolveBoundaries,
+  resolveCcrConfig,
+  resolveCrushConfig,
+  resolveImageCompressionConfig,
+  resolveOutputSteeringConfig,
   resolvePrompts,
   resolveRuleLimits,
   resolveTransformChannel,
+  resolveVerbosityLevel,
+  retrieveByRef,
+  retrievedMessageId,
   runPipeline,
   sanitizePackSurface,
   searchBlocks,
   searchBlocksAsync,
   setDocCacheCap,
+  storeCoveredOriginals,
+  storeLargeResults,
+  storeOriginal,
   summarizeFoldEconomics,
   summaryMessageId,
   syncBlocks,
   truncateLargeToolOutputs,
+  unregisterCrushPlugin,
   validateConfig,
+  verbosityDirective,
   viableRanges,
   visibleBlockAnchor
 };