opencode-acp 1.12.2 → 1.12.4

package/dist/index.js

@@ -904,6 +904,9 @@ var VALID_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "compress.protectUserMessages",
   "compress.maxSummaryLengthHard",
   "compress.minCompressRange",
+  "compress.minNudgeGrowthRatio",
+  "compress.minNudgeGrowthFloor",
+  "compress.emergencyThresholdPercent",
   "compress.maxVisibleSegments",
   "compress.keepEmbedMaxChars",
   "gc",
@@ -1187,6 +1190,61 @@ function validateConfigTypes(config) {
           actual: `${compress.minCompressRange}`
         });
       }
+      if (compress.minNudgeGrowthRatio !== void 0 && typeof compress.minNudgeGrowthRatio !== "number") {
+        errors.push({
+          key: "compress.minNudgeGrowthRatio",
+          expected: "number",
+          actual: typeof compress.minNudgeGrowthRatio
+        });
+      }
+      if (typeof compress.minNudgeGrowthRatio === "number" && (compress.minNudgeGrowthRatio < 0 || compress.minNudgeGrowthRatio > 1)) {
+        errors.push({
+          key: "compress.minNudgeGrowthRatio",
+          expected: "number in range [0, 1]",
+          actual: `${compress.minNudgeGrowthRatio}`
+        });
+      }
+      if (compress.minNudgeGrowthFloor !== void 0 && typeof compress.minNudgeGrowthFloor !== "number") {
+        errors.push({
+          key: "compress.minNudgeGrowthFloor",
+          expected: "number",
+          actual: typeof compress.minNudgeGrowthFloor
+        });
+      }
+      if (typeof compress.minNudgeGrowthFloor === "number" && compress.minNudgeGrowthFloor < 0) {
+        errors.push({
+          key: "compress.minNudgeGrowthFloor",
+          expected: "non-negative number (>= 0)",
+          actual: `${compress.minNudgeGrowthFloor}`
+        });
+      }
+      const emergencyThreshold = compress.emergencyThresholdPercent;
+      if (emergencyThreshold !== void 0) {
+        if (typeof emergencyThreshold === "number") {
+          if (emergencyThreshold < 0) {
+            errors.push({
+              key: "compress.emergencyThresholdPercent",
+              expected: 'non-negative number or "${number}%" (0\u2013100)',
+              actual: `${emergencyThreshold}`
+            });
+          }
+        } else if (typeof emergencyThreshold === "string" && emergencyThreshold.endsWith("%")) {
+          const parsed = parseFloat(emergencyThreshold.slice(0, -1));
+          if (isNaN(parsed) || parsed < 0 || parsed > 100) {
+            errors.push({
+              key: "compress.emergencyThresholdPercent",
+              expected: '"${number}%" with percentage in [0, 100]',
+              actual: JSON.stringify(emergencyThreshold)
+            });
+          }
+        } else {
+          errors.push({
+            key: "compress.emergencyThresholdPercent",
+            expected: 'number | "${number}%"',
+            actual: JSON.stringify(emergencyThreshold)
+          });
+        }
+      }
       if (compress.maxVisibleSegments !== void 0 && typeof compress.maxVisibleSegments !== "number") {
         errors.push({
           key: "compress.maxVisibleSegments",
@@ -1529,7 +1587,10 @@ var defaultConfig = {
     protectTags: false,
     protectUserMessages: false,
     maxSummaryLengthHard: 1e4,
-    minCompressRange: 2e3,
+    minCompressRange: 5e3,
+    minNudgeGrowthRatio: 0.45,
+    minNudgeGrowthFloor: 5e3,
+    emergencyThresholdPercent: "98%",
     maxVisibleSegments: 50,
     keepEmbedMaxChars: 2e3
   },
@@ -1688,6 +1749,9 @@ function mergeCompress(base, override) {
     protectUserMessages: override.protectUserMessages ?? base.protectUserMessages,
     maxSummaryLengthHard: override.maxSummaryLengthHard ?? base.maxSummaryLengthHard,
     minCompressRange: override.minCompressRange ?? base.minCompressRange,
+    minNudgeGrowthRatio: override.minNudgeGrowthRatio ?? base.minNudgeGrowthRatio,
+    minNudgeGrowthFloor: override.minNudgeGrowthFloor ?? base.minNudgeGrowthFloor,
+    emergencyThresholdPercent: override.emergencyThresholdPercent ?? base.emergencyThresholdPercent,
     maxVisibleSegments: override.maxVisibleSegments ?? base.maxVisibleSegments,
     keepEmbedMaxChars: override.keepEmbedMaxChars ?? base.keepEmbedMaxChars
   };
@@ -1949,27 +2013,22 @@ function getCurrentTokenUsage(state, messages) {
       continue;
     }
     const assistantInfo = msg.info;
-    if ((assistantInfo.tokens?.output || 0) <= 0) {
-      continue;
-    }
-    if (state.lastCompaction > 0 && (msg.info.time.created < state.lastCompaction || msg.info.summary === true && msg.info.time.created === state.lastCompaction)) {
-      return 0;
-    }
     const input = assistantInfo.tokens?.input || 0;
     const output = assistantInfo.tokens?.output || 0;
     const reasoning = assistantInfo.tokens?.reasoning || 0;
     const cacheRead = assistantInfo.tokens?.cache?.read || 0;
     const cacheWrite = assistantInfo.tokens?.cache?.write || 0;
+    if (input <= 0 && output <= 0) {
+      continue;
+    }
+    if (state.lastCompaction > 0 && (msg.info.time.created < state.lastCompaction || msg.info.summary === true && msg.info.time.created === state.lastCompaction)) {
+      return 0;
+    }
     return input + cacheRead + cacheWrite + output + reasoning;
   }
   let estimated = 0;
   for (const m of messages) {
-    const parts = Array.isArray(m.parts) ? m.parts : [];
-    for (const part of parts) {
-      if (part.type === "text" && typeof part.text === "string") {
-        estimated += countTokens2(part.text);
-      }
-    }
+    estimated += countAllMessageTokens(m);
   }
   return estimated;
 }
@@ -5678,9 +5737,9 @@ import { tool as tool4 } from "@opencode-ai/plugin";
 import { createHash } from "crypto";
 var SUMMARY_ID_HASH_LENGTH = 16;
 var ACP_RECAP_TOOL_NAME = "acp_context_recap";
-var DCP_BLOCK_ID_TAG_REGEX = /(<dcp-message-id(?=[\s>])[^>]*>)b\d+(<\/(?:dcp|acp)-message-id>)/g;
-var DCP_MESSAGE_REF_TAG_REGEX = /<dcp-message-id>m\d+<\/(?:dcp|acp)-message-id>/g;
-var DCP_PAIRED_TAG_REGEX = /<dcp[^>]*>[\s\S]*?<\/(?:dcp|acp)[^>]*>/gi;
+var DCP_BLOCK_ID_TAG_REGEX = /(<(?:dcp|acp)-message-id[^>]*>)b\d+(<\/(?:dcp|acp)-message-id>)/g;
+var DCP_MESSAGE_REF_TAG_REGEX = /<(?:dcp|acp)-message-id[^>]*>m\d+<\/(?:dcp|acp)-message-id>/g;
+var DCP_PAIRED_TAG_REGEX = /<(?:dcp|acp)[^>]*>[\s\S]*?<\/(?:dcp|acp)[^>]*>/gi;
 var DCP_UNPAIRED_TAG_REGEX = /<\/?(?:dcp|acp)[^>]*>/gi;
 var generateStableId = (prefix, seed) => {
   const hash = createHash("sha256").update(seed).digest("hex").slice(0, SUMMARY_ID_HASH_LENGTH);
@@ -6600,20 +6659,41 @@ function applyAnchoredNudges(state, config, messages, prompts, compressionPriori
     const nudgeParts = [];
     if (config.compress.mode === "message") {
       if (state.nudges.contextLimitAnchors.size > 0) {
-        for (const { index } of collectAnchoredMessages(state.nudges.contextLimitAnchors, messages)) {
-          const guidance = buildMessagePriorityGuidance(messages, compressionPriorities, index, MESSAGE_MODE_NUDGE_PRIORITY);
+        for (const { index } of collectAnchoredMessages(
+          state.nudges.contextLimitAnchors,
+          messages
+        )) {
+          const guidance = buildMessagePriorityGuidance(
+            messages,
+            compressionPriorities,
+            index,
+            MESSAGE_MODE_NUDGE_PRIORITY
+          );
           nudgeParts.push(appendGuidanceToDcpTag(prompts.contextLimitNudge, guidance));
         }
       }
       if (turnNudgeAnchors.size > 0) {
         for (const { index } of collectAnchoredMessages(turnNudgeAnchors, messages)) {
-          const guidance = buildMessagePriorityGuidance(messages, compressionPriorities, index, MESSAGE_MODE_NUDGE_PRIORITY);
+          const guidance = buildMessagePriorityGuidance(
+            messages,
+            compressionPriorities,
+            index,
+            MESSAGE_MODE_NUDGE_PRIORITY
+          );
           nudgeParts.push(appendGuidanceToDcpTag(prompts.turnNudge, guidance));
         }
       }
       if (state.nudges.iterationNudgeAnchors.size > 0) {
-        for (const { index } of collectAnchoredMessages(state.nudges.iterationNudgeAnchors, messages)) {
-          const guidance = buildMessagePriorityGuidance(messages, compressionPriorities, index, MESSAGE_MODE_NUDGE_PRIORITY);
+        for (const { index } of collectAnchoredMessages(
+          state.nudges.iterationNudgeAnchors,
+          messages
+        )) {
+          const guidance = buildMessagePriorityGuidance(
+            messages,
+            compressionPriorities,
+            index,
+            MESSAGE_MODE_NUDGE_PRIORITY
+          );
           nudgeParts.push(appendGuidanceToDcpTag(prompts.iterationNudge, guidance));
         }
       }
@@ -6661,12 +6741,7 @@ function applyAnchoredNudges(state, config, messages, prompts, compressionPriori
     prompts.contextLimitNudge,
     ""
   );
-  applyRangeModeAnchoredNudge(
-    turnNudgeAnchors,
-    messages,
-    prompts.turnNudge,
-    ""
-  );
+  applyRangeModeAnchoredNudge(turnNudgeAnchors, messages, prompts.turnNudge, "");
   applyRangeModeAnchoredNudge(
     state.nudges.iterationNudgeAnchors,
     messages,
@@ -6687,11 +6762,12 @@ function estimateCodeTokens(text) {
   }
   return Math.round(codeChars / 4);
 }
-function estimateContextComposition(messages, state) {
+function estimateContextComposition(messages, state, protectedTools = [], protectedFilePatterns = []) {
   let toolTokens = 0;
   let codeTokens = 0;
   let summaryTokens = 0;
   let messageTokens = 0;
+  let protectedTokens = 0;
   const perMessage = [];
   const perTool = [];
   const perCode = [];
@@ -6701,6 +6777,7 @@ function estimateContextComposition(messages, state) {
     const text = (msg.parts || []).filter((p) => p.type === "text").map((p) => p.text || "").join("");
     const msgId = msg.info?.id || "";
     const isSummary = msgId.startsWith("msg_dcp_summary") || text.includes("[Compressed conversation section]");
+    const isProtected = (protectedTools.length > 0 || protectedFilePatterns.length > 0) && messageContainsProtectedTool(msg, protectedTools, protectedFilePatterns);
     let msgTotal = 0;
     let msgTool = 0;
     let msgCode = 0;
@@ -6733,6 +6810,9 @@ function estimateContextComposition(messages, state) {
         if (!msgToolName) msgToolName = toolName;
       }
     }
+    if (isProtected && !isSummary) {
+      protectedTokens += msgTotal;
+    }
     if (!isSummary) {
       const ref = state?.messageIds?.byRawId?.get(msgId) || "?";
       if (msgTotal > 500) perMessage.push({ ref, tokens: msgTotal });
@@ -6752,6 +6832,7 @@ function estimateContextComposition(messages, state) {
     summaryTokens,
     messageTokens,
     textTokens: Math.max(0, messageTokens - codeTokens),
+    protectedTokens,
     total: toolTokens + summaryTokens + messageTokens,
     largestRanges: perMessage.slice(0, 15),
     largestToolRanges: perTool.slice(0, 15),
@@ -6760,12 +6841,33 @@ function estimateContextComposition(messages, state) {
     toolTypeBreakdown
   };
 }
-function buildCompressibleRanges(messages, state) {
+function refNum(ref) {
+  const n = parseInt(ref.slice(1), 10);
+  return Number.isNaN(n) ? -1 : n;
+}
+function buildCompressibleRanges(messages, state, protectedTools = [], protectedFilePatterns = []) {
   const msgInfo = [];
+  const protectedMsgInfo = [];
   for (const msg of messages) {
     if (isSyntheticMessage(msg)) continue;
     const ref = state.messageIds.byRawId.get(msg.info.id);
     if (!ref) continue;
+    const rn = parseInt(ref.slice(1), 10);
+    if ((protectedTools.length > 0 || protectedFilePatterns.length > 0) && messageContainsProtectedTool(msg, protectedTools, protectedFilePatterns)) {
+      let tokens2 = 0;
+      const tools = /* @__PURE__ */ new Set();
+      for (const part of msg.parts || []) {
+        if (part.type === "text" && typeof part.text === "string") {
+          tokens2 += Math.round(part.text.length / 4);
+        } else if (part.type !== "text" && part.type !== "reasoning") {
+          tokens2 += Math.round(JSON.stringify(part).length / 4);
+          const toolName = part?.tool;
+          if (toolName) tools.add(toolName);
+        }
+      }
+      protectedMsgInfo.push({ ref, refNum: rn, tokens: tokens2, tools: [...tools] });
+      continue;
+    }
     let tokens = 0;
     let isTool = false;
     for (const part of msg.parts || []) {
@@ -6776,10 +6878,8 @@ function buildCompressibleRanges(messages, state) {
         isTool = true;
       }
     }
-    const refNum = parseInt(ref.slice(1), 10);
-    msgInfo.push({ ref, refNum, tokens, isTool, isUser: msg.info.role === "user" });
+    msgInfo.push({ ref, refNum: rn, tokens, isTool, isUser: msg.info.role === "user" });
   }
-  if (msgInfo.length === 0) return [];
   const groups = [];
   let cur = null;
   let prevRefNum = -2;
@@ -6812,14 +6912,114 @@ function buildCompressibleRanges(messages, state) {
     }
   }
   if (cur) groups.push(cur);
-  return groups.filter((g) => g.tokens > 0);
+  const protectedGroups = [];
+  let pcur = null;
+  let pPrevRefNum = -2;
+  for (const info of protectedMsgInfo) {
+    const hasGap = info.refNum > pPrevRefNum + 1;
+    if (pcur && hasGap) {
+      protectedGroups.push(pcur);
+      pcur = null;
+    }
+    pPrevRefNum = info.refNum;
+    if (!pcur) {
+      pcur = {
+        startRef: info.ref,
+        endRef: info.ref,
+        count: 1,
+        tokens: info.tokens,
+        tools: [...info.tools]
+      };
+    } else {
+      pcur.endRef = info.ref;
+      pcur.count++;
+      pcur.tokens += info.tokens;
+      for (const t of info.tools) {
+        if (!pcur.tools.includes(t)) pcur.tools.push(t);
+      }
+    }
+  }
+  if (pcur) protectedGroups.push(pcur);
+  return {
+    compressible: groups.filter((g) => g.tokens > 0),
+    protected: protectedGroups
+  };
 }
-function formatCompressibleRanges(ranges) {
-  if (ranges.length === 0) return "";
+function formatCompressibleRanges(ranges, protectedRanges) {
   const fmt = (n) => n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
-  const lines = ranges.map((r, i) => {
-    const suffix = i === ranges.length - 1 ? "  (recent \u2014 may still be in active use)" : "";
-    return `  ${r.startRef}\u2013${r.endRef}  ${r.count} msgs  ${fmt(r.tokens)} [tool ${r.toolPct}% | text ${r.textPct}%]${suffix}`;
+  if (!protectedRanges || protectedRanges.length === 0) {
+    if (ranges.length === 0) return "";
+    const lines2 = ranges.map((r, i) => {
+      const suffix = i === ranges.length - 1 ? "  (recent \u2014 may still be in active use)" : "";
+      return `  ${r.startRef}\u2013${r.endRef}  ${r.count} msgs  ${fmt(r.tokens)} [tool ${r.toolPct}% | text ${r.textPct}%]${suffix}`;
+    });
+    return `Compressible ranges (oldest first):
+${lines2.join("\n")}`;
+  }
+  const entries = [];
+  for (const r of ranges) {
+    entries.push({
+      startRef: r.startRef,
+      endRef: r.endRef,
+      startNum: refNum(r.startRef),
+      endNum: refNum(r.endRef),
+      count: r.count,
+      tokens: r.tokens,
+      toolPct: r.toolPct,
+      textPct: r.textPct,
+      compressibleTokens: r.tokens,
+      compressibleCount: r.count,
+      protectedTokens: 0,
+      protectedCount: 0,
+      protectedTools: []
+    });
+  }
+  for (const r of protectedRanges) {
+    entries.push({
+      startRef: r.startRef,
+      endRef: r.endRef,
+      startNum: refNum(r.startRef),
+      endNum: refNum(r.endRef),
+      count: r.count,
+      tokens: r.tokens,
+      toolPct: 0,
+      textPct: 0,
+      compressibleTokens: 0,
+      compressibleCount: 0,
+      protectedTokens: r.tokens,
+      protectedCount: r.count,
+      protectedTools: [...r.tools]
+    });
+  }
+  entries.sort((a, b) => a.startNum - b.startNum);
+  const merged = [];
+  for (const entry of entries) {
+    const last = merged[merged.length - 1];
+    if (last && entry.startNum <= last.endNum + 1) {
+      last.endRef = entry.endRef;
+      last.endNum = Math.max(last.endNum, entry.endNum);
+      last.count += entry.count;
+      last.tokens += entry.tokens;
+      last.compressibleTokens += entry.compressibleTokens;
+      last.compressibleCount += entry.compressibleCount;
+      last.protectedTokens += entry.protectedTokens;
+      last.protectedCount += entry.protectedCount;
+      for (const t of entry.protectedTools) {
+        if (!last.protectedTools.includes(t)) last.protectedTools.push(t);
+      }
+    } else {
+      merged.push({ ...entry });
+    }
+  }
+  const lines = merged.map((e, i) => {
+    const suffix = i === merged.length - 1 && e.compressibleTokens > 0 ? "  (recent \u2014 may still be in active use)" : "";
+    if (e.protectedTokens > 0 && e.compressibleTokens === 0) {
+      return `  ${e.startRef}\u2013${e.endRef}  ${e.count} msgs  ${fmt(e.tokens)} [PROTECTED: ${e.protectedTools.join(", ")} \u2014 not compressible]${suffix}`;
+    }
+    if (e.protectedTokens > 0 && e.compressibleTokens > 0) {
+      return `  ${e.startRef}\u2013${e.endRef}  ${e.count} msgs  ${fmt(e.tokens)} [${fmt(e.compressibleTokens)} compressible | ${fmt(e.protectedTokens)} protected: ${e.protectedTools.join(", ")}]${suffix}`;
+    }
+    return `  ${e.startRef}\u2013${e.endRef}  ${e.count} msgs  ${fmt(e.tokens)} [tool ${e.toolPct}% | text ${e.textPct}%]${suffix}`;
   });
   return `Compressible ranges (oldest first):
 ${lines.join("\n")}`;
@@ -6995,8 +7195,13 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
     }
   }
   const suffixMessage = createSuffixMessage(messages);
-  applyAnchoredNudges(state, config, messages, prompts, compressionPriorities, currentTokens, modelContextLimit, suffixMessage);
   const nudgeGrowthTokens = config.compress?.nudgeGrowthTokens ?? resolveAdaptiveNudgeGrowth(modelContextLimit);
+  const growthFloor = Math.max(
+    config.compress?.minNudgeGrowthFloor ?? 5e3,
+    (config.compress?.minNudgeGrowthRatio ?? 0.45) * nudgeGrowthTokens
+  );
+  const emergencyThreshold = resolveEmergencyThreshold(config, modelContextLimit);
+  const emergencyOverride = emergencyThreshold !== void 0 && currentTokens !== void 0 && currentTokens >= emergencyThreshold;
   if (currentTokens !== void 0 && state.nudges.lastPerMessageNudgeTokens !== void 0 && currentTokens < state.nudges.lastPerMessageNudgeTokens - nudgeGrowthTokens) {
     state.nudges.lastPerMessageNudgeTokens = currentTokens;
     state.nudges.lastNudgeShownTokens = void 0;
@@ -7014,14 +7219,25 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
     minNudgeContextPercent: config.compress?.minNudgeContextPercent ?? 15,
     nudgeGrowthTokens: effectiveThreshold
   });
-  state.nudges.shouldInjectThisTurn = decision.shouldNudge;
+  const growthSinceBaseline = currentTokens !== void 0 && growthReference !== void 0 ? currentTokens - growthReference : void 0;
+  const nudgeAllowed = emergencyOverride || growthSinceBaseline !== void 0 && growthSinceBaseline >= growthFloor;
+  state.nudges.shouldInjectThisTurn = nudgeAllowed;
+  const effectiveTipsVariant = emergencyOverride ? "maxLimit" : decision.tipsVariant;
+  if (nudgeAllowed) {
+    applyAnchoredNudges(state, config, messages, prompts, compressionPriorities, currentTokens, modelContextLimit, suffixMessage);
+  }
   if (state.nudges.lastPerMessageNudgeTokens === void 0 && currentTokens !== void 0) {
     state.nudges.lastPerMessageNudgeTokens = currentTokens;
     baselineReEstablished = true;
   }
-  const composition = estimateContextComposition(messages, state);
+  const composition = estimateContextComposition(
+    messages,
+    state,
+    config.compress.protectedTools,
+    config.protectedFilePatterns
+  );
   let tipsText = null;
-  if (decision.shouldNudge) {
+  if (nudgeAllowed) {
     injectContextUsage(suffixMessage, config, currentTokens, modelContextLimit);
     if (suffixMessage && composition.total > 0) {
       const fmt = (n) => n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
@@ -7029,30 +7245,40 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
       const growth = currentTokens !== void 0 && state.nudges.lastPerMessageNudgeTokens !== void 0 ? currentTokens - state.nudges.lastPerMessageNudgeTokens : 0;
       const growthStr = growth > 0 ? ` (+${fmt(growth)} since last nudge)` : "";
       const plainTextTokens = composition.textTokens;
-      const efficiencyNote = decision.tipsVariant !== "maxLimit" ? `
+      const efficiencyNote = effectiveTipsVariant !== "maxLimit" ? `
 This is an efficiency nudge to compress early and keep context lean \u2014 not an overflow warning. A separate, stronger alert will appear if the context is actually full.
 
 ${COMPRESS_PHILOSOPHY}` : "";
       let breakdown = `${efficiencyNote}
 Breakdown: ${fmt(composition.toolTokens)} tool (${pct2(composition.toolTokens)}%) | ${fmt(composition.summaryTokens)} summaries (${pct2(composition.summaryTokens)}%) | ${fmt(composition.codeTokens)} code (${pct2(composition.codeTokens)}%) | ${fmt(plainTextTokens)} text (${pct2(plainTextTokens)}%)${growthStr}`;
-      const ranges = buildCompressibleRanges(messages, state);
-      if (ranges.length > 0) {
+      const compressibleTokens = composition.total - composition.protectedTokens - composition.summaryTokens;
+      if (composition.protectedTokens > 0) {
+        breakdown += `
+\u26A0\uFE0F ${fmt(composition.protectedTokens)} tokens are protected (environment-managed tools) \u2014 not compressible. Effective compressible: ~${fmt(compressibleTokens)}.`;
+      }
+      const contextRanges = buildCompressibleRanges(
+        messages,
+        state,
+        config.compress.protectedTools,
+        config.protectedFilePatterns
+      );
+      if (contextRanges.compressible.length > 0) {
         breakdown += `
 
-${formatCompressibleRanges(ranges)}`;
+${formatCompressibleRanges(contextRanges.compressible, contextRanges.protected)}`;
         breakdown += `
 \u{1F4A1} Compress all ranges in one call (pass multiple content entries: \`content: [{...}, {...}]\`).`;
       }
       breakdown += `
 Use \`acp_status({scope:"uncompressed"})\` to re-fetch compressible ranges after compressing, or \`acp_status\` for compressed block details.`;
-      if (decision.tipsVariant !== "maxLimit") {
+      if (effectiveTipsVariant !== "maxLimit") {
         breakdown += `
 
 ${HOW_TO_COMPRESS_RULES}`;
       }
       appendToLastTextPart(suffixMessage, breakdown);
     }
-    if (decision.tipsVariant === "maxLimit") {
+    if (effectiveTipsVariant === "maxLimit") {
       tipsText = '\n\n\u26A0\uFE0F Context limit reached \u2014 compress now. Prioritize consumed tool outputs.\n\n{ "topic": "...", "content": [{ "startId": "<ID>", "endId": "<ID>", "summary": "..." }] }\n\nOnly use IDs from visible messages above. Compress older work first.';
     }
     state.nudges.lastNudgeShownTokens = currentTokens;
@@ -7090,11 +7316,21 @@ ${HOW_TO_COMPRESS_RULES}`;
       }
     }
   }
-  if (anchorsChanged || decision.shouldNudge || baselineReEstablished || baselineCorrected) {
+  if (anchorsChanged || nudgeAllowed || baselineReEstablished || baselineCorrected) {
     saveSessionState(state, logger).catch(() => {
     });
   }
 };
+function resolveEmergencyThreshold(config, modelContextLimit) {
+  const threshold = config.compress?.emergencyThresholdPercent;
+  if (threshold === void 0 || modelContextLimit === void 0) return void 0;
+  if (typeof threshold === "number") return threshold;
+  if (!threshold.endsWith("%")) return void 0;
+  const parsedPercent = parseFloat(threshold.slice(0, -1));
+  if (isNaN(parsedPercent)) return void 0;
+  const clampedPercent = Math.max(0, Math.min(100, Math.round(parsedPercent)));
+  return Math.round(clampedPercent / 100 * modelContextLimit);
+}
 function injectContextUsage(target, config, currentTokens, modelContextLimit) {
   if (!target) return;
   const rawUsage = buildContextUsageGuidance(config, currentTokens, modelContextLimit);
@@ -7124,14 +7360,11 @@ var injectMessageIds = (state, config, messages, compressionPriorities) => {
     const priority = config.compress.mode === "message" && !isBlockedMessage ? compressionPriorities?.get(message.info.id)?.priority : void 0;
     const msgType = classifyMessageType(message.parts);
     const msgTokens = Math.round(countMessageCharacters(message) / 4);
-    const tag = formatMessageIdTag(
-      isBlockedMessage ? "BLOCKED" : messageRef,
-      {
-        priority: priority ?? void 0,
-        type: msgType,
-        tokens: formatTokenSize(msgTokens)
-      }
-    );
+    const tag = formatMessageIdTag(isBlockedMessage ? "BLOCKED" : messageRef, {
+      priority: priority ?? void 0,
+      type: msgType,
+      tokens: formatTokenSize(msgTokens)
+    });
     if (message.info.role === "user") {
       let injected = false;
       for (const part of message.parts) {
@@ -7732,7 +7965,9 @@ function renderOverview(visibleMessages, summaryTokens, blocks, fetchFailed, raw
     );
     const topTypes = Array.from(toolTypeMap.entries()).map(([tool8, tokens]) => ({ tool: tool8, tokens })).sort((a, b) => b.tokens - a.tokens).slice(0, 3);
     if (topTypes.length > 0) {
-      lines.push(`  Top tools: ${topTypes.map((t) => `${t.tool} (${pct(t.tokens, total)}%)`).join(", ")}`);
+      lines.push(
+        `  Top tools: ${topTypes.map((t) => `${t.tool} (${pct(t.tokens, total)}%)`).join(", ")}`
+      );
     }
   }
   lines.push("");
@@ -7751,7 +7986,9 @@ function renderOverview(visibleMessages, summaryTokens, blocks, fetchFailed, raw
       const ageStr = formatAge(b.createdAt);
       const range = formatIdRange(b);
       const topic = b.topic || "(no topic)";
-      lines.push(`  b${b.blockId}  ${formatTokens(b.compressedTokens)}\u2192${formatTokens(b.summaryTokens)}  ${ageStr}  ${range}  "${topic}"`);
+      lines.push(
+        `  b${b.blockId}  ${formatTokens(b.compressedTokens)}\u2192${formatTokens(b.summaryTokens)}  ${ageStr}  ${range}  "${topic}"`
+      );
     }
   }
   if (!fetchFailed) {
@@ -7761,15 +7998,24 @@ function renderOverview(visibleMessages, summaryTokens, blocks, fetchFailed, raw
       const entry = pruneMap.get(msgId);
       return !entry || entry.activeBlockIds.length === 0;
     });
-    const ranges = buildCompressibleRanges(visibleRaw, ctx.state);
-    if (ranges.length > 0) {
+    const contextRanges = buildCompressibleRanges(
+      visibleRaw,
+      ctx.state,
+      ctx.config?.compress?.protectedTools ?? [],
+      ctx.config?.protectedFilePatterns ?? []
+    );
+    if (contextRanges.compressible.length > 0 || contextRanges.protected.length > 0) {
       lines.push("");
-      lines.push(formatCompressibleRanges(ranges));
+      lines.push(
+        formatCompressibleRanges(contextRanges.compressible, contextRanges.protected)
+      );
     }
   }
   lines.push("");
   const hintTool = topToolName || "bash";
-  lines.push(`Tip: acp_status({scope:"uncompressed", view:"messages", tool:"${hintTool}"}) for per-message listing`);
+  lines.push(
+    `Tip: acp_status({scope:"uncompressed", view:"messages", tool:"${hintTool}"}) for per-message listing`
+  );
   return lines;
 }
 function renderUncompressedRanges(rawMessages, ctx) {
@@ -7779,16 +8025,24 @@ function renderUncompressedRanges(rawMessages, ctx) {
     const entry = pruneMap.get(msgId);
     return !entry || entry.activeBlockIds.length === 0;
   });
-  const ranges = buildCompressibleRanges(visibleMessages, ctx.state);
-  const totalTokens = ranges.reduce((s, r) => s + r.tokens, 0);
-  const totalMsgs = ranges.reduce((s, r) => s + r.count, 0);
+  const contextRanges = buildCompressibleRanges(
+    visibleMessages,
+    ctx.state,
+    ctx.config?.compress?.protectedTools ?? [],
+    ctx.config?.protectedFilePatterns ?? []
+  );
+  const compressible = contextRanges.compressible;
+  const totalTokens = compressible.reduce((s, r) => s + r.tokens, 0);
+  const totalMsgs = compressible.reduce((s, r) => s + r.count, 0);
   const lines = [];
-  lines.push(`UNCOMPRESSED \u2014 ${formatTokens(totalTokens)} | ${totalMsgs} msgs in ${ranges.length} ranges`);
+  lines.push(
+    `UNCOMPRESSED \u2014 ${formatTokens(totalTokens)} | ${totalMsgs} msgs in ${compressible.length} ranges`
+  );
   lines.push("");
-  if (ranges.length === 0) {
+  if (compressible.length === 0 && contextRanges.protected.length === 0) {
     lines.push("  (no compressible ranges)");
   } else {
-    lines.push(formatCompressibleRanges(ranges));
+    lines.push(formatCompressibleRanges(compressible, contextRanges.protected));
   }
   lines.push("");
   lines.push(`Per-message listing: acp_status({scope:"uncompressed", view:"messages"})`);
@@ -7820,7 +8074,9 @@ function renderUncompressedDrilldown(visibleMessages, toolFilter, sort, limit) {
   }
   if (filtered.length > shown.length) {
     lines.push("");
-    lines.push(`${shown.length} of ${filtered.length} shown (${filtered.length - shown.length} hidden).`);
+    lines.push(
+      `${shown.length} of ${filtered.length} shown (${filtered.length - shown.length} hidden).`
+    );
   }
   if (filtered.length > 1 && sort !== "time") {
     const refs = filtered.map((m) => m.index);
@@ -7847,7 +8103,9 @@ function renderCompressedDrilldown(blocks, sort, limit) {
   }
   const totalSummary = sorted.reduce((s, b) => s + (b.summaryTokens || 0), 0);
   const totalCompressed = sorted.reduce((s, b) => s + (b.compressedTokens || 0), 0);
-  lines.push(`COMPRESSED \u2014 ${sorted.length} blocks | ${formatTokens(totalCompressed)} original \u2192 ${formatTokens(totalSummary)} summary`);
+  lines.push(
+    `COMPRESSED \u2014 ${sorted.length} blocks | ${formatTokens(totalCompressed)} original \u2192 ${formatTokens(totalSummary)} summary`
+  );
   lines.push(`Sorted by ${sort === "time" ? "time" : sort === "age" ? "age" : "size"}`);
   lines.push("");
   const shown = sorted.slice(0, limit);
@@ -7867,7 +8125,9 @@ function renderCompressedDrilldown(blocks, sort, limit) {
     lines.push(`${shown.length} of ${sorted.length} shown.`);
   }
   lines.push("");
-  lines.push("Use decompress to restore a block's content, or search_context to search within blocks.");
+  lines.push(
+    "Use decompress to restore a block's content, or search_context to search within blocks."
+  );
   return lines;
 }
 function createAcpStatusTool(ctx) {
@@ -7876,8 +8136,12 @@ function createAcpStatusTool(ctx) {
     description: ACP_STATUS_TOOL_DESCRIPTION,
     args: {
       scope: tool5.schema.string().optional().describe('Drill down: "compressed" or "uncompressed". No arg = overview of both.'),
-      view: tool5.schema.string().optional().describe('Display format for scope:"uncompressed": "ranges" (default, grouped by turn \u2014 matches nudge format) or "messages" (per-message listing with sort/filter)'),
-      tool: tool5.schema.string().optional().describe('Filter by tool type (only with scope:"uncompressed", view:"messages"). e.g., "bash", "todowrite", "write"'),
+      view: tool5.schema.string().optional().describe(
+        'Display format for scope:"uncompressed": "ranges" (default, grouped by turn \u2014 matches nudge format) or "messages" (per-message listing with sort/filter)'
+      ),
+      tool: tool5.schema.string().optional().describe(
+        'Filter by tool type (only with scope:"uncompressed", view:"messages"). e.g., "bash", "todowrite", "write"'
+      ),
       sort: tool5.schema.string().optional().describe('Sort order: "size" (default), "time", or "tool"'),
       limit: tool5.schema.number().optional().describe("Max items to list (default 30)")
     },
@@ -7915,7 +8179,16 @@ function createAcpStatusTool(ctx) {
           lines.push(...renderUncompressedRanges(rawMessages, ctx));
         }
       } else {
-        lines.push(...renderOverview(visibleMsgs, summaryTokens, allBlocks, fetchFailed, rawMessages, ctx));
+        lines.push(
+          ...renderOverview(
+            visibleMsgs,
+            summaryTokens,
+            allBlocks,
+            fetchFailed,
+            rawMessages,
+            ctx
+          )
+        );
       }
       return lines.join("\n");
     }