mixdog 0.9.85 → 0.9.87

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

@@ -35,10 +35,8 @@ export function createSlashDispatch({
   openThemePicker,
   themeNotice,
   openEffortPicker,
-  projectNameFromPath,
   enterProject,
   openProjectPicker,
-  openToolsPicker,
   openMcpPicker,
   openSkillsPicker,
   openPluginsPicker,
@@ -231,19 +229,6 @@ export function createSlashDispatch({
           .catch((e) => store.pushNotice(`Couldn’t update fast mode: ${e?.message || e}`, 'error'));
         return true;
       }
-      case 'cwd': {
-        const nextPath = arg.trim();
-        if (!nextPath) {
-          store.pushNotice(`Project path: ${state.cwd}`, 'info');
-          return true;
-        }
-        try {
-          store.setCwd?.(nextPath, { message: `Project set: ${projectNameFromPath(nextPath)}` });
-        } catch (e) {
-          store.pushNotice(`project switch failed: ${e?.message || e}`, 'error');
-        }
-        return true;
-      }
       case 'project': {
         const target = arg.trim();
         if (target) {
@@ -253,9 +238,6 @@ export function createSlashDispatch({
         openProjectPicker();
         return true;
       }
-      case 'tools':
-        openToolsPicker(arg.trim());
-        return true;
       case 'mcp':
         openMcpPicker();
         return true;
@@ -280,23 +262,6 @@ export function createSlashDispatch({
         // palette, and a typed command answers instead of opening a picker.
         store.pushNotice('Schedules and webhooks are managed in the Mixdog desktop app', 'info');
         return true;
-      case 'auth':
-        store.pushNotice('/auth moved to /providers', 'info');
-        void openProviderSetupPicker();
-        return true;
-      case 'auth-forget': {
-        const providerId = arg.trim();
-        if (!providerId) {
-          store.pushNotice('usage: /auth-forget <provider>', 'warn');
-          return true;
-        }
-        try {
-          store.forgetProviderAuth(providerId);
-        } catch (e) {
-          store.pushNotice(`auth-forget failed: ${e?.message || e}`, 'error');
-        }
-        return true;
-      }
       case 'memory': {
         if (!arg.trim()) {
           openMemoryCorePicker({ returnTo: null });
@@ -306,16 +271,6 @@ export function createSlashDispatch({
           .catch((e) => store.pushNotice(`memory failed: ${e?.message || e}`, 'error'));
         return true;
       }
-      case 'recall': {
-        const query = arg.trim();
-        if (!query) {
-          store.pushNotice('usage: /recall <query>', 'warn');
-          return true;
-        }
-        void store.recall?.(query)
-          .catch((e) => store.pushNotice(`recall failed: ${e?.message || e}`, 'error'));
-        return true;
-      }
       case 'autoclear': {
         const value = arg.trim().toLowerCase();
         if (!value) {

package/src/tui/app/usage-context-panels.mjs

@@ -0,0 +1,288 @@
+// /usage and /context panel builders, extracted from App.jsx. Follows the
+// createRoutePickers factory pattern: called each render with the current
+// store/state and panel setters; opening either surface closes every other
+// prompt/picker first so exactly one bottom surface owns the screen.
+export function createUsageContextPanels({
+  store,
+  state,
+  usageRequestRef,
+  setPicker,
+  setProviderPrompt,
+  setChannelPrompt,
+  setHookPrompt,
+  setSettingsPrompt,
+  setContextPanel,
+  setUsagePanel,
+  closeUsagePanel,
+}) {
+  const openUsagePanel = (arg = '') => {
+    const refresh = /(?:^|\s)(?:refresh|--refresh|-r|true)(?:\s|$)/i.test(String(arg || ''));
+    const requestId = usageRequestRef.current + 1;
+    usageRequestRef.current = requestId;
+    setProviderPrompt(null);
+    setChannelPrompt(null);
+    setHookPrompt(null);
+    setSettingsPrompt(null);
+    setPicker(null);
+    setContextPanel(null);
+    setUsagePanel({
+      title: 'Provider Quotas',
+      subtitle: 'Statusline-style provider quota windows.',
+      checking: true,
+      refresh,
+      rows: [],
+      total: null,
+    });
+    setTimeout(() => {
+      if (usageRequestRef.current !== requestId) return;
+      void store.getUsageDashboard?.({
+        refresh,
+        onUpdate: (dashboard) => {
+          if (usageRequestRef.current !== requestId) return;
+          if (!dashboard) return;
+          setUsagePanel(dashboard);
+        },
+      })
+        .then((dashboard) => {
+          if (usageRequestRef.current !== requestId) return;
+          if (!dashboard) {
+            closeUsagePanel();
+            store.pushNotice('usage dashboard unavailable', 'warn');
+            return;
+          }
+          setUsagePanel(dashboard);
+        })
+        .catch((e) => {
+          if (usageRequestRef.current !== requestId) return;
+          closeUsagePanel();
+          store.pushNotice(`usage failed: ${e?.message || e}`, 'error');
+        });
+    }, 0);
+  };
+
+  const openContextPicker = () => {
+    const tools = store.toolsStatus?.() || {
+      activeCount: 0,
+      count: 0,
+      mcpToolCount: 0,
+      activeMcpToolCount: 0,
+      activeTools: [],
+    };
+    const mcp = store.mcpStatus?.() || { connectedCount: 0, configuredCount: 0, failedCount: 0 };
+    const skills = store.skillsStatus?.() || { count: 0 };
+    const plugins = store.pluginsStatus?.() || { count: 0 };
+    const context = store.contextStatus?.() || {};
+    const usage = context.usage || {};
+    const messages = context.messages || {};
+    const request = context.request || {};
+    const schemaBreakdown = request.toolSchemaBreakdown || {};
+    const schemaTokensFor = (buckets) => buckets.reduce(
+      (sum, bucket) => sum + Number(schemaBreakdown?.[bucket]?.tokens || 0),
+      0,
+    );
+    const builtInToolSchemaTokens = schemaTokensFor(['code', 'web', 'mutation', 'channels', 'setup', 'other']);
+    const mcpToolSchemaTokens = schemaTokensFor(['mcp']);
+    const compaction = context.compaction || {};
+    const windowTokens = Number(context.contextWindow || state.contextWindow || context.rawContextWindow || state.rawContextWindow || 0);
+    const rawWindowTokens = Number(context.rawContextWindow || state.rawContextWindow || windowTokens || 0);
+    // Compaction boundary/trigger are sourced from the runtime contextStatus
+    // (context.compaction). Fall back to the visible window for the boundary
+    // and to the boundary for the trigger so /context still renders on a
+    // fresh/resumed session before any compaction telemetry exists.
+    const compactBoundary = Number(compaction.boundaryTokens || windowTokens || 0);
+    const compactTrigger = Number(compaction.triggerTokens || compactBoundary || 0);
+    const usedTokens = Number(context.usedTokens || context.currentEstimatedTokens || usage.lastContextTokens || 0);
+    const freeTokens = windowTokens ? Math.max(0, windowTokens - usedTokens) : Number(context.freeTokens || 0);
+    const pct = (value, total = windowTokens) => {
+      const n = Number(value || 0);
+      const d = Number(total || 0);
+      if (!d) return 'N/A';
+      const p = Math.max(0, Math.min(100, (n / d) * 100));
+      return `${p > 0 && p < 1 ? p.toFixed(1) : Math.floor(p)}%`;
+    };
+    const fmt = (value) => {
+      const n = Number(value || 0);
+      if (!Number.isFinite(n) || n <= 0) return '0';
+      if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}m`;
+      if (n >= 10_000) return `${Math.round(n / 1000)}k`;
+      if (n >= 1000) return `${(n / 1000).toFixed(1)}k`;
+      return `${Math.round(n)}`;
+    };
+    const cachedRead = Number(usage.lastCachedReadTokens || 0);
+    const cacheWrite = Number(usage.lastCacheWriteTokens || 0);
+    const freshInput = Number(
+      usage.lastUncachedInputTokens != null
+        ? usage.lastUncachedInputTokens
+        : Math.max(Number(usage.lastInputTokens || 0) - cachedRead - cacheWrite, 0)
+    );
+    const cacheDenom = Number(usage.lastContextTokens || 0) || (cachedRead + freshInput + cacheWrite);
+    const cacheHitRate = cacheDenom > 0
+      ? `${((cachedRead / cacheDenom) * 100).toFixed(0)}%`
+      : 'N/A';
+    const cacheWriteLabel = cacheWrite > 0 ? ` · ${fmt(cacheWrite)} write` : '';
+    const contextSource = context.usedSource === 'last_api_request' ? 'last API request' : 'estimated';
+    const lastApiLabel = context.lastApiRequestStale ? 'last API request (pre-compact)' : 'last API request';
+    const compactElapsed = (value) => {
+      const n = Number(value || 0);
+      if (!Number.isFinite(n) || n <= 0) return '';
+      return `${Math.max(1, Math.ceil(n / 1000))}s`;
+    };
+    const compactRunning = compaction.inProgress === true || compaction.lastStage === 'compacting';
+    const autoClearFailed = compaction.lastStage === 'auto_clear_failed' || !!compaction.lastClearCompactError;
+    const autoClearStage = compaction.lastStage === 'auto_clear' || compaction.lastClearAt;
+    const compactDuration = compactElapsed(compaction.lastDurationMs);
+    const compactInterrupted = compaction.lastStage === 'interrupted';
+    const compactReactive = String(compaction.lastTrigger || '').toLowerCase() === 'reactive';
+    const compactState = compactRunning
+      ? 'Compacting conversation'
+      : compactInterrupted
+      ? 'Compact interrupted'
+      : autoClearFailed
+      ? `auto-clear skipped${compaction.lastClearCompactError ? `: ${compaction.lastClearCompactError}` : ''}`
+      : autoClearStage
+      ? 'Auto-clear complete'
+      : compaction.lastChanged
+      ? (compactReactive ? 'Compact complete (overflow recovery)' : 'Compact complete')
+      : 'Compact checked';
+    const compactDescription = compactDuration
+      ? `${compactState} · ${compactDuration}`
+      : compactState;
+    const contextRows = [
+      {
+        value: 'summary',
+        label: 'Context Usage',
+        description: `${fmt(usedTokens)}/${fmt(windowTokens)} (${pct(usedTokens)}) · ${fmt(freeTokens)} free · ${contextSource} · effective`,
+        _action: 'summary',
+      },
+      {
+        value: 'compaction',
+        label: 'Compaction',
+        description: compactDescription,
+        _action: 'compaction',
+      },
+      {
+        value: 'messages',
+        label: 'Messages',
+        description: `${fmt(messages.estimatedTokens)} tokens (${pct(messages.estimatedTokens)}) · ${messages.count || 0} messages`,
+        _action: 'messages',
+      },
+      {
+        value: 'tools',
+        label: 'Tools',
+        description: `${fmt(builtInToolSchemaTokens)} schema tokens (${pct(builtInToolSchemaTokens)}) · ${tools.activeCount || 0}/${tools.count || 0} active`,
+        _action: 'tools',
+      },
+      {
+        value: 'tool-io',
+        label: 'Tool calls/results',
+        description: `${messages.toolCallCount || 0} calls (${fmt(messages.toolCallTokens)}) · ${messages.toolResultCount || 0} results (${fmt(messages.toolResultTokens)})`,
+        _action: 'tool-io',
+      },
+      {
+        value: 'request',
+        label: 'Request overhead',
+        description: `${fmt(request.requestOverheadTokens)} framing · ${fmt(request.reserveTokens)} reserve incl. tools`,
+        _action: 'request',
+      },
+      {
+        value: 'last-api',
+        label: 'Last API usage',
+        description: `${fmt(usage.lastContextTokens)} context · ${fmt(freshInput)} uncached input · ${fmt(usage.lastOutputTokens)} output · ${lastApiLabel}`,
+        _action: 'last-api',
+      },
+      {
+        value: 'cache',
+        label: 'Prompt cache',
+        description: `${cacheHitRate} hit · ${fmt(usage.lastCachedReadTokens)} read${cacheWriteLabel} · ${fmt(freshInput)} new (last request)`,
+        _action: 'cache',
+      },
+      {
+        value: 'free',
+        label: 'Free space',
+        description: `${fmt(freeTokens)} tokens (${pct(freeTokens)}) · raw window ${fmt(rawWindowTokens)}`,
+        _action: 'free',
+      },
+      {
+        value: 'extensions',
+        label: 'Skills/plugins',
+        description: `${skills.count || 0} skills · ${plugins.count || 0} plugins`,
+        _action: 'extensions',
+      },
+    ];
+    setProviderPrompt(null);
+    setChannelPrompt(null);
+    setHookPrompt(null);
+    setSettingsPrompt(null);
+    setPicker(null);
+    setContextPanel({
+      kind: 'context',
+      title: 'Context Usage',
+      detail: {
+        type: 'context',
+        usage: {
+          usedTokens,
+          windowTokens,
+          freeTokens,
+          rawWindowTokens,
+          source: contextSource,
+          effective: true,
+        },
+        compaction: {
+          stage: compaction.lastStage || 'pending',
+          state: compactState,
+          triggerTokens: compactTrigger,
+          boundaryTokens: compactBoundary,
+          type: compaction.compactType || compaction.type || null,
+          bufferTokens: Number(compaction.bufferTokens || (compactBoundary && compactTrigger ? Math.max(0, compactBoundary - compactTrigger) : 0)) || null,
+          pressureTokens: Number(compaction.lastPressureTokens || compaction.currentEstimatedTokens || 0) || null,
+          lastChanged: compaction.lastChanged === true,
+        },
+        messages: {
+          tokens: messages.estimatedTokens,
+          count: messages.count,
+          semantic: messages.semantic,
+        },
+        tools: {
+          schemaTokens: builtInToolSchemaTokens,
+          active: tools.activeCount,
+          count: tools.count,
+        },
+        toolIo: {
+          calls: messages.toolCallCount,
+          results: messages.toolResultCount,
+        },
+        request: {
+          toolSchemaBreakdown: request.toolSchemaBreakdown,
+          overheadTokens: request.requestOverheadTokens,
+          reserveTokens: request.reserveTokens,
+        },
+        lastApi: {
+          contextTokens: usage.lastContextTokens,
+          inputTokens: freshInput,
+          rawInputTokens: usage.lastInputTokens,
+          outputTokens: usage.lastOutputTokens,
+        },
+        cache: {
+          hitRate: cacheHitRate,
+          readTokens: usage.lastCachedReadTokens,
+          writeTokens: cacheWrite,
+        },
+        extensions: {
+          skills: skills.count,
+          plugins: plugins.count,
+        },
+        mcp: {
+          connected: mcp.connectedCount,
+          configured: mcp.configuredCount,
+          failed: mcp.failedCount,
+          tools: tools.mcpToolCount,
+          activeTools: tools.activeMcpToolCount,
+          schemaTokens: mcpToolSchemaTokens,
+        },
+      },
+      rows: contextRows,
+    });
+  };
+
+  return { openUsagePanel, openContextPicker };
+}

package/src/tui/app/use-copy-selection.mjs

@@ -0,0 +1,56 @@
+// Ctrl+C selection copy, extracted from App.jsx. Merges the three harvest
+// sources — the current render's visible selection, the last fully-painted
+// remembered text, and the cross-scroll stitch buffer (only when contiguous)
+// — retries briefly while ink refreshes, and reports feedback via the prompt
+// hint band.
+import { useCallback } from 'react';
+import { copyToClipboard } from './clipboard.mjs';
+
+export function useCopySelection({
+  store,
+  selectionTextRef,
+  getStitchedSelectionText,
+  showSelectionCopyHint,
+}) {
+  const copySelection = useCallback((attempt = 0) => {
+    const renderText = store.getRenderSelectionText?.();
+    const remembered = selectionTextRef.current || '';
+    // A selection that has partially scrolled out of the viewport renders —
+    // and therefore harvests — only its visible rows. The remembered text
+    // (captured while the selection was last fully painted) is the fuller
+    // copy; prefer whichever is longer so scrolling never shrinks a copy.
+    let text = renderText == null
+      ? remembered
+      : (remembered.length > renderText.length ? remembered : renderText);
+    // The stitch buffer accumulates rows harvested across every scroll position
+    // during a transcript drag, so it can reconstruct rows that scrolled out of
+    // view entirely (neither renderText nor the last-full-paint remembered text
+    // ever saw them). getStitchedSelectionText reports a `complete` flag:
+    // prefer the stitch ONLY when it contiguously covers the selection (no
+    // interior gap) AND adds rows. A gapped stitch silently drops a scrolled-off
+    // row, so preferring it purely on length yielded a mangled copy.
+    const stitched = getStitchedSelectionText?.() || { text: '', complete: false };
+    if (stitched.complete && stitched.text.length > text.length) text = stitched.text;
+    if ((!text || !text.trim()) && attempt < 4) {
+      setTimeout(() => copySelection(attempt + 1), attempt === 0 ? 0 : 24);
+      return;
+    }
+    if (!text || !text.trim()) {
+      // Retries exhausted with nothing to copy: never return silently — the
+      // user pressed Ctrl+C expecting feedback. Surface a hint (and still
+      // swallow the key, which the caller already did).
+      showSelectionCopyHint('nothing to copy · select text first', 'error');
+      return;
+    }
+    selectionTextRef.current = text;
+    copyToClipboard(text)
+      .then(() => {
+        const lines = text.split('\n').length;
+        const chars = text.length;
+        showSelectionCopyHint(`copied ${chars} char${chars === 1 ? '' : 's'}${lines > 1 ? ` · ${lines} lines` : ''}`, 'plain');
+      })
+      .catch((e) => showSelectionCopyHint(`copy failed: ${e?.message || e}`, 'error'));
+  }, [store, selectionTextRef, showSelectionCopyHint, getStitchedSelectionText]);
+
+  return { copySelection };
+}

package/src/tui/app/use-global-key-input.mjs

@@ -0,0 +1,151 @@
+// Global key input, extracted from App.jsx. Everything the app handles
+// before PromptInput sees a key: tool-approval y/n, copy-first Ctrl+C with
+// region-aware selection sources, Ctrl+O expand, shift-arrow grid-selection
+// moves, panel Escapes, and PageUp/PageDown transcript paging.
+import { useInput } from 'ink';
+import { copyToClipboard } from './clipboard.mjs';
+import { overlayBlocksGlobalTranscriptScroll } from './slash-commands.mjs';
+export function useGlobalKeyInput({
+  store,
+  state,
+  toolApproval,
+  picker,
+  usagePanel,
+  contextPanel,
+  setContextPanel,
+  closeUsagePanel,
+  isRawModeSupported,
+  resizeState,
+  promptSelectionRef,
+  promptMouseSelectionRef,
+  dragRef,
+  scrollFocusRef,
+  gridSelectionActiveRef,
+  moveSelectionFocus,
+  copySelection,
+  showSelectionCopyHint,
+  toggleExpand,
+  scrollTranscriptRows,
+  resetTranscriptScroll,
+  applySelectionRect,
+}) {
+  // (body moved verbatim)
+  useInput((input, key) => {
+    if (toolApproval) {
+      const value = String(input || '').trim().toLowerCase();
+      if (key.escape || value === 'd' || value === 'n') {
+        store.resolveToolApproval?.(toolApproval.id, { approved: false, reason: 'denied by user' });
+        return;
+      }
+      if (value === 'a' || value === 'y') {
+        store.resolveToolApproval?.(toolApproval.id, { approved: true, reason: 'approved by user' });
+        return;
+      }
+    }
+    if (key.ctrl && (input === 'c' || input === 'C')) {
+      // Ctrl+C is copy-first. Native terminal selections can still forward the
+      // key event to us on Windows Terminal, so a missing app-owned selection
+      // must NOT cancel the active turn; use Esc to interrupt instead.
+      // Region-aware copy source: a prompt-box selection (its OWN engine) copies
+      // from promptSelectionRef; a transcript/status ink-grid selection copies
+      // from store.getRenderSelectionText via copySelection(). Only one region is
+      // ever active at a time (a press in one region clears the others), but when
+      // the last drag was in the prompt we prefer its selection explicitly.
+      const promptSelectionText = promptSelectionRef.current?.text;
+      const lastRegion = dragRef.current.region;
+      const inkRect = dragRef.current.rect;
+      const hasInkSelection = inkRect && !(inkRect.x1 === inkRect.x2 && inkRect.y1 === inkRect.y2);
+      if (promptSelectionText && (lastRegion === 'prompt' || !hasInkSelection)) {
+        copyToClipboard(promptSelectionText)
+          .then(() => showSelectionCopyHint(`copied ${promptSelectionText.length} char${promptSelectionText.length === 1 ? '' : 's'}`, 'plain'))
+          .catch((e) => showSelectionCopyHint(`copy failed: ${e?.message || e}`, 'error'));
+        return;
+      }
+      if (hasInkSelection) {
+        copySelection();
+        return;
+      }
+      // No app-owned selection. On Windows Terminal the same Ctrl+C is also the
+      // native terminal's copy shortcut for a mouse selection we can't see — so
+      // rendering a hint here fights that copy and flashes a spurious message.
+      // Suppress the hint on win32 (interrupt routing is unchanged: Esc still
+      // interrupts). Other platforms keep the guidance.
+      if (process.platform !== 'win32') {
+        showSelectionCopyHint('select text to copy · Esc interrupts', 'plain');
+      }
+      return;
+    }
+    if (key.ctrl && (input === 'o' || input === 'O')) {
+      toggleExpand();
+      return;
+    }
+    const rawShiftUp = input === '\x1b[1;2A' || input === '\x1b[a' || input === '[1;2A';
+    const rawShiftDown = input === '\x1b[1;2B' || input === '\x1b[b' || input === '[1;2B';
+    const rawShiftRight = input === '\x1b[1;2C' || input === '\x1b[c' || input === '[1;2C';
+    const rawShiftLeft = input === '\x1b[1;2D' || input === '\x1b[d' || input === '[1;2D';
+    const rawCtrlShiftUp = input === '\x1b[1;6A' || input === '[1;6A';
+    const rawCtrlShiftDown = input === '\x1b[1;6B' || input === '[1;6B';
+    const rawCtrlShiftRight = input === '\x1b[1;6C' || input === '[1;6C';
+    const rawCtrlShiftLeft = input === '\x1b[1;6D' || input === '[1;6D';
+    const rawModifiedShiftArrow = rawShiftUp || rawShiftDown || rawShiftLeft || rawShiftRight
+      || rawCtrlShiftUp || rawCtrlShiftDown || rawCtrlShiftLeft || rawCtrlShiftRight;
+    if (
+      !picker
+      && (
+        (key.shift && (key.leftArrow || key.rightArrow || key.upArrow || key.downArrow || key.home || key.end))
+        || rawModifiedShiftArrow
+      )
+    ) {
+      // Consume the chord whenever a transcript/status ink-grid selection is
+      // live — even if the focus clamps at an edge (moveSelectionFocus returns
+      // false there). PromptInput independently skips the same chord via the
+      // shared gridSelectionActiveRef predicate, so there is no double-handling.
+      // When no grid selection is live, fall through to PromptInput.
+      let move = null;
+      if (key.leftArrow || rawShiftLeft || rawCtrlShiftLeft) move = 'left';
+      else if (key.rightArrow || rawShiftRight || rawCtrlShiftRight) move = 'right';
+      else if (key.upArrow || rawShiftUp || rawCtrlShiftUp) move = 'up';
+      else if (key.downArrow || rawShiftDown || rawCtrlShiftDown) move = 'down';
+      else if (key.home) move = 'lineStart';
+      else if (key.end) move = 'lineEnd';
+      if (move && gridSelectionActiveRef.current()) {
+        moveSelectionFocus(move);
+        return;
+      }
+    }
+    if (key.escape && usagePanel && !picker) {
+      closeUsagePanel();
+      return;
+    }
+    if (key.escape && contextPanel && !picker) {
+      setContextPanel(null);
+      return;
+    }
+    if (key.pageUp) {
+      if (overlayBlocksGlobalTranscriptScroll(scrollFocusRef.current)) return;
+      const pageRows = Math.max(3, Math.floor((resizeState.rows ?? 24) * 0.6));
+      scrollTranscriptRows(pageRows);
+      return;
+    }
+    if (key.pageDown) {
+      if (overlayBlocksGlobalTranscriptScroll(scrollFocusRef.current)) return;
+      const pageRows = Math.max(3, Math.floor((resizeState.rows ?? 24) * 0.6));
+      scrollTranscriptRows(-pageRows);
+      return;
+    }
+    if (key.ctrl && key.end) {
+      resetTranscriptScroll();
+      return;
+    }
+    if (key.escape && !picker) {
+      dragRef.current.active = false;
+      dragRef.current.region = null;
+      dragRef.current.anchorSpan = null;
+      // Clear whichever region's selection is active. PromptInput's own ESC also
+      // clears its selection when focused/enabled; this covers the disabled case
+      // and a status/transcript ink-grid selection in one press.
+      promptMouseSelectionRef.current?.clear?.();
+      applySelectionRect(null);
+    }
+  }, { isActive: isRawModeSupported });
+}

package/src/tui/app/use-pasted-buffers.mjs

@@ -0,0 +1,115 @@
+// Pasted-attachment buffers, extracted from App.jsx. Large pasted images and
+// texts fold into [Image #N] / [Pasted text #N +M lines] prompt tokens; the
+// original payloads live here (ref + mirrored state) until submit expands
+// them back. install* rehydrates a queued/restored draft's buffers, the
+// snapshot clears drop exactly the entries a submit consumed, and register*
+// mints the next token for a fresh paste.
+import { useCallback, useRef, useState } from 'react';
+import { formatImageRef, formatPastedTextRef } from '../paste-attachments.mjs';
+
+export function usePastedBuffers() {
+  const [, setPastedImages] = useState({});
+  const pastedImagesRef = useRef({});
+  const nextPastedImageIdRef = useRef(1);
+  const [, setPastedTexts] = useState({});
+  const pastedTextsRef = useRef({});
+  const nextPastedTextIdRef = useRef(1);
+
+  const installPastedImages = useCallback((images, { merge = true } = {}) => {
+    if (!images || typeof images !== 'object' || Object.keys(images).length === 0) return;
+    const next = merge ? { ...pastedImagesRef.current, ...images } : { ...images };
+    pastedImagesRef.current = next;
+    const maxId = Object.keys(next)
+      .map((id) => Number(id) || 0)
+      .reduce((max, id) => Math.max(max, id), 0);
+    if (maxId >= nextPastedImageIdRef.current) nextPastedImageIdRef.current = maxId + 1;
+    setPastedImages(next);
+  }, []);
+
+  const clearPastedImagesSnapshot = useCallback((snapshot = null) => {
+    if (!snapshot) {
+      if (Object.keys(pastedImagesRef.current || {}).length === 0) return;
+      pastedImagesRef.current = {};
+      setPastedImages({});
+      return;
+    }
+    if (typeof snapshot !== 'object' || Object.keys(snapshot).length === 0) return;
+    const next = { ...pastedImagesRef.current };
+    let changed = false;
+    for (const [id, image] of Object.entries(snapshot)) {
+      if (next[id] === image) {
+        delete next[id];
+        changed = true;
+      }
+    }
+    if (!changed) return;
+    pastedImagesRef.current = next;
+    setPastedImages(next);
+  }, []);
+
+  const registerPastedImage = useCallback((image) => {
+    if (!image || image.type !== 'image' || !image.content) return '';
+    const id = nextPastedImageIdRef.current++;
+    const entry = { ...image, id };
+    pastedImagesRef.current = { ...pastedImagesRef.current, [id]: entry };
+    setPastedImages(pastedImagesRef.current);
+    return formatImageRef(id);
+  }, []);
+
+  const installPastedTexts = useCallback((texts, { merge = true } = {}) => {
+    if (!texts || typeof texts !== 'object' || Object.keys(texts).length === 0) return;
+    const next = merge ? { ...pastedTextsRef.current, ...texts } : { ...texts };
+    pastedTextsRef.current = next;
+    const maxId = Object.keys(next)
+      .map((id) => Number(id) || 0)
+      .reduce((max, id) => Math.max(max, id), 0);
+    if (maxId >= nextPastedTextIdRef.current) nextPastedTextIdRef.current = maxId + 1;
+    setPastedTexts(next);
+  }, []);
+
+  const clearPastedTextsSnapshot = useCallback((snapshot = null) => {
+    if (!snapshot) {
+      if (Object.keys(pastedTextsRef.current || {}).length === 0) return;
+      pastedTextsRef.current = {};
+      setPastedTexts({});
+      return;
+    }
+    if (typeof snapshot !== 'object' || Object.keys(snapshot).length === 0) return;
+    const next = { ...pastedTextsRef.current };
+    let changed = false;
+    for (const [id, text] of Object.entries(snapshot)) {
+      if (next[id] === text) {
+        delete next[id];
+        changed = true;
+      }
+    }
+    if (!changed) return;
+    pastedTextsRef.current = next;
+    setPastedTexts(next);
+  }, []);
+
+  const registerPastedText = useCallback((text) => {
+    const value = String(text ?? '');
+    if (!value) return '';
+    const id = nextPastedTextIdRef.current++;
+    const entry = { id, text: value };
+    pastedTextsRef.current = { ...pastedTextsRef.current, [id]: entry };
+    setPastedTexts(pastedTextsRef.current);
+    return formatPastedTextRef(id, value);
+  }, []);
+
+  return {
+    pastedImagesRef,
+    nextPastedImageIdRef,
+    pastedTextsRef,
+    nextPastedTextIdRef,
+    setPastedImages,
+    setPastedTexts,
+    installPastedImages,
+    clearPastedImagesSnapshot,
+    registerPastedImage,
+    installPastedTexts,
+    clearPastedTextsSnapshot,
+    registerPastedText,
+  };
+}