acp-kernel 0.0.82 → 0.0.83-pr.358.229

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;
+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;
+    }
   }
-  return void 0;
+  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();
@@ -2403,18 +4147,30 @@ function mergeRangesToThreshold(ranges, minChars) {
   const result = [];
   let batch = [];
   let batchChars = 0;
-  for (const r of ranges) {
-    batch.push(r);
-    batchChars += rangeChars(r);
-    if (batchChars >= minChars) {
-      result.push(mergeBatch(batch));
+  const closeBatch = () => {
+    if (batch.length > 0) {
+      if (batchChars >= minChars) result.push(mergeBatch(batch));
       batch = [];
       batchChars = 0;
     }
+  };
+  for (const r of ranges) {
+    const prev = batch[batch.length - 1];
+    if (prev && prev.endIndex !== void 0 && r.startIndex !== void 0 && r.startIndex > prev.endIndex + 1) {
+      closeBatch();
+    }
+    batch.push(r);
+    batchChars += rangeChars(r);
+    if (batchChars >= minChars) closeBatch();
   }
   if (batch.length > 0 && result.length > 0) {
     const prev = result[result.length - 1];
-    result[result.length - 1] = mergeBatch([prev, ...batch]);
+    const contiguous = prev.endIndex === void 0 || batch[0].startIndex === void 0 || batch[0].startIndex <= prev.endIndex + 1;
+    if (contiguous) {
+      result[result.length - 1] = mergeBatch([prev, ...batch]);
+    } else if (batchChars >= minChars) {
+      result.push(mergeBatch(batch));
+    }
   }
   return result;
 }
@@ -2672,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,
@@ -2685,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);
   }
@@ -2712,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() {
@@ -2723,7 +4491,9 @@ function createCore(ports = {}) {
       assignRefsNode,
       syncBlocksNode,
       pruneNode,
+      ccrStoreNode,
       absorbHideNode,
+      crushNode,
       absorbPromptNode,
       filterNode,
       hideCompressCallsNode,
@@ -2736,6 +4506,7 @@ function createCore(ports = {}) {
   }
   return {
     processTurn,
+    retrieve,
     applyCompression,
     defaultNodes,
     decompress,
@@ -2752,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 } };
   }
@@ -2796,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,
@@ -4732,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;
@@ -5260,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);
@@ -5672,10 +7755,27 @@ export {
   DECOMPRESS_TOOL_RESPONSES,
   DEFAULT_ABSORB_CONFIG,
   DEFAULT_ALGORITHM,
+  DEFAULT_CCR_CONFIG,
+  DEFAULT_CRUSH_CONFIG,
+  DEFAULT_IMAGE_COMPRESSION_CONFIG,
   DEFAULT_ROLE_WEIGHTS,
   DEFAULT_RULE_LIMITS,
+  DEFAULT_SCREENSHOT_CLASSIFIER,
   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,
+  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,
@@ -5683,6 +7783,7 @@ export {
   SEARCH_CONTEXT_TOOL_NAME,
   SEARCH_CONTEXT_TOOL_OPENAI,
   SEARCH_CONTEXT_TOOL_RESPONSES,
+  STORED_PLACEHOLDER_MARKER,
   SUMMARY_HEADER,
   TIER2_DISTILL_RULES,
   TIER3_CONDENSE_RULES,
@@ -5697,7 +7798,10 @@ export {
   appendAbsorbPrompts,
   applyAbsorb,
   applyAcpToolOverrides,
+  applyCrushToMessages,
+  applyImageFull,
   applyMessageFilters,
+  applyRetrieve,
   applySectionOverrides,
   assignRefs,
   blockById,
@@ -5709,26 +7813,38 @@ export {
   buildCompressHybridSystemPrompt,
   buildCompressSystemPrompt,
   buildCompressTextSystemPrompt,
+  buildImageFullSystemNote,
   buildRecap,
   buildRestoredContentPreview,
+  buildRetrievalInjection,
   buildStatusReport,
+  buildStoredPlaceholder,
   builtinSource,
+  ccrStoreNode,
+  classifyCrushText,
+  classifyKind,
   clearDocFeatures,
   clearMessageFilters,
   clearRules,
   cloneWithDescriptions,
+  codeTrimPlugin,
   collectBlockContent,
   collectLatestProtected,
   computeFoldEconomics,
+  contentStoreStats,
   countMessageTokens,
   coveredMessageIds,
   createBpeTokenizer,
+  createContentStore,
   createCore,
   createDirPackSource,
+  createHeuristicClassifier,
   createInitialState,
   createPackResolver,
   createRenderRefsNode,
+  crushText,
   deactivateBlock,
+  decideImageRoute,
   decomposeSample,
   defaultConfig,
   defaultCountTokens,
@@ -5738,7 +7854,10 @@ export {
   docCacheInfo,
   docFeatures,
   emptyRefMap,
+  estimateImageTokens,
   estimateTokensFast,
+  evaluateToolResult,
+  extractCommand,
   findActiveAncestor,
   findBlocksOverlappingMessages,
   formatCacheReport,
@@ -5748,35 +7867,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,
@@ -5785,21 +7921,32 @@ export {
   renderNudgeText,
   renderRefsNode,
   renderVisibleRefs,
+  resetCrushPlugins,
+  resetImageFullState,
   resolveAbsorbConfig,
   resolveBlockSpan,
   resolveBoundaries,
+  resolveCcrConfig,
+  resolveCrushConfig,
+  resolveImageCompressionConfig,
   resolvePrompts,
   resolveRuleLimits,
   resolveTransformChannel,
+  retrieveByRef,
+  retrievedMessageId,
   runPipeline,
   sanitizePackSurface,
   searchBlocks,
   searchBlocksAsync,
   setDocCacheCap,
+  storeCoveredOriginals,
+  storeLargeResults,
+  storeOriginal,
   summarizeFoldEconomics,
   summaryMessageId,
   syncBlocks,
   truncateLargeToolOutputs,
+  unregisterCrushPlugin,
   validateConfig,
   viableRanges,
   visibleBlockAnchor