opencode-acp 1.18.4 → 1.18.5-pr.490.223

package/dist/index.js

@@ -920,7 +920,10 @@ var VALID_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "compress.images.enabled",
   "compress.images.minBytes",
   "compress.images.ttlDays",
+  "compress.images.largeBytes",
+  "compress.images.nudge",
   "compress.completionReserveTokens",
+  "compress.emergencyTruncation",
   "gc",
   "gc.algorithm",
   "gc.promotionThreshold",
@@ -1316,7 +1319,7 @@ function validateConfigTypes(config) {
         if (typeof compress.images !== "object" || compress.images === null || Array.isArray(compress.images)) {
           errors.push({
             key: "compress.images",
-            expected: "object { enabled?: boolean; minBytes?: integer (>= 0); ttlDays?: number (> 0) }",
+            expected: "object { enabled?: boolean; minBytes?: integer (>= 0); ttlDays?: number (> 0); largeBytes?: integer (>= 0); nudge?: boolean }",
             actual: JSON.stringify(compress.images)
           });
         } else {
@@ -1341,6 +1344,20 @@ function validateConfigTypes(config) {
               actual: JSON.stringify(compress.images.ttlDays)
             });
           }
+          if (compress.images.largeBytes !== void 0 && (typeof compress.images.largeBytes !== "number" || !Number.isInteger(compress.images.largeBytes) || compress.images.largeBytes < 0)) {
+            errors.push({
+              key: "compress.images.largeBytes",
+              expected: "integer (>= 0)",
+              actual: JSON.stringify(compress.images.largeBytes)
+            });
+          }
+          if (compress.images.nudge !== void 0 && typeof compress.images.nudge !== "boolean") {
+            errors.push({
+              key: "compress.images.nudge",
+              expected: "boolean",
+              actual: typeof compress.images.nudge
+            });
+          }
         }
       }
       if (compress.completionReserveTokens !== void 0 && typeof compress.completionReserveTokens !== "number") {
@@ -1350,6 +1367,13 @@ function validateConfigTypes(config) {
           actual: typeof compress.completionReserveTokens
         });
       }
+      if (compress.emergencyTruncation !== void 0 && typeof compress.emergencyTruncation !== "boolean") {
+        errors.push({
+          key: "compress.emergencyTruncation",
+          expected: "boolean",
+          actual: typeof compress.emergencyTruncation
+        });
+      }
       if (typeof compress.completionReserveTokens === "number" && compress.completionReserveTokens < 0) {
         errors.push({
           key: "compress.completionReserveTokens",
@@ -1422,6 +1446,7 @@ function validateConfigTypes(config) {
       const OVERRIDE_FIELD_TYPES = {
         showCompression: "boolean",
         summaryBuffer: "boolean",
+        emergencyTruncation: "boolean",
         protectTags: "boolean",
         protectUserMessages: "boolean",
         lastSegmentSoftBlock: "boolean",
@@ -1733,7 +1758,9 @@ var DEFAULT_COMPRESS_REASONING = {
 var DEFAULT_COMPRESS_IMAGES = {
   enabled: true,
   minBytes: 16384,
-  ttlDays: 7
+  ttlDays: 7,
+  largeBytes: 524288,
+  nudge: true
 };
 var DEFAULT_PROTECTED_TOOLS = [
   "task",
@@ -1809,6 +1836,7 @@ var defaultConfig = {
     permission: "allow",
     showCompression: true,
     summaryBuffer: true,
+    emergencyTruncation: false,
     candidates: false,
     maxContextLimit: "80%",
     minContextLimit: "80%",
@@ -2015,9 +2043,12 @@ function mergeCompress(base, override) {
     images: {
       enabled: override.images?.enabled ?? base.images?.enabled ?? DEFAULT_COMPRESS_IMAGES.enabled,
       minBytes: override.images?.minBytes ?? base.images?.minBytes ?? DEFAULT_COMPRESS_IMAGES.minBytes,
-      ttlDays: override.images?.ttlDays ?? base.images?.ttlDays ?? DEFAULT_COMPRESS_IMAGES.ttlDays
+      ttlDays: override.images?.ttlDays ?? base.images?.ttlDays ?? DEFAULT_COMPRESS_IMAGES.ttlDays,
+      largeBytes: override.images?.largeBytes ?? base.images?.largeBytes ?? DEFAULT_COMPRESS_IMAGES.largeBytes,
+      nudge: override.images?.nudge ?? base.images?.nudge ?? DEFAULT_COMPRESS_IMAGES.nudge
     },
-    completionReserveTokens: override.completionReserveTokens ?? base.completionReserveTokens
+    completionReserveTokens: override.completionReserveTokens ?? base.completionReserveTokens,
+    emergencyTruncation: override.emergencyTruncation ?? base.emergencyTruncation
   };
 }
 function mergeCommands(base, override) {
@@ -2410,174 +2441,18 @@ function isProtectedUserMessage(_config, message) {
   return false;
 }
 
-// lib/token-utils.ts
-var anthropicCountTokens = _anthropicTokenizer.countTokens ?? _anthropicTokenizer.default?.countTokens;
-function getCurrentTokenUsage(state, messages) {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const msg = messages[i];
-    if (msg.info.role !== "assistant") {
-      continue;
-    }
-    const assistantInfo = msg.info;
-    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) {
-    estimated += countAllMessageTokens(m);
-  }
-  return estimated;
-}
-function estimateSystemPromptTokens(messages) {
-  let firstInput;
-  for (const msg of messages) {
-    if (msg.info.role !== "assistant") continue;
-    const assistantInfo = msg.info;
-    const t = assistantInfo.tokens;
-    if (!t) continue;
-    const input = (t.input || 0) + (t.cache?.read || 0) + (t.cache?.write || 0);
-    if (input > 0) {
-      firstInput = input;
-      break;
-    }
-  }
-  if (firstInput === void 0) return 0;
-  let firstUserText = "";
-  for (const msg of messages) {
-    if (msg.info.role !== "user") continue;
-    const parts = Array.isArray(msg.parts) ? msg.parts : [];
-    for (const part of parts) {
-      if (part.type === "text" && typeof part.text === "string") {
-        firstUserText += part.text;
-      }
-    }
-    if (firstUserText) break;
-  }
-  return Math.max(0, firstInput - countTokens2(firstUserText));
-}
-function getCurrentParams(state, messages, logger) {
-  const userMsg = getLastUserMessage(messages);
-  if (!userMsg) {
-    logger.debug("No user message found when determining current params");
-    return {
-      providerId: void 0,
-      modelId: void 0,
-      agent: void 0,
-      variant: void 0
-    };
-  }
-  const userInfo = userMsg.info;
-  const agent = userInfo.agent;
-  const providerId = userInfo.model.providerID;
-  const modelId = userInfo.model.modelID;
-  const variant = userInfo.model.variant;
-  return { providerId, modelId, agent, variant };
-}
-function countTokens2(text) {
-  if (!text) return 0;
-  try {
-    return anthropicCountTokens(text);
-  } catch {
-    return Math.round(text.length / 4);
-  }
-}
-function estimateTokensBatch(texts) {
-  if (texts.length === 0) return 0;
-  return countTokens2(texts.join(" "));
-}
-var COMPACTED_TOOL_OUTPUT_PLACEHOLDER = "[Old tool result content cleared]";
-function stringifyToolContent(value) {
-  return typeof value === "string" ? value : JSON.stringify(value);
-}
-function extractCompletedToolOutput(part) {
-  if (part?.type !== "tool" || part.state?.status !== "completed" || part.state?.output === void 0) {
-    return void 0;
-  }
-  if (part.state?.time?.compacted) {
-    return COMPACTED_TOOL_OUTPUT_PLACEHOLDER;
-  }
-  return stringifyToolContent(part.state.output);
-}
-function extractToolContent(part) {
-  const contents = [];
-  if (part?.type !== "tool") {
-    return contents;
-  }
-  if (part.state?.input !== void 0) {
-    contents.push(stringifyToolContent(part.state.input));
-  }
-  const completedOutput = extractCompletedToolOutput(part);
-  if (completedOutput !== void 0) {
-    contents.push(completedOutput);
-  } else if (part.state?.status === "error" && part.state?.error) {
-    contents.push(stringifyToolContent(part.state.error));
-  }
-  return contents;
-}
-function countAllMessageTokens(msg) {
-  const parts = Array.isArray(msg.parts) ? msg.parts : [];
-  const texts = [];
-  for (const part of parts) {
-    if (part.type === "text") {
-      texts.push(part.text);
-    } else {
-      texts.push(...extractToolContent(part));
-    }
-  }
-  if (texts.length === 0) return 0;
-  return estimateTokensBatch(texts);
-}
-function countMessageCharacters(msg) {
-  const parts = Array.isArray(msg.parts) ? msg.parts : [];
-  let total = 0;
-  for (const part of parts) {
-    if (part.type === "text" && typeof part.text === "string") {
-      total += part.text.length;
-    } else {
-      for (const content of extractToolContent(part)) {
-        total += content.length;
-      }
-    }
-  }
-  return total;
-}
-function estimateAllMessageTokensFast(msg) {
-  return Math.round(countMessageCharacters(msg) / 4);
-}
-
-// lib/prompts/extensions/tool.ts
-var RANGE_FORMAT_EXTENSION = `
-
-THE FORMAT OF COMPRESS
-
-\`\`\`
-{
-  topic?: string,          // OPTIONAL fallback topic for entries without their own.
-                           //   Omit when every content entry specifies its own topic.
-  content: [               // One or more ranges to compress
-    {
-      topic?: string,      // OPTIONAL per-entry topic for this range.
-                           //   Falls back to top-level topic.
-                           //   Give each entry its own topic when compressing
-                           //   unrelated ranges in one call.
-      startId: string,     // Boundary ID at range start: mNNNNN or bN
-      endId: string,       // Boundary ID at range end: mNNNNN or bN
-      summary: string      // Complete technical summary replacing all content in range
-    }
-  ]
-}
-\`\`\`
-Each entry needs a topic \u2014 either its own or the top-level fallback.`;
+// lib/compress/image-archive.ts
+import { createHash } from "crypto";
+import {
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  readdirSync,
+  rmdirSync,
+  statSync as statSync2,
+  unlinkSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { join as join3 } from "path";
 
 // lib/state/persistence.ts
 import * as fs from "fs/promises";
@@ -2731,7 +2606,7 @@ function loadPruneMessagesState(persisted) {
         deactivatedByUser: block.deactivatedByUser === true,
         deactivatedByUserDeep: block.deactivatedByUserDeep === true ? true : void 0,
         compressedTokens: typeof block.compressedTokens === "number" && Number.isFinite(block.compressedTokens) ? Math.max(0, block.compressedTokens) : 0,
-        summaryTokens: typeof block.summaryTokens === "number" && Number.isFinite(block.summaryTokens) ? Math.max(0, block.summaryTokens) : typeof block.summary === "string" ? countTokens2(block.summary) : 0,
+        summaryTokens: typeof block.summaryTokens === "number" && Number.isFinite(block.summaryTokens) ? Math.max(0, block.summaryTokens) : typeof block.summary === "string" ? countTokens(block.summary) : 0,
         durationMs: typeof block.durationMs === "number" && Number.isFinite(block.durationMs) ? Math.max(0, block.durationMs) : 0,
         mode: block.mode === "range" || block.mode === "message" ? block.mode : void 0,
         topic: typeof block.topic === "string" ? block.topic : "",
@@ -2955,7 +2830,9 @@ function saveSessionState(sessionState, logger, sessionName) {
     modelContextLimit: sessionState.modelContextLimit,
     modelProviderID: sessionState.modelProviderID,
     modelID: sessionState.modelID,
-    imageArchive: sessionState.imageArchive
+    imageArchive: sessionState.imageArchive,
+    imageSurgeNudged: sessionState.imageSurgeNudged,
+    stickyTruncations: sessionState.stickyTruncations
   };
   const key = saveQueueKey(sessionState.sessionId, sessionState.storageDir);
   let queue = saveQueues.get(key);
@@ -3070,22 +2947,509 @@ async function loadSessionState(sessionId, logger, storageDir) {
       ;
       state._persistedLastCompaction = persistedLastCompaction;
     }
-    logger.info("Loaded session state from disk", {
-      sessionId
-    });
-    return state;
-  } catch (error) {
-    logger.warn("Failed to load session state", {
-      sessionId,
-      error: error?.message
-    });
-    return null;
-  }
+    logger.info("Loaded session state from disk", {
+      sessionId
+    });
+    return state;
+  } catch (error) {
+    logger.warn("Failed to load session state", {
+      sessionId,
+      error: error?.message
+    });
+    return null;
+  }
+}
+
+// lib/compress/image-archive.ts
+var DATA_URL_REGEX = /^data:(image\/[a-z0-9.+-]+);base64,(.+)$/is;
+var IMAGE_EXTENSIONS = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/jpg": "jpg",
+  "image/gif": "gif",
+  "image/webp": "webp",
+  "image/avif": "avif",
+  "image/bmp": "bmp"
+};
+function sha8(input) {
+  return createHash("sha256").update(input).digest("hex").slice(0, 8);
+}
+function parseImageDataUrl(url) {
+  if (typeof url !== "string") return void 0;
+  const match = DATA_URL_REGEX.exec(url);
+  if (!match) return void 0;
+  return { mediaType: match[1].toLowerCase(), base64: match[2] };
+}
+function extForMediaType(mediaType) {
+  return IMAGE_EXTENSIONS[mediaType.toLowerCase()];
+}
+function archiveDirName(sessionId) {
+  let name = sessionId.replace(/[^a-zA-Z0-9_-]/g, "-").slice(0, 100);
+  if (name !== sessionId) {
+    name = `${name}-${sha8(sessionId)}`;
+  }
+  return name || "-";
+}
+function archiveRoot(storageDir, sessionId) {
+  return join3(storageDir ?? getDefaultStorageDir(), "images", archiveDirName(sessionId));
+}
+function archiveSessionImages(state, messages, images, logger) {
+  if (!images.enabled || !state.sessionId) return 0;
+  const root = archiveRoot(state.storageDir, state.sessionId);
+  let archived = 0;
+  for (const message of messages) {
+    const rawId = message.info.id;
+    if (!rawId) continue;
+    const parts = Array.isArray(message.parts) ? message.parts : [];
+    for (let partIndex = 0; partIndex < parts.length; partIndex++) {
+      const part = parts[partIndex];
+      if (part.type !== "file") continue;
+      const parsed = parseImageDataUrl(part.url);
+      if (!parsed) continue;
+      const ext = extForMediaType(parsed.mediaType);
+      if (!ext) continue;
+      const fileName = `${sha8(rawId)}-p${partIndex}-${sha8(parsed.base64)}.${ext}`;
+      const filePath = join3(root, fileName);
+      const existing = state.imageArchive[rawId]?.find((e) => e.path === filePath);
+      if (existing) continue;
+      let bytes;
+      try {
+        if (existsSync3(filePath)) {
+          bytes = statSync2(filePath).size;
+        } else {
+          const buffer = Buffer.from(parsed.base64, "base64");
+          bytes = buffer.byteLength;
+          if (bytes < images.minBytes) continue;
+          mkdirSync2(root, { recursive: true });
+          writeFileSync2(filePath, buffer, { mode: 384 });
+        }
+      } catch (error) {
+        logger.warn(
+          `[#478] failed to archive image ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+        );
+        continue;
+      }
+      const entry = {
+        path: filePath,
+        mediaType: parsed.mediaType,
+        bytes
+      };
+      if (!state.imageArchive[rawId]) {
+        state.imageArchive[rawId] = [];
+      }
+      state.imageArchive[rawId].push(entry);
+      state.stats.imagesArchived = (state.stats.imagesArchived ?? 0) + 1;
+      state.stats.imageBytesArchived = (state.stats.imageBytesArchived ?? 0) + bytes;
+      archived++;
+    }
+  }
+  return archived;
+}
+function pruneImageArchive(state, images, logger) {
+  if (state.imagePruneDone || !state.sessionId) return;
+  state.imagePruneDone = true;
+  try {
+    const root = archiveRoot(state.storageDir, state.sessionId);
+    if (!existsSync3(root)) return;
+    const cutoff = Date.now() - images.ttlDays * 864e5;
+    const prunedPaths = /* @__PURE__ */ new Set();
+    for (const name of readdirSync(root)) {
+      const filePath = join3(root, name);
+      try {
+        if (statSync2(filePath).mtimeMs < cutoff) {
+          unlinkSync(filePath);
+          prunedPaths.add(filePath);
+        }
+      } catch {
+      }
+    }
+    if (prunedPaths.size > 0) {
+      for (const [rawId, entries] of Object.entries(state.imageArchive)) {
+        const kept = entries.filter((e) => !prunedPaths.has(e.path));
+        if (kept.length === 0) {
+          delete state.imageArchive[rawId];
+        } else if (kept.length !== entries.length) {
+          state.imageArchive[rawId] = kept;
+        }
+      }
+      logger.info(`[#478] TTL sweep removed ${prunedPaths.size} expired archived image(s)`);
+    }
+    if (readdirSync(root).length === 0) {
+      rmdirSync(root);
+    }
+  } catch (error) {
+    logger.warn(
+      `[#478] image TTL sweep failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function appendArchivedImagePointers(summary, selection, state, enabled) {
+  if (!enabled) return summary;
+  const lines = [];
+  for (const messageId of selection.messageIds) {
+    const entries = state.imageArchive[messageId];
+    if (!entries || entries.length === 0) continue;
+    const ref = state.messageIds.byRawId.get(messageId) ?? messageId;
+    for (const entry of entries) {
+      lines.push(`- ${ref}: ${entry.path} (${entry.mediaType}, ${entry.bytes} bytes)`);
+    }
+  }
+  if (lines.length === 0) return summary;
+  const heading = "\n\nImages captured in this range were archived to disk (their pixels are NOT summarized). Re-read them with your file tools if you need the pixels again:";
+  return summary + heading + "\n" + lines.join("\n");
+}
+
+// lib/compress/image-tokens.ts
+var VISION_MAX_SIDE = 1568;
+var VISION_TILE_SIZE = 512;
+var TOKENS_PER_TILE = 167;
+var VISION_MAX_TILES = Math.ceil(VISION_MAX_SIDE / VISION_TILE_SIZE) ** 2;
+var UNKNOWN_DIM_LARGE_BYTES = 256 * 1024;
+function estimateVisionTokensForDimensions(width, height) {
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+    return 0;
+  }
+  const scale = Math.min(1, VISION_MAX_SIDE / Math.max(width, height));
+  const scaledWidth = Math.max(1, Math.floor(width * scale));
+  const scaledHeight = Math.max(1, Math.floor(height * scale));
+  const tiles = Math.ceil(scaledWidth / VISION_TILE_SIZE) * Math.ceil(scaledHeight / VISION_TILE_SIZE);
+  return Math.min(tiles, VISION_MAX_TILES) * TOKENS_PER_TILE;
+}
+function validDimensions(width, height) {
+  if (typeof width !== "number" || typeof height !== "number" || !Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0 || width > 1e6 || height > 1e6) {
+    return void 0;
+  }
+  return { width, height };
+}
+function fourcc(bytes, offset) {
+  return String.fromCharCode(bytes[offset], bytes[offset + 1], bytes[offset + 2], bytes[offset + 3]);
+}
+function parseImageDimensions(bytes, mediaType) {
+  const len = bytes.length;
+  const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  switch (mediaType.toLowerCase()) {
+    case "image/png": {
+      if (len < 24) return void 0;
+      const sig = [137, 80, 78, 71, 13, 10, 26, 10];
+      for (let i = 0; i < sig.length; i++) {
+        if (bytes[i] !== sig[i]) return void 0;
+      }
+      return validDimensions(dv.getUint32(16, false), dv.getUint32(20, false));
+    }
+    case "image/jpeg":
+    case "image/jpg": {
+      if (len < 4 || bytes[0] !== 255 || bytes[1] !== 216) return void 0;
+      let i = 2;
+      while (i + 9 < len) {
+        if (bytes[i] !== 255) {
+          i++;
+          continue;
+        }
+        const marker = bytes[i + 1];
+        if (marker === 216 || marker === 217 || marker >= 218 && marker <= 223) {
+          return void 0;
+        }
+        if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
+          if (i + 9 >= len) return void 0;
+          return validDimensions(dv.getUint16(i + 8, false), dv.getUint16(i + 6, false));
+        }
+        const segLen = dv.getUint16(i + 2, false);
+        if (segLen < 2) return void 0;
+        i += 2 + segLen;
+      }
+      return void 0;
+    }
+    case "image/gif": {
+      if (len < 10) return void 0;
+      if (fourcc(bytes, 0) !== "GIF8") return void 0;
+      return validDimensions(dv.getUint16(6, true), dv.getUint16(8, true));
+    }
+    case "image/webp": {
+      if (len < 30) return void 0;
+      if (fourcc(bytes, 0) !== "RIFF" || fourcc(bytes, 8) !== "WEBP") return void 0;
+      let i = 12;
+      while (i + 8 < len) {
+        const id = fourcc(bytes, i);
+        const size = dv.getUint32(i + 4, true);
+        const payload = i + 8;
+        if (id === "VP8 ") {
+          if (payload + 10 > len) return void 0;
+          return validDimensions(
+            dv.getUint16(payload + 6, true) & 16383,
+            dv.getUint16(payload + 8, true) & 16383
+          );
+        }
+        if (id === "VP8L") {
+          if (payload + 5 > len) return void 0;
+          if (bytes[payload] !== 47) return void 0;
+          const packed = bytes[payload + 1] | bytes[payload + 2] << 8 | bytes[payload + 3] << 16;
+          return validDimensions(
+            1 + (packed & 16383),
+            1 + (packed >>> 14 & 16383)
+          );
+        }
+        if (id === "VP8X") {
+          if (payload + 10 > len) return void 0;
+          const w = bytes[payload + 4] | bytes[payload + 5] << 8 | bytes[payload + 6] << 16;
+          const h = bytes[payload + 7] | bytes[payload + 8] << 8 | bytes[payload + 9] << 16;
+          return validDimensions(w + 1, h + 1);
+        }
+        if (size === 4294967295) return void 0;
+        i = payload + size + (size & 1);
+      }
+      return void 0;
+    }
+    case "image/bmp": {
+      if (len < 26) return void 0;
+      if (bytes[0] !== 66 || bytes[1] !== 77) return void 0;
+      return validDimensions(
+        Math.abs(dv.getInt32(18, true)),
+        Math.abs(dv.getInt32(22, true))
+      );
+    }
+    default:
+      return void 0;
+  }
+}
+function decodedBytesFromBase64(base64) {
+  if (typeof base64 !== "string" || base64.length === 0) return 0;
+  return Math.max(0, Math.floor(base64.length * 3 / 4));
+}
+function decodeBase64Prefix(base64, maxBytes) {
+  const chars = Math.min(base64.length, Math.ceil(maxBytes * 4 / 3));
+  const aligned = chars - chars % 4;
+  if (aligned < 4) return void 0;
+  try {
+    return new Uint8Array(Buffer.from(base64.slice(0, aligned), "base64"));
+  } catch {
+    return void 0;
+  }
+}
+var HEADER_SCAN_BYTES = 256 * 1024;
+var estimateCache = /* @__PURE__ */ new Map();
+var ESTIMATE_CACHE_CAP = 512;
+function remember(key, value) {
+  if (estimateCache.size >= ESTIMATE_CACHE_CAP && !estimateCache.has(key)) {
+    const oldest = estimateCache.keys().next().value;
+    if (oldest !== void 0) {
+      estimateCache.delete(oldest);
+    }
+  }
+  estimateCache.set(key, value);
+}
+function estimateImagePartTokens(part) {
+  if (!part || typeof part !== "object") return 0;
+  const candidate = part;
+  if (candidate.type !== "file") return 0;
+  const url = typeof candidate.url === "string" ? candidate.url : void 0;
+  if (!url) return 0;
+  const parsed = parseImageDataUrl(url);
+  if (!parsed) return 0;
+  const key = `${parsed.mediaType}:${url.length}:${url.slice(-32)}`;
+  const cached = estimateCache.get(key);
+  if (cached !== void 0) return cached;
+  let estimate;
+  const prefix = decodeBase64Prefix(parsed.base64, HEADER_SCAN_BYTES);
+  const dims = prefix ? parseImageDimensions(prefix, parsed.mediaType) : void 0;
+  if (dims) {
+    estimate = estimateVisionTokensForDimensions(dims.width, dims.height);
+  } else {
+    const bytes = decodedBytesFromBase64(parsed.base64);
+    estimate = bytes >= UNKNOWN_DIM_LARGE_BYTES ? VISION_MAX_TILES * TOKENS_PER_TILE : Math.round(parsed.base64.length / 4);
+  }
+  remember(key, estimate);
+  return estimate;
+}
+
+// lib/token-utils.ts
+var anthropicCountTokens = _anthropicTokenizer.countTokens ?? _anthropicTokenizer.default?.countTokens;
+function countPendingImageTokens(messages, startIndex) {
+  let total = 0;
+  for (let i = Math.max(0, startIndex); i < messages.length; i++) {
+    const parts = Array.isArray(messages[i].parts) ? messages[i].parts : [];
+    for (const part of parts) {
+      if (part.type === "file") {
+        total += estimateImagePartTokens(part);
+      }
+    }
+  }
+  return total;
+}
+function getCurrentTokenUsage(state, messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.info.role !== "assistant") {
+      continue;
+    }
+    const assistantInfo = msg.info;
+    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 + countPendingImageTokens(messages, i + 1);
+  }
+  let estimated = 0;
+  for (const m of messages) {
+    estimated += countAllMessageTokens(m);
+  }
+  return estimated;
+}
+function estimateSystemPromptTokens(messages) {
+  let firstInput;
+  for (const msg of messages) {
+    if (msg.info.role !== "assistant") continue;
+    const assistantInfo = msg.info;
+    const t = assistantInfo.tokens;
+    if (!t) continue;
+    const input = (t.input || 0) + (t.cache?.read || 0) + (t.cache?.write || 0);
+    if (input > 0) {
+      firstInput = input;
+      break;
+    }
+  }
+  if (firstInput === void 0) return 0;
+  let firstUserText = "";
+  for (const msg of messages) {
+    if (msg.info.role !== "user") continue;
+    const parts = Array.isArray(msg.parts) ? msg.parts : [];
+    for (const part of parts) {
+      if (part.type === "text" && typeof part.text === "string") {
+        firstUserText += part.text;
+      }
+    }
+    if (firstUserText) break;
+  }
+  return Math.max(0, firstInput - countTokens(firstUserText));
+}
+function getCurrentParams(state, messages, logger) {
+  const userMsg = getLastUserMessage(messages);
+  if (!userMsg) {
+    logger.debug("No user message found when determining current params");
+    return {
+      providerId: void 0,
+      modelId: void 0,
+      agent: void 0,
+      variant: void 0
+    };
+  }
+  const userInfo = userMsg.info;
+  const agent = userInfo.agent;
+  const providerId = userInfo.model.providerID;
+  const modelId = userInfo.model.modelID;
+  const variant = userInfo.model.variant;
+  return { providerId, modelId, agent, variant };
+}
+function countTokens(text) {
+  if (!text) return 0;
+  try {
+    return anthropicCountTokens(text);
+  } catch {
+    return Math.round(text.length / 4);
+  }
+}
+function estimateTokensBatch(texts) {
+  if (texts.length === 0) return 0;
+  return countTokens(texts.join(" "));
+}
+var COMPACTED_TOOL_OUTPUT_PLACEHOLDER = "[Old tool result content cleared]";
+function stringifyToolContent(value) {
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+function extractCompletedToolOutput(part) {
+  if (part?.type !== "tool" || part.state?.status !== "completed" || part.state?.output === void 0) {
+    return void 0;
+  }
+  if (part.state?.time?.compacted) {
+    return COMPACTED_TOOL_OUTPUT_PLACEHOLDER;
+  }
+  return stringifyToolContent(part.state.output);
+}
+function extractToolContent(part) {
+  const contents = [];
+  if (part?.type !== "tool") {
+    return contents;
+  }
+  if (part.state?.input !== void 0) {
+    contents.push(stringifyToolContent(part.state.input));
+  }
+  const completedOutput = extractCompletedToolOutput(part);
+  if (completedOutput !== void 0) {
+    contents.push(completedOutput);
+  } else if (part.state?.status === "error" && part.state?.error) {
+    contents.push(stringifyToolContent(part.state.error));
+  }
+  return contents;
+}
+function countAllMessageTokens(msg) {
+  const parts = Array.isArray(msg.parts) ? msg.parts : [];
+  const texts = [];
+  let imageTokens = 0;
+  for (const part of parts) {
+    if (part.type === "text") {
+      texts.push(part.text);
+    } else if (part.type === "file") {
+      imageTokens += estimateImagePartTokens(part);
+    } else {
+      texts.push(...extractToolContent(part));
+    }
+  }
+  if (texts.length === 0 && imageTokens === 0) return 0;
+  return imageTokens + (texts.length > 0 ? estimateTokensBatch(texts) : 0);
+}
+function countMessageCharacters(msg) {
+  const parts = Array.isArray(msg.parts) ? msg.parts : [];
+  let total = 0;
+  for (const part of parts) {
+    if (part.type === "text" && typeof part.text === "string") {
+      total += part.text.length;
+    } else if (part.type === "file") {
+      total += estimateImagePartTokens(part) * 4;
+    } else {
+      for (const content of extractToolContent(part)) {
+        total += content.length;
+      }
+    }
+  }
+  return total;
+}
+function estimateAllMessageTokensFast(msg) {
+  return Math.round(countMessageCharacters(msg) / 4);
+}
+
+// lib/prompts/extensions/tool.ts
+var RANGE_FORMAT_EXTENSION = `
+
+THE FORMAT OF COMPRESS
+
+\`\`\`
+{
+  topic?: string,          // OPTIONAL fallback topic for entries without their own.
+                           //   Omit when every content entry specifies its own topic.
+  content: [               // One or more ranges to compress
+    {
+      topic?: string,      // OPTIONAL per-entry topic for this range.
+                           //   Falls back to top-level topic.
+                           //   Give each entry its own topic when compressing
+                           //   unrelated ranges in one call.
+      startId: string,     // Boundary ID at range start: mNNNNN or bN
+      endId: string,       // Boundary ID at range end: mNNNNN or bN
+      summary: string      // Complete technical summary replacing all content in range
+    }
+  ]
 }
+\`\`\`
+Each entry needs a topic \u2014 either its own or the top-level fallback.`;
 
 // lib/state/state.ts
-import { existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
 import { cwd } from "process";
 
 // lib/message-ids.ts
@@ -4630,7 +4994,7 @@ function appendMissingBlockSummaries(summary, _missingBlockIds, _summaryByBlockI
 }
 
 // lib/state/rebuild.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 function collectCompressInvocations(messages) {
   const invocations = [];
   for (const message of messages) {
@@ -4701,7 +5065,7 @@ function fingerprintMessage(message) {
     }
     return { type: part.type };
   });
-  return createHash("sha256").update(JSON.stringify({ role: message.info.role, parts })).digest("hex");
+  return createHash2("sha256").update(JSON.stringify({ role: message.info.role, parts })).digest("hex");
 }
 function mapForkIds(state, parent, parentMessages, forkMessages) {
   const parentRefs = parent.messageIds?.byRef;
@@ -4828,7 +5192,7 @@ function rebuildRangeInvocation(state, input, searchContext, invocation, protect
     ]);
     const blockId = allocateBlockId(state);
     const storedSummary = wrapCompressedSummary(blockId, plan.entry.summary);
-    const summaryTokens = countTokens2(storedSummary);
+    const summaryTokens = countTokens(storedSummary);
     applyCompressionState(
       state,
       {
@@ -4890,7 +5254,7 @@ function rebuildMessageInvocation(state, input, searchContext, invocation, gcCon
     }
     const blockId = allocateBlockId(state);
     const storedSummary = wrapCompressedSummary(blockId, entry.summary);
-    const summaryTokens = countTokens2(storedSummary);
+    const summaryTokens = countTokens(storedSummary);
     applyCompressionState(
       state,
       {
@@ -5124,7 +5488,9 @@ function createSessionState() {
     qualityGateRetryPending: false,
     noContextLimitWarned: false,
     imageArchive: {},
-    imagePruneDone: false
+    imagePruneDone: false,
+    imageSurgeNudged: {},
+    stickyTruncations: {}
   };
 }
 function resetSessionState(state) {
@@ -5170,6 +5536,8 @@ function resetSessionState(state) {
   state.noContextLimitWarned = false;
   state.imageArchive = {};
   state.imagePruneDone = false;
+  state.imageSurgeNudged = {};
+  state.stickyTruncations = {};
 }
 async function ensureSessionInitialized(client, state, sessionId, logger, messages, config, projectDir) {
   if (state.sessionId === sessionId) {
@@ -5186,8 +5554,8 @@ async function ensureSessionInitialized(client, state, sessionId, logger, messag
   state.nudges.turnNudgeAnchors = collectTurnNudgeAnchors(messages);
   const persisted = await loadSessionState(sessionId, logger, state.storageDir);
   if (persisted === null) {
-    const defaultPath = join3(getDefaultStorageDir(), `${sessionId}.json`);
-    if (state.storageDir && existsSync3(defaultPath)) {
+    const defaultPath = join4(getDefaultStorageDir(), `${sessionId}.json`);
+    if (state.storageDir && existsSync4(defaultPath)) {
       logger.warn(
         "storagePath is set but no valid state was found there; a state file exists at the default location \u2014 move it manually to keep history",
         { sessionId, storageDir: state.storageDir, defaultPath }
@@ -5198,6 +5566,13 @@ async function ensureSessionInitialized(client, state, sessionId, logger, messag
       if (parentSessionId) {
         try {
           const parent = await loadSessionState(parentSessionId, logger);
+          if (parent?.stickyTruncations) {
+            for (const [callID, output] of Object.entries(parent.stickyTruncations)) {
+              if (typeof output === "string") {
+                state.stickyTruncations[callID] = output;
+              }
+            }
+          }
           const response = parent ? await client.session.messages({ path: { id: parentSessionId } }) : void 0;
           const parentMessages = Array.isArray(response?.data) ? response.data : Array.isArray(response) ? response : [];
           if (parent && parentMessages.length > 0) {
@@ -5263,6 +5638,21 @@ async function ensureSessionInitialized(client, state, sessionId, logger, messag
       }
     }
   }
+  if (persisted.imageSurgeNudged && typeof persisted.imageSurgeNudged === "object") {
+    for (const [key, ts] of Object.entries(persisted.imageSurgeNudged)) {
+      if (typeof key === "string" && typeof ts === "number" && Number.isFinite(ts)) {
+        state.imageSurgeNudged[key] = ts;
+      }
+    }
+  }
+  const persistedSticky = persisted.stickyTruncations;
+  if (persistedSticky && typeof persistedSticky === "object") {
+    for (const [callID, output] of Object.entries(persistedSticky)) {
+      if (typeof output === "string") {
+        state.stickyTruncations[callID] = output;
+      }
+    }
+  }
   const persistedAny = persisted;
   if (persistedAny._persistedMessageIds) {
     state.messageIds = {
@@ -5438,7 +5828,7 @@ function cacheSystemPromptTokens(state, messages) {
     }
     break;
   }
-  const estimatedSystemTokens = Math.max(0, firstInputTokens - countTokens2(firstUserText));
+  const estimatedSystemTokens = Math.max(0, firstInputTokens - countTokens(firstUserText));
   state.systemPromptTokens = estimatedSystemTokens > 0 ? estimatedSystemTokens : void 0;
 }
 
@@ -6675,156 +7065,6 @@ function buildPhantomSkipNotice(identification) {
   return `Skipped ${identification.phantomIndices.length} already-compressed ${noun} (${skippedNums}) \u2014 they are no-ops; the remaining entries were compressed.`;
 }
 
-// lib/compress/image-archive.ts
-import { createHash as createHash2 } from "crypto";
-import {
-  existsSync as existsSync4,
-  mkdirSync as mkdirSync2,
-  readdirSync,
-  rmdirSync,
-  statSync as statSync2,
-  unlinkSync,
-  writeFileSync as writeFileSync2
-} from "fs";
-import { join as join4 } from "path";
-var DATA_URL_REGEX = /^data:(image\/[a-z0-9.+-]+);base64,(.+)$/is;
-var IMAGE_EXTENSIONS = {
-  "image/png": "png",
-  "image/jpeg": "jpg",
-  "image/jpg": "jpg",
-  "image/gif": "gif",
-  "image/webp": "webp",
-  "image/avif": "avif",
-  "image/bmp": "bmp"
-};
-function sha8(input) {
-  return createHash2("sha256").update(input).digest("hex").slice(0, 8);
-}
-function parseImageDataUrl(url) {
-  if (typeof url !== "string") return void 0;
-  const match = DATA_URL_REGEX.exec(url);
-  if (!match) return void 0;
-  return { mediaType: match[1].toLowerCase(), base64: match[2] };
-}
-function extForMediaType(mediaType) {
-  return IMAGE_EXTENSIONS[mediaType.toLowerCase()];
-}
-function archiveDirName(sessionId) {
-  let name = sessionId.replace(/[^a-zA-Z0-9_-]/g, "-").slice(0, 100);
-  if (name !== sessionId) {
-    name = `${name}-${sha8(sessionId)}`;
-  }
-  return name || "-";
-}
-function archiveRoot(storageDir, sessionId) {
-  return join4(storageDir ?? getDefaultStorageDir(), "images", archiveDirName(sessionId));
-}
-function archiveSessionImages(state, messages, images, logger) {
-  if (!images.enabled || !state.sessionId) return 0;
-  const root = archiveRoot(state.storageDir, state.sessionId);
-  let archived = 0;
-  for (const message of messages) {
-    const rawId = message.info.id;
-    if (!rawId) continue;
-    const parts = Array.isArray(message.parts) ? message.parts : [];
-    for (let partIndex = 0; partIndex < parts.length; partIndex++) {
-      const part = parts[partIndex];
-      if (part.type !== "file") continue;
-      const parsed = parseImageDataUrl(part.url);
-      if (!parsed) continue;
-      const ext = extForMediaType(parsed.mediaType);
-      if (!ext) continue;
-      const fileName = `${sha8(rawId)}-p${partIndex}-${sha8(parsed.base64)}.${ext}`;
-      const filePath = join4(root, fileName);
-      const existing = state.imageArchive[rawId]?.find((e) => e.path === filePath);
-      if (existing) continue;
-      let bytes;
-      try {
-        if (existsSync4(filePath)) {
-          bytes = statSync2(filePath).size;
-        } else {
-          const buffer = Buffer.from(parsed.base64, "base64");
-          bytes = buffer.byteLength;
-          if (bytes < images.minBytes) continue;
-          mkdirSync2(root, { recursive: true });
-          writeFileSync2(filePath, buffer, { mode: 384 });
-        }
-      } catch (error) {
-        logger.warn(
-          `[#478] failed to archive image ${filePath}: ${error instanceof Error ? error.message : String(error)}`
-        );
-        continue;
-      }
-      const entry = {
-        path: filePath,
-        mediaType: parsed.mediaType,
-        bytes
-      };
-      if (!state.imageArchive[rawId]) {
-        state.imageArchive[rawId] = [];
-      }
-      state.imageArchive[rawId].push(entry);
-      state.stats.imagesArchived = (state.stats.imagesArchived ?? 0) + 1;
-      state.stats.imageBytesArchived = (state.stats.imageBytesArchived ?? 0) + bytes;
-      archived++;
-    }
-  }
-  return archived;
-}
-function pruneImageArchive(state, images, logger) {
-  if (state.imagePruneDone || !state.sessionId) return;
-  state.imagePruneDone = true;
-  try {
-    const root = archiveRoot(state.storageDir, state.sessionId);
-    if (!existsSync4(root)) return;
-    const cutoff = Date.now() - images.ttlDays * 864e5;
-    const prunedPaths = /* @__PURE__ */ new Set();
-    for (const name of readdirSync(root)) {
-      const filePath = join4(root, name);
-      try {
-        if (statSync2(filePath).mtimeMs < cutoff) {
-          unlinkSync(filePath);
-          prunedPaths.add(filePath);
-        }
-      } catch {
-      }
-    }
-    if (prunedPaths.size > 0) {
-      for (const [rawId, entries] of Object.entries(state.imageArchive)) {
-        const kept = entries.filter((e) => !prunedPaths.has(e.path));
-        if (kept.length === 0) {
-          delete state.imageArchive[rawId];
-        } else if (kept.length !== entries.length) {
-          state.imageArchive[rawId] = kept;
-        }
-      }
-      logger.info(`[#478] TTL sweep removed ${prunedPaths.size} expired archived image(s)`);
-    }
-    if (readdirSync(root).length === 0) {
-      rmdirSync(root);
-    }
-  } catch (error) {
-    logger.warn(
-      `[#478] image TTL sweep failed: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
-function appendArchivedImagePointers(summary, selection, state, enabled) {
-  if (!enabled) return summary;
-  const lines = [];
-  for (const messageId of selection.messageIds) {
-    const entries = state.imageArchive[messageId];
-    if (!entries || entries.length === 0) continue;
-    const ref = state.messageIds.byRawId.get(messageId) ?? messageId;
-    for (const entry of entries) {
-      lines.push(`- ${ref}: ${entry.path} (${entry.mediaType}, ${entry.bytes} bytes)`);
-    }
-  }
-  if (lines.length === 0) return summary;
-  const heading = "\n\nImages captured in this range were archived to disk (their pixels are NOT summarized). Re-read them with your file tools if you need the pixels again:";
-  return summary + heading + "\n" + lines.join("\n");
-}
-
 // lib/compress/keep-markers.ts
 var KEEP_REGEX = /\[\[KEEP:(m\d+)\]\]/g;
 var REF_REGEX = /\[\[REF:(m\d+)\|([^\]]+)\]\]/g;
@@ -7576,6 +7816,7 @@ function estimateContextComposition(messages, state, protectedTools = [], protec
   let messageTokens = 0;
   let protectedTokens = 0;
   let reasoningTokens = 0;
+  let imageTokens = 0;
   const perMessage = [];
   const perTool = [];
   const perCode = [];
@@ -7633,6 +7874,12 @@ function estimateContextComposition(messages, state, protectedTools = [], protec
         const tokens = Math.round(part.text.length / 4);
         msgTotal += tokens;
         reasoningTokens += tokens;
+      } else if (part.type === "file") {
+        const imgTokens = estimateImagePartTokens(part);
+        if (imgTokens > 0) {
+          msgTotal += imgTokens;
+          imageTokens += imgTokens;
+        }
       }
     }
     if (isProtected && !isSummary) {
@@ -7661,7 +7908,8 @@ function estimateContextComposition(messages, state, protectedTools = [], protec
     systemTokens,
     protectedTokens,
     reasoningTokens,
-    total: systemTokens + toolTokens + summaryTokens + messageTokens + reasoningTokens,
+    imageTokens,
+    total: systemTokens + toolTokens + summaryTokens + messageTokens + reasoningTokens + imageTokens,
     largestRanges: perMessage.slice(0, 15),
     largestToolRanges: perTool.slice(0, 15),
     largestCodeRanges: perCode.slice(0, 5),
@@ -7942,6 +8190,8 @@ function computeProtectedRefs(messages, state, compress) {
     for (const part of msg.parts || []) {
       if (part.type === "text" && typeof part.text === "string") {
         tokens += Math.round(part.text.length / 4);
+      } else if (part.type === "file") {
+        tokens += estimateImagePartTokens(part);
       } else if (part.type !== "text" && part.type !== "reasoning") {
         tokens += Math.round(JSON.stringify(part).length / 4);
       }
@@ -8359,7 +8609,7 @@ function createCompressRangeTool(factoryCtx) {
           );
           preparedPlan.finalSummary = keepResult.summary;
           const storedSummary = wrapCompressedSummary(blockId, preparedPlan.finalSummary);
-          const summaryTokens = countTokens2(storedSummary);
+          const summaryTokens = countTokens(storedSummary);
           const applied = applyCompressionState(
             ctx.state,
             {
@@ -8696,6 +8946,73 @@ var syncCompressPermissionState = (state, config, hostPermissions, messages) =>
   );
 };
 
+// lib/messages/large-images.ts
+var IMAGE_SURGE_DEDUP_CAP = 512;
+function detectNewLargeImages(messages, state, largeBytes) {
+  if (!Number.isFinite(largeBytes) || largeBytes <= 0) return [];
+  const nudged = state.imageSurgeNudged ??= {};
+  const found = [];
+  for (const message of messages) {
+    const rawId = message.info.id;
+    if (!rawId) continue;
+    const ref = state.messageIds.byRawId.get(rawId);
+    if (!ref) continue;
+    const parts = Array.isArray(message.parts) ? message.parts : [];
+    for (let partIndex = 0; partIndex < parts.length; partIndex++) {
+      const part = parts[partIndex];
+      if (part.type !== "file") continue;
+      const parsed = parseImageDataUrl(part.url);
+      if (!parsed) continue;
+      if (!extForMediaType(parsed.mediaType)) continue;
+      const bytes = decodedBytesFromBase64(parsed.base64);
+      if (bytes < largeBytes) continue;
+      const slotPrefix = `${sha8(rawId)}:p${partIndex}:`;
+      let slotSeen = false;
+      for (const key2 of Object.keys(nudged)) {
+        if (key2.startsWith(slotPrefix)) {
+          slotSeen = true;
+          break;
+        }
+      }
+      if (slotSeen) continue;
+      const key = `${slotPrefix}${sha8(parsed.base64)}`;
+      if (nudged[key] !== void 0) continue;
+      nudged[key] = Date.now();
+      found.push({
+        ref,
+        mediaType: parsed.mediaType,
+        bytes,
+        estimatedTokens: estimateImagePartTokens(part)
+      });
+    }
+  }
+  const keys = Object.keys(nudged);
+  if (keys.length > IMAGE_SURGE_DEDUP_CAP) {
+    for (const key of keys.slice(0, keys.length - IMAGE_SURGE_DEDUP_CAP)) {
+      delete nudged[key];
+    }
+  }
+  return found;
+}
+function formatBytes(bytes) {
+  if (bytes >= 1048576) return `${(bytes / 1048576).toFixed(1)} MB`;
+  return `${Math.max(1, Math.round(bytes / 1024))} KB`;
+}
+function formatLargeImageNotice(images) {
+  const items = images.map(
+    (image) => `- ${image.ref}: ${image.mediaType}, ${formatBytes(image.bytes)} (\u2248${formatTokens(image.estimatedTokens)} vision tokens; far more if your provider bills base64 as text)`
+  ).join("\n");
+  return `
+
+\u{1F5BC}\uFE0F Large image(s) just entered context:
+${items}
+Before doing anything else, make room: call the \`compress\` tool NOW on older conversation ranges you no longer need (acp_status lists them). Once you are done analyzing the image(s), compress the range(s) containing them \u2014 archived copies stay re-readable via their disk pointers.`;
+}
+function formatTokens(n) {
+  if (!Number.isFinite(n) || n <= 0) return "0";
+  return n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
+}
+
 // lib/prompts/context-limit-nudge.ts
 var CONTEXT_LIMIT_NUDGE = `
 <system-reminder>
@@ -9513,6 +9830,21 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
   let shouldInjectNotice = emergencyNoTargets && noticeCadenceMet;
   let shouldInject = shouldInjectNudge || shouldInjectNotice;
   let armedSmartPlan;
+  const imagesConfig = config.compress?.images ?? DEFAULT_COMPRESS_IMAGES;
+  let imageNoticeEmitted = false;
+  if (suffixMessage && imagesConfig.nudge !== false && imagesConfig.largeBytes > 0) {
+    const newLargeImages = detectNewLargeImages(messages, state, imagesConfig.largeBytes);
+    if (newLargeImages.length > 0) {
+      appendToLastTextPart(suffixMessage, formatLargeImageNotice(newLargeImages));
+      imageNoticeEmitted = true;
+      saveSessionState(state, logger).catch(() => {
+      });
+      logger.info("Large image notice injected", {
+        session: state.sessionId,
+        images: newLargeImages.map((image) => `${image.ref}:${image.mediaType}:${image.bytes}B`)
+      });
+    }
+  }
   if (shouldInjectNudge && config.compress.smartPlanRequired === true && state.sessionId) {
     const planningRanges = candidatesEnabled ? candidatePlan.candidates.map((candidate) => ({
       startRef: candidate.startRef,
@@ -9575,7 +9907,7 @@ ${ITERATION_CANDIDATE_GUIDANCE}` : ITERATION_CANDIDATE_GUIDANCE
     state.nudges.lastPerMessageNudgeTokens = currentTokens;
     baselineReEstablished = true;
   }
-  if (suffixMessage && !shouldInject) {
+  if (suffixMessage && !shouldInject && !imageNoticeEmitted) {
     const tierUsage = tierUsageEarly;
     const tierChecks = [
       {
@@ -9678,7 +10010,7 @@ ${rules}`;
       break;
     }
   }
-  state.nudges.shouldInjectThisTurn = shouldInject;
+  state.nudges.shouldInjectThisTurn = shouldInject || imageNoticeEmitted;
   const usagePct = currentTokens !== void 0 && modelContextLimit ? `${(currentTokens / modelContextLimit * 100).toFixed(1)}%` : void 0;
   if (shouldInjectNudge) {
     logger.info("Compression nudge injected", {
@@ -9738,7 +10070,7 @@ ${rules}`;
       const efficiencyNote = effectiveTipsVariant !== "maxLimit" ? candidatesEnabled ? "\nThis is an efficiency nudge to compress early when content is no longer needed and keep context lean \u2014 not an overflow warning. A separate, stronger alert will appear if the context is actually full.\n\n" + COMPRESS_PHILOSOPHY : "\nThis 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.\n\n" + COMPRESS_PHILOSOPHY : "";
       const sysPart = composition.systemTokens > 0 ? `${fmt(composition.systemTokens)} system (${pct2(composition.systemTokens)}%) | ` : "";
       let breakdown = `${efficiencyNote}
-Breakdown: ${sysPart}${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)}%) | ${fmt(composition.reasoningTokens)} reasoning (${pct2(composition.reasoningTokens)}%)${growthStr}`;
+Breakdown: ${sysPart}${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)}%) | ${fmt(composition.reasoningTokens)} reasoning (${pct2(composition.reasoningTokens)}%) | ${fmt(composition.imageTokens)} images (${pct2(composition.imageTokens)}%)${growthStr}`;
       const compressibleTokens = composition.total - composition.systemTokens - composition.protectedTokens - composition.summaryTokens;
       if (composition.protectedTokens > 0) {
         breakdown += `
@@ -10698,7 +11030,7 @@ Use this tool to:
 - Focus on ranges only (scope:"uncompressed")
 - Find all messages of a specific tool type (scope:"uncompressed", view:"messages", tool:"bash")
 - Check block details before decompressing (scope:"compressed")`;
-function formatTokens(n) {
+function formatTokens2(n) {
   if (!Number.isFinite(n) || n <= 0) return "0";
   return n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
 }
@@ -10742,7 +11074,7 @@ function tierBreakdown(blocks) {
   const parts = [];
   for (const t of [1, 2, 3]) {
     if (tierTokens[t]) {
-      parts.push(`T${t}: ${formatTokens(tierTokens[t])}`);
+      parts.push(`T${t}: ${formatTokens2(tierTokens[t])}`);
     }
   }
   return parts.join(" | ");
@@ -10768,10 +11100,13 @@ function collectVisibleMessages(rawMessages, ctx) {
     if (!ref) return;
     let tokens = 0;
     let reasoning = 0;
+    let image = 0;
     let toolName = "";
     for (const part of msg.parts || []) {
       if (part.type === "text" && typeof part.text === "string") {
         tokens += Math.round(part.text.length / 4);
+      } else if (part.type === "file") {
+        image += estimateImagePartTokens(part);
       } else if (part.type === "tool") {
         const raw = JSON.stringify(part);
         tokens += Math.round(raw.length / 4);
@@ -10782,8 +11117,8 @@ function collectVisibleMessages(rawMessages, ctx) {
         reasoning += Math.round(part.text.length / 4);
       }
     }
-    if (tokens > 0 || reasoning > 0) {
-      result.push({ ref, tokens, tool: toolName || "text", index: idx, reasoning });
+    if (tokens > 0 || reasoning > 0 || image > 0) {
+      result.push({ ref, tokens, tool: toolName || "text", index: idx, reasoning, image });
     }
   });
   return {
@@ -10806,15 +11141,17 @@ function renderOverview(visibleMessages, summaryTokens, systemTokens, blocks, fe
     const totalTool = visibleMessages.filter((m) => m.tool !== "text" && m.tool !== "step-finish").reduce((s, m) => s + m.tokens, 0);
     const totalText = visibleMessages.filter((m) => m.tool === "text").reduce((s, m) => s + m.tokens, 0);
     const totalReasoning = visibleMessages.reduce((s, m) => s + m.reasoning, 0);
-    const total = systemTokens + totalTool + totalText + summaryTokens + totalReasoning;
+    const totalImage = visibleMessages.reduce((s, m) => s + m.image, 0);
+    const total = systemTokens + totalTool + totalText + summaryTokens + totalReasoning + totalImage;
     const sysPct = pct(systemTokens, total);
     const toolPct = pct(totalTool, total);
     const textPct = pct(totalText, total);
     const summaryPct = pct(summaryTokens, total);
     const reasoningPct = pct(totalReasoning, total);
+    const imagePct = pct(totalImage, total);
     lines.push("CONTEXT BREAKDOWN");
     lines.push(
-      `  ${formatTokens(systemTokens)} system (${sysPct}%) | ${formatTokens(totalTool)} tool (${toolPct}%) | ${formatTokens(totalText)} text (${textPct}%) | ${formatTokens(summaryTokens)} summaries (${summaryPct}%) | ${formatTokens(totalReasoning)} reasoning (${reasoningPct}%)`
+      `  ${formatTokens2(systemTokens)} system (${sysPct}%) | ${formatTokens2(totalTool)} tool (${toolPct}%) | ${formatTokens2(totalText)} text (${textPct}%) | ${formatTokens2(summaryTokens)} summaries (${summaryPct}%) | ${formatTokens2(totalReasoning)} reasoning (${reasoningPct}%) | ${formatTokens2(totalImage)} images (${imagePct}%)`
     );
     const topTypes = Array.from(toolTypeMap.entries()).map(([tool6, tokens]) => ({ tool: tool6, tokens })).sort((a, b) => b.tokens - a.tokens).slice(0, 3);
     if (topTypes.length > 0) {
@@ -10834,7 +11171,7 @@ function renderOverview(visibleMessages, summaryTokens, systemTokens, blocks, fe
       (s, b) => s + getEffectiveCompressedTokens(b, blocksById),
       0
     );
-    const header = `COMPRESSED BLOCKS \u2014 ${blocks.length} active (${formatTokens(totalSummary)} summary, ${formatTokens(totalEffective)} original)`;
+    const header = `COMPRESSED BLOCKS \u2014 ${blocks.length} active (${formatTokens2(totalSummary)} summary, ${formatTokens2(totalEffective)} original)`;
     lines.push(header);
     const breakdown = tierBreakdown(blocks);
     if (breakdown) {
@@ -10853,7 +11190,7 @@ function renderOverview(visibleMessages, summaryTokens, systemTokens, blocks, fe
       const tier = tierLabel(b);
       const effTokens = getEffectiveCompressedTokens(b, blocksById);
       lines.push(
-        `  b${b.blockId} (${tier})  ${formatTokens(effTokens)}\u2192${formatTokens(b.summaryTokens)}  ${ageStr}  ${range}  "${topic}"`
+        `  b${b.blockId} (${tier})  ${formatTokens2(effTokens)}\u2192${formatTokens2(b.summaryTokens)}  ${ageStr}  ${range}  "${topic}"`
       );
     }
   }
@@ -10914,7 +11251,7 @@ function renderUncompressedRanges(rawMessages, ctx) {
   const totalMsgs = compressible.reduce((s, r) => s + r.count, 0);
   const lines = [];
   lines.push(
-    `UNCOMPRESSED \u2014 ${formatTokens(totalTokens)} | ${totalMsgs} msgs in ${compressible.length} ranges`
+    `UNCOMPRESSED \u2014 ${formatTokens2(totalTokens)} | ${totalMsgs} msgs in ${compressible.length} ranges`
   );
   lines.push("");
   if (compressible.length === 0 && contextRanges.protected.length === 0) {
@@ -10971,7 +11308,7 @@ function renderUncompressedDrilldown(visibleMessages, toolFilter, sort, limit) {
   if (toolFilter) {
     filtered = filtered.filter((m) => m.tool === toolFilter);
   }
-  const sizeOf = (m) => m.tokens + m.reasoning;
+  const sizeOf = (m) => m.tokens + m.reasoning + m.image;
   if (sort === "time") {
     filtered.sort((a, b) => a.index - b.index);
   } else if (sort === "tool") {
@@ -10981,13 +11318,13 @@ function renderUncompressedDrilldown(visibleMessages, toolFilter, sort, limit) {
   }
   const totalTokens = filtered.reduce((s, m) => s + sizeOf(m), 0);
   const allTokens = visibleMessages.reduce((s, m) => s + sizeOf(m), 0);
-  const header = toolFilter ? `UNCOMPRESSED \u2014 ${toolFilter}: ${formatTokens(totalTokens)} | ${filtered.length} msgs | ${pct(totalTokens, allTokens)}% of visible` : `UNCOMPRESSED \u2014 ${formatTokens(totalTokens)} | ${filtered.length} msgs`;
+  const header = toolFilter ? `UNCOMPRESSED \u2014 ${toolFilter}: ${formatTokens2(totalTokens)} | ${filtered.length} msgs | ${pct(totalTokens, allTokens)}% of visible` : `UNCOMPRESSED \u2014 ${formatTokens2(totalTokens)} | ${filtered.length} msgs`;
   lines.push(header);
   lines.push(`Sorted by ${sort}`);
   lines.push("");
   const shown = filtered.slice(0, limit);
   for (const m of shown) {
-    lines.push(`  ${m.ref} (${formatTokens(sizeOf(m))}) ${m.tool}`);
+    lines.push(`  ${m.ref} (${formatTokens2(sizeOf(m))}) ${m.tool}`);
   }
   if (filtered.length > shown.length) {
     lines.push("");
@@ -11026,7 +11363,7 @@ function renderCompressedDrilldown(blocks, sort, limit, blocksById) {
     0
   );
   lines.push(
-    `COMPRESSED \u2014 ${sorted.length} blocks | ${formatTokens(totalEffective)} original \u2192 ${formatTokens(totalSummary)} summary`
+    `COMPRESSED \u2014 ${sorted.length} blocks | ${formatTokens2(totalEffective)} original \u2192 ${formatTokens2(totalSummary)} summary`
   );
   const breakdown = tierBreakdown(sorted);
   if (breakdown) {
@@ -11051,7 +11388,7 @@ function renderCompressedDrilldown(blocks, sort, limit, blocksById) {
     const tier = tierLabel(b);
     const effTokens = getEffectiveCompressedTokens(b, blocksById);
     lines.push(
-      `  b${b.blockId} (${tier})  ${formatTokens(effTokens)}\u2192${formatTokens(b.summaryTokens)}  ${formatAge(b.createdAt)}  ${formatIdRange(b)}  age=${survived} ${gen} eff=${effCount}${consumed}${status}`
+      `  b${b.blockId} (${tier})  ${formatTokens2(effTokens)}\u2192${formatTokens2(b.summaryTokens)}  ${formatAge(b.createdAt)}  ${formatIdRange(b)}  age=${survived} ${gen} eff=${effCount}${consumed}${status}`
     );
     lines.push(`    "${topic}"`);
   }
@@ -11329,7 +11666,7 @@ import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
 import { join as join5 } from "path";
 import { existsSync as existsSync5 } from "fs";
 import { homedir as homedir3 } from "os";
-var LOG_VERSION = true ? "1.18.4" : "dev";
+var LOG_VERSION = true ? "1.18.5-pr.490.223" : "dev";
 var LEVEL_RANK = {
   debug: 10,
   info: 20,
@@ -11780,6 +12117,8 @@ NOTE: Message-mode blocks created in the same batch (same runId) are restored to
 Decompressing one block from a batch restores all blocks in that batch.
 </dcp-system-reminder>
 `;
+var IMAGE_GUARD_SYSTEM_EXTENSION = `
+IMAGE HANDLING: Before reading an image file into context, make sure there is room: if context usage is high, compress older conversation ranges first. A large image consumes significant context for as long as it stays uncompressed. Once you are done analyzing an image, prefer compressing the range that contains it \u2014 archived images remain re-readable through their disk pointers.`;
 
 // lib/prompts/store.ts
 var PROMPT_DEFINITIONS = [
@@ -12116,7 +12455,7 @@ var PromptStore = class {
 };
 
 // lib/prompts/index.ts
-function renderSystemPrompt(prompts, protectedToolsExtension, subagent) {
+function renderSystemPrompt(prompts, protectedToolsExtension, subagent, imageGuardExtension) {
   const extensions = [];
   if (protectedToolsExtension) {
     extensions.push(protectedToolsExtension.trim());
@@ -12124,6 +12463,9 @@ function renderSystemPrompt(prompts, protectedToolsExtension, subagent) {
   if (subagent) {
     extensions.push(prompts.subagentExtension.trim());
   }
+  if (imageGuardExtension) {
+    extensions.push(imageGuardExtension.trim());
+  }
   extensions.push(prompts.decompressExtension.trim());
   return [prompts.system.trim(), ...extensions].filter(Boolean).join("\n\n").replace(/\n([ \t]*\n)+/g, "\n\n").trim();
 }
@@ -12184,11 +12526,12 @@ function truncateLargeToolOutputs(state, config, logger, messages) {
       const part = parts[pi];
       if (part?.type !== "tool") continue;
       if (part.state?.status !== "completed") continue;
+      if (part.tool === "compress") continue;
       const content = extractCompletedToolOutput(part);
       if (content === void 0) continue;
       if (content === "[Old tool result content cleared]") continue;
       if (content.includes(TRUNCATION_MARKER)) continue;
-      const tokens = countTokens2(content);
+      const tokens = countTokens(content);
       if (tokens < MIN_OUTPUT_TOKENS) continue;
       candidates.push({ part, content, tokens });
     }
@@ -12209,7 +12552,7 @@ function truncateLargeToolOutputs(state, config, logger, messages) {
 
 ` + suffix;
     part.state.output = truncated;
-    savedTokens += tokens - countTokens2(truncated);
+    savedTokens += tokens - countTokens(truncated);
     truncatedCount++;
   }
   if (truncatedCount > 0) {
@@ -12224,6 +12567,74 @@ function truncateLargeToolOutputs(state, config, logger, messages) {
   }
 }
 
+// lib/messages/sticky-truncation.ts
+function collectToolParts(messages) {
+  const parts = [];
+  for (const message of messages) {
+    const messageParts = Array.isArray(message.parts) ? message.parts : [];
+    for (const part of messageParts) {
+      if (part?.type === "tool") {
+        parts.push(part);
+      }
+    }
+  }
+  return parts;
+}
+function applyStickyTruncations(state, messages, logger) {
+  const frozen = state.stickyTruncations;
+  if (Object.keys(frozen).length === 0) return;
+  let replayed = 0;
+  const seen = /* @__PURE__ */ new Set();
+  for (const part of collectToolParts(messages)) {
+    const callID = typeof part.callID === "string" ? part.callID : void 0;
+    if (!callID) continue;
+    seen.add(callID);
+    const recorded = frozen[callID];
+    if (recorded === void 0) continue;
+    if (!part.state) continue;
+    if (part.state.output === recorded) continue;
+    part.state.output = recorded;
+    replayed++;
+  }
+  for (const callID of Object.keys(frozen)) {
+    if (!seen.has(callID)) delete frozen[callID];
+  }
+  if (replayed > 0) {
+    logger.debug("Sticky truncation: replayed frozen tool outputs", {
+      replayed,
+      frozen: Object.keys(frozen).length
+    });
+  }
+}
+function snapshotToolOutputs(messages) {
+  const snapshot = /* @__PURE__ */ new Map();
+  for (const part of collectToolParts(messages)) {
+    const callID = typeof part.callID === "string" ? part.callID : void 0;
+    if (!callID) continue;
+    const content = extractCompletedToolOutput(part);
+    if (content === void 0) continue;
+    snapshot.set(callID, content);
+  }
+  return snapshot;
+}
+function recordStickyTruncations(state, messages, before, logger) {
+  let recorded = 0;
+  for (const part of collectToolParts(messages)) {
+    const callID = typeof part.callID === "string" ? part.callID : void 0;
+    if (!callID) continue;
+    if (typeof part.state?.output !== "string") continue;
+    const prior = before.get(callID);
+    if (prior === void 0 || prior === part.state.output) continue;
+    if (state.stickyTruncations[callID] === part.state.output) continue;
+    state.stickyTruncations[callID] = part.state.output;
+    recorded++;
+  }
+  if (recorded > 0) {
+    logger.info("Sticky truncation: froze truncated tool outputs", { recorded });
+  }
+  return recorded;
+}
+
 // lib/messages/enforce-budget.ts
 var DEFAULT_COMPLETION_RESERVE_TOKENS = 32768;
 var TRUNCATION_MARKER2 = "[truncated for context space";
@@ -12295,7 +12706,7 @@ function enforceContextBudget(state, config, logger, messages) {
       const content = extractCompletedToolOutput(part);
       if (content === void 0) continue;
       if (content === COMPACTED_TOOL_OUTPUT_PLACEHOLDER) continue;
-      const tokens = countTokens2(content);
+      const tokens = countTokens(content);
       if (tokens <= 0) continue;
       candidates.push({ part, content, tokens, index: mi });
     }
@@ -12317,20 +12728,20 @@ function enforceContextBudget(state, config, logger, messages) {
 ` + suffix;
     if (truncated.length >= c.content.length) continue;
     c.part.state.output = truncated;
-    saved += c.tokens - countTokens2(truncated);
+    saved += c.tokens - countTokens(truncated);
     truncatedCount++;
   }
   if (estimatedTokens - saved > budget) {
     const clearable = candidates.filter((c) => {
       const out = extractCompletedToolOutput(c.part);
-      return out !== void 0 && out !== COMPACTED_TOOL_OUTPUT_PLACEHOLDER && countTokens2(out) > MIN_CLEAR_TOKENS;
+      return out !== void 0 && out !== COMPACTED_TOOL_OUTPUT_PLACEHOLDER && countTokens(out) > MIN_CLEAR_TOKENS;
     }).sort((a, b) => a.index - b.index);
     for (const c of clearable) {
       if (estimatedTokens - saved <= budget) break;
       const current = extractCompletedToolOutput(c.part);
       if (current === void 0 || current === COMPACTED_TOOL_OUTPUT_PLACEHOLDER) continue;
       c.part.state.output = COMPACTED_TOOL_OUTPUT_PLACEHOLDER;
-      saved += countTokens2(current) - countTokens2(COMPACTED_TOOL_OUTPUT_PLACEHOLDER);
+      saved += countTokens(current) - countTokens(COMPACTED_TOOL_OUTPUT_PLACEHOLDER);
       clearedCount++;
     }
   }
@@ -12474,10 +12885,10 @@ function analyzeTokens(state, messages) {
   breakdown.toolsInContextCount = toolsInContextCount;
   breakdown.prunedToolCount = prunedToolIds.size;
   breakdown.prunedMessageCount = prunedMessageCount;
-  const firstUserTokens = countTokens2(firstUserText);
-  breakdown.user = countTokens2(userTextParts.join("\n"));
-  const toolInputTokens = countTokens2(toolInputParts.join("\n"));
-  const toolOutputTokens = countTokens2(toolOutputParts.join("\n"));
+  const firstUserTokens = countTokens(firstUserText);
+  breakdown.user = countTokens(userTextParts.join("\n"));
+  const toolInputTokens = countTokens(toolInputParts.join("\n"));
+  const toolOutputTokens = countTokens(toolOutputParts.join("\n"));
   if (firstAssistant) {
     const firstInput = (firstAssistant.tokens?.input || 0) + (firstAssistant.tokens?.cache?.read || 0) + (firstAssistant.tokens?.cache?.write || 0);
     breakdown.system = Math.max(0, firstInput - firstUserTokens);
@@ -12689,7 +13100,7 @@ function resolveDefaultOutputPath(sessionId, cwd2) {
   const short = (sessionId || "session").slice(0, 8);
   return join7(cwd2, ".opencode", `acp-export-${short}.md`);
 }
-function formatTokens2(n) {
+function formatTokens3(n) {
   if (!Number.isFinite(n) || n <= 0) return "0";
   return n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
 }
@@ -12742,7 +13153,7 @@ function renderExportMarkdown(params) {
   const span = tokenSpans(blocks);
   if (blocks.length > 0) {
     out.push(
-      `- **Coverage**: ${formatTokens2(span.effective)} original \u2192 ${formatTokens2(span.summary)} summary`
+      `- **Coverage**: ${formatTokens3(span.effective)} original \u2192 ${formatTokens3(span.summary)} summary`
     );
   }
   out.push("");
@@ -12773,7 +13184,7 @@ function renderExportMarkdown(params) {
         out.push(`- **Tier**: T${tier} \xB7 **Mode**: ${mode}`);
         out.push(`- **Messages**: ${msgCount} (effective)`);
         out.push(
-          `- **Tokens**: ${formatTokens2(effectiveTokens(block))} \u2192 ${formatTokens2(block.summaryTokens || 0)} summary`
+          `- **Tokens**: ${formatTokens3(effectiveTokens(block))} \u2192 ${formatTokens3(block.summaryTokens || 0)} summary`
         );
         out.push(`- **Created**: ${created}`);
         out.push(`- **Age**: survived ${age} transform${age === 1 ? "" : "s"}`);
@@ -13243,7 +13654,7 @@ function mergeMarkedBlocks(state, markedIds, maxMergedLength) {
   const mergedRaw = bodies.join("\n---\n");
   const mergedBody = truncateMergedSummary(mergedRaw, maxMergedLength);
   const newSummary = wrapCompressedSummary(newBlockId, mergedBody);
-  const newSummaryTokens = countTokens2(newSummary);
+  const newSummaryTokens = countTokens(newSummary);
   const oldest = sourceBlocks[0];
   const newest = sourceBlocks[sourceBlocks.length - 1];
   const effectiveMessageIds = /* @__PURE__ */ new Set();
@@ -13419,7 +13830,8 @@ function createSystemPromptHandler(registry4, logger, config, prompts) {
     const newPrompt = renderSystemPrompt(
       runtimePrompts,
       buildProtectedToolsExtension(config.compress.protectedTools),
-      state.isSubAgent && config.allowSubAgents
+      state.isSubAgent && config.allowSubAgents,
+      (config.compress.images ?? DEFAULT_COMPRESS_IMAGES).nudge !== false ? IMAGE_GUARD_SYSTEM_EXTENSION : void 0
     );
     if (output.system.length > 0) {
       output.system[output.system.length - 1] += "\n\n" + newPrompt;
@@ -13594,13 +14006,32 @@ ${text}`);
       prePruneTokens,
       candidateMessages
     );
-    truncateLargeToolOutputs(
-      state,
+    const emergencyTruncationEnabled = applyCompressOverrides(
       config,
-      logger,
-      output.messages.filter((message) => !isSyntheticMessage(message))
-    );
-    enforceContextBudget(state, config, logger, output.messages);
+      dropReasoningModel?.providerID ?? state.modelProviderID,
+      dropReasoningModel?.modelID ?? state.modelID
+    ).compress.emergencyTruncation;
+    if (emergencyTruncationEnabled === true) {
+      applyStickyTruncations(state, output.messages, logger);
+      const toolOutputsBefore = snapshotToolOutputs(output.messages);
+      truncateLargeToolOutputs(
+        state,
+        config,
+        logger,
+        output.messages.filter((message) => !isSyntheticMessage(message))
+      );
+      enforceContextBudget(state, config, logger, output.messages);
+      const frozenCount = recordStickyTruncations(
+        state,
+        output.messages,
+        toolOutputsBefore,
+        logger
+      );
+      if (frozenCount > 0) {
+        saveSessionState(state, logger).catch(() => {
+        });
+      }
+    }
     injectMessageIds(state, config, output.messages, compressionPriorities);
     hideFailedCompressCalls(output.messages);
     stripStaleMetadata(output.messages);
@@ -14039,7 +14470,7 @@ var server = (async (ctx) => {
   }
   const logger = new Logger(config.debug, config.debug ? "debug" : config.logLevel);
   logger.info("ACP plugin initialized", {
-    version: true ? "1.18.4" : "dev",
+    version: true ? "1.18.5-pr.490.223" : "dev",
     workspace: ctx.directory,
     logLevel: logger.level,
     debug: config.debug,