mixdog 1.3.1 → 1.3.3

package/src/standalone/session-client.mjs

@@ -148,12 +148,12 @@ function request({
       }
     );
     req.on('timeout', () => {
-      req.destroy(new Error(`session timeout: ${method} ${urlPath}`));
+      req.destroy(sessionTimeoutError(method, urlPath));
     });
     req.on('error', reject);
     if (deadlineMs > 0) {
       deadlineTimer = setTimeout(() => {
-        const error = new Error(`session timeout: ${method} ${urlPath}`);
+        const error = sessionTimeoutError(method, urlPath);
         reject(error);
         req.destroy(error);
       }, deadlineMs);
@@ -163,6 +163,11 @@ function request({
   });
 }
 
+/** No answer within the request's bound: the daemon may be busy with it, not gone. */
+function sessionTimeoutError(method, urlPath) {
+  return Object.assign(new Error(`session timeout: ${method} ${urlPath}`), { code: 'ESESSIONTIMEOUT' });
+}
+
 /** /health within `timeoutMs` of total duration; null when it does not answer. */
 export async function probeSessionHealth({ port, token, timeoutMs = 800 } = {}) {
   try {

package/src/standalone/session-protocol.mjs

@@ -15,12 +15,14 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'getAgentAvatarImage',
   'getAgentConnectors',
   'getProjectConnectors',
+  'getAgentAlwaysAllowedTools',
   'getAgentPermissions',
   'listConnectors',
   'listConnectorTools',
   'getLeadPersona',
   'getLeadAgentBody',
   'getLeadStatus',
+  'getLeadHomeRoute',
   'getAutoClear',
   'getChannelSettings',
   'getChannelSetup',
@@ -45,6 +47,8 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'getQuotaHistory',
   'getRecapSettings',
   'getSessionTitleSettings',
+  'getLeadAppearance',
+  'getBotOrder',
   'getWebSearchRoute',
   'getSettingsSnapshot',
   'getSystemShell',
@@ -188,6 +192,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'setAgentConnectorToolPermission',
   'setProjectConnectorEnabled',
   'setAgentPermission',
+  'recordAgentApprovalAudit',
   'saveLeadPersona',
   'saveLeadAgentBody',
   'setLeadCreated',
@@ -233,6 +238,8 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'setProgressHint',
   'setRecapEnabled',
   'setAiSessionTitles',
+  'setLeadAppearance',
+  'setBotOrder',
   'setRoute',
   'setScheduleEnabled',
   'setWebSearchRoute',
@@ -241,6 +248,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'setToolMode',
   'setWebSearchEnabled',
   'setInstructionFiles',
+  'setAutoEffortBase',
   'setWebhookConfig',
   'setWebhookEnabled',
   'setWorkflow',

package/src/standalone/session-runtime-inline-host/boot-loaders.mjs

@@ -57,6 +57,8 @@ export function createInlineBootLoaders({
     if (isClosed()) return false;
     try {
       const module = await loadLocalModule();
+      // A loop turn between the two graph loads: one piece held the loop.
+      await new Promise((resolve) => setImmediate(resolve));
       if (isClosed()) return false;
       return (await module.warmLocalSessionRuntime?.()) !== false;
     } catch {

package/src/standalone/session-service/agent-route-follow.mjs

@@ -0,0 +1,69 @@
+// A bot's saved model route reaches the chats it already has: its home thread
+// and its group-room member sessions, from their next turn (the session route
+// API's deferred pick, the one every model picker uses: a running turn finishes
+// on the model it started on). The latest saved route wins. A thread no
+// runtime hosts keeps its model until it is opened (the desktop refreshes it
+// then, agent-home-sessions.ts).
+import { subscribeAgentRouteChanges } from '../../session-runtime/agent-profile-changes.mjs';
+import { agentHomeSessionId } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
+import { roomMemberOfSession } from '../../runtime/agent/orchestrator/session/agent-room.mjs';
+
+const ROUTE_KEYS = [
+  'provider',
+  'model',
+  'effort',
+  'fast',
+  'autoEffort',
+  'modelParameters',
+  'contextPercent',
+  'contextTokens',
+];
+
+/** The pick the session route API takes for a saved route. */
+function sessionRoutePick(route) {
+  const pick = { sessionOnly: true };
+  for (const key of ROUTE_KEYS) if (route?.[key] !== undefined && route[key] !== null) pick[key] = route[key];
+  return pick;
+}
+
+export function createAgentRouteFollow({ sessionsById, sessionOwner, advance, publishStep, log }) {
+  // Each chat takes its updates one at a time, in the order they were
+  // published: a slow chat never lets an older route land after a newer one.
+  const tails = new Map(); // sessionId -> Promise of its last queued update
+
+  function apply(sessionId, pick) {
+    const entry = sessionOwner(sessionId);
+    if (typeof entry?.runtime?.setRoute !== 'function') return Promise.resolve();
+    return Promise.resolve()
+      .then(async () => {
+        await entry.runtime.setRoute(pick);
+        const step = advance(entry);
+        if (step.changed) publishStep(entry, step);
+      })
+      .catch((error) => {
+        // A route the runtime refuses (provider signed out) leaves the chat on its model.
+        log(`agent route change not applied to ${sessionId}: ${error?.message || error}`);
+      });
+  }
+
+  function enqueue(sessionId, pick) {
+    const queued = (tails.get(sessionId) || Promise.resolve()).then(() => apply(sessionId, pick));
+    tails.set(sessionId, queued);
+    queued.then(() => {
+      if (tails.get(sessionId) === queued) tails.delete(sessionId);
+    });
+    return queued;
+  }
+
+  // Every matching chat is queued before the first await: publications queue in order.
+  function follow(agentId, route) {
+    const home = agentHomeSessionId(agentId);
+    if (!home || !route?.provider || !route?.model) return Promise.resolve();
+    const pick = sessionRoutePick(route);
+    const queued = [...sessionsById.keys()]
+      .filter((sessionId) => sessionId === home || roomMemberOfSession(sessionId)?.agentId === agentId)
+      .map((sessionId) => enqueue(sessionId, pick));
+    return Promise.all(queued);
+  }
+  return subscribeAgentRouteChanges(follow);
+}

package/src/standalone/session-service/session-calls/session-turns.mjs

@@ -62,15 +62,43 @@ export function createSessionTurnCalls(ctx) {
     return step;
   };
 
-  async function submitSession({ sessionId, prompt, options = {}, open: openHints = {}, baseRevision = null } = {}) {
+  // Intakes in flight per session: an abort of the session also cancels an
+  // attachment conversion that has not yet become a turn.
+  const intakeAborts = new Map();
+
+  async function submitSession({
+    sessionId,
+    prompt,
+    options = {},
+    open: openHints = {},
+    baseRevision = null,
+    signal = null,
+  } = {}) {
     const id = String(sessionId || '');
     if (!id) throw new TypeError('sessionId is required');
     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 || {}), {
-      nativePdf: providerNativePdf(entry.runtime.provider || entry.runtime.session?.provider || ''),
-    });
+    const intakeAbort = new AbortController();
+    const forwardAbort = () => intakeAbort.abort(signal.reason);
+    if (signal?.aborted) forwardAbort();
+    else signal?.addEventListener?.('abort', forwardAbort, { once: true });
+    if (!intakeAborts.has(id)) intakeAborts.set(id, new Set());
+    intakeAborts.get(id).add(intakeAbort);
+    let intake;
+    try {
+      intake = await preparePromptSubmissionForProvider(
+        materializePromptSubmission(prompt, options || {}),
+        { nativePdf: providerNativePdf(entry.runtime.provider || entry.runtime.session?.provider || '') },
+        { signal: intakeAbort.signal }
+      );
+    } finally {
+      signal?.removeEventListener?.('abort', forwardAbort);
+      intakeAborts.get(id)?.delete(intakeAbort);
+      if (!intakeAborts.get(id)?.size) intakeAborts.delete(id);
+    }
+    // A cancel that landed after the last conversion step must not submit.
+    intakeAbort.signal.throwIfAborted();
     // Await intake only: submitAsync resolves once the prompt is represented by
     // the queue/user row, while provider execution remains daemon-owned and
     // detached.
@@ -131,6 +159,7 @@ export function createSessionTurnCalls(ctx) {
   async function abortSession({ sessionId, open: openHints = {}, options = {}, baseRevision = null } = {}) {
     const id = String(sessionId || '');
     if (!id) throw new TypeError('sessionId is required');
+    for (const intakeAbort of intakeAborts.get(id) ?? []) intakeAbort.abort();
     const entry = await entryForSession(id, openHints || {});
     const target = entry.runtime.abort;
     if (typeof target !== 'function') throw new TypeError('session action abort is unavailable');

package/src/standalone/session-service.mjs

@@ -23,6 +23,8 @@ import { createViewerRegistry } from './session-service/viewers.mjs';
 import { createSessionEntries } from './session-service/entries.mjs';
 import { createSessionCalls } from './session-service/session-calls.mjs';
 import { createQuotaResumeScheduler } from './session-service/quota-resume.mjs';
+import { createAgentRouteFollow } from './session-service/agent-route-follow.mjs';
+import { registerDelegatedApprovalOpener } from '../runtime/shared/delegated-approval-host.mjs';
 
 const EXTERNAL_SESSION_ACTIONS = new Set([
   ...SESSION_READ_ACTION_SET,
@@ -205,6 +207,17 @@ export function createSessionService({
     retainUnwatched: retention.retainUnwatched,
     createSession: calls.createSession,
   });
+  // A sub-agent's approval shows in its top-level chat; one not loaded is
+  // brought up so the copy (and its notifications) appear there.
+  const unregisterApprovalOpener = registerDelegatedApprovalOpener((sessionId) => calls.materializeSession(sessionId));
+  // A bot's saved route reaches its hosted home and room-member chats from their next turn.
+  const agentRouteFollow = createAgentRouteFollow({
+    sessionsById,
+    sessionOwner: projection.sessionOwner,
+    advance: projection.advance,
+    publishStep: projection.publishStep,
+    log,
+  });
   const quotaUsableReader = typeof readQuotaUsable === 'function' ? readQuotaUsable : async () => false;
   const quotaResume = quotaResumeStore
     ? createQuotaResumeScheduler({
@@ -219,6 +232,8 @@ export function createSessionService({
   function stop(reason = 'service stop') {
     if (stopPromise) return stopPromise;
     closed = true;
+    unregisterApprovalOpener();
+    agentRouteFollow.unsubscribe();
     quotaResume?.stop();
     stopPromise = Promise.resolve().then(async () => {
       try {
@@ -243,6 +258,11 @@ export function createSessionService({
     return Boolean(owner) && retention.stateBusy(owner.runtime?.getState?.());
   }
 
+  /** Whether the runtime hosting `sessionId` shows an approval card waiting on the user. */
+  function liveSessionAwaitingApproval(sessionId) {
+    return Boolean(projection.sessionOwner(sessionId)?.runtime?.getState?.()?.toolApproval);
+  }
+
   /** Show a transcript notice in the hosted runtime of `sessionId` (no turn)
    *  and publish it to its views; false when no runtime hosts it. */
   function pushLiveSessionNotice(sessionId, { text, tone = 'info', ...options } = {}) {
@@ -300,6 +320,7 @@ export function createSessionService({
     methods: {
       ...calls,
       liveSessionBusy,
+      liveSessionAwaitingApproval,
       pushLiveSessionNotice,
       stop,
       startQuotaResume: () => quotaResume?.start(),

package/src/standalone/session-state-projection.mjs

@@ -1,4 +1,6 @@
 import { sanitizeForWire } from './session-wire-values.mjs';
+import { stripAgentMessageEnvelope } from '../runtime/shared/agent-message-envelope.mjs';
+import { transcriptSourceFields } from '../runtime/shared/transcript-metadata.mjs';
 
 /** Immutable source fields keep their wire identity until they actually change.
  * In particular, a live tail must not rebuild the settled transcript or resend
@@ -29,15 +31,23 @@ export function projectSessionState(entry, raw) {
     }
     let cloned;
     if (key === 'queued' && Array.isArray(value)) {
-      cloned = 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 } : {}),
-      }));
+      cloned = value.map((item) => {
+        // A queued bot message reads like its delivered row: the sender tag
+        // and the message without its envelope.
+        const source = transcriptSourceFields(item?.transcriptMeta);
+        const queuedText = String(item?.displayText ?? item?.text ?? '');
+        const text = (source.fromAgent ? stripAgentMessageEnvelope(queuedText) : queuedText).slice(0, 2_000);
+        return {
+          id: item?.id,
+          submittedAt: item?.submittedAt,
+          text,
+          displayText: text,
+          mode: item?.mode || 'prompt',
+          priority: item?.priority || 'next',
+          ...source,
+          ...(Array.isArray(item?.images) && item.images.length ? { images: item.images } : {}),
+        };
+      });
     } else if (key === 'items' && Array.isArray(value)) {
       const items = entry.itemCache;
       const nextItems = new Map();

package/src/standalone/session-tool-output.mjs

@@ -1,4 +1,6 @@
 import { encodeCatalogCursor } from '../runtime/agent/orchestrator/session/catalog-db/schema.mjs';
+import { UNTRUSTED_NOTE, sessionBotOf } from '../session-runtime/bot-status.mjs';
+import { escapeHarnessTags } from '../runtime/shared/shell-output-summary.mjs';
 import { truncateToolText } from '../runtime/shared/tool-primitives.mjs';
 import { summarizeToolResult } from '../runtime/shared/tool-result-summary.mjs';
 
@@ -6,18 +8,43 @@ import { TOOL_OUTPUT_PAGE_BYTES, TOOL_OUTPUT_TAIL_BYTES } from '../runtime/share
 
 export const SESSION_TOOL_OUTPUT_BYTES = TOOL_OUTPUT_TAIL_BYTES;
 const MESSAGE_TEXT_LIMIT = 2000;
+const LIST_PREVIEW_LIMIT = 100;
 const outputBytes = (value) => Buffer.byteLength(JSON.stringify(value), 'utf8');
 
-/** Keep catalog paging authoritative even when the output budget shortens a page. */
-export function sessionListOutput(page, limit) {
+/** Keep catalog paging authoritative even when the output budget shortens a page.
+ *  `rich` adds the owning bot, last activity, latest line and working state
+ *  (never for a background caller: bot-status.mjs scopedBot). */
+export function sessionListOutput(page, limit, { rich = true } = {}) {
   const raw = page.sessions;
-  const sessions = raw.slice(0, limit).map((row) => ({
-    id: row.id,
-    ...(row.title || row.preview ? { title: truncateToolText(row.title || row.preview, 160) } : {}),
-    ...(row.status ? { status: row.status } : {}),
-    ...(row.cwd ? { cwd: row.cwd } : {}),
-  }));
-  const result = { sessions, nextCursor: page.nextCursor ?? null };
+  const sessions = raw.slice(0, limit).map((row) => {
+    const base = {
+      id: row.id,
+      ...(row.title || row.preview
+        ? { title: escapeHarnessTags(truncateToolText(row.title || row.preview, 160)) }
+        : {}),
+      ...(row.status ? { status: row.status } : {}),
+      ...(row.cwd ? { cwd: row.cwd } : {}),
+      ...(row.archived === true ? { archived: true } : {}),
+    };
+    if (!rich) return base;
+    // The bot it belongs to: its chat, room seat or the task's creator.
+    const bot = sessionBotOf(row);
+    const lastUsedAt = Number(row.lastUsedAt) || 0;
+    const preview = String(row.lastMessagePreview || '').replace(/\s+/g, ' ');
+    return {
+      ...base,
+      ...(bot ? { bot } : {}),
+      ...(lastUsedAt ? { lastUsedAt: new Date(lastUsedAt).toISOString() } : {}),
+      // The latest user or assistant line, quoted data.
+      ...(preview.trim() ? { preview: escapeHarnessTags(truncateToolText(preview, LIST_PREVIEW_LIMIT)) } : {}),
+      ...(row.working === true || row.agentWorking === true ? { working: true } : {}),
+    };
+  });
+  const result = {
+    sessions,
+    nextCursor: page.nextCursor ?? null,
+    ...(sessions.some((row) => row.preview) ? { note: UNTRUSTED_NOTE } : {}),
+  };
   for (;;) {
     if (sessions.length < raw.length && sessions.length) {
       result.nextCursor = encodeCatalogCursor(raw[sessions.length - 1]);

package/src/standalone/staged-import.mjs

@@ -0,0 +1,47 @@
+// Staged dynamic import of a large module graph. Loading a graph (file reads,
+// compilation, evaluation) runs synchronously inside one import() call, so the
+// daemon's session-runtime warm-up held the event loop for ~0.5 s in one
+// piece right after `daemon-ready`. Importing the graph's top-level stages one
+// loop turn apart splits that block without changing what is loaded.
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+// A static `import … from './x'`, `export … from './x'` or bare `import './x'`
+// at the start of a line, in source order.
+const STATIC_RELATIVE_IMPORT =
+  /^(?:import|export)\b[^;]*?\bfrom\s*['"](\.{1,2}\/[^'"]+)['"]|^import\s*['"](\.{1,2}\/[^'"]+)['"]/gm;
+
+/** The relative static imports of the module at `url`, resolved, in source order. */
+export function staticRelativeImports(url) {
+  const source = readFileSync(fileURLToPath(url), 'utf8');
+  return [...source.matchAll(STATIC_RELATIVE_IMPORT)].map((match) => new URL(match[1] || match[2], url).href);
+}
+
+const nextTurn = () => new Promise((resolve) => setImmediate(resolve));
+
+/**
+ * import(url), after importing each static relative dependency of `stagesOf`
+ * (in its source order, one loop turn apart). Module evaluation order is the
+ * one a single import gives — dependencies depth-first in source order — as
+ * long as no module of a stage's graph imports `stagesOf` or an importer of it
+ * back. Staging stops at the first stage that fails, so no later stage
+ * evaluates; the final import then reports the failure as a single import
+ * would.
+ */
+export async function importInStages(url, stagesOf) {
+  let stages = [];
+  try {
+    stages = staticRelativeImports(stagesOf);
+  } catch {
+    // Unreadable source: one import, as before.
+  }
+  for (const stage of stages) {
+    try {
+      await import(stage);
+    } catch {
+      break;
+    }
+    await nextTurn();
+  }
+  return import(url);
+}

package/src/tui/App.jsx

@@ -516,6 +516,8 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false, on
     syncPromptLayoutRows,
     showPromptHint,
     clearPromptHint,
+    installPastedImages,
+    installPastedTexts,
   });
 
   // PROMPT HANDLER cluster extracted to app/use-prompt-handlers.mjs.

package/src/tui/app/maintenance-pickers/auto-clear-picker.mjs

@@ -3,10 +3,14 @@
 // the Advanced list of provider default idle windows edited as text.
 
 // Lead BP4 messages cache TTL follows autoClear (cache-strategy.mjs
-// resolveLeadMessagesTtl): off or idle>=1h -> 1h, shorter idle -> 5m.
+// resolveLeadMessagesTtl): off or idle>=1h (incl. unlimited) -> 1h, shorter
+// idle -> 5m.
 const HOUR_MS = 60 * 60 * 1000;
+// Typed (and shown) for "never auto-clear"; the runtime stores it as 0.
+const UNLIMITED_INPUT = 'unlimited';
 
-const formatDurationInput = (ms) => {
+const formatDurationInput = (ms, unlimited = false) => {
+  if (unlimited) return UNLIMITED_INPUT;
   const value = Math.max(0, Math.round(Number(ms) || 0));
   if (value > 0 && value % HOUR_MS === 0) return `${value / HOUR_MS}h`;
   if (value > 0 && value % 60_000 === 0) return `${value / 60_000}m`;
@@ -39,7 +43,7 @@ export function createAutoClearPicker({
       label: entry.provider,
       marker: entry.provider === provider ? '✓' : '',
       markerColor: theme.success,
-      meta: `${formatDuration(entry.idleMs)}${entry.custom ? ' custom' : ''}`,
+      meta: `${entry.unlimited ? 'Unlimited' : formatDuration(entry.idleMs)}${entry.custom ? ' custom' : ''}`,
       description: `Default idle window for ${entry.provider}. Enter to edit as text.`,
       _action: 'provider-default',
       _entry: entry,
@@ -66,10 +70,10 @@ export function createAutoClearPicker({
             store.pushNotice('autoclear unavailable', 'warn');
             return;
           }
-          store.pushNotice(
-            next.enabled ? `autoclear on · idle ${formatDuration(next.idleMs)}` : 'autoclear off',
-            'info'
-          );
+          let notice = 'autoclear off';
+          if (next.enabled)
+            notice = next.unlimited ? 'autoclear on · unlimited' : `autoclear on · idle ${formatDuration(next.idleMs)}`;
+          store.pushNotice(notice, 'info');
         })
         .catch((e) => store.pushNotice(`autoclear failed: ${e?.message || e}`, 'error'))
         .finally(settled);
@@ -80,8 +84,8 @@ export function createAutoClearPicker({
       setSettingsPrompt({
         kind: 'autoclear-provider',
         label: `Auto-clear · ${entry.provider}`,
-        hint: `Type a duration like 10m, 1h, or 24h. Empty resets to built-in ${formatDurationInput(entry.builtInMs)}.`,
-        initialValue: formatDurationInput(entry.idleMs),
+        hint: `Type a duration like 10m, 1h, or 24h, or ${UNLIMITED_INPUT} to never auto-clear. Empty resets to built-in ${formatDurationInput(entry.builtInMs, entry.builtInUnlimited)}.`,
+        initialValue: formatDurationInput(entry.idleMs, entry.unlimited),
         provider: entry.provider,
         builtInMs: entry.builtInMs,
         returnTo,
@@ -109,18 +113,20 @@ export function createAutoClearPicker({
       const current = await readCurrent();
       const enabled = current?.enabled !== false;
       const idleMs = Number(current?.idleMs || HOUR_MS);
+      const unlimited = current?.unlimited === true;
       const cacheTtlLabel = !enabled || idleMs >= HOUR_MS ? '1h' : '5m';
       let sourceLabel = `${current?.provider || 'default'} default`;
       if (current?.providerCustom) sourceLabel = `${current.provider} override`;
       else if (current?.custom) sourceLabel = 'global';
+      const clearText = unlimited
+        ? `Never clear idle sessions (${sourceLabel})`
+        : `Clear idle sessions after ${formatDuration(idleMs)} (${sourceLabel})`;
       const items = [
         {
           value: 'toggle',
           label: 'Auto-clear',
           meta: enabled ? 'On' : 'Off',
-          description: enabled
-            ? `Clear idle sessions after ${formatDuration(idleMs)} (${sourceLabel}) · lead cache TTL ${cacheTtlLabel}.`
-            : 'Idle auto-clear disabled.',
+          description: enabled ? `${clearText} · lead cache TTL ${cacheTtlLabel}.` : 'Idle auto-clear disabled.',
           _action: 'toggle',
         },
         {
@@ -132,7 +138,7 @@ export function createAutoClearPicker({
       ];
       own.paint({
         title: 'Auto-clear',
-        description: `Clear idle context after ${enabled ? `${formatDuration(idleMs)} (${sourceLabel})` : 'never'} · lead cache TTL ${cacheTtlLabel}.`,
+        description: `Clear idle context after ${enabled && !unlimited ? `${formatDuration(idleMs)} (${sourceLabel})` : 'never'} · lead cache TTL ${cacheTtlLabel}.`,
         help: '↑/↓ Select · ←/→ Toggle On/Off · Enter Open/Toggle · Esc Close',
         indexMode: 'always',
         labelWidth: 10,

package/src/tui/app/message-selector.mjs

@@ -45,6 +45,8 @@ export function useMessageSelector({
   syncPromptLayoutRows,
   showPromptHint,
   clearPromptHint,
+  installPastedImages,
+  installPastedTexts,
 }) {
   // Cheap enough to recompute only when the transcript array identity changes;
   // the prompt asks for this on every Escape, never per keystroke.
@@ -64,11 +66,22 @@ export function useMessageSelector({
         return false;
       }
       clearPromptHint();
+      // The prompt's pasted blocks return with it, so its tokens still expand.
+      if (restored.pastedImages) installPastedImages?.(restored.pastedImages, { merge: true });
+      if (restored.pastedTexts) installPastedTexts?.(restored.pastedTexts, { merge: true });
       syncPromptLayoutRows(text);
       setPromptDraftOverride({ id: Date.now(), value: text });
+      if (restored.notice) showPromptHint(restored.notice, 'error');
       return true;
     },
-    [clearPromptHint, syncPromptLayoutRows, setPromptDraftOverride, showPromptHint]
+    [
+      clearPromptHint,
+      syncPromptLayoutRows,
+      setPromptDraftOverride,
+      showPromptHint,
+      installPastedImages,
+      installPastedTexts,
+    ]
   );
 
   const openMessageSelector = useCallback(() => {
@@ -89,7 +102,7 @@ export function useMessageSelector({
         own.close();
         let restored;
         try {
-          restored = store.rewindToItem?.(value);
+          restored = store.rewindToItem?.(value, { restoreFiles: false });
         } catch (error) {
           showPromptHint(`rewind failed: ${error?.message || error}`, 'error');
           return;

package/src/tui/app/model-options.mjs

@@ -221,6 +221,18 @@ export const loadProviderDisplayNames = async (store) => {
   return names;
 };
 
+/** Provider names for the picker: custom rows' own `providerName` first, then
+ *  setup names over them (setup wins). Works when setup is missing or failed. */
+export const catalogProviderDisplayNames = (models, setupNames = null) => {
+  const names = {};
+  for (const model of Array.isArray(models) ? models : []) {
+    const provider = String(model?.provider || '').trim();
+    const name = String(model?.providerName || '').trim();
+    if (provider.startsWith('custom-') && name) names[provider] = name;
+  }
+  return { ...names, ...setupNames };
+};
+
 /** `{ id, text }` for each provider whose model list failed, with the reason
  *  (the setup row's `catalogError`) and what to do about it. */
 export const loadProviderCatalogFailures = async (store) => {
@@ -368,9 +380,11 @@ const routeModelDetails = (route) =>
     .filter(Boolean)
     .join(' · ');
 
-export const routeLabel = (route) => {
+export const routeLabel = (route, providerNames = null) => {
   if (!route?.provider || !route?.model) return '(unset)';
-  return [providerDisplayName(route.provider), routeModelDetails(route)].filter(Boolean).join(' · ');
+  return [resolveProviderDisplayName(route.provider, providerNames), routeModelDetails(route)]
+    .filter(Boolean)
+    .join(' · ');
 };
 
 export const routeModelLabel = (route) => (route?.model ? routeModelDetails(route) : '(unset)');

package/src/tui/app/model-picker.mjs

@@ -14,6 +14,7 @@ import {
   normalizeModelOptions,
   buildCatalogFailureItems,
   buildModelProviderItems,
+  catalogProviderDisplayNames,
   loadProviderCatalogFailures,
   loadProviderDisplayNames,
 } from './model-options.mjs';
@@ -83,7 +84,7 @@ export function createModelPicker({
     }
 
     const models = normalizeModelOptions(providerModels);
-    const providerNames = await loadProviderDisplayNames(store);
+    const providerNames = catalogProviderDisplayNames(models, await loadProviderDisplayNames(store));
     const catalogFailures = await loadProviderCatalogFailures(store);
     const activeRoute = options.currentRoute || {
       provider: state.provider,

package/src/tui/app/route-pickers.mjs

@@ -7,6 +7,7 @@
  * openers (openModelPicker) thread as lazy getter wrappers so they resolve the
  * live binding at call time.
  */
+import { loadProviderDisplayNames } from './model-options.mjs';
 import { createAgentsPicker } from './route-pickers/agents-picker.mjs';
 import { createOutputStylePicker } from './route-pickers/output-style-picker.mjs';
 import { createWorkflowPicker } from './route-pickers/workflow-picker.mjs';
@@ -59,7 +60,8 @@ export function createRoutePickers({
           store.pushNotice('Web-search model save is already running.', 'warn');
           return;
         }
-        store.pushNotice(`Web-search model set to ${routeLabel(result)}`, 'info');
+        const providerNames = await loadProviderDisplayNames(store);
+        store.pushNotice(`Web-search model set to ${routeLabel(result, providerNames)}`, 'info');
         return result;
       },
       onAfterSelect: null,

package/src/tui/app/settings-picker/settings-rows.mjs

@@ -139,9 +139,9 @@ export function buildSettingsItems({
     {
       value: 'autoclear',
       label: 'Auto-clear',
-      meta: autoClearEnabled ? `On (${formatDuration(autoClear.idleMs)})` : 'Off',
+      meta: autoClearEnabled ? `On (${autoClear.unlimited ? 'Unlimited' : formatDuration(autoClear.idleMs)})` : 'Off',
       description: autoClearEnabled
-        ? `Clear idle sessions after ${formatDuration(autoClear.idleMs)}${autoClearSource}. Enter for options.`
+        ? `${autoClear.unlimited ? 'Never clear idle sessions' : `Clear idle sessions after ${formatDuration(autoClear.idleMs)}`}${autoClearSource}. Enter for options.`
         : 'Idle auto-clear disabled. Enter for options.',
       _action: 'autoclear',
     },

package/src/tui/app/slash-commands.mjs

@@ -30,7 +30,7 @@ export const SLASH_COMMANDS = [
   {
     name: 'autoclear',
     usage: '/autoclear',
-    params: '[on|off|duration]',
+    params: '[on|off|duration|unlimited]',
     description: 'Reduce cache-miss cost after long idle gaps',
   },
   { name: 'resume', usage: '/resume', params: '[id]', description: 'Resume a saved chat' },