opencode-acp 1.18.3 → 1.18.4-pr.483.216

package/dist/index.js

@@ -916,6 +916,10 @@ var VALID_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "compress.reasoning",
   "compress.reasoning.drop",
   "compress.reasoning.threshold",
+  "compress.images",
+  "compress.images.enabled",
+  "compress.images.minBytes",
+  "compress.images.ttlDays",
   "compress.completionReserveTokens",
   "gc",
   "gc.algorithm",
@@ -1308,6 +1312,37 @@ function validateConfigTypes(config) {
           }
         }
       }
+      if (compress.images !== void 0) {
+        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) }",
+            actual: JSON.stringify(compress.images)
+          });
+        } else {
+          if (compress.images.enabled !== void 0 && typeof compress.images.enabled !== "boolean") {
+            errors.push({
+              key: "compress.images.enabled",
+              expected: "boolean",
+              actual: typeof compress.images.enabled
+            });
+          }
+          if (compress.images.minBytes !== void 0 && (typeof compress.images.minBytes !== "number" || !Number.isInteger(compress.images.minBytes) || compress.images.minBytes < 0)) {
+            errors.push({
+              key: "compress.images.minBytes",
+              expected: "integer (>= 0)",
+              actual: JSON.stringify(compress.images.minBytes)
+            });
+          }
+          if (compress.images.ttlDays !== void 0 && (typeof compress.images.ttlDays !== "number" || !Number.isFinite(compress.images.ttlDays) || compress.images.ttlDays <= 0)) {
+            errors.push({
+              key: "compress.images.ttlDays",
+              expected: "number (> 0)",
+              actual: JSON.stringify(compress.images.ttlDays)
+            });
+          }
+        }
+      }
       if (compress.completionReserveTokens !== void 0 && typeof compress.completionReserveTokens !== "number") {
         errors.push({
           key: "compress.completionReserveTokens",
@@ -1695,6 +1730,11 @@ var DEFAULT_COMPRESS_REASONING = {
   drop: true,
   threshold: 2048
 };
+var DEFAULT_COMPRESS_IMAGES = {
+  enabled: true,
+  minBytes: 16384,
+  ttlDays: 7
+};
 var DEFAULT_PROTECTED_TOOLS = [
   "task",
   "skill",
@@ -1793,7 +1833,8 @@ var defaultConfig = {
     preserveRecentMessages: 5,
     preserveRecentTokens: 5e3,
     preserveLastUserMessage: true,
-    reasoning: { ...DEFAULT_COMPRESS_REASONING }
+    reasoning: { ...DEFAULT_COMPRESS_REASONING },
+    images: { ...DEFAULT_COMPRESS_IMAGES }
   },
   gc: {
     algorithm: "truncate",
@@ -1971,6 +2012,11 @@ function mergeCompress(base, override) {
       drop: override.reasoning?.drop ?? base.reasoning?.drop ?? DEFAULT_COMPRESS_REASONING.drop,
       threshold: override.reasoning?.threshold ?? base.reasoning?.threshold ?? DEFAULT_COMPRESS_REASONING.threshold
     },
+    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
+    },
     completionReserveTokens: override.completionReserveTokens ?? base.completionReserveTokens
   };
 }
@@ -2908,7 +2954,8 @@ function saveSessionState(sessionState, logger, sessionName) {
     lastCompaction: sessionState.lastCompaction,
     modelContextLimit: sessionState.modelContextLimit,
     modelProviderID: sessionState.modelProviderID,
-    modelID: sessionState.modelID
+    modelID: sessionState.modelID,
+    imageArchive: sessionState.imageArchive
   };
   const key = saveQueueKey(sessionState.sessionId, sessionState.storageDir);
   let queue = saveQueues.get(key);
@@ -5075,7 +5122,9 @@ function createSessionState() {
     systemPromptTokens: void 0,
     storageDir: void 0,
     qualityGateRetryPending: false,
-    noContextLimitWarned: false
+    noContextLimitWarned: false,
+    imageArchive: {},
+    imagePruneDone: false
   };
 }
 function resetSessionState(state) {
@@ -5119,6 +5168,8 @@ function resetSessionState(state) {
   state.storageDir = void 0;
   state.qualityGateRetryPending = false;
   state.noContextLimitWarned = false;
+  state.imageArchive = {};
+  state.imagePruneDone = false;
 }
 async function ensureSessionInitialized(client, state, sessionId, logger, messages, config, projectDir) {
   if (state.sessionId === sessionId) {
@@ -5197,8 +5248,21 @@ async function ensureSessionInitialized(client, state, sessionId, logger, messag
   state.nudges.compressBaselineSet = persisted.nudges.compressBaselineSet ?? false;
   state.stats = {
     pruneTokenCounter: persisted.stats?.pruneTokenCounter || 0,
-    totalPruneTokens: persisted.stats?.totalPruneTokens || 0
+    totalPruneTokens: persisted.stats?.totalPruneTokens || 0,
+    imagesArchived: persisted.stats?.imagesArchived,
+    imageBytesArchived: persisted.stats?.imageBytesArchived
   };
+  if (persisted.imageArchive && typeof persisted.imageArchive === "object") {
+    for (const [rawId, entries] of Object.entries(persisted.imageArchive)) {
+      if (!Array.isArray(entries)) continue;
+      const valid = entries.filter(
+        (e) => !!e && typeof e.path === "string" && typeof e.mediaType === "string" && typeof e.bytes === "number"
+      );
+      if (valid.length > 0) {
+        state.imageArchive[rawId] = valid;
+      }
+    }
+  }
   const persistedAny = persisted;
   if (persistedAny._persistedMessageIds) {
     state.messageIds = {
@@ -6611,6 +6675,156 @@ 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;
@@ -6785,12 +6999,12 @@ ${afterClose}`;
 }
 
 // lib/messages/utils.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 var SUMMARY_ID_HASH_LENGTH = 16;
 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 = createHash2("sha256").update(seed).digest("hex").slice(0, SUMMARY_ID_HASH_LENGTH);
+  const hash = createHash3("sha256").update(seed).digest("hex").slice(0, SUMMARY_ID_HASH_LENGTH);
   return `${prefix}_${hash}`;
 };
 var createSyntheticMessage = (baseMessage, content, stableSeed, role = "user") => {
@@ -7203,7 +7417,8 @@ function resolveMinNudgeFloorTokens(config, modelContextLimit, providerId, model
 }
 var OVERRIDE_BLANKET_APPLY_EXCLUDE = /* @__PURE__ */ new Set([
   "maxContextLimit",
-  "reasoning"
+  "reasoning",
+  "images"
 ]);
 function applyCompressOverrides(config, providerId, modelId) {
   const overrides = resolveCompressOverrides(config, providerId, modelId);
@@ -8057,7 +8272,12 @@ function createCompressRangeTool(factoryCtx) {
           entry: plan.entry,
           selection: plan.selection,
           anchorMessageId: plan.anchorMessageId,
-          finalSummary: completedSummary.expandedSummary,
+          finalSummary: appendArchivedImagePointers(
+            completedSummary.expandedSummary,
+            plan.selection,
+            ctx.state,
+            ctx.config.compress.images?.enabled !== false
+          ),
           consumedBlockIds: mergeConsumedBlockIds
         });
       }
@@ -9733,6 +9953,66 @@ function dropCompressReasoning(messages, threshold) {
   return removed;
 }
 
+// lib/messages/reasoning-canonicalize.ts
+var CANONICAL_OPEN = "<thinking>\n";
+var CANONICAL_CLOSE = "\n</thinking>";
+function canonicalizeReasoningShape(messages) {
+  let normalized = 0;
+  for (const message of messages) {
+    if (!message || message.info.role !== "assistant") {
+      continue;
+    }
+    const parts = Array.isArray(message.parts) ? message.parts : [];
+    let allReasoning = "";
+    for (const part of parts) {
+      if (part.type === "reasoning") {
+        allReasoning += part.text;
+      }
+    }
+    if (allReasoning.length === 0) {
+      continue;
+    }
+    let allText = "";
+    for (const part of parts) {
+      if (part.type === "text") {
+        allText += part.text;
+      }
+    }
+    const merged = allText.length > 0 ? `${CANONICAL_OPEN}${allReasoning}${CANONICAL_CLOSE}
+${allText}` : `${CANONICAL_OPEN}${allReasoning}${CANONICAL_CLOSE}`;
+    const rebuilt = [];
+    let placed = false;
+    const placeMerged = (carrier) => {
+      if (placed) {
+        return;
+      }
+      placed = true;
+      const part = {
+        id: carrier.id,
+        sessionID: message.info.sessionID,
+        messageID: message.info.id,
+        type: "text",
+        text: merged
+      };
+      rebuilt.push(part);
+    };
+    for (const part of parts) {
+      if (part.type === "reasoning") {
+        placeMerged(part);
+        continue;
+      }
+      if (part.type === "text") {
+        placeMerged(part);
+        continue;
+      }
+      rebuilt.push(part);
+    }
+    message.parts = rebuilt;
+    normalized++;
+  }
+  return normalized;
+}
+
 // lib/messages/priority.ts
 function buildPriorityMap(_config, _state, _messages) {
   return /* @__PURE__ */ new Map();
@@ -11106,10 +11386,10 @@ function hideFailedCompressCalls(messages) {
 
 // lib/logger.ts
 import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { join as join4 } from "path";
-import { existsSync as existsSync4 } from "fs";
+import { join as join5 } from "path";
+import { existsSync as existsSync5 } from "fs";
 import { homedir as homedir3 } from "os";
-var LOG_VERSION = true ? "1.18.3" : "dev";
+var LOG_VERSION = true ? "1.18.4-pr.483.216" : "dev";
 var LEVEL_RANK = {
   debug: 10,
   info: 20,
@@ -11129,8 +11409,8 @@ var Logger = class {
   constructor(enabled, level) {
     const resolved = level !== void 0 && LEVEL_RANK[level] !== void 0 ? level : void 0;
     this.level = resolved ?? (enabled ? "debug" : "warn");
-    const configHome = process.env.XDG_CONFIG_HOME || join4(homedir3(), ".config");
-    this.logDir = join4(configHome, "opencode", "logs", "acp");
+    const configHome = process.env.XDG_CONFIG_HOME || join5(homedir3(), ".config");
+    this.logDir = join5(configHome, "opencode", "logs", "acp");
   }
   /** Back-compat view of the old flag: true only at full debug verbosity. */
   get enabled() {
@@ -11140,7 +11420,7 @@ var Logger = class {
     return LEVEL_RANK[level] >= LEVEL_RANK[this.level];
   }
   async ensureLogDir() {
-    if (!existsSync4(this.logDir)) {
+    if (!existsSync5(this.logDir)) {
       await mkdir2(this.logDir, { recursive: true });
     }
   }
@@ -11192,11 +11472,11 @@ var Logger = class {
       const dataStr = this.formatData(data);
       const logLine = `${timestamp} ${level.padEnd(5)} ${component}: ${message}${dataStr ? " | " + dataStr : ""} | v=${LOG_VERSION}
 `;
-      const dailyLogDir = join4(this.logDir, "daily");
-      if (!existsSync4(dailyLogDir)) {
+      const dailyLogDir = join5(this.logDir, "daily");
+      if (!existsSync5(dailyLogDir)) {
         await mkdir2(dailyLogDir, { recursive: true });
       }
-      const logFile = join4(dailyLogDir, `${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.log`);
+      const logFile = join5(dailyLogDir, `${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.log`);
       await writeFile2(logFile, logLine, { flag: "a" });
     } catch (error) {
     }
@@ -11307,18 +11587,18 @@ var Logger = class {
   async saveContext(sessionId, messages) {
     if (this.level !== "debug") return;
     try {
-      const contextDir = join4(this.logDir, "context", sessionId);
-      if (!existsSync4(contextDir)) {
+      const contextDir = join5(this.logDir, "context", sessionId);
+      if (!existsSync5(contextDir)) {
         await mkdir2(contextDir, { recursive: true });
       }
       const minimized = this.minimizeForDebug(messages).filter(
         (msg) => msg.parts && msg.parts.length > 0
       );
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-      const contextFile = join4(contextDir, `${timestamp}.json`);
+      const contextFile = join5(contextDir, `${timestamp}.json`);
       await writeFile2(contextFile, JSON.stringify(minimized, null, 2));
-      const versionFile = join4(contextDir, "_version");
-      if (!existsSync4(versionFile)) {
+      const versionFile = join5(contextDir, "_version");
+      if (!existsSync5(versionFile)) {
         await writeFile2(versionFile, LOG_VERSION);
       }
     } catch (error) {
@@ -11327,8 +11607,8 @@ var Logger = class {
 };
 
 // lib/prompts/store.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, statSync as statSync2 } from "fs";
-import { join as join5, dirname as dirname2 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync3, statSync as statSync3 } from "fs";
+import { join as join6, dirname as dirname2 } from "path";
 import { homedir as homedir4 } from "os";
 
 // lib/prompts/system.ts
@@ -11636,10 +11916,10 @@ function createBundledRuntimePrompts(candidatesEnabled) {
 function findOpencodeDir2(startDir) {
   let current = startDir;
   while (current !== "/") {
-    const candidate = join5(current, ".opencode");
-    if (existsSync5(candidate)) {
+    const candidate = join6(current, ".opencode");
+    if (existsSync6(candidate)) {
       try {
-        if (statSync2(candidate).isDirectory()) {
+        if (statSync3(candidate).isDirectory()) {
           return candidate;
         }
       } catch {
@@ -11654,13 +11934,13 @@ function findOpencodeDir2(startDir) {
   return null;
 }
 function resolvePromptPaths(workingDirectory) {
-  const configHome = process.env.XDG_CONFIG_HOME || join5(homedir4(), ".config");
-  const globalRoot = join5(configHome, "opencode", "acp-prompts");
-  const defaultsDir = join5(globalRoot, "defaults");
-  const globalOverridesDir = join5(globalRoot, "overrides");
-  const configDirOverridesDir = process.env.OPENCODE_CONFIG_DIR ? join5(process.env.OPENCODE_CONFIG_DIR, "acp-prompts", "overrides") : null;
+  const configHome = process.env.XDG_CONFIG_HOME || join6(homedir4(), ".config");
+  const globalRoot = join6(configHome, "opencode", "acp-prompts");
+  const defaultsDir = join6(globalRoot, "defaults");
+  const globalOverridesDir = join6(globalRoot, "overrides");
+  const configDirOverridesDir = process.env.OPENCODE_CONFIG_DIR ? join6(process.env.OPENCODE_CONFIG_DIR, "acp-prompts", "overrides") : null;
   const opencodeDir = findOpencodeDir2(workingDirectory);
-  const projectOverridesDir = opencodeDir ? join5(opencodeDir, "acp-prompts", "overrides") : null;
+  const projectOverridesDir = opencodeDir ? join6(opencodeDir, "acp-prompts", "overrides") : null;
   return {
     defaultsDir,
     globalOverridesDir,
@@ -11760,7 +12040,7 @@ function buildDefaultsReadmeContent() {
 `;
 }
 function readFileIfExists(filePath) {
-  if (!existsSync5(filePath)) {
+  if (!existsSync6(filePath)) {
     return null;
   }
   try {
@@ -11833,23 +12113,23 @@ var PromptStore = class {
     const candidates = [];
     if (this.paths.projectOverridesDir) {
       candidates.push({
-        path: join5(this.paths.projectOverridesDir, fileName)
+        path: join6(this.paths.projectOverridesDir, fileName)
       });
     }
     if (this.paths.configDirOverridesDir) {
       candidates.push({
-        path: join5(this.paths.configDirOverridesDir, fileName)
+        path: join6(this.paths.configDirOverridesDir, fileName)
       });
     }
     candidates.push({
-      path: join5(this.paths.globalOverridesDir, fileName)
+      path: join6(this.paths.globalOverridesDir, fileName)
     });
     return candidates;
   }
   ensureDefaultFiles() {
     try {
-      mkdirSync2(this.paths.defaultsDir, { recursive: true });
-      mkdirSync2(this.paths.globalOverridesDir, { recursive: true });
+      mkdirSync3(this.paths.defaultsDir, { recursive: true });
+      mkdirSync3(this.paths.globalOverridesDir, { recursive: true });
     } catch {
       this.logger.warn("Failed to initialize prompt directories", {
         defaultsDir: this.paths.defaultsDir,
@@ -11866,13 +12146,13 @@ var PromptStore = class {
       const managedContent = buildDefaultPromptFileContent(
         bundledEditable || bundledPrompts[definition.runtimeField]
       );
-      const filePath = join5(this.paths.defaultsDir, definition.fileName);
+      const filePath = join6(this.paths.defaultsDir, definition.fileName);
       try {
         const existing = readFileIfExists(filePath);
         if (existing === managedContent) {
           continue;
         }
-        writeFileSync2(filePath, managedContent, "utf-8");
+        writeFileSync3(filePath, managedContent, "utf-8");
       } catch {
         this.logger.warn("Failed to write default prompt file", {
           key: definition.key,
@@ -11880,12 +12160,12 @@ var PromptStore = class {
         });
       }
     }
-    const readmePath = join5(this.paths.defaultsDir, DEFAULTS_README_FILE);
+    const readmePath = join6(this.paths.defaultsDir, DEFAULTS_README_FILE);
     const readmeContent = buildDefaultsReadmeContent();
     try {
       const existing = readFileIfExists(readmePath);
       if (existing !== readmeContent) {
-        writeFileSync2(readmePath, readmeContent, "utf-8");
+        writeFileSync3(readmePath, readmeContent, "utf-8");
       }
     } catch {
       this.logger.warn("Failed to write defaults README", {
@@ -12353,8 +12633,8 @@ ${report}`;
 
 // lib/commands/export.ts
 import * as fs2 from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
-import { dirname as dirname3, isAbsolute as isAbsolute2, join as join6, resolve } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join7, resolve } from "path";
 var ALL_TIERS = [1, 2, 3];
 var TIER_NAMES = {
   1: "Tier 1 \u2014 Capture",
@@ -12467,7 +12747,7 @@ function parseTiers(raw) {
 }
 function resolveDefaultOutputPath(sessionId, cwd2) {
   const short = (sessionId || "session").slice(0, 8);
-  return join6(cwd2, ".opencode", `acp-export-${short}.md`);
+  return join7(cwd2, ".opencode", `acp-export-${short}.md`);
 }
 function formatTokens2(n) {
   if (!Number.isFinite(n) || n <= 0) return "0";
@@ -12598,11 +12878,11 @@ async function handleExportCommand(ctx, args) {
   const targetPath = options.outputPath !== "" ? isAbsolute2(options.outputPath) ? options.outputPath : resolve(cwd2, options.outputPath) : resolveDefaultOutputPath(sessionId, cwd2);
   try {
     const dir = dirname3(targetPath);
-    if (!existsSync6(dir)) {
+    if (!existsSync7(dir)) {
       await fs2.mkdir(dir, { recursive: true });
     }
     const flag = options.append ? "a" : "w";
-    if (options.append && existsSync6(targetPath)) {
+    if (options.append && existsSync7(targetPath)) {
       await fs2.appendFile(targetPath, `
 
 ---
@@ -13308,6 +13588,12 @@ function createChatMessageTransformHandler(client, registry4, logger, config, pr
         });
       }
     }
+    const canonicalizedReasoning = canonicalizeReasoningShape(output.messages);
+    if (canonicalizedReasoning > 0) {
+      logger.debug("reasoning-canonicalize: pinned historical thinking shape", {
+        messages: canonicalizedReasoning
+      });
+    }
     ensureBuiltinFiltersRegistered();
     const effectiveLimit = resolveEffectiveContextLimit(state, config);
     applyMessageFilters(output.messages, config.messageFilters, logger, {
@@ -13317,6 +13603,20 @@ function createChatMessageTransformHandler(client, registry4, logger, config, pr
     });
     cacheSystemPromptTokens(state, output.messages);
     assignMessageRefs(state, output.messages);
+    const imagesConfig = config.compress.images ?? DEFAULT_COMPRESS_IMAGES;
+    if (imagesConfig.enabled) {
+      const archivedImages = archiveSessionImages(
+        state,
+        output.messages,
+        imagesConfig,
+        logger
+      );
+      if (archivedImages > 0) {
+        saveSessionState(state, logger).catch(() => {
+        });
+      }
+      pruneImageArchive(state, imagesConfig, logger);
+    }
     const activeBlockCountBefore = state.prune.messages.activeBlockIds.size;
     const compressionStateChanged = syncCompressionBlocks(state, logger, output.messages);
     if (compressionStateChanged || state.prune.messages.activeBlockIds.size !== activeBlockCountBefore) {
@@ -13594,7 +13894,7 @@ function configureClientAuth(client) {
 
 // lib/update.ts
 import { readFile as readFile2, rm } from "fs/promises";
-import { basename, dirname as dirname4, join as join7 } from "path";
+import { basename, dirname as dirname4, join as join8 } from "path";
 import { fileURLToPath } from "url";
 var PACKAGE_NAME = "opencode-acp";
 function startAutoUpdate(ctx, enabled, logger) {
@@ -13641,7 +13941,7 @@ async function checkAutoUpdate(signal, logger) {
     logger?.info("Auto-update skipped: package dir not found");
     return { updated: false };
   }
-  const pkg = await readPackageJson(join7(packageDir, "package.json"));
+  const pkg = await readPackageJson(join8(packageDir, "package.json"));
   if (!pkg?.name || !pkg.version) {
     logger?.info("Auto-update skipped: package.json unreadable", { packageDir });
     return { updated: false };
@@ -13682,7 +13982,7 @@ async function checkAutoUpdate(signal, logger) {
 async function findPackageDir(name) {
   let dir = dirname4(fileURLToPath(import.meta.url));
   for (; ; ) {
-    const pkg = await readPackageJson(join7(dir, "package.json"));
+    const pkg = await readPackageJson(join8(dir, "package.json"));
     if (pkg?.name === name) return dir;
     const parent = dirname4(dir);
     if (parent === dir) return void 0;
@@ -13694,7 +13994,7 @@ async function updateTarget(packageDir, name) {
   const nodeModulesDir = basename(packageParent).startsWith("@") ? dirname4(packageParent) : packageParent;
   if (basename(nodeModulesDir) !== "node_modules") return void 0;
   const wrapperDir = dirname4(nodeModulesDir);
-  const wrapperPkg = await readPackageJson(join7(wrapperDir, "package.json"));
+  const wrapperPkg = await readPackageJson(join8(wrapperDir, "package.json"));
   const spec = wrapperSpec(wrapperDir, name) ?? wrapperPkg?.dependencies?.[name];
   if (!spec || !isAutoUpdatableSpec(spec)) return void 0;
   return { removeDir: wrapperDir, spec };
@@ -13805,7 +14105,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.3" : "dev",
+    version: true ? "1.18.4-pr.483.216" : "dev",
     workspace: ctx.directory,
     logLevel: logger.level,
     debug: config.debug,