mixdog 0.9.97 → 0.9.99

package/src/tui/dist/index.mjs

@@ -62,6 +62,40 @@ var init_plugin_paths = __esm({
 });
 
 // src/runtime/agent/orchestrator/tools/builtin/read-image-resize.mjs
+import { createHash } from "node:crypto";
+function imageProfileForProvider(provider) {
+  const value = String(provider || "").trim().toLowerCase();
+  return /^(?:openai|xai|grok|deepseek|opencode-go|ollama|lmstudio)(?:-|$)/.test(value) ? "openai" : "anthropic";
+}
+function openAIImagePatchCount(width, height) {
+  return Math.ceil(Math.max(1, Number(width) || 1) / OPENAI_IMAGE_PATCH_SIZE) * Math.ceil(Math.max(1, Number(height) || 1) / OPENAI_IMAGE_PATCH_SIZE);
+}
+function resizeCacheKey(buffer, ext, maxTokens, profile) {
+  return createHash("sha256").update(String(ext || "")).update("\0").update(String(maxTokens || 0)).update("\0").update(String(profile || "")).update("\0").update(buffer).digest("hex");
+}
+function cloneResizeResult(result) {
+  return {
+    ...result,
+    ...result?.dimensions ? { dimensions: { ...result.dimensions } } : {}
+  };
+}
+function rememberResizeResult(key, result) {
+  const bytes = Buffer.byteLength(String(result?.data || ""), "base64");
+  if (bytes <= 0 || bytes > IMAGE_RESIZE_CACHE_MAX_BYTES) return;
+  const existing = imageResizeCache.get(key);
+  if (existing) {
+    imageResizeCacheBytes -= existing.bytes;
+    imageResizeCache.delete(key);
+  }
+  imageResizeCache.set(key, { result: cloneResizeResult(result), bytes });
+  imageResizeCacheBytes += bytes;
+  while (imageResizeCacheBytes > IMAGE_RESIZE_CACHE_MAX_BYTES && imageResizeCache.size > 0) {
+    const oldest = imageResizeCache.keys().next().value;
+    const evicted = imageResizeCache.get(oldest);
+    imageResizeCache.delete(oldest);
+    imageResizeCacheBytes -= evicted?.bytes || 0;
+  }
+}
 async function loadSharp() {
   if (_sharpPromise === void 0) {
     _sharpPromise = (async () => {
@@ -101,8 +135,21 @@ function imageMetadataText(dims, sourcePath) {
   }
   return `[Image: ${parts.join(", ")}]`;
 }
-async function resizeImageBuffer(buffer, ext, { maxTokens = DEFAULT_IMAGE_MAX_TOKENS } = {}) {
+async function resizeImageBuffer(buffer, ext, {
+  maxTokens = DEFAULT_IMAGE_MAX_TOKENS,
+  profile = "anthropic"
+} = {}) {
   if (!Buffer.isBuffer(buffer) || buffer.length === 0) return null;
+  const normalizedProfile = profile === "openai" ? "openai" : "anthropic";
+  const cacheKey = resizeCacheKey(buffer, ext, maxTokens, normalizedProfile);
+  const cached = imageResizeCache.get(cacheKey);
+  if (cached) {
+    imageResizeCacheHits += 1;
+    imageResizeCache.delete(cacheKey);
+    imageResizeCache.set(cacheKey, cached);
+    return cloneResizeResult(cached.result);
+  }
+  imageResizeCacheMisses += 1;
   const sharp = await loadSharp();
   if (!sharp) return null;
   try {
@@ -118,13 +165,20 @@ async function resizeImageBuffer(buffer, ext, { maxTokens = DEFAULT_IMAGE_MAX_TO
     if (originalWidth && originalHeight) {
       let width = originalWidth;
       let height = originalHeight;
-      if (width > IMAGE_MAX_WIDTH) {
-        height = Math.round(height * IMAGE_MAX_WIDTH / width);
-        width = IMAGE_MAX_WIDTH;
+      const maxWidth = normalizedProfile === "openai" ? OPENAI_IMAGE_MAX_DIMENSION : IMAGE_MAX_WIDTH;
+      const maxHeight = normalizedProfile === "openai" ? OPENAI_IMAGE_MAX_DIMENSION : IMAGE_MAX_HEIGHT;
+      let scale = Math.min(1, maxWidth / width, maxHeight / height);
+      if (normalizedProfile === "openai") {
+        scale = Math.min(
+          scale,
+          Math.sqrt(OPENAI_IMAGE_MAX_PATCHES * OPENAI_IMAGE_PATCH_SIZE ** 2 / (width * height))
+        );
       }
-      if (height > IMAGE_MAX_HEIGHT) {
-        width = Math.round(width * IMAGE_MAX_HEIGHT / height);
-        height = IMAGE_MAX_HEIGHT;
+      width = Math.max(1, Math.floor(width * scale));
+      height = Math.max(1, Math.floor(height * scale));
+      while (normalizedProfile === "openai" && openAIImagePatchCount(width, height) > OPENAI_IMAGE_MAX_PATCHES) {
+        if (width >= height) width -= 1;
+        else height -= 1;
       }
       const needsResize = width !== originalWidth || height !== originalHeight;
       if (needsResize || originalSize > IMAGE_TARGET_RAW_SIZE) {
@@ -161,16 +215,18 @@ async function resizeImageBuffer(buffer, ext, { maxTokens = DEFAULT_IMAGE_MAX_TO
         }
       }
     }
-    return {
+    const result = {
       data: base64,
       mimeType: `image/${mediaType}`,
       dimensions: { originalWidth, originalHeight, displayWidth: displayWidth2, displayHeight }
     };
+    rememberResizeResult(cacheKey, result);
+    return result;
   } catch {
     return null;
   }
 }
-var API_IMAGE_MAX_BASE64_SIZE, IMAGE_TARGET_RAW_SIZE, IMAGE_MAX_WIDTH, IMAGE_MAX_HEIGHT, DEFAULT_IMAGE_MAX_TOKENS, _sharpPromise;
+var API_IMAGE_MAX_BASE64_SIZE, IMAGE_TARGET_RAW_SIZE, IMAGE_MAX_WIDTH, IMAGE_MAX_HEIGHT, DEFAULT_IMAGE_MAX_TOKENS, OPENAI_IMAGE_MAX_DIMENSION, OPENAI_IMAGE_PATCH_SIZE, OPENAI_IMAGE_MAX_PATCHES, IMAGE_RESIZE_CACHE_MAX_BYTES, imageResizeCache, imageResizeCacheBytes, imageResizeCacheHits, imageResizeCacheMisses, _sharpPromise;
 var init_read_image_resize = __esm({
   "src/runtime/agent/orchestrator/tools/builtin/read-image-resize.mjs"() {
     API_IMAGE_MAX_BASE64_SIZE = 5 * 1024 * 1024;
@@ -178,6 +234,14 @@ var init_read_image_resize = __esm({
     IMAGE_MAX_WIDTH = 2e3;
     IMAGE_MAX_HEIGHT = 2e3;
     DEFAULT_IMAGE_MAX_TOKENS = Math.ceil(API_IMAGE_MAX_BASE64_SIZE * 0.125);
+    OPENAI_IMAGE_MAX_DIMENSION = 2048;
+    OPENAI_IMAGE_PATCH_SIZE = 32;
+    OPENAI_IMAGE_MAX_PATCHES = 1536;
+    IMAGE_RESIZE_CACHE_MAX_BYTES = 64 * 1024 * 1024;
+    imageResizeCache = /* @__PURE__ */ new Map();
+    imageResizeCacheBytes = 0;
+    imageResizeCacheHits = 0;
+    imageResizeCacheMisses = 0;
   }
 });
 
@@ -246,17 +310,6 @@ function pastedTextReferenceIds(input) {
   const re = /\[Pasted text #(\d+) \+\d+ lines\]/g;
   return new Set([...String(input || "").matchAll(re)].map((m) => Number(m[1]) || 0).filter(Boolean));
 }
-function expandPastedTextTokens(value, pastedTexts = {}) {
-  let out = String(value ?? "");
-  if (!pastedTexts || typeof pastedTexts !== "object") return out;
-  const re = /\[Pasted text #(\d+) \+\d+ lines\]/g;
-  out = out.replace(re, (match, idRaw) => {
-    const entry = pastedTexts[Number(idRaw)] || pastedTexts[idRaw];
-    if (entry && typeof entry.text === "string") return entry.text;
-    return match;
-  });
-  return out;
-}
 function buildPromptContentWithImages(text, pastedImages = {}) {
   const value = String(text ?? "");
   const refs = imageReferenceIds(value);
@@ -290,10 +343,14 @@ function splitPastedImagePathCandidates(text) {
   }
   return out;
 }
-async function imageAttachmentFromBuffer(buffer, mimeType, { filename = "Pasted image", sourcePath = "" } = {}) {
+async function imageAttachmentFromBuffer(buffer, mimeType, {
+  filename = "Pasted image",
+  sourcePath = "",
+  provider = ""
+} = {}) {
   if (!Buffer2.isBuffer(buffer) || buffer.length === 0) throw new Error("image is empty");
   const ext = (mimeType || "image/png").split("/")[1] || "png";
-  const resized = await resizeImageBuffer(buffer, ext);
+  const resized = await resizeImageBuffer(buffer, ext, { profile: imageProfileForProvider(provider) });
   if (resized) {
     return {
       type: "image",
@@ -313,7 +370,7 @@ async function imageAttachmentFromBuffer(buffer, mimeType, { filename = "Pasted
   }
   return { type: "image", content: data, mediaType: mimeType || "image/png", filename, sourcePath };
 }
-async function readImageAttachmentFromPath(rawPath, cwd = process.cwd()) {
+async function readImageAttachmentFromPath(rawPath, cwd = process.cwd(), { provider = "" } = {}) {
   const cleaned = cleanPathText(rawPath);
   const mimeType = mimeForPath(cleaned);
   if (!mimeType) return null;
@@ -328,7 +385,8 @@ async function readImageAttachmentFromPath(rawPath, cwd = process.cwd()) {
   const buffer = await readFileAsync(fullPath);
   return imageAttachmentFromBuffer(buffer, mimeType, {
     filename: basename2(fullPath),
-    sourcePath: fullPath
+    sourcePath: fullPath,
+    provider
   });
 }
 async function readClipboardImageToTempFile() {
@@ -350,19 +408,19 @@ close access fp`;
   }
   return null;
 }
-async function readClipboardImageAttachment() {
+async function readClipboardImageAttachment({ provider = "" } = {}) {
   if (process.platform === "linux") {
     const wl = await execFileBuffer("wl-paste", ["--type", "image/png"], { timeout: 3e3 });
-    if (wl.ok && wl.stdout?.length) return imageAttachmentFromBuffer(wl.stdout, "image/png");
+    if (wl.ok && wl.stdout?.length) return imageAttachmentFromBuffer(wl.stdout, "image/png", { provider });
     const xc = await execFileBuffer("xclip", ["-selection", "clipboard", "-t", "image/png", "-o"], { timeout: 3e3 });
-    if (xc.ok && xc.stdout?.length) return imageAttachmentFromBuffer(xc.stdout, "image/png");
+    if (xc.ok && xc.stdout?.length) return imageAttachmentFromBuffer(xc.stdout, "image/png", { provider });
     return null;
   }
   const file = await readClipboardImageToTempFile();
   if (!file) return null;
   try {
     const buffer = await readFileAsync(file);
-    return await imageAttachmentFromBuffer(buffer, "image/png");
+    return await imageAttachmentFromBuffer(buffer, "image/png", { provider });
   } finally {
     try {
       unlinkSync(file);
@@ -879,7 +937,7 @@ import {
 } from "fs/promises";
 import { dirname as dirname4, join as join4, resolve as resolve2 } from "path";
 import { homedir as homedir2 } from "os";
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 function mixdogConfigBaseDir() {
   return process.env.MIXDOG_CONFIG_DIR || join4(homedir2(), ".mixdog");
 }
@@ -893,7 +951,7 @@ function safeReason(reason) {
   return String(reason || "snapshot").replace(/[^a-z0-9_.-]+/gi, "-").slice(0, 48) || "snapshot";
 }
 function initMarkerPath(dataDir) {
-  const id = createHash("sha256").update(String(dataDir || "unknown")).digest("hex").slice(0, 16);
+  const id = createHash2("sha256").update(String(dataDir || "unknown")).digest("hex").slice(0, 16);
   return join4(getBackupRoot(), `.initialized-${id}.json`);
 }
 function isPlainObject(value) {
@@ -1497,7 +1555,7 @@ import React22 from "react";
 import { render } from "../../../vendor/ink/build/index.js";
 import { closeSync as closeSync2, constants as fsConstants, createWriteStream, mkdirSync as mkdirSync6, openSync as openSync2, readSync } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { dirname as dirname7, join as join8 } from "node:path";
+import { dirname as dirname7, join as join9 } from "node:path";
 import { performance as performance3 } from "node:perf_hooks";
 import { format } from "node:util";
 
@@ -14316,15 +14374,14 @@ function createPromptSubmit({
     const textRefs = pastedTextReferenceIds(text);
     const textSnapshot = Object.fromEntries(Object.entries(pastedTextsRef.current || {}).filter(([id]) => textRefs.has(Number(id))));
     const hasTextSnapshot = Object.keys(textSnapshot).length > 0;
-    const expandedText = hasTextSnapshot ? expandPastedTextTokens(text, textSnapshot) : text;
-    const content = buildPromptContentWithImages(expandedText, imageSnapshot);
+    const content = buildPromptContentWithImages(text, imageSnapshot);
+    const imageRestoreMeta = Object.fromEntries(Object.entries(imageSnapshot).map(([id, image]) => {
+      const { content: _content, ...metadata } = image;
+      return [id, { ...metadata, sizeBytes: Math.floor(String(image.content || "").length * 3 / 4) }];
+    }));
     const accepted = submitPrompt(content, {
-      // Store the EXPANDED text in the transcript/history so a later prompt-
-      // history recall resubmits the real content, not the literal token
-      // (pastedTexts entries are cleared on accept). History recall therefore
-      // shows the full original text instead of the token — acceptable.
-      displayText: expandedText,
-      pastedImages: imageSnapshot,
+      ...hasImageSnapshot || hasTextSnapshot ? { displayText: text } : {},
+      pastedImages: imageRestoreMeta,
       pastedTexts: textSnapshot,
       onCommitted: hasImageSnapshot || hasTextSnapshot ? () => {
         clearPastedImagesSnapshot(imageSnapshot);
@@ -22091,6 +22148,10 @@ import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync5, readFile
 init_plugin_paths();
 import { dirname as dirname6, join as join6, resolve as resolve3 } from "node:path";
 var PROMPT_HISTORY_LIMIT2 = 50;
+var PROMPT_HISTORY_CACHE_LIMIT = Math.max(
+  8,
+  Number(process.env.MIXDOG_PROMPT_HISTORY_CACHE_LIMIT) || 128
+);
 function promptHistoryKey2(value) {
   return String(value || "").trim().replace(/\s+/g, " ");
 }
@@ -22209,7 +22270,11 @@ function usePromptHandlers({
       return Promise.all(chunks.map(async (chunk) => {
         if (!chunk.imagePath) return chunk.text;
         try {
-          const image = await readImageAttachmentFromPath(chunk.text, state.cwd || process.cwd());
+          const image = await readImageAttachmentFromPath(
+            chunk.text,
+            state.cwd || process.cwd(),
+            { provider: state.provider || "" }
+          );
           if (!image) return chunk.text;
           const ref = registerPastedImage(image);
           showPromptHint(`attached ${image.filename || "image"}`, "plain");
@@ -22242,7 +22307,7 @@ function usePromptHandlers({
       return readClipboardText().then((clip) => {
         const normalized = String(clip ?? "").replace(/\r\n?/g, "\n");
         if (normalized) return processText(normalized, true);
-        return readClipboardImageAttachment().then((image) => {
+        return readClipboardImageAttachment({ provider: state.provider || "" }).then((image) => {
           if (!image) {
             showPromptHint("no text or image found on clipboard", "plain");
             return false;
@@ -22257,7 +22322,7 @@ function usePromptHandlers({
       });
     }
     return processText(value);
-  }, [registerPastedImage, registerPastedText, showPromptHint, state.cwd]);
+  }, [registerPastedImage, registerPastedText, showPromptHint, state.cwd, state.provider]);
   const handlePromptHistoryNavigate = useCallback12((direction, currentText = "", meta = {}) => {
     const currentValue = String(currentText || "");
     const currentKey = promptHistoryKey2(currentValue);
@@ -23401,6 +23466,147 @@ import { performance as performance2 } from "node:perf_hooks";
 var BOOT_PROFILE_ENABLED = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_BOOT_PROFILE || ""));
 var BOOT_PROFILE_START = globalThis.__mixdogBootProfileStart || (globalThis.__mixdogBootProfileStart = performance2.now());
 
+// src/runtime/attachments/store.mjs
+init_plugin_paths();
+import {
+  readdir,
+  readFile as readFileAsync3,
+  stat,
+  unlink
+} from "node:fs/promises";
+import { join as join8 } from "node:path";
+
+// src/runtime/attachments/pdf-extract.mjs
+var DEFAULT_MAX_OUTPUT_BYTES = 1024 * 1024;
+
+// src/runtime/attachments/store.mjs
+var ATTACHMENT_REF_RE = /^[a-f0-9]{64}$/;
+var MAX_PROMPT_TEXT_BYTES = 1024 * 1024;
+var MAX_PROMPT_PDF_BYTES = 20 * 1024 * 1024;
+var ATTACHMENT_CACHE_MAX_BYTES = 64 * 1024 * 1024;
+var ATTACHMENT_GC_MIN_AGE_MS = Math.max(
+  6e4,
+  Number(process.env.MIXDOG_ATTACHMENT_GC_MIN_AGE_MS) || 7 * 24 * 60 * 60 * 1e3
+);
+var ATTACHMENT_GC_INTERVAL_MS = 6 * 60 * 60 * 1e3;
+var ATTACHMENT_GC_START_DELAY_MS = 5e3;
+var bufferCache = /* @__PURE__ */ new Map();
+var bufferCacheBytes = 0;
+var attachmentGcTimer = null;
+var lastAttachmentGcAt = 0;
+function attachmentsDir() {
+  return join8(resolvePluginData(), "prompt-attachments", "sha256");
+}
+function dropCachedAttachment(path2) {
+  const cached = bufferCache.get(path2);
+  if (!cached) return;
+  bufferCache.delete(path2);
+  bufferCacheBytes -= cached.length;
+}
+async function persistedAttachmentReferencePaths() {
+  const root = resolvePluginData();
+  const paths = [];
+  for (const dirname8 of ["sessions", "turn-checkpoints"]) {
+    const dir = join8(root, dirname8);
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch (error) {
+      if (error?.code === "ENOENT") continue;
+      throw error;
+    }
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".json")) paths.push(join8(dir, entry.name));
+    }
+  }
+  paths.push(join8(root, "session-pending-messages.json"));
+  return paths;
+}
+async function collectPromptAttachments({
+  now = Date.now(),
+  minAgeMs = ATTACHMENT_GC_MIN_AGE_MS
+} = {}) {
+  const referenced = /* @__PURE__ */ new Set();
+  let referenceFiles = 0;
+  for (const path2 of await persistedAttachmentReferencePaths()) {
+    let raw;
+    try {
+      raw = await readFileAsync3(path2, "utf8");
+    } catch (error) {
+      if (error?.code === "ENOENT") continue;
+      return { deleted: 0, referenced: 0, fresh: 0, scanned: 0, incomplete: true };
+    }
+    referenceFiles += 1;
+    const regex = /"attachmentRef"\s*:\s*"([a-f0-9]{64})"/g;
+    let match;
+    while ((match = regex.exec(raw)) !== null) referenced.add(match[1]);
+  }
+  const cutoff = Number(now) - Math.max(0, Number(minAgeMs) || 0);
+  let prefixes;
+  try {
+    prefixes = await readdir(attachmentsDir(), { withFileTypes: true });
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return { deleted: 0, referenced: referenced.size, fresh: 0, scanned: 0, referenceFiles };
+    }
+    return { deleted: 0, referenced: referenced.size, fresh: 0, scanned: 0, referenceFiles, incomplete: true };
+  }
+  let deleted = 0;
+  let fresh = 0;
+  let scanned = 0;
+  for (const prefix of prefixes) {
+    if (!prefix.isDirectory() || !/^[a-f0-9]{2}$/.test(prefix.name)) continue;
+    const dir = join8(attachmentsDir(), prefix.name);
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isFile() || !ATTACHMENT_REF_RE.test(entry.name)) continue;
+      scanned += 1;
+      if (referenced.has(entry.name)) continue;
+      const path2 = join8(dir, entry.name);
+      try {
+        const first = await stat(path2);
+        if (first.mtimeMs > cutoff) {
+          fresh += 1;
+          continue;
+        }
+        const latest = await stat(path2);
+        if (latest.mtimeMs > cutoff || latest.mtimeMs !== first.mtimeMs) {
+          fresh += 1;
+          continue;
+        }
+        await unlink(path2);
+        dropCachedAttachment(path2);
+        deleted += 1;
+      } catch (error) {
+        if (error?.code !== "ENOENT") fresh += 1;
+      }
+    }
+  }
+  return { deleted, referenced: referenced.size, fresh, scanned, referenceFiles };
+}
+function armAttachmentGc(delayMs) {
+  if (attachmentGcTimer) return;
+  attachmentGcTimer = setTimeout(() => {
+    attachmentGcTimer = null;
+    void collectPromptAttachments().catch(() => void 0).finally(() => {
+      lastAttachmentGcAt = Date.now();
+      armAttachmentGc(ATTACHMENT_GC_INTERVAL_MS);
+    });
+  }, Math.max(ATTACHMENT_GC_START_DELAY_MS, Number(delayMs) || 0));
+  attachmentGcTimer.unref?.();
+}
+function scheduleAttachmentGc() {
+  if (attachmentGcTimer) return;
+  const elapsed = Date.now() - lastAttachmentGcAt;
+  armAttachmentGc(lastAttachmentGcAt === 0 ? ATTACHMENT_GC_START_DELAY_MS : ATTACHMENT_GC_INTERVAL_MS - elapsed);
+}
+scheduleAttachmentGc();
+
 // src/tui/session/agent-job-feed.mjs
 init_paste_attachments();
 
@@ -23656,7 +23862,7 @@ function scheduleHardExit(code = 0) {
   timer2.unref?.();
 }
 function resolveTuiStderrLogPath() {
-  return process.env.MIXDOG_TUI_STDERR_LOG || join8(process.env.MIXDOG_RUNTIME_ROOT || join8(tmpdir2(), "mixdog"), "mixdog-tui.stderr.log");
+  return process.env.MIXDOG_TUI_STDERR_LOG || join9(process.env.MIXDOG_RUNTIME_ROOT || join9(tmpdir2(), "mixdog"), "mixdog-tui.stderr.log");
 }
 function ansiFg(rgb) {
   const m = /rgb\((\d+),\s*(\d+),\s*(\d+)\)/.exec(String(rgb || ""));

package/src/tui/paste-attachments.mjs

@@ -8,6 +8,7 @@ import { basename, extname, isAbsolute, resolve } from 'node:path';
 import {
   API_IMAGE_MAX_BASE64_SIZE,
   IMAGE_TARGET_RAW_SIZE,
+  imageProfileForProvider,
   imageMetadataText,
   resizeImageBuffer,
 } from '../runtime/agent/orchestrator/tools/builtin/read-image-resize.mjs';
@@ -148,10 +149,14 @@ export function splitPastedImagePathCandidates(text) {
 // Exported for the desktop engine capability surface (resizeImage): the GUI
 // composer routes its attachments through this SAME pipeline so desktop and
 // TUI submit byte-identical image payloads.
-export async function imageAttachmentFromBuffer(buffer, mimeType, { filename = 'Pasted image', sourcePath = '' } = {}) {
+export async function imageAttachmentFromBuffer(buffer, mimeType, {
+  filename = 'Pasted image',
+  sourcePath = '',
+  provider = '',
+} = {}) {
   if (!Buffer.isBuffer(buffer) || buffer.length === 0) throw new Error('image is empty');
   const ext = (mimeType || 'image/png').split('/')[1] || 'png';
-  const resized = await resizeImageBuffer(buffer, ext);
+  const resized = await resizeImageBuffer(buffer, ext, { profile: imageProfileForProvider(provider) });
   if (resized) {
     return {
       type: 'image',
@@ -172,7 +177,7 @@ export async function imageAttachmentFromBuffer(buffer, mimeType, { filename = '
   return { type: 'image', content: data, mediaType: mimeType || 'image/png', filename, sourcePath };
 }
 
-export async function readImageAttachmentFromPath(rawPath, cwd = process.cwd()) {
+export async function readImageAttachmentFromPath(rawPath, cwd = process.cwd(), { provider = '' } = {}) {
   const cleaned = cleanPathText(rawPath);
   const mimeType = mimeForPath(cleaned);
   if (!mimeType) return null;
@@ -190,6 +195,7 @@ export async function readImageAttachmentFromPath(rawPath, cwd = process.cwd())
   return imageAttachmentFromBuffer(buffer, mimeType, {
     filename: basename(fullPath),
     sourcePath: fullPath,
+    provider,
   });
 }
 
@@ -210,19 +216,19 @@ async function readClipboardImageToTempFile() {
   return null;
 }
 
-export async function readClipboardImageAttachment() {
+export async function readClipboardImageAttachment({ provider = '' } = {}) {
   if (process.platform === 'linux') {
     const wl = await execFileBuffer('wl-paste', ['--type', 'image/png'], { timeout: 3000 });
-    if (wl.ok && wl.stdout?.length) return imageAttachmentFromBuffer(wl.stdout, 'image/png');
+    if (wl.ok && wl.stdout?.length) return imageAttachmentFromBuffer(wl.stdout, 'image/png', { provider });
     const xc = await execFileBuffer('xclip', ['-selection', 'clipboard', '-t', 'image/png', '-o'], { timeout: 3000 });
-    if (xc.ok && xc.stdout?.length) return imageAttachmentFromBuffer(xc.stdout, 'image/png');
+    if (xc.ok && xc.stdout?.length) return imageAttachmentFromBuffer(xc.stdout, 'image/png', { provider });
     return null;
   }
   const file = await readClipboardImageToTempFile();
   if (!file) return null;
   try {
     const buffer = await readFileAsync(file);
-    return await imageAttachmentFromBuffer(buffer, 'image/png');
+    return await imageAttachmentFromBuffer(buffer, 'image/png', { provider });
   } finally {
     try { unlinkSync(file); } catch {}
   }

package/src/tui/prompt-history-store.mjs

@@ -9,6 +9,10 @@ import { dirname, join, resolve } from 'node:path';
 import { resolvePluginData } from '../runtime/shared/plugin-paths.mjs';
 
 export const PROMPT_HISTORY_LIMIT = 50;
+export const PROMPT_HISTORY_CACHE_LIMIT = Math.max(
+  8,
+  Number(process.env.MIXDOG_PROMPT_HISTORY_CACHE_LIMIT) || 128,
+);
 
 export function promptHistoryKey(value) {
   return String(value || '').trim().replace(/\s+/g, ' ');
@@ -101,10 +105,43 @@ const memCache = new Map(); // filePath -> entries[] (optimistic in-memory view)
 const pendingAppends = new Map(); // filePath -> string[] appends since last flush
 const pendingTimers = new Map(); // filePath -> timeout handle
 
+function flushPendingSyncForEviction(filePath) {
+  const timer = pendingTimers.get(filePath);
+  if (timer) clearTimeout(timer);
+  pendingTimers.delete(filePath);
+  const pend = pendingAppends.get(filePath);
+  pendingAppends.delete(filePath);
+  if (!pend?.length) return;
+  const merged = reconcileWithDisk(filePath, pend);
+  writeEntriesSync(filePath, merged);
+}
+
+function trimMemCache() {
+  while (memCache.size > PROMPT_HISTORY_CACHE_LIMIT) {
+    const oldest = memCache.keys().next().value;
+    if (oldest === undefined) break;
+    // Never drop the only optimistic copy of an unflushed prompt. Cwd churn is
+    // rare; once the cache is full, synchronously landing the oldest dirty
+    // bucket gives all three maps a deterministic process-lifetime bound.
+    flushPendingSyncForEviction(oldest);
+    memCache.delete(oldest);
+  }
+}
+
+function rememberCachedEntries(filePath, entries) {
+  memCache.delete(filePath);
+  memCache.set(filePath, entries);
+  trimMemCache();
+}
+
 function cachedEntries(filePath) {
-  if (memCache.has(filePath)) return memCache.get(filePath);
+  if (memCache.has(filePath)) {
+    const entries = memCache.get(filePath);
+    rememberCachedEntries(filePath, entries);
+    return entries;
+  }
   const entries = readEntries(filePath);
-  memCache.set(filePath, entries);
+  rememberCachedEntries(filePath, entries);
   return entries;
 }
 
@@ -141,13 +178,15 @@ async function writeBehindFlush(filePath) {
   // and reconcile against the file we are about to write.
   pendingAppends.set(filePath, []);
   const merged = reconcileWithDisk(filePath, pend);
-  memCache.set(filePath, merged);
+  rememberCachedEntries(filePath, merged);
   const ok = await writeEntriesAsync(filePath, merged);
   if (!ok) {
     // Retry: re-queue our appends ahead of any newer ones (oldest → newest).
     const cur = pendingAppends.get(filePath) || [];
     pendingAppends.set(filePath, pend.concat(cur));
     scheduleWriteBehind(filePath);
+  } else if (!(pendingAppends.get(filePath)?.length)) {
+    pendingAppends.delete(filePath);
   }
 }
 
@@ -229,14 +268,23 @@ export function appendPromptHistory(cwd, value) {
   if (!filePath) return null;
   // Optimistic in-memory update for immediate return/reads.
   const trimmed = applyAppend(cachedEntries(filePath), value);
-  memCache.set(filePath, trimmed);
   // Queue the append for a durable, disk-reconciled flush (async, coalesced).
   const pend = pendingAppends.get(filePath) || [];
   pend.push(String(value).trim());
   pendingAppends.set(filePath, pend);
+  rememberCachedEntries(filePath, trimmed);
   // Bound crash-loss to FLUSH_CAP appends; otherwise coalesce over the window.
   if (pend.length >= FLUSH_CAP) void writeBehindFlush(filePath);
   else scheduleWriteBehind(filePath);
   return trimmed;
 }
 
+export function promptHistoryStoreStatsForTest() {
+  return {
+    cacheEntries: memCache.size,
+    pendingEntries: pendingAppends.size,
+    timerEntries: pendingTimers.size,
+    cacheLimit: PROMPT_HISTORY_CACHE_LIMIT,
+  };
+}
+

package/src/tui/session/agent-job-feed.mjs

@@ -395,7 +395,11 @@ export function createAgentJobFeed({
           if (modelContent) parts.push({ type: 'text', text: modelContent });
           for (const p of imagePaths) {
             let att = null;
-            try { att = await readImageAttachmentFromPath(p); } catch { att = null; }
+            try {
+              att = await readImageAttachmentFromPath(p, process.cwd(), {
+                provider: getState()?.provider || '',
+              });
+            } catch { att = null; }
             if (!att) continue;
             if (att.metadataText) parts.push({ type: 'text', text: att.metadataText });
             parts.push({ type: 'image', data: att.content, mimeType: att.mediaType || 'image/png' });