mixdog 0.9.97 → 0.9.99

package/src/session-runtime/quick-model-rows.mjs

@@ -5,6 +5,7 @@ import { clean } from './session-text.mjs';
 import { QUICK_SEARCH_MODELS } from './quick-search-models.mjs';
 import { SEARCH_DEFAULT_PROVIDER, SEARCH_DEFAULT_MODEL } from './workflow.mjs';
 import { getModelMetadataSync } from '../runtime/agent/orchestrator/providers/model-catalog.mjs';
+import { providerCachedModelsSync } from '../runtime/agent/orchestrator/providers/provider-catalog-cache.mjs';
 
 function metadataFor(provider, modelId) {
   try {
@@ -51,15 +52,39 @@ export function createQuickModelRows({
     const pickerConfig = displayConfig();
     const rows = [];
     const seen = new Set();
+    const addModel = (provider, modelLike = {}) => {
+      const model = modelLike && typeof modelLike === 'object'
+        ? modelLike
+        : { id: clean(modelLike) };
+      const modelId = clean(model.id || model.name);
+      if (!provider || !modelId) return;
+      const key = `${provider}:${modelId}`;
+      if (seen.has(key)) return;
+      seen.add(key);
+      const meta = metadataFor(provider, modelId);
+      const row = providerModelCacheRow(provider, {
+        ...model,
+        id: modelId,
+        name: model.name || model.display || modelId,
+        display: model.display || model.name || modelId,
+        contextWindow: model.contextWindow || meta.contextWindow || null,
+        outputTokens: model.outputTokens || meta.outputTokens || null,
+        supportsReasoning: model.supportsReasoning === true || meta.supportsReasoning === true,
+        supportsFunctionCalling: model.supportsFunctionCalling === true || meta.supportsFunctionCalling === true,
+        supportsPromptCaching: model.supportsPromptCaching === true || meta.supportsPromptCaching === true,
+        reasoningOptions: model.reasoningOptions?.length ? model.reasoningOptions : (meta.reasoningOptions || []),
+        reasoningContentField: model.reasoningContentField || meta.reasoningContentField || null,
+        mode: model.mode || meta.mode || 'chat',
+      });
+      rows.push(row);
+      modelMetaByRoute.set(modelMetaKey(provider, modelId), row);
+    };
     const addRoute = (routeLike = {}) => {
       const provider = clean(routeLike.provider);
       const model = clean(routeLike.model);
       if (!provider || !model) return;
-      const key = `${provider}:${model}`;
-      if (seen.has(key)) return;
-      seen.add(key);
       const meta = metadataFor(provider, model);
-      const row = providerModelCacheRow(provider, {
+      addModel(provider, {
         id: model,
         name: routeLike.modelDisplay || routeLike.display || model,
         display: routeLike.modelDisplay || routeLike.display || model,
@@ -73,10 +98,12 @@ export function createQuickModelRows({
         reasoningContentField: meta.reasoningContentField || null,
         mode: 'chat',
       });
-      rows.push(row);
-      modelMetaByRoute.set(modelMetaKey(provider, model), row);
     };
 
+    for (const [provider, providerConfig] of Object.entries(pickerConfig.providers || {})) {
+      if (!providerConfig?.enabled) continue;
+      for (const model of providerCachedModelsSync(provider)) addModel(provider, model);
+    }
     addRoute(route);
     for (const preset of pickerConfig.presets || []) addRoute(preset);
     for (const workflowRoute of Object.values(pickerConfig.workflowRoutes || {})) addRoute(workflowRoute);
@@ -146,7 +173,11 @@ export function createQuickModelRows({
     for (const [name, providerConfig] of Object.entries(pickerConfig.providers || {})) {
       const providerName = normalizeSearchProviderId(name);
       if (!providerConfig?.enabled || !isSearchCapableProvider(providerName)) continue;
-      for (const model of QUICK_SEARCH_MODELS[providerName] || []) {
+      const cachedModels = providerCachedModelsSync(providerName);
+      const quickModels = cachedModels.length
+        ? cachedModels
+        : (QUICK_SEARCH_MODELS[providerName] || []);
+      for (const model of quickModels) {
         addQuickSearchModel(rows, seen, providerName, model);
       }
     }

package/src/session-runtime/quick-search-models.mjs

@@ -6,10 +6,11 @@ export const ONBOARDING_VERSION = 1;
 
 export const QUICK_SEARCH_MODELS = Object.freeze({
   'openai-oauth': [
+    { id: 'gpt-5.6-sol', display: 'GPT-5.6 Sol', latest: true },
+    { id: 'gpt-5.6-terra', display: 'GPT-5.6 Terra', latest: true },
+    { id: 'gpt-5.6-luna', display: 'GPT-5.6 Luna' },
     { id: 'gpt-5.5', display: 'GPT-5.5', latest: true },
-    { id: 'gpt-5.4', display: 'GPT-5.4', latest: true },
-    { id: 'gpt-5', display: 'GPT-5' },
-    { id: 'gpt-4.1', display: 'GPT-4.1' },
+    { id: 'gpt-5.4-mini', display: 'GPT-5.4 Mini' },
   ],
   openai: [
     { id: 'gpt-5.5', display: 'GPT-5.5', latest: true },
@@ -19,29 +20,26 @@ export const QUICK_SEARCH_MODELS = Object.freeze({
     { id: 'gpt-4o', display: 'GPT-4o' },
   ],
   'grok-oauth': [
-    { id: 'grok-4.3', display: 'Grok 4.3', latest: true },
-    { id: 'grok-4.20', display: 'Grok 4.20' },
-    { id: 'grok-4', display: 'Grok 4' },
+    { id: 'grok-4.5', display: 'Grok 4.5', latest: true },
   ],
   xai: [
-    { id: 'grok-4.3', display: 'Grok 4.3', latest: true },
-    { id: 'grok-4.20', display: 'Grok 4.20' },
-    { id: 'grok-4', display: 'Grok 4' },
+    { id: 'grok-4.5', display: 'Grok 4.5', latest: true },
   ],
   gemini: [
-    { id: 'gemini-3-pro', display: 'Gemini 3 Pro', latest: true },
-    { id: 'gemini-2.5-pro', display: 'Gemini 2.5 Pro' },
-    { id: 'gemini-2.5-flash', display: 'Gemini 2.5 Flash' },
-    { id: 'gemini-2.0-flash', display: 'Gemini 2.0 Flash' },
+    { id: 'gemini-3.6-flash', display: 'Gemini 3.6 Flash', latest: true },
+    { id: 'gemini-3.5-flash-lite', display: 'Gemini 3.5 Flash Lite', latest: true },
+    { id: 'gemini-3.1-pro-preview', display: 'Gemini 3.1 Pro Preview' },
   ],
   'anthropic-oauth': [
-    { id: 'claude-opus-4-8', display: 'Claude Opus 4.8', latest: true },
-    { id: 'claude-sonnet-4-6', display: 'Claude Sonnet 4.6', latest: true },
+    { id: 'claude-opus-5', display: 'Claude Opus 5', latest: true },
+    { id: 'claude-sonnet-5', display: 'Claude Sonnet 5', latest: true },
+    { id: 'claude-fable-5', display: 'Claude Fable 5', latest: true },
     { id: 'claude-haiku-4-5-20251001', display: 'Claude Haiku 4.5' },
   ],
   anthropic: [
-    { id: 'claude-opus-4-8', display: 'Claude Opus 4.8', latest: true },
-    { id: 'claude-sonnet-4-6', display: 'Claude Sonnet 4.6', latest: true },
+    { id: 'claude-opus-5', display: 'Claude Opus 5', latest: true },
+    { id: 'claude-sonnet-5', display: 'Claude Sonnet 5', latest: true },
+    { id: 'claude-fable-5', display: 'Claude Fable 5', latest: true },
     { id: 'claude-haiku-4-5-20251001', display: 'Claude Haiku 4.5' },
   ],
 });

package/src/session-runtime/runtime-core.mjs

@@ -229,6 +229,7 @@ import { createWarmupSchedulers } from './warmup-schedulers.mjs';
 import { createPrewarmSchedulers } from './prewarm.mjs';
 import {
   getTurnReviewDiff as getTurnSnapshotReviewDiff,
+  revertTurnReview as revertTurnSnapshotReview,
   revertTurnReviewFile as revertTurnSnapshotReviewFile,
 } from '../runtime/shared/turn-snapshot.mjs';
 import { createMcpGlue } from './mcp-glue.mjs';
@@ -1303,10 +1304,10 @@ export async function createMixdogSessionRuntime({
   scheduleProviderSetupWarmup();
   scheduleModelCatalogWarmup();
   scheduleProviderWarmup();
-  // Warm the provider model catalog in the background, but keep it on its own
-  // delay so short-lived detached runtimes can exit before /models I/O starts.
-  // Operators that want earlier catalog warming can lower
-  // MIXDOG_PROVIDER_MODEL_WARMUP_DELAY_MS explicitly.
+  // Daemon-hosted product sessions warm the provider model catalog immediately
+  // in the background. This does not delay runtime readiness; an early picker
+  // joins the boot prefetch instead of starting duplicate provider I/O.
+  // Standalone runtimes retain an exit-safe grace period (runtime-tunables).
   scheduleProviderModelWarmup();
   scheduleStatuslineUsageWarmup();
   // Channels are opt-in: only boot the worker when this session started in (or
@@ -1649,6 +1650,10 @@ export async function createMixdogSessionRuntime({
       rt.session?.id,
       options,
     ),
+    revertTurnReview: () => revertTurnSnapshotReview(
+      rt.currentCwd,
+      rt.session?.id,
+    ),
     revertTurnReviewFile: (file) => revertTurnSnapshotReviewFile(
       rt.currentCwd,
       rt.session?.id,

package/src/session-runtime/runtime-tunables.mjs

@@ -6,16 +6,19 @@ import { envDelayMs, envFlag, envPresent } from './env.mjs';
 
 export function readRuntimeTunables() {
   const codeGraphPrewarmEnabled = !envFlag('MIXDOG_DISABLE_CODE_GRAPH_PREWARM');
+  const daemonHosted = envFlag('MIXDOG_DAEMON_HOST');
   return {
     providerSetupWarmupDelayMs: envDelayMs('MIXDOG_PROVIDER_SETUP_WARMUP_DELAY_MS', 300, { min: 0, max: 60_000 }),
     modelCatalogWarmupDelayMs: envDelayMs('MIXDOG_MODEL_CATALOG_WARMUP_DELAY_MS', 200, { min: 0, max: 60_000 }),
     providerWarmupDelayMs: envDelayMs('MIXDOG_PROVIDER_WARMUP_DELAY_MS', 1_500, { min: 0, max: 60_000 }),
-    // Background model-catalog prefetch delay. Kept short so the first `/model`
-    // open finds a warm cache instead of paying a cold full network load. The
-    // work is async + unref'd, so short-lived detached runtimes still exit
-    // cleanly without waiting on it. Operators can raise it via env if a
-    // detached runtime must avoid the /models round-trip entirely.
-    providerModelWarmupDelayMs: envDelayMs('MIXDOG_PROVIDER_MODEL_WARMUP_DELAY_MS', 2_000, { min: 0, max: 120_000 }),
+    // A product session lives in the long-running daemon, so start its model
+    // prefetch on the first background tick. Standalone/short-lived runtimes
+    // keep the old grace period so provider sockets cannot hold process exit.
+    providerModelWarmupDelayMs: envDelayMs(
+      'MIXDOG_PROVIDER_MODEL_WARMUP_DELAY_MS',
+      daemonHosted ? 0 : 2_000,
+      { min: 0, max: 120_000 },
+    ),
     codeGraphPrewarmDelayMs: envDelayMs('MIXDOG_CODE_GRAPH_PREWARM_DELAY_MS', 250, { min: 0, max: 60_000 }),
     statuslineUsageWarmupDelayMs: envDelayMs('MIXDOG_STATUSLINE_USAGE_WARMUP_DELAY_MS', 800, { min: 0, max: 60_000 }),
     // Idle keep-alive: re-fetch usage before the statusline's 10-min staleness

package/src/session-runtime/session-title.mjs

@@ -111,11 +111,24 @@ export function createSessionTitleController(deps = {}) {
   const firstAttempts = new Set();
   const thirdAttempts = new Set();
   const active = new Map();
+  const attemptLimit = Number.isFinite(Number(deps.attemptLimit))
+    ? Math.max(1, Number(deps.attemptLimit))
+    : 2048;
   const timeoutMs = Number.isFinite(Number(deps.timeoutMs))
     ? Math.max(1, Number(deps.timeoutMs))
     : SESSION_TITLE_TIMEOUT_MS;
   let disposed = false;
 
+  const rememberAttempt = (attempts, sessionId) => {
+    attempts.delete(sessionId);
+    attempts.add(sessionId);
+    while (attempts.size > attemptLimit) {
+      const oldest = attempts.values().next().value;
+      if (oldest === undefined) break;
+      attempts.delete(oldest);
+    }
+  };
+
   const log = (line) => {
     const message = `[mixdog] llm-title ${line}`;
     try { deps.log?.(message); } catch {}
@@ -190,7 +203,7 @@ export function createSessionTitleController(deps = {}) {
     if (priorMeaningfulUser) return false;
     const source = firstTurnTitleSource(prompt);
     if (!source) return false;
-    firstAttempts.add(sessionId);
+    rememberAttempt(firstAttempts, sessionId);
     const greeting = greetingTitle(source);
     if (greeting) {
       log(`generated id=${sessionId} stage=first title=${JSON.stringify(greeting)} deterministic=greeting`);
@@ -211,7 +224,7 @@ export function createSessionTitleController(deps = {}) {
       || session?.generatedTitleStage === 'third') return false;
     const source = thirdTurnTitleSource(session?.messages);
     if (!source) return false;
-    thirdAttempts.add(sessionId);
+    rememberAttempt(thirdAttempts, sessionId);
     run(sessionId, source, 'third', thirdAttempts);
     return true;
   }
@@ -222,7 +235,18 @@ export function createSessionTitleController(deps = {}) {
       abort.abort(new Error('Session title generation disposed.'));
     }
     active.clear();
+    firstAttempts.clear();
+    thirdAttempts.clear();
   }
 
-  return { scheduleFirst, observeThird, disposeAll };
+  return {
+    scheduleFirst,
+    observeThird,
+    disposeAll,
+    attemptStatsForTest: () => ({
+      first: firstAttempts.size,
+      third: thirdAttempts.size,
+      limit: attemptLimit,
+    }),
+  };
 }

package/src/standalone/channel-transport.mjs

@@ -20,6 +20,12 @@ import { writeJsonAtomicSync } from '../runtime/shared/atomic-file.mjs';
 import { readBody, sendJson, sendError } from '../runtime/memory/lib/http-wire.mjs';
 import { createFairCallScheduler } from './fair-call-scheduler.mjs';
 
+export const CHANNEL_HTTP_BODY_MAX_BYTES = 64 * 1024 * 1024;
+
+function readChannelBody(req) {
+  return readBody(req, { maxBytes: CHANNEL_HTTP_BODY_MAX_BYTES });
+}
+
 function parsePid(value) {
   const n = Number(value);
   return Number.isInteger(n) && n > 0 ? n : null;
@@ -425,7 +431,13 @@ export function createChannelTransport({
   function writeRemoteStateTo(client, state) {
     if (!client) return false;
     const frame = JSON.stringify({ type: 'notify', method: REMOTE_STATE_METHOD, params: { state } });
-    if (!client.sse) { client.pending.push(frame); return true; }
+    if (!client.sse) {
+      // This is state, not an event log. Ownership churn before an SSE
+      // reconnect only needs the newest transition; retaining every displaced
+      // frame lets one disconnected client grow without bound.
+      client.pendingRemoteStateFrame = frame;
+      return true;
+    }
     try { client.sse.write(`data: ${frame}\n\n`); return true; }
     catch (err) { log(`remote-state '${state}' write failed for lead=${client.leadPid}: ${err?.message || err}`); return false; }
   }
@@ -539,7 +551,7 @@ export function createChannelTransport({
       leadPid: pid,
       cwd: cwd || null,
       sse: null,
-      pending: [],
+      pendingRemoteStateFrame: null,
       lastSeen: nowMs(),
       registeredAt: nowMs(),
     });
@@ -574,7 +586,10 @@ export function createChannelTransport({
       const replacedWasPointer = pointerToken === replaced.token;
       // Token-scoped state belongs to the logical client, not only the owner.
       // A non-owner can hold a buffered superseded frame or stored bind intent.
-      if (replaced.pending?.length) fresh.pending.push(...replaced.pending.splice(0));
+      if (replaced.pendingRemoteStateFrame) {
+        fresh.pendingRemoteStateFrame = replaced.pendingRemoteStateFrame;
+        replaced.pendingRemoteStateFrame = null;
+      }
       if (replaced.remoteSessionId) fresh.remoteSessionId = replaced.remoteSessionId;
       if (replacedWasPointer) pointerToken = token;
       removeClientRecord(replaced.token);
@@ -605,10 +620,10 @@ export function createChannelTransport({
     c.lastSeen = nowMs();
     // Flush any targeted frames buffered while this client had no stream (e.g. a
     // 'superseded' emitted at the moment it was reconnecting). Drop-with-client.
-    if (c.pending?.length) {
-      for (const frame of c.pending.splice(0)) {
-        try { res.write(`data: ${frame}\n\n`); } catch {}
-      }
+    if (c.pendingRemoteStateFrame) {
+      const frame = c.pendingRemoteStateFrame;
+      c.pendingRemoteStateFrame = null;
+      try { res.write(`data: ${frame}\n\n`); } catch {}
     }
     // Replay the sticky 'acquired' badge ONLY when THIS attaching client is the
     // current pointer (the owner). A non-pointer late attach must NOT light the
@@ -661,7 +676,7 @@ export function createChannelTransport({
           sendError(res, `daemon is draining: ${drainingReason}`, 503);
           return;
         }
-        const body = await readBody(req);
+        const body = await readChannelBody(req);
         const clientToken = registerClient({
           leadPid: body.leadPid, cwd: body.cwd, passive: body.passive === true,
           replaceToken: body.replaceToken, registrationId: body.registrationId,
@@ -672,7 +687,7 @@ export function createChannelTransport({
         return;
       }
       if (req.method === 'POST' && pathName === '/client/deregister') {
-        const body = await readBody(req);
+        const body = await readChannelBody(req);
         if (body.registrationId) {
           const cancelled = cancelReplacementRegistration(body);
           if (cancelled === 'forbidden') { sendError(res, 'forbidden replacement deregister', 403); return; }
@@ -695,7 +710,7 @@ export function createChannelTransport({
       // parallel fair scheduler and per-call cancellation.
       if (req.method === 'POST' && pathName === '/agent/dispatch') {
         if (!agentBroker?.dispatch) { sendError(res, 'agent broker unavailable', 503); return; }
-        const body = await readBody(req);
+        const body = await readChannelBody(req);
         const callId = String(body.callId || '').trim();
         if (!callId) { sendError(res, 'callId required', 400); return; }
         res.on('close', () => {
@@ -712,7 +727,7 @@ export function createChannelTransport({
       }
       if (req.method === 'POST' && pathName === '/agent/cancel') {
         if (!agentBroker?.cancel) { sendError(res, 'agent broker unavailable', 503); return; }
-        const body = await readBody(req);
+        const body = await readChannelBody(req);
         const callId = String(body.callId || '').trim();
         if (!callId) { sendError(res, 'callId required', 400); return; }
         const cancelled = agentBroker.cancelAndWait
@@ -728,7 +743,7 @@ export function createChannelTransport({
         return;
       }
       if (req.method === 'POST' && pathName === '/call') {
-        const body = await readBody(req);
+        const body = await readChannelBody(req);
         const clientToken = body.token || null;
         const c = clientToken ? clients.get(clientToken) : null;
         if (!c) { sendError(res, 'unknown client token', 404); return; }
@@ -920,6 +935,7 @@ export function createChannelTransport({
     _clientsForTest: clients,
     _registrationReplaysForTest: registrationReplays,
     _resolveTargetForTest: resolveTarget,
+    _writeRemoteStateToForTest: writeRemoteStateTo,
     get _pointerTokenForTest() { return pointerToken; },
     get _remoteIntentForTest() { return remoteIntent; },
   };

package/src/standalone/daemon.mjs

@@ -526,6 +526,9 @@ async function main() {
   function prewarmSessionRuntime() {
     if (sessionRuntimePrewarmStarted) return;
     sessionRuntimePrewarmStarted = true;
+    void import('../runtime/agent/orchestrator/tools/builtin/read-image-resize.mjs')
+      .then((module) => module.prewarmImageResizer?.())
+      .catch((error) => log(`image pipeline prewarm failed (non-fatal): ${error?.message || error}`));
     void sessionRuntimePool.prewarm()
       .then(() => log('session shard runtime/agent-loop/keychain prewarm started'))
       .catch((error) => {

package/src/standalone/session-protocol.mjs

@@ -103,6 +103,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'restoreNewerTranscript',
   'restoreOlderTranscript',
   'restoreQueued',
+  'revertTurnReview',
   'revertTurnReviewFile',
   'rewindToItem',
   'runDoctor',

package/src/standalone/session-service.mjs

@@ -15,6 +15,10 @@ import {
   SESSION_CONFIGURE_ACTION_SET,
   SESSION_READ_ACTION_SET,
 } from './session-protocol.mjs';
+import {
+  materializePromptSubmission,
+  preparePromptSubmissionForProvider,
+} from '../runtime/attachments/store.mjs';
 
 const MAX_CLONE_DEPTH = 24;
 const requireDesktopService = createRequire(import.meta.url);
@@ -272,6 +276,20 @@ export function createSessionService({
     const items = entry.itemCache ??= new Map();
     const out = {};
     for (const [key, value] of Object.entries(raw)) {
+      if (key === 'queued' && Array.isArray(value)) {
+        const projected = value.map((item) => ({
+          id: item?.id,
+          submittedAt: item?.submittedAt,
+          text: String(item?.displayText ?? item?.text ?? '').slice(0, 2_000),
+          displayText: String(item?.displayText ?? item?.text ?? '').slice(0, 2_000),
+          mode: item?.mode || 'prompt',
+          priority: item?.priority || 'next',
+          ...(Array.isArray(item?.images) && item.images.length ? { images: item.images } : {}),
+        }));
+        fields.set(key, { source: value, value: projected });
+        out[key] = projected;
+        continue;
+      }
       if (key === 'items' && Array.isArray(value)) {
         const nextItems = new Map();
         out.items = value.map((item) => {
@@ -815,10 +833,14 @@ export function createSessionService({
     const entry = await entryForSession(id, openHints || {});
     const target = entry.runtime.submitAsync;
     if (typeof target !== 'function') throw new TypeError('session runtime must implement submitAsync');
+    const intake = await preparePromptSubmissionForProvider(
+      materializePromptSubmission(prompt, options || {}),
+      entry.runtime.provider || entry.runtime.session?.provider || '',
+    );
     // Await intake only: submitAsync resolves once the prompt is represented by
     // the queue/user row, while provider execution remains daemon-owned and
     // detached.
-    const accepted = await Promise.resolve(target.call(entry.runtime, prompt, options || {}));
+    const accepted = await Promise.resolve(target.call(entry.runtime, intake.prompt, intake.options));
     const firstSubmit = accepted === true && entry.reservedOnly;
     if (accepted === true) {
       entry.reservedOnly = false;

package/src/standalone/session-transport.mjs

@@ -12,7 +12,7 @@
 // the same transport is exercised by the real daemon entry AND by the smoke
 // harness with a stub session runtime (no provider, no model download).
 import http from 'node:http';
-import { createHash, randomUUID } from 'node:crypto';
+import { randomUUID } from 'node:crypto';
 import { sendJson, sendError } from '../runtime/memory/lib/http-wire.mjs';
 import {
   compareRuntimeVersions,
@@ -22,6 +22,7 @@ import {
   runtimeVersion,
 } from './session-wire.mjs';
 import { createFairCallScheduler } from './fair-call-scheduler.mjs';
+import { hashStructuredValue } from '../runtime/shared/json-metrics.mjs';
 
 // A loopback front door still buffers whatever a client sends before it can be
 // parsed, so the body has an explicit ceiling instead of the client's memory.
@@ -93,7 +94,7 @@ function readLimitedBody(req, {
  *  submission id that happens to be reused carries a different one. */
 function callSignature(name, args) {
   try {
-    return createHash('sha1').update(`${name}\u0000${JSON.stringify(args ?? {})}`).digest('hex');
+    return hashStructuredValue({ name, args: args ?? {} });
   } catch { return null; }
 }
 

package/src/tui/app/prompt-submit.mjs

@@ -12,7 +12,6 @@ import {
 import { projectNameFromPath } from './app-format.mjs';
 import {
   buildPromptContentWithImages,
-  expandPastedTextTokens,
   imageReferenceIds,
   pastedTextReferenceIds,
 } from '../paste-attachments.mjs';
@@ -489,15 +488,14 @@ export function createPromptSubmit({
     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); clearPastedTextsSnapshot(textSnapshot); }

package/src/tui/app/use-prompt-handlers.mjs

@@ -83,7 +83,11 @@ export 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');
@@ -123,7 +127,7 @@ export function usePromptHandlers({
         .then((clip) => {
           const normalized = String(clip ?? '').replace(/\r\n?/g, '\n');
           if (normalized) return processText(normalized, true);
-          return readClipboardImageAttachment()
+          return readClipboardImageAttachment({ provider: state.provider || '' })
             .then((image) => {
               if (!image) {
                 showPromptHint('no text or image found on clipboard', 'plain');
@@ -141,7 +145,7 @@ export function usePromptHandlers({
     }
 
     return processText(value);
-  }, [registerPastedImage, registerPastedText, showPromptHint, state.cwd]);
+  }, [registerPastedImage, registerPastedText, showPromptHint, state.cwd, state.provider]);
 
   const handlePromptHistoryNavigate = useCallback((direction, currentText = '', meta = {}) => {
     const currentValue = String(currentText || '');