billion-context-pi 0.1.46 → 0.1.47-pr.217.13

package/dist/index.js

@@ -324,7 +324,7 @@ function viableRanges(ranges) {
   return ranges.filter((r) => r.tokens >= VIABLE_RANGE_MIN_TOKENS);
 }
 
-// node_modules/acp-kernel/dist/chunk-DPH62BGM.js
+// node_modules/acp-kernel/dist/chunk-UX4LINT7.js
 function createInitialState() {
   return {
     blocks: [],
@@ -337,7 +337,8 @@ function createInitialState() {
       anchors: {},
       lastShownByTier: {}
     },
-    stats: { tokensCompressed: 0, compressionCount: 0 },
+    stats: { tokensCompressed: 0, compressionCount: 0, absorbedTokens: 0 },
+    absorbed: [],
     nextBlockId: 1,
     nextRunId: 1
   };
@@ -601,6 +602,7 @@ function syncBlocks(messages, state) {
     tokenSnapshot: { ...state.tokenSnapshot ?? {} },
     nudge: { ...state.nudge, anchors: { ...state.nudge.anchors } },
     stats: { ...state.stats },
+    absorbed: (state.absorbed ?? []).map((record) => ({ ...record })),
     nextBlockId: state.nextBlockId,
     nextRunId: state.nextRunId
   };
@@ -661,7 +663,14 @@ function defaultConfig(modelContextLimit, overrides = {}) {
     protectedTools: [],
     preserveRecentMessages: 5,
     preserveRecentTokens: 5e3,
-    modelContextLimit
+    modelContextLimit,
+    absorb: {
+      enabled: false,
+      toolName: "absorb",
+      minToolTokens: 1e3,
+      contextThresholdPct: 0,
+      excludeTools: []
+    }
   };
   return {
     ...base,
@@ -669,7 +678,8 @@ function defaultConfig(modelContextLimit, overrides = {}) {
     tiers: { ...base.tiers, ...overrides.tiers },
     nudge: { ...base.nudge, ...overrides.nudge },
     truncate: { ...base.truncate, ...overrides.truncate },
-    compress: { ...base.compress, ...overrides.compress }
+    compress: { ...base.compress, ...overrides.compress },
+    absorb: overrides.absorb ? { ...base.absorb, ...overrides.absorb } : base.absorb
   };
 }
 function validateConfig(config) {
@@ -699,6 +709,17 @@ function validateConfig(config) {
   if (config.tiers.tier3Trigger <= config.tiers.tier2Trigger) {
     errors.push("tiers.tier3Trigger must be greater than tiers.tier2Trigger");
   }
+  if (config.absorb) {
+    if (config.absorb.enabled && !config.absorb.toolName) {
+      errors.push("absorb.toolName must be a non-empty string when enabled");
+    }
+    if (!Number.isFinite(config.absorb.minToolTokens) || config.absorb.minToolTokens < 0) {
+      errors.push("absorb.minToolTokens must be >= 0");
+    }
+    if (config.absorb.contextThresholdPct < 0 || config.absorb.contextThresholdPct > 1) {
+      errors.push("absorb.contextThresholdPct must be in [0, 1]");
+    }
+  }
   return errors;
 }
 var MESSAGE_REF_PATTERN = /^m0*(\d{1,5})$/;
@@ -1055,6 +1076,306 @@ function hideConsumedCompressCalls(state, messages) {
   }
   return { messages: result, hidden };
 }
+var COMPRESS_TOOL_NAME = "compress";
+var DECOMPRESS_TOOL_NAME = "decompress";
+var SEARCH_CONTEXT_TOOL_NAME = "search_context";
+var ACP_STATUS_TOOL_NAME = "acp_status";
+var ABSORB_TOOL_NAME = "absorb";
+var COMPRESS_TOOL = {
+  name: COMPRESS_TOOL_NAME,
+  description: "Replace a contiguous range of older conversation with a detailed summary you write. Use when content is genuinely consumed. Batch form: content=[{startId,endId,summary,topic?}]. REQUIRED \u2014 compress without content is invalid.",
+  input_schema: {
+    type: "object",
+    properties: {
+      topic: {
+        type: "string",
+        description: "Optional short title for the compressed range"
+      },
+      content: {
+        type: "array",
+        description: "One or more ranges to compress into separate summary blocks",
+        items: {
+          type: "object",
+          properties: {
+            topic: { type: "string" },
+            startId: {
+              type: "string",
+              description: "mNNNNN ref at the start of the range"
+            },
+            endId: {
+              type: "string",
+              description: "mNNNNN ref at the end of the range"
+            },
+            summary: {
+              type: "string",
+              description: "Self-contained summary replacing the range"
+            }
+          },
+          required: ["startId", "endId", "summary"]
+        }
+      }
+    },
+    required: ["content"]
+  }
+};
+var COMPRESS_TOOL_OPENAI = {
+  type: "function",
+  function: {
+    name: COMPRESS_TOOL_NAME,
+    description: COMPRESS_TOOL.description,
+    parameters: {
+      type: "object",
+      properties: {
+        topic: {
+          type: "string",
+          description: "Optional short title for the compressed range"
+        },
+        content: {
+          type: "array",
+          description: "One or more ranges to compress into separate summary blocks. REQUIRED \u2014 compress without content is invalid.",
+          items: {
+            type: "object",
+            properties: {
+              topic: { type: "string" },
+              startId: {
+                type: "string",
+                description: "mNNNNN ref at the start of the range"
+              },
+              endId: {
+                type: "string",
+                description: "mNNNNN ref at the end of the range"
+              },
+              summary: {
+                type: "string",
+                description: "Self-contained summary replacing the range"
+              }
+            },
+            required: ["startId", "endId", "summary"]
+          }
+        }
+      },
+      required: ["content"]
+    }
+  }
+};
+var DECOMPRESS_TOOL_OPENAI = {
+  type: "function",
+  function: {
+    name: DECOMPRESS_TOOL_NAME,
+    description: "Restores previously compressed content. Use when you need exact details lost in compression. By default restores one tier up. Use full:true for all the way to original messages. Use toFile to write to file instead of inflating context.",
+    parameters: {
+      type: "object",
+      properties: {
+        blockId: {
+          type: "string",
+          description: "Block ID to decompress (e.g. b5)"
+        },
+        toFile: {
+          type: "string",
+          description: "Optional: write content to file instead of context"
+        },
+        full: {
+          type: "boolean",
+          description: "Restore all the way to original messages"
+        }
+      },
+      required: ["blockId"]
+    }
+  }
+};
+var SEARCH_CONTEXT_TOOL_OPENAI = {
+  type: "function",
+  function: {
+    name: SEARCH_CONTEXT_TOOL_NAME,
+    description: "Search through compressed block summaries by keyword. Use BEFORE decompressing to find the right block.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search query" },
+        limit: { type: "number", description: "Max results (default 5)" }
+      },
+      required: ["query"]
+    }
+  }
+};
+var ACP_STATUS_TOOL_OPENAI = {
+  type: "function",
+  function: {
+    name: ACP_STATUS_TOOL_NAME,
+    description: "Show context usage and compressible ranges. No args = overview. Use to find what to compress next.",
+    parameters: {
+      type: "object",
+      properties: {}
+    }
+  }
+};
+var DECOMPRESS_TOOL = {
+  name: DECOMPRESS_TOOL_NAME,
+  description: DECOMPRESS_TOOL_OPENAI.function.description,
+  input_schema: DECOMPRESS_TOOL_OPENAI.function.parameters
+};
+var SEARCH_CONTEXT_TOOL = {
+  name: SEARCH_CONTEXT_TOOL_NAME,
+  description: SEARCH_CONTEXT_TOOL_OPENAI.function.description,
+  input_schema: SEARCH_CONTEXT_TOOL_OPENAI.function.parameters
+};
+var ACP_STATUS_TOOL = {
+  name: ACP_STATUS_TOOL_NAME,
+  description: ACP_STATUS_TOOL_OPENAI.function.description,
+  input_schema: ACP_STATUS_TOOL_OPENAI.function.parameters
+};
+var COMPRESS_TOOL_RESPONSES = {
+  type: "function",
+  name: COMPRESS_TOOL_NAME,
+  description: COMPRESS_TOOL.description,
+  parameters: COMPRESS_TOOL_OPENAI.function.parameters
+};
+var DECOMPRESS_TOOL_RESPONSES = {
+  type: "function",
+  name: DECOMPRESS_TOOL_OPENAI.function.name,
+  description: DECOMPRESS_TOOL_OPENAI.function.description,
+  parameters: DECOMPRESS_TOOL_OPENAI.function.parameters
+};
+var SEARCH_CONTEXT_TOOL_RESPONSES = {
+  type: "function",
+  name: SEARCH_CONTEXT_TOOL_OPENAI.function.name,
+  description: SEARCH_CONTEXT_TOOL_OPENAI.function.description,
+  parameters: SEARCH_CONTEXT_TOOL_OPENAI.function.parameters
+};
+var ACP_STATUS_TOOL_RESPONSES = {
+  type: "function",
+  name: ACP_STATUS_TOOL_OPENAI.function.name,
+  description: ACP_STATUS_TOOL_OPENAI.function.description,
+  parameters: ACP_STATUS_TOOL_OPENAI.function.parameters
+};
+var ACP_TOOL_NAMES = /* @__PURE__ */ new Set([
+  COMPRESS_TOOL_NAME,
+  DECOMPRESS_TOOL_NAME,
+  SEARCH_CONTEXT_TOOL_NAME,
+  ACP_STATUS_TOOL_NAME
+]);
+var ALWAYS_PROTECTED_TOOLS = ["compress"];
+var NEVER_PRESERVE_RECENT_TOOLS = [
+  "decompress",
+  "search_context",
+  "read",
+  "bash"
+];
+function isNeverPreserveRecent(msg) {
+  if (msg.contentType !== "tool-call" && msg.contentType !== "tool-result") {
+    return false;
+  }
+  if (!msg.toolName) return false;
+  return NEVER_PRESERVE_RECENT_TOOLS.includes(msg.toolName);
+}
+function matchToolPattern(toolName, pattern) {
+  if (pattern.endsWith("*")) {
+    return toolName.startsWith(pattern.slice(0, -1));
+  }
+  return toolName === pattern;
+}
+function isMessageProtected(msg, config) {
+  if (msg.contentType !== "tool-call" && msg.contentType !== "tool-result" || !msg.toolName) {
+    return false;
+  }
+  if (ALWAYS_PROTECTED_TOOLS.includes(msg.toolName)) {
+    return true;
+  }
+  for (const pattern of config.protectedTools) {
+    if (matchToolPattern(msg.toolName, pattern)) return true;
+  }
+  if (config.isToolProtected?.(msg.toolName, msg.text)) return true;
+  return false;
+}
+function collectProtectedToolCallIds(messages, config) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const m of messages) {
+    if (m.contentType === "tool-call" && m.toolCallId && isMessageProtected(m, config)) {
+      ids.add(m.toolCallId);
+    }
+  }
+  return ids;
+}
+function isMessageProtectedWithPairing(msg, config, protectedCallIds) {
+  if (isMessageProtected(msg, config)) return true;
+  if (msg.contentType === "tool-result" && msg.toolCallId && protectedCallIds.has(msg.toolCallId)) {
+    return true;
+  }
+  return false;
+}
+var ABSORB_PROMPT_MARKER = "[ACP absorb]";
+var DEFAULT_ABSORB_CONFIG = {
+  enabled: false,
+  toolName: ABSORB_TOOL_NAME,
+  minToolTokens: 1e3,
+  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 isAcpOrConfiguredTool(toolName, cfg) {
+  if (!toolName) return false;
+  if (toolName === cfg.toolName) return true;
+  return ACP_TOOL_NAMES.has(toolName);
+}
+function isAbsorbCandidate(msg, config) {
+  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;
+  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 out = messages.map((msg) => {
+    if (!isAbsorbCandidate(msg, config)) 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 };
+}
 var registry = /* @__PURE__ */ new Map();
 function listMessageFilters() {
   return [...registry.values()];
@@ -1205,55 +1526,6 @@ function createRenderRefsNode(strategy) {
   };
 }
 var renderRefsNode = createRenderRefsNode("all");
-var ALWAYS_PROTECTED_TOOLS = ["compress"];
-var NEVER_PRESERVE_RECENT_TOOLS = [
-  "decompress",
-  "search_context",
-  "read",
-  "bash"
-];
-function isNeverPreserveRecent(msg) {
-  if (msg.contentType !== "tool-call" && msg.contentType !== "tool-result") {
-    return false;
-  }
-  if (!msg.toolName) return false;
-  return NEVER_PRESERVE_RECENT_TOOLS.includes(msg.toolName);
-}
-function matchToolPattern(toolName, pattern) {
-  if (pattern.endsWith("*")) {
-    return toolName.startsWith(pattern.slice(0, -1));
-  }
-  return toolName === pattern;
-}
-function isMessageProtected(msg, config) {
-  if (msg.contentType !== "tool-call" && msg.contentType !== "tool-result" || !msg.toolName) {
-    return false;
-  }
-  if (ALWAYS_PROTECTED_TOOLS.includes(msg.toolName)) {
-    return true;
-  }
-  for (const pattern of config.protectedTools) {
-    if (matchToolPattern(msg.toolName, pattern)) return true;
-  }
-  if (config.isToolProtected?.(msg.toolName, msg.text)) return true;
-  return false;
-}
-function collectProtectedToolCallIds(messages, config) {
-  const ids = /* @__PURE__ */ new Set();
-  for (const m of messages) {
-    if (m.contentType === "tool-call" && m.toolCallId && isMessageProtected(m, config)) {
-      ids.add(m.toolCallId);
-    }
-  }
-  return ids;
-}
-function isMessageProtectedWithPairing(msg, config, protectedCallIds) {
-  if (isMessageProtected(msg, config)) return true;
-  if (msg.contentType === "tool-result" && msg.toolCallId && protectedCallIds.has(msg.toolCallId)) {
-    return true;
-  }
-  return false;
-}
 function adjustBoundariesForToolPairs(startIndex, endIndex, messages, maxScan = 20) {
   const callIdsInRange = /* @__PURE__ */ new Set();
   for (let i = startIndex; i <= endIndex; i++) {
@@ -1628,7 +1900,7 @@ function createCore(ports = {}) {
       if (!hasBlockBoundaryRange && totalRangeChars < input.config.compress.minCompressRange) {
         const live = activeBlocks(state).map((b) => b.blockId).sort((x, y) => numericBlockId(x) - numericBlockId(y));
         const liveHint = live.length > 0 ? ` Current active blocks span ${live[0]}..${live[live.length - 1]} \u2014 retry with startId/endId set to active block IDs in that span.` : "";
-        const gateMessage = resolvableCount === 0 && consumedRanges.length === 0 && unknownCount > 0 ? `None of the ${input.ranges.length} requested range(s) resolved \u2014 every ref failed with "does not exist in this session". Refs recorded before an earlier compress are stale: each successful compress renumbers the remaining refs. Run acp_status, then re-issue the compress in the same turn using only the refs it reports.` : consumedRanges.length > 0 ? `Requested range(s) already compressed (e.g. ${consumedRanges[0].startRef}..${consumedRanges[0].endRef}); remaining compressible content ${totalRangeChars} chars < min ${input.config.compress.minCompressRange}. Nothing to do.${liveHint}` : `Total compressible content too small (${totalRangeChars} chars across ${countedRanges} range(s), min ${input.config.compress.minCompressRange}). Combine more messages into your range(s) to meet the threshold.`;
+        const gateMessage = resolvableCount === 0 && consumedRanges.length === 0 && unknownCount > 0 ? `None of the ${input.ranges.length} requested range(s) resolved \u2014 every ref failed with "does not exist in this session". Refs recorded before an earlier compress are stale: each successful compress renumbers the remaining refs. Run acp_status, then call the compress tool again using only the refs it reports.` : consumedRanges.length > 0 ? `Requested range(s) already compressed (e.g. ${consumedRanges[0].startRef}..${consumedRanges[0].endRef}) \u2014 your refs are stale: a prior compress renumbered the remaining refs, so this range now falls inside an active block. Run acp_status, then call the compress tool again using only the CURRENT compressible ranges it reports.${liveHint}` : `Total compressible content too small (${totalRangeChars} chars across ${countedRanges} range(s), min ${input.config.compress.minCompressRange}). Combine more messages into your range(s) to meet the threshold.`;
         return {
           state: input.state,
           result: {
@@ -1746,6 +2018,8 @@ function createCore(ports = {}) {
       assignRefsNode,
       syncBlocksNode,
       pruneNode,
+      absorbHideNode,
+      absorbPromptNode,
       filterNode,
       hideCompressCallsNode,
       recommendNode,
@@ -1791,6 +2065,31 @@ var pruneNode = {
     return { ...io, messages: prune(io.messages, io.state) };
   }
 };
+var absorbHideNode = {
+  name: "absorb-hide",
+  enabled: (io) => (io.state.absorbed?.length ?? 0) > 0,
+  run(io) {
+    return { ...io, messages: hideAbsorbedMessages(io.messages, io.state) };
+  }
+};
+var absorbPromptNode = {
+  name: "absorb-prompt",
+  enabled: (_io, ctx) => ctx.config.absorb?.enabled === true,
+  run(io, ctx) {
+    const applied = appendAbsorbPrompts(
+      io.messages,
+      io.state,
+      ctx.config,
+      ctx.tokenCount,
+      ctx.countTokens
+    );
+    return {
+      ...io,
+      messages: applied.messages,
+      effects: { ...io.effects, absorbPromptedCount: applied.promptedCount }
+    };
+  }
+};
 var filterNode = {
   name: "filter",
   enabled: (_io, ctx) => !!ctx.config.messageFilters?.enabled && listMessageFilters().length > 0,
@@ -2328,6 +2627,7 @@ function cloneState(state) {
     tokenSnapshot: { ...state.tokenSnapshot ?? {} },
     nudge: { ...state.nudge, anchors: { ...state.nudge.anchors } },
     stats: { ...state.stats },
+    absorbed: (state.absorbed ?? []).map((record) => ({ ...record })),
     nextBlockId: state.nextBlockId,
     nextRunId: state.nextRunId
   };
@@ -2544,14 +2844,14 @@ function renderUncompressedRanges(visible) {
   };
   const merged = [];
   for (const m of visible) {
-    const num = refNum2(m.ref);
+    const num2 = refNum2(m.ref);
     const last = merged[merged.length - 1];
-    if (last && num === last.startNum + last.count) {
+    if (last && num2 === last.startNum + last.count) {
       last.endRef = m.ref;
       last.count += 1;
       last.tokens += m.tokens;
     } else {
-      merged.push({ startRef: m.ref, endRef: m.ref, startNum: num, count: 1, tokens: m.tokens, tool: m.tool });
+      merged.push({ startRef: m.ref, endRef: m.ref, startNum: num2, count: 1, tokens: m.tokens, tool: m.tool });
     }
   }
   for (const r of merged.slice(0, 30)) {
@@ -2618,6 +2918,296 @@ function renderCompressedDrilldown(blocks, state, sort, limit, countTokens) {
   }
   return lines.join("\n");
 }
+function parseCompressArgs(input, opts) {
+  const callId = opts?.callId;
+  const diag = { ok: false, kind: "ok", invalidItems: 0 };
+  if (input === null || input === void 0) {
+    diag.kind = "empty-input";
+    return finish([], diag);
+  }
+  if (typeof input === "string") {
+    return parseStringInput(input, callId, diag);
+  }
+  if (typeof input !== "object" || Array.isArray(input)) {
+    diag.kind = "not-object";
+    return finish([], diag);
+  }
+  return parseObjectValue(input, callId, diag);
+}
+function parseStringInput(raw, callId, diag) {
+  diag.rawPrefix = raw.slice(0, 800);
+  diag.length = raw.length;
+  const cleaned = stripFence(raw.trim());
+  if (cleaned === "") {
+    diag.kind = "empty-input";
+    return finish([], diag);
+  }
+  let value = tryParseLenient(cleaned);
+  if (typeof value === "string") {
+    const inner = tryParseLenient(stripFence(value));
+    if (inner !== void 0) value = inner;
+  }
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    return parseObjectValue(value, callId, diag);
+  }
+  if (value !== void 0) {
+    diag.kind = "not-object";
+    return finish([], diag);
+  }
+  const entries = salvageContentEntries(cleaned);
+  return finishSalvage(entries, callId, diag, looksTruncated(cleaned));
+}
+function parseObjectValue(value, callId, diag) {
+  diag.keys = Object.keys(value);
+  const content = value["content"];
+  if (content === void 0) {
+    const single = validateEntry(value, callId);
+    if (single) {
+      diag.kind = "ok";
+      return finish([single], diag);
+    }
+    diag.kind = "missing-content";
+    return finish([], diag);
+  }
+  let entries;
+  let salvaged = false;
+  if (Array.isArray(content)) {
+    entries = content;
+  } else if (typeof content === "string") {
+    const parsed = parseContentArray(content);
+    if (parsed === null) {
+      diag.kind = "content-not-array";
+      return finish([], diag);
+    }
+    entries = parsed.entries;
+    salvaged = parsed.salvaged;
+  } else {
+    diag.kind = "content-not-array";
+    return finish([], diag);
+  }
+  const { ranges, invalid } = validateEntries(entries, callId);
+  const topTopic = stringOr(value["topic"]);
+  const topMaxChars = value["summaryMaxChars"];
+  const hasTopMaxChars = typeof topMaxChars === "number" && Number.isFinite(topMaxChars);
+  if (topTopic !== void 0 || hasTopMaxChars) {
+    for (const r of ranges) {
+      if (r.topic === void 0 && topTopic !== void 0) r.topic = topTopic;
+      if (r.summaryMaxChars === void 0 && hasTopMaxChars) r.summaryMaxChars = topMaxChars;
+    }
+  }
+  diag.invalidItems = invalid;
+  diag.kind = salvaged ? "truncated" : ranges.length > 0 ? "ok" : "no-valid-ranges";
+  return finish(ranges, diag);
+}
+function parseContentArray(s) {
+  const cleaned = stripFence(s.trim());
+  let value = cleaned === "" ? void 0 : tryParseLenient(cleaned);
+  if (typeof value === "string") {
+    value = tryParseLenient(stripFence(value));
+  }
+  if (Array.isArray(value)) {
+    return { entries: value, salvaged: false };
+  }
+  if (value === void 0) {
+    const entries = salvageContentEntries('{"content": ' + cleaned);
+    return { entries, salvaged: entries.length > 0 };
+  }
+  return null;
+}
+function finish(ranges, diag) {
+  diag.ok = ranges.length > 0;
+  return { ranges, diagnostics: diag };
+}
+function finishSalvage(entries, callId, diag, truncatedShape) {
+  const { ranges, invalid } = validateEntries(entries, callId);
+  diag.invalidItems = invalid;
+  diag.kind = entries.length > 0 || truncatedShape ? "truncated" : "malformed-json";
+  return finish(ranges, diag);
+}
+function validateEntries(entries, callId) {
+  const ranges = [];
+  let invalid = 0;
+  for (const entry of entries) {
+    const range = validateEntry(entry, callId);
+    if (range !== null) ranges.push(range);
+    else invalid++;
+  }
+  return { ranges, invalid };
+}
+function validateEntry(entry, callId) {
+  if (entry === null || typeof entry !== "object" || Array.isArray(entry)) return null;
+  const e = entry;
+  const start = stringOr(e["startRef"]) ?? stringOr(e["startId"]) ?? stringOr(e["messageId"]);
+  const end = stringOr(e["endRef"]) ?? stringOr(e["endId"]) ?? stringOr(e["messageId"]);
+  if (start === void 0 || end === void 0) return null;
+  const summary = stringOr(e["summary"]);
+  if (summary === void 0) return null;
+  const range = { startRef: start, endRef: end, summary };
+  const topic = stringOr(e["topic"]);
+  if (topic !== void 0) range.topic = topic;
+  const maxChars = e["summaryMaxChars"];
+  if (typeof maxChars === "number" && Number.isFinite(maxChars)) range.summaryMaxChars = maxChars;
+  if (callId !== void 0) range.compressCallId = callId;
+  return range;
+}
+function stringOr(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function tryParseLenient(s) {
+  if (s === "") return void 0;
+  try {
+    return JSON.parse(s);
+  } catch {
+  }
+  const noTrailingCommas = stripTrailingCommas(s);
+  if (noTrailingCommas !== s) {
+    try {
+      return JSON.parse(noTrailingCommas);
+    } catch {
+    }
+  }
+  const fixed = escapeRawNewlinesInStrings(noTrailingCommas);
+  if (fixed !== noTrailingCommas) {
+    try {
+      return JSON.parse(fixed);
+    } catch {
+    }
+  }
+  return void 0;
+}
+function stripFence(s) {
+  if (!s.startsWith("```")) return s;
+  const firstNewline = s.indexOf("\n");
+  if (firstNewline === -1) return s;
+  const bodyStart = firstNewline + 1;
+  const end = s.lastIndexOf("```");
+  return end > bodyStart ? s.slice(bodyStart, end).trim() : s.slice(bodyStart).trim();
+}
+function stripTrailingCommas(s) {
+  let out = "";
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s.charAt(i);
+    if (inString) {
+      out += ch;
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      out += ch;
+      continue;
+    }
+    if (ch === ",") {
+      let j = i + 1;
+      while (j < s.length && (s.charAt(j) === " " || s.charAt(j) === "	" || s.charAt(j) === "\n" || s.charAt(j) === "\r")) j++;
+      if (j < s.length && (s.charAt(j) === "}" || s.charAt(j) === "]")) continue;
+    }
+    out += ch;
+  }
+  return out;
+}
+function escapeRawNewlinesInStrings(s) {
+  let out = "";
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s.charAt(i);
+    if (!inString) {
+      if (ch === '"') inString = true;
+      out += ch;
+      continue;
+    }
+    if (escaped) {
+      out += ch;
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\") {
+      out += ch;
+      escaped = true;
+      continue;
+    }
+    if (ch === "\n") {
+      out += "\\n";
+      continue;
+    }
+    if (ch === "\r") {
+      out += "\\r";
+      continue;
+    }
+    if (ch === "	") {
+      out += "\\t";
+      continue;
+    }
+    if (ch === '"') inString = false;
+    out += ch;
+  }
+  return out;
+}
+function looksTruncated(s) {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s.charAt(i);
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "{" || ch === "[") depth++;
+    else if (ch === "}" || ch === "]") depth--;
+  }
+  return depth > 0 || inString;
+}
+function salvageContentEntries(raw) {
+  const match = /"content"\s*:\s*\[/.exec(raw);
+  if (match === null) return [];
+  const arrayStart = match.index + match[0].length - 1;
+  const entries = [];
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  let entryStart = -1;
+  for (let i = arrayStart + 1; i < raw.length; i++) {
+    const ch = raw.charAt(i);
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "{" || ch === "[") {
+      if (depth === 0 && ch === "{" && entryStart === -1) entryStart = i;
+      depth++;
+      continue;
+    }
+    if (ch === "}" || ch === "]") {
+      depth--;
+      if (depth < 0) break;
+      if (depth === 0 && entryStart !== -1) {
+        const entrySlice = raw.slice(entryStart, i + 1);
+        entryStart = -1;
+        const parsed = tryParseLenient(entrySlice);
+        if (parsed !== void 0) entries.push(parsed);
+      }
+    }
+  }
+  return entries;
+}
 function stem(word) {
   let w = word;
   if (w.length <= 3) return w;
@@ -4017,6 +4607,7 @@ function pruneOrphanRefs(state, messages) {
   }
 }
 var MAX_COMPRESS_ATTEMPTS = 3;
+var MAX_RETRY_PROMPT_FIRES = 5;
 function createRuntime(adapter) {
   const density = new DensityEstimator();
   let countModelId = "default";
@@ -4061,33 +4652,52 @@ function createRuntime(adapter) {
   const compressOutcomeSeen = /* @__PURE__ */ new Set();
   let compressFailTurnKey = null;
   let compressFailCount = 0;
+  let retryPromptFires = 0;
+  let retryExhaustedNotified = false;
   function noteCompressOutcomes(turnKey, outcomes) {
     if (compressFailTurnKey !== turnKey) {
       compressFailTurnKey = turnKey;
       compressFailCount = 0;
+      retryPromptFires = 0;
+      retryExhaustedNotified = false;
     }
     const prevCount = compressFailCount;
+    let sawNewOutcome = false;
     for (const o of outcomes) {
       if (compressOutcomeSeen.has(o.toolCallId)) continue;
       compressOutcomeSeen.add(o.toolCallId);
+      sawNewOutcome = true;
       if (o.isError || o.noop === true) {
         compressFailCount += 1;
       } else if (o.success) {
         compressFailCount = 0;
       }
     }
+    if (sawNewOutcome) {
+      retryPromptFires = 0;
+      retryExhaustedNotified = false;
+    }
     const latest = outcomes.length > 0 ? outcomes[outcomes.length - 1] : void 0;
-    const retryFor = latest && (latest.isError || latest.noop === true) && compressFailCount >= 1 && compressFailCount < MAX_COMPRESS_ATTEMPTS ? latest.toolCallId : null;
+    const latestFailed = latest !== void 0 && (latest.isError || latest.noop === true);
+    const retryFor = latestFailed && compressFailCount >= 1 && compressFailCount < MAX_COMPRESS_ATTEMPTS && retryPromptFires < MAX_RETRY_PROMPT_FIRES ? latest.toolCallId : null;
+    if (retryFor !== null) retryPromptFires += 1;
     const cappedNow = compressFailCount >= MAX_COMPRESS_ATTEMPTS && prevCount < MAX_COMPRESS_ATTEMPTS;
-    return { count: compressFailCount, retryFor, cappedNow };
+    const exhaustedNow = retryFor === null && latestFailed && compressFailCount >= 1 && compressFailCount < MAX_COMPRESS_ATTEMPTS && retryPromptFires >= MAX_RETRY_PROMPT_FIRES && !retryExhaustedNotified;
+    if (exhaustedNow) retryExhaustedNotified = true;
+    return { count: compressFailCount, retryFor, cappedNow, exhaustedNow, fires: retryPromptFires };
   }
   function compressRetryCappedFor(turnKey) {
     return compressFailTurnKey === turnKey && compressFailCount >= MAX_COMPRESS_ATTEMPTS;
   }
+  function compressRetryExhaustedFor(turnKey) {
+    return compressFailTurnKey === turnKey && compressFailCount >= 1 && compressFailCount < MAX_COMPRESS_ATTEMPTS && retryPromptFires >= MAX_RETRY_PROMPT_FIRES;
+  }
   function clearCompressRetryTracking() {
     compressOutcomeSeen.clear();
     compressFailTurnKey = null;
     compressFailCount = 0;
+    retryPromptFires = 0;
+    retryExhaustedNotified = false;
   }
   async function acquireLock(sid) {
     const prev = locks.get(sid) ?? Promise.resolve();
@@ -4176,7 +4786,7 @@ function createRuntime(adapter) {
     nudgeShownTurns.add(k);
   }, nudgeShownFor: (k) => nudgeShownTurns.has(k), clearNudgeTracking: () => {
     nudgeShownTurns.clear();
-  }, noteCompressOutcomes, compressRetryCappedFor, clearCompressRetryTracking, liveContextLimit, configFor, reloadConfig, stateFor, save, acquireLock, overflowFor, overflowDrop, throttleFor, throttleDrop };
+  }, noteCompressOutcomes, compressRetryCappedFor, compressRetryExhaustedFor, clearCompressRetryTracking, liveContextLimit, configFor, reloadConfig, stateFor, save, acquireLock, overflowFor, overflowDrop, throttleFor, throttleDrop };
 }
 
 // node_modules/typebox/build/system/memory/memory.mjs
@@ -8668,25 +9278,24 @@ function makeCompressTool(runtime) {
     }
   };
 }
-function normalizeRanges(content) {
-  let ranges = content ?? [];
-  if (typeof ranges === "string") {
-    try {
-      ranges = JSON.parse(ranges);
-    } catch (e) {
-      return `Invalid content: not valid JSON (${e instanceof Error ? e.message : String(e)}). content must be an ARRAY of {startId, endId, summary} objects \u2014 pass the array directly, not a string.`;
-    }
+function normalizeRanges(args) {
+  const { ranges, diagnostics } = parseCompressArgs(args);
+  if (ranges.length === 0) {
+    if (Array.isArray(args.content) && args.content.length === 0) return [];
+    return describeDiagnostics(diagnostics, args.content);
   }
-  if (!Array.isArray(ranges)) {
-    return `Invalid content: expected an array of ranges, got ${ranges === null ? "null" : typeof ranges}.`;
+  return ranges.map((r) => ({ startId: r.startRef, endId: r.endRef, summary: r.summary, topic: r.topic }));
+}
+function describeDiagnostics(diagnostics, content) {
+  const shape = typeof content === "string" ? "a JSON-encoded string (non-strict-tool providers stringify array arguments)" : content === null ? "null" : `a ${typeof content}`;
+  const base = `Invalid compress content (${diagnostics.kind}): got ${shape}`;
+  if (diagnostics.kind === "truncated") {
+    return `${base}; the input was truncated and no complete ranges could be recovered. Shorten the summary or split into smaller ranges.`;
   }
-  for (const [i, r] of ranges.entries()) {
-    const o = r;
-    if (!o || typeof o !== "object" || typeof o.startId !== "string" || typeof o.endId !== "string" || typeof o.summary !== "string") {
-      return `Invalid content[${i}]: each range must be an object with string fields startId, endId, summary.`;
-    }
+  if (diagnostics.invalidItems > 0) {
+    return `${base}; ${diagnostics.invalidItems} entr${diagnostics.invalidItems === 1 ? "y was" : "ies were"} dropped as invalid. Each range must be an object with string fields startId, endId, summary.`;
   }
-  return ranges;
+  return `${base}. content must be an ARRAY of {startId, endId, summary} objects.`;
 }
 function compressPanelBlocks(text) {
   if (!text.trimStart().startsWith("\u25A3 ACP |")) return -1;
@@ -8713,7 +9322,7 @@ function tier3OnlyRewrite(newBlocks, allBlocks) {
   return spans;
 }
 async function handleCompress(args, runtime, ctx, toolCallId) {
-  const maybeRanges = normalizeRanges(args.content);
+  const maybeRanges = normalizeRanges(args);
   if (typeof maybeRanges === "string") throw new Error(maybeRanges);
   const ranges = maybeRanges;
   if (ranges.length === 0) return "No ranges provided.";
@@ -9923,7 +10532,7 @@ function makeDelegateWaitTool(_pi) {
       return new Promise((resolve3) => {
         let settled = false;
         let timer2;
-        const finish = (result) => {
+        const finish2 = (result) => {
           if (settled) return;
           settled = true;
           run.waiter = void 0;
@@ -9932,19 +10541,19 @@ function makeDelegateWaitTool(_pi) {
           resolve3(result);
         };
         const onAbort = () => {
-          finish({ details: void 0, content: [{ type: "text", text: `Aborted; delegate \`${args.runId}\` is still running in the background. A notification will be injected when it finishes.` }] });
+          finish2({ details: void 0, content: [{ type: "text", text: `Aborted; delegate \`${args.runId}\` is still running in the background. A notification will be injected when it finishes.` }] });
         };
         run.waiter = () => {
           run.consumed = true;
           if (run.status === "cancelled") {
-            finish(buildWaitResult(run, `Delegate \`${run.runId}\` was cancelled (no result).${remainingLineForWait(run.runId)}`, displayMode));
+            finish2(buildWaitResult(run, `Delegate \`${run.runId}\` was cancelled (no result).${remainingLineForWait(run.runId)}`, displayMode));
             return;
           }
-          finish(buildWaitResult(run, formatRunResult(run), displayMode));
+          finish2(buildWaitResult(run, formatRunResult(run), displayMode));
         };
         signal?.addEventListener("abort", onAbort);
         timer2 = setTimeout(
-          () => finish({ details: void 0, content: [{ type: "text", text: `Failed: delegate \`${args.runId}\` result not ready after ${Math.round(timeoutMs / 1e3)}s. Do NOT keep waiting or retry \u2014 go do other work now. The run continues in the background and a completion notification (with the result file path) will be injected into the chat when it finishes.` }] }),
+          () => finish2({ details: void 0, content: [{ type: "text", text: `Failed: delegate \`${args.runId}\` result not ready after ${Math.round(timeoutMs / 1e3)}s. Do NOT keep waiting or retry \u2014 go do other work now. The run continues in the background and a completion notification (with the result file path) will be injected into the chat when it finishes.` }] }),
           timeoutMs
         );
       });
@@ -10222,20 +10831,20 @@ function waitForChild(child, signal) {
     });
     const timer2 = setTimeout(() => {
       child.kill("SIGTERM");
-      finish({ code: null, stdout: "", stderr: stderrText, timedOut: true });
+      finish2({ code: null, stdout: "", stderr: stderrText, timedOut: true });
     }, SYNC_TIMEOUT_MS);
     const onAbort = () => {
       clearTimeout(timer2);
       child.kill("SIGTERM");
     };
     signal?.addEventListener("abort", onAbort, { once: true });
-    function finish(r) {
+    function finish2(r) {
       clearTimeout(timer2);
       signal?.removeEventListener("abort", onAbort);
       resolve3(r);
     }
     child.on("close", (code) => {
-      finish({
+      finish2({
         code,
         stdout: Buffer.concat(stdoutChunks).toString("utf8").trim(),
         stderr: stderrText,
@@ -10243,7 +10852,7 @@ function waitForChild(child, signal) {
       });
     });
     child.on("error", (err) => {
-      finish({ code: null, stdout: "", stderr: err.message, timedOut: false });
+      finish2({ code: null, stdout: "", stderr: err.message, timedOut: false });
     });
   });
 }
@@ -10448,6 +11057,37 @@ function formatCompactTokens2(count) {
   if (count < 1e7) return `${(count / 1e6).toFixed(1)}M`;
   return `${Math.round(count / 1e6)}M`;
 }
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0;
+}
+function cacheHitStats(usages) {
+  let cacheRead = 0;
+  let billedPrompt = 0;
+  let requests = 0;
+  let last;
+  for (const u of usages) {
+    const read = num(u?.cacheRead);
+    const write = num(u?.cacheWrite);
+    const input = num(u?.input);
+    if (read + write <= 0) continue;
+    const total = read + write + input;
+    if (total <= 0) continue;
+    cacheRead += read;
+    billedPrompt += total;
+    requests += 1;
+    last = read / total;
+  }
+  return {
+    session: requests > 0 ? cacheRead / billedPrompt : void 0,
+    last,
+    requests,
+    cacheRead,
+    billedPrompt
+  };
+}
+function formatHitRate(rate) {
+  return `${(Math.max(0, Math.min(1, rate)) * 100).toFixed(1)}%`;
+}
 function bar(value, total, width = 20) {
   if (total === 0) return "";
   const filled = Math.max(0, Math.min(width, Math.round(value / total * width)));
@@ -10500,6 +11140,15 @@ function buildStatusPanel(input) {
       lines.push(`  ${cat.label.padEnd(10)} ${b} ${String(pct2).padStart(3)}%  ${fmt2(cat.value)}`);
     }
   }
+  if (input.cacheUsages) {
+    const cache2 = cacheHitStats(input.cacheUsages);
+    if (cache2.requests > 0 && cache2.session !== void 0 && cache2.last !== void 0) {
+      lines.push("");
+      lines.push(
+        `Prompt cache (provider-reported): ${formatHitRate(cache2.last)} last \xB7 ${formatHitRate(cache2.session)} session avg \u2014 ${fmt2(cache2.cacheRead)} of ${fmt2(cache2.billedPrompt)} billed prompt tokens served from cache (${cache2.requests} req)`
+      );
+    }
+  }
   lines.push("");
   if (nudge) {
     if (nudge.shouldInject) {
@@ -10730,6 +11379,16 @@ function ensureSubagentAcpTools(settingsPath, options) {
 }
 
 // src/commands.ts
+function cacheUsageSamples(entries) {
+  const out = [];
+  for (const e of entries) {
+    if (e.type !== "message") continue;
+    const m = e.message;
+    if (m?.role !== "assistant" || !m.usage) continue;
+    out.push({ input: m.usage.input ?? 0, cacheRead: m.usage.cacheRead ?? 0, cacheWrite: m.usage.cacheWrite ?? 0 });
+  }
+  return out;
+}
 function makeCommands(runtime) {
   return [
     {
@@ -10816,7 +11475,7 @@ ${text}`);
   ];
 }
 async function statusReport(runtime, ctx) {
-  const { state, coreMessages } = await runtime.stateFor(ctx);
+  const { state, coreMessages, entries } = await runtime.stateFor(ctx);
   const config = runtime.configFor(ctx);
   const realUsage = ctx.getContextUsage?.();
   const systemPromptText = getSystemPromptText(ctx);
@@ -10826,7 +11485,7 @@ async function statusReport(runtime, ctx) {
   const modelId = ctx.model?.id ?? "default";
   const sentTokens = estimateTokens(coreMessages, coveredIds) + systemPromptTokens;
   const turn = runtime.core.processTurn({ messages: coreMessages, state, config, tokenCount: calibrateTokens(sentTokens, runtime.density.densityFor(modelId)) });
-  const versionStr = "0.1.46" ? `billion-context-pi@${"0.1.46"}` : void 0;
+  const versionStr = "0.1.47" ? `billion-context-pi@${"0.1.47"}` : void 0;
   let text = buildStatusPanel({
     version: versionStr,
     tokenCount: sessionTokens,
@@ -10834,7 +11493,8 @@ async function statusReport(runtime, ctx) {
     state: turn.state,
     nudge: turn.nudge,
     modelContextLimit: config.modelContextLimit,
-    unprunedTokens: coreMessages.reduce((sum, m) => sum + defaultCountTokens(m.text ?? ""), 0)
+    unprunedTokens: coreMessages.reduce((sum, m) => sum + defaultCountTokens(m.text ?? ""), 0),
+    cacheUsages: cacheUsageSamples(entries ?? [])
   });
   const delegateUsage = getDelegateUsage();
   if (delegateUsage && delegateUsage.totalTokens > 0) {
@@ -11025,14 +11685,12 @@ function wireToolGuardrails(pi, runtime) {
     const fullPath = isBash ? event.details?.fullOutputPath : void 0;
     const timeoutSecs = isBash && event.isError ? detectBashTimeout(event.content) : void 0;
     let modified;
-    const max = runtime.adapter.toolOutputMaxBytes;
-    if (max !== void 0 && max > 0) {
-      const next = capToolOutput(event.content, max, fullPath);
-      if (next) {
-        modified = next;
-        debug.event("guardrail-output-cap", { max, hadPath: !!fullPath });
-        logWarn("guardrail", { event: "output-cap", max, hadPath: !!fullPath });
-      }
+    const max = runtime.adapter.toolOutputMaxBytes ?? DEFAULT_TOOL_OUTPUT_MAX_BYTES;
+    const next = capToolOutput(event.content, max, fullPath);
+    if (next) {
+      modified = next;
+      debug.event("guardrail-output-cap", { max, hadPath: !!fullPath });
+      logWarn("guardrail", { event: "output-cap", max, hadPath: !!fullPath });
     }
     if (timeoutSecs !== void 0) {
       modified = appendTimeoutNotice(modified ?? event.content, timeoutSecs);
@@ -11188,7 +11846,7 @@ async function autoInstallLatest(latest, extDirOverride) {
       "--no-fund",
       "--no-save"
     ];
-    const prevVersion = (await readPackageJson(join8(extDir, "package.json")))?.version ?? "0.1.46";
+    const prevVersion = (await readPackageJson(join8(extDir, "package.json")))?.version ?? "0.1.47";
     const { code, stderr } = await runNpmImpl(installArgs(latest), { cwd: npmDir, timeout: 6e4 });
     if (code !== 0) {
       logWarn("update", {
@@ -11201,7 +11859,7 @@ async function autoInstallLatest(latest, extDirOverride) {
     }
     const verify = await verifyInstall(npmDir, latest);
     if (!verify.ok) {
-      const rollbackTo = SEMVER_RE.test(prevVersion) ? prevVersion : "0.1.46";
+      const rollbackTo = SEMVER_RE.test(prevVersion) ? prevVersion : "0.1.47";
       logWarn("update", { event: "auto-install-verify-failed", latest, reason: verify.reason, rollbackTo });
       const rb = await runNpmImpl(installArgs(rollbackTo), { cwd: npmDir, timeout: 6e4 });
       logInfo("update", { event: "rollback", from: latest, to: rollbackTo, ok: rb.code === 0 });
@@ -11262,7 +11920,7 @@ async function checkForUpdate(autoUpdate, notify) {
     const runtimeVersion = await getRuntimeVersion();
     const latest = await fetchLatestVersion();
     if (!latest) return;
-    const current = runtimeVersion ?? "0.1.46";
+    const current = runtimeVersion ?? "0.1.47";
     const hasUpdate = isNewer(latest, current);
     debug.event("update-check", {
       current,
@@ -11303,6 +11961,10 @@ async function getRuntimeVersion() {
 // src/index.ts
 function createAcpExtension(adapter = {}) {
   return (pi) => {
+    if (process.env.BILLION_CONTEXT_PROXY) {
+      console.log("[bcp] disabled: BILLION_CONTEXT_PROXY detected \u2014 proxy handles compression");
+      return;
+    }
     const runtime = createRuntime(adapter);
     wireCompactionDisable(pi);
     wireSessionLifecycle(pi, runtime);
@@ -11337,7 +11999,7 @@ function wireSessionLifecycle(pi, runtime) {
     const sid = ctx.sessionManager.getSessionId();
     runtime.clearSessionTracking(sid);
     const modelInfo = ctx.model;
-    logInfo("session", { event: "start", sid, cwd: ctx.cwd, debug: runtime.adapter.debug ?? null, version: true ? "0.1.46" : null, model: modelInfo?.id ?? null, modelApi: modelInfo?.api ?? null, contextWindow: modelInfo?.contextWindow ?? null });
+    logInfo("session", { event: "start", sid, cwd: ctx.cwd, debug: runtime.adapter.debug ?? null, version: true ? "0.1.47" : null, model: modelInfo?.id ?? null, modelApi: modelInfo?.api ?? null, contextWindow: modelInfo?.contextWindow ?? null });
     try {
       await runtime.reloadConfig(ctx.cwd);
       setDelegateDisplayUsage(resolveDelegate(runtime.adapter).displayUsage);
@@ -11466,7 +12128,8 @@ function wireContextTransform(pi, runtime) {
         const emergency = turn.nudge.breakdown?.emergencyOverride === 1;
         turn.nudge.compressibleRanges = viableRanges(turn.nudge.compressibleRanges);
         const retryCapped = runtime.compressRetryCappedFor(turnKey);
-        const alreadyShown = retryCapped || !emergency && runtime.nudgeShownFor(turnKey);
+        const retryQuiet = retryCapped || runtime.compressRetryExhaustedFor(turnKey);
+        const alreadyShown = retryQuiet || !emergency && runtime.nudgeShownFor(turnKey);
         if (!alreadyShown) {
           rebuilt.push(nudgeMessage(turn.nudge, turn.state.blocks.filter((b) => b.active), runtime.prompts));
           const rendered = renderNudgeText(turn.nudge, runtime.prompts);
@@ -11491,7 +12154,7 @@ ${rendered.text}${example}`);
         const failed = outcome.retryFor !== null ? compressOutcomes.find((o) => o.toolCallId === outcome.retryFor) : void 0;
         if (failed) {
           rebuilt.push(compressRetryMessage(failed.text, outcome.count, MAX_COMPRESS_ATTEMPTS));
-          logWarn("nudge", { sid, event: "compress-retry-inject", attempt: outcome.count, max: MAX_COMPRESS_ATTEMPTS, toolCallId: failed.toolCallId });
+          logWarn("nudge", { sid, event: "compress-retry-inject", attempt: outcome.count, max: MAX_COMPRESS_ATTEMPTS, fires: outcome.fires, fireMax: MAX_RETRY_PROMPT_FIRES, toolCallId: failed.toolCallId });
           debug.event("compress-retry-injected", { sid, turnKey, attempt: outcome.count, toolCallId: failed.toolCallId, text: failed.text.slice(0, 200) });
         } else if (outcome.cappedNow) {
           logWarn("nudge", { sid, event: "compress-retry-capped", failures: outcome.count });
@@ -11499,6 +12162,12 @@ ${rendered.text}${example}`);
           if (ctx.hasUI) {
             ctx.ui.notify(`[ACP] compress failed ${outcome.count}\xD7 this turn \u2014 retry prompts disabled until the next user message.`);
           }
+        } else if (outcome.exhaustedNow) {
+          logWarn("nudge", { sid, event: "compress-retry-exhausted", failures: outcome.count, fires: outcome.fires, fireMax: MAX_RETRY_PROMPT_FIRES });
+          debug.event("compress-retry-exhausted", { sid, turnKey, failures: outcome.count });
+          if (ctx.hasUI) {
+            ctx.ui.notify(`[ACP] compress retry prompt ignored ${MAX_RETRY_PROMPT_FIRES}\xD7 this turn \u2014 retry prompts paused until a new compress attempt or the next user message.`);
+          }
         }
       }
       debug.event("context-out", { outMsgs: rebuilt.length, injected: turn.nudge?.shouldInject ?? false, emergency: turn.nudge?.breakdown?.emergencyOverride === 1 });