jaitus 0.3.4 → 0.3.5

package/src/tui-ink.js

@@ -21,6 +21,8 @@
 // Reduced motion (`/animations off`, `JAITUS_NO_ANIMATION=1`) is a first-class mode:
 // every animated widget has a still frame that reads correctly on its own.
 
+import fs from 'node:fs';
+import path from 'node:path';
 import React from 'react';
 import { Box, Spacer, Text, render, useAnimation, useApp, useCursor, useInput, usePaste, useWindowSize } from 'ink';
 import { palette, resetPalette, mix, ramp } from './tui/theme.js';
@@ -30,7 +32,8 @@ import { Spinner, Shimmer, GradientText, FlowingRule, Meter, Elapsed, Caret, Row
 import { wordRows, wordSize } from './tui/wordmark.js';
 import { enableMouse, disableMouse, parseMouse, isMouse, isMouseFragment, createHitMap } from './tui/mouse.js';
 import { openUrl } from './open.js';
-import { readClipboardText, readClipboardImage } from './tui/clipboard.js';
+import { readClipboardText, readClipboardImage, shrinkImageFile } from './tui/clipboard.js';
+import { onSettingsChange } from './config.js';
 import { MASCOT_ROWS, startupTip } from './brand.js';
 
 const h = React.createElement;
@@ -387,22 +390,54 @@ export function selectHint(env = process.env, platform = process.platform) {
   return 'drag copies · shift drag: native';
 }
 
-/** Register every URL on screen as a click target. */
-function registerLinkHits(visible, screenTop, hits) {
-  if (!hits) return;
-  visible.forEach((row, index) => {
-    const text = rowText(row);
+/**
+ * Register every URL on screen as a click target.
+ *
+ * A URL longer than the line is hard-cut across rows by wrapRow, so the match on the
+ * first row is only a prefix of it — clicking it opened a truncated address. wrapRow
+ * marks the rows it cut mid-word (`cut` on the last span); when a match runs to the end
+ * of such a row, the next row's leading token (after the hanging indent) is appended, and
+ * that piece is registered with the whole URL too.
+ */
+export function linkHitsFor(rows) {
+  const texts = rows.map((row) => rowText(row));
+  const cut = rows.map((row) => Boolean(row.length && row[row.length - 1].cut));
+  const out = [];
+  const claimed = new Set(); // "row:col" of continuation pieces, so they are not matched again
+  texts.forEach((text, index) => {
     for (const match of text.matchAll(URL_IN_TEXT)) {
-      const url = match[0].replace(/[.,;:)\]]+$/, '');
-      hits.add({
-        x1: 2 + match.index,
-        x2: 2 + match.index + url.length - 1,
-        y1: screenTop + index,
-        y2: screenTop + index,
-        action: { type: 'link', url },
-      });
+      if (claimed.has(`${index}:${match.index}`)) continue;
+      let url = match[0];
+      const pieces = [{ row: index, x: match.index, len: match[0].length }];
+      let row = index;
+      let end = match.index + match[0].length;
+      while (cut[row] && end === texts[row].length && row + 1 < texts.length) {
+        const lead = /^(\s*)([^\s<>"'`]+)/.exec(texts[row + 1]);
+        if (!lead) break;
+        url += lead[2];
+        row += 1;
+        pieces.push({ row, x: lead[1].length, len: lead[2].length });
+        claimed.add(`${row}:${lead[1].length}`);
+        end = lead[0].length;
+      }
+      url = url.replace(/[.,;:)\]]+$/, '');
+      for (const piece of pieces) out.push({ ...piece, url });
     }
   });
+  return out;
+}
+
+function registerLinkHits(visible, screenTop, hits) {
+  if (!hits) return;
+  for (const piece of linkHitsFor(visible)) {
+    hits.add({
+      x1: 2 + piece.x,
+      x2: 2 + piece.x + piece.len - 1,
+      y1: screenTop + piece.row,
+      y2: screenTop + piece.row,
+      action: { type: 'link', url: piece.url },
+    });
+  }
 }
 
 function Transcript({ state, width, height, layout }) {
@@ -419,6 +454,10 @@ function Transcript({ state, width, height, layout }) {
 // far more often than it names a path called `.`.
 const URL_IN_TEXT = /https?:\/\/[^\s<>"'`]+/g;
 
+// Replies to the startup probe (terminal.js), with or without the ESC Ink strips: OSC 11
+// background colour, then CSI ? … c device attributes — alone or run together.
+export const TERMINAL_REPLY = /^(?=[\x1b\][])(?:\x1b?\]11;rgb:[0-9a-f]{1,4}\/[0-9a-f]{1,4}\/[0-9a-f]{1,4}(?:\x07|\x1b\\)?)?(?:\x1b?\[\?[0-9;]*c)?$/i;
+
 /**
  * Draw the drag selection.
  *
@@ -503,17 +542,17 @@ function Composer({ state, width }) {
   // and might have to delete.
   const composed = [];
   let at = 0;
-  for (const match of state.input.matchAll(/\[#\d+ pasted [^\]]*\]/g)) {
-    if (match.index > at) composed.push({ t: state.input.slice(at, match.index), color: p.text });
+  for (const match of state.input.matchAll(/\[#\d+ pasted [^\]]*\]|\[Image #\d+\]/g)) {
+    if (match.index > at) composed.push({ t: state.input.slice(at, match.index), color: p.body });
     composed.push({ t: match[0], color: p.purple, backgroundColor: p.raised });
     at = match.index + match[0].length;
   }
-  if (at < state.input.length) composed.push({ t: state.input.slice(at), color: p.text });
+  if (at < state.input.length) composed.push({ t: state.input.slice(at), color: p.body });
 
   // The same lines the App measured the composer's height from (composerLayout): the
   // frame height is fixed, so a composer one row taller than it was counted as pushes
   // the whole screen up — that was the header vanishing after a multi-line paste.
-  const { lines, caretLine } = composerLayout(state, inner - 2, composed);
+  const { lines, caretLine, caretCol } = composerLayout(state, inner - 2, composed);
   const placeholder = state.placeholder || 'Describe a change, ask a question, or / for commands';
 
   const borderColor = state.busy ? p.brand : state.menu.length ? p.teal : p.line;
@@ -529,29 +568,46 @@ function Composer({ state, width }) {
     h(Box, { flexDirection: 'row' },
       h(Text, { color: promptColor, bold: true }, promptMark),
       h(Box, { flexDirection: 'column', width: inner - 2 },
-        lines.map((row, index) => h(Box, { key: index, flexDirection: 'row' },
-          h(Row, { spans: row, wrap: 'wrap' }),
+        lines.map((row, index) => {
+          // The caret sits AT the cursor. It used to be drawn after the whole line, so
+          // moving left with the arrow keys showed no movement at all while typing went
+          // in somewhere in the middle.
+          const [left, right] = index === caretLine ? splitSpansAt(row, caretCol) : [row, []];
+          return h(Box, { key: index, flexDirection: 'row' },
+          h(Row, { spans: left, wrap: 'wrap' }),
           // The caret is always present, including at an empty prompt. Hiding it there
           // was meant to keep it off the placeholder, but the result is a prompt with
           // no cursor at all — there is nothing on screen saying the app is waiting for
           // typing, which is the one thing a prompt has to say. The placeholder sits
           // AFTER the caret instead, so the caret is at the insertion point either way.
           index === caretLine ? h(Caret, { color: p.brand, char: g('▏', '_') }) : null,
+          right.length ? h(Row, { spans: right, wrap: 'wrap' }) : null,
           !state.input && index === 0
             ? h(Text, { color: p.faint, italic: true, wrap: 'truncate-end' }, placeholder)
             : null,
-        )),
+          );
+        }),
       ),
     ),
     state.queued.length
       ? h(Box, { marginTop: 1 }, h(Text, { color: p.purple }, `${g('⏎', '>')} ${state.queued.length} message${state.queued.length === 1 ? '' : 's'} queued — they send when this turn finishes`))
       : null,
-    state.attachments.length
-      ? h(Box, { marginTop: 1 }, h(Text, { color: p.purple }, state.attachments.map((a) => `${g('⧉', '[img]')} ${a.name || 'image'}`).join('   ')))
+    liveAttachments(state).length
+      ? h(Box, { marginTop: 1 }, h(Text, { color: p.purple, wrap: 'truncate-end' },
+        `${liveAttachments(state).map((a) => `${g('⧉', '[img]')} #${a.id} ${a.name || 'image'}${a.bytes ? ` ${Math.max(1, Math.round(a.bytes / 1024))} KB` : ''}`).join('   ')}`,
+        h(Text, { color: p.faint }, '   · backspace over a chip removes it')))
       : null,
   );
 }
 
+/** Attachments whose chip is still in the input — the ones that will be sent. */
+function liveAttachments(state) {
+  // Current attachments, and earlier ones a line recalled from history still names.
+  const all = new Map();
+  for (const a of [...(state.imageStore ? state.imageStore.values() : []), ...(state.attachments || [])]) if (a?.id) all.set(a.id, a);
+  return [...all.values()].filter((a) => state.input.includes(`[Image #${a.id}]`));
+}
+
 const COMPOSER_MAX_LINES = 8;
 
 /** Spans split at every newline: one array of spans per line the user typed. */
@@ -584,27 +640,45 @@ function composerLayout(state, width, spans = null) {
   const paragraphs = splitSpansAtNewlines(spans || [{ t: input }]);
   const all = [];
   let caret = 0;
+  let caretCol = 0;
   let start = 0;                                   // offset of this paragraph in `input`
   const cursor = Math.max(0, Math.min(input.length, state.cursor ?? input.length));
   for (const para of paragraphs) {
     const text = para.map((s) => s.t).join('');
     const rows = para.length ? wrapRow(para, width) : [[]];
     if (cursor >= start && cursor <= start + text.length) {
-      let seen = start;
+      let rowStart = start;
       let line = rows.length - 1;
+      let col = 0;
       for (let i = 0; i < rows.length; i++) {
-        seen += rows[i].map((s) => s.t).join('').length;
-        if (cursor <= seen) { line = i; break; }
-        seen += 1; // the space the wrap consumed
+        const len = rows[i].map((s) => s.t).join('').length;
+        if (cursor <= rowStart + len || i === rows.length - 1) { line = i; col = Math.max(0, Math.min(len, cursor - rowStart)); break; }
+        rowStart += len + 1;                       // + the space the wrap consumed
       }
       caret = all.length + line;
+      caretCol = col;
     }
     all.push(...rows);
     start += text.length + 1;                      // + the newline
   }
-  if (all.length <= COMPOSER_MAX_LINES) return { lines: all, caretLine: caret, total: all.length };
+  if (all.length <= COMPOSER_MAX_LINES) return { lines: all, caretLine: caret, caretCol, total: all.length };
   const first = Math.max(0, Math.min(caret - COMPOSER_MAX_LINES + 1, all.length - COMPOSER_MAX_LINES));
-  return { lines: all.slice(first, first + COMPOSER_MAX_LINES), caretLine: caret - first, total: all.length };
+  return { lines: all.slice(first, first + COMPOSER_MAX_LINES), caretLine: caret - first, caretCol, total: all.length };
+}
+
+/** A row of spans cut at character `n`: [before, after]. */
+function splitSpansAt(row, n) {
+  const before = [];
+  const after = [];
+  let seen = 0;
+  for (const span of row || []) {
+    const t = String(span.t);
+    if (seen + t.length <= n) before.push(span);
+    else if (seen >= n) after.push(span);
+    else { before.push({ ...span, t: t.slice(0, n - seen) }); after.push({ ...span, t: t.slice(n - seen) }); }
+    seen += t.length;
+  }
+  return [before, after];
 }
 
 function StatusBar({ state, width }) {
@@ -686,9 +760,27 @@ function Dialog({ state, width, height, hits }) {
   const dialog = state.dialog;
   if (!dialog) return null;
   const boxWidth = Math.min(Math.max(48, Math.floor(width * 0.78)), width - 4);
-  const previewRows = (dialog.preview || []).slice(0, 12);
   const questionRows = wrapRow([{ t: plain(dialog.question) }], boxWidth - 6).length;
-  const rows = dialogHeight(questionRows, previewRows.length, dialog.options.length);
+  // What is being approved is WRAPPED, never cut at the box edge: a long command's tail
+  // (`… && curl x | sh`) was simply not shown, so it could be approved unseen. When it
+  // is taller than the screen allows, the start and the END are shown with the count of
+  // what is hidden between them.
+  const wrappedPreview = (dialog.preview || []).flatMap((line) => wrapRow(previewSpans(line, p), boxWidth - 6));
+  const roomForPreview = Math.max(4, height - (questionRows + dialog.options.length + 12));
+  let previewRows = wrappedPreview;
+  if (wrappedPreview.length > roomForPreview) {
+    const head = Math.floor((roomForPreview - 1) / 2);
+    const tail = roomForPreview - 1 - head;
+    const hidden = wrappedPreview.length - head - tail;
+    previewRows = [...wrappedPreview.slice(0, head), [{ t: `… ${hidden} more line${hidden === 1 ? '' : 's'} …`, color: p.yellow }], ...wrappedPreview.slice(-tail)];
+  }
+  // More options than fit: a window that follows the selection (a picker of 20 sessions
+  // or models no longer has to be cut to the 9 that have a number key).
+  const roomForOptions = Math.max(3, height - questionRows - previewRows.length - 12);
+  const optionCount = Math.min(dialog.options.length, roomForOptions);
+  const firstOption = Math.max(0, Math.min(dialog.index - Math.floor(optionCount / 2), dialog.options.length - optionCount));
+  const visibleOptions = dialog.options.slice(firstOption, firstOption + optionCount);
+  const rows = dialogHeight(questionRows, previewRows.length, optionCount);
   const accent = dialog.tone === 'danger' ? p.red : p.brand;
 
   const top = Math.max(0, Math.round((height - rows) / 2));
@@ -699,10 +791,10 @@ function Dialog({ state, width, height, hits }) {
   // arithmetic mirrors dialogHeight() exactly — terminal rows are 1-based, hence the +1.
   hits?.add({ x1: left + 1, x2: left + boxWidth, y1: top + 1, y2: top + rows, action: { type: 'swallow' } });
   const optionsTop = top + 2 + 1 + 1 + questionRows + (previewRows.length ? 1 + previewRows.length : 0) + 1;
-  dialog.options.forEach((option, index) => {
+  visibleOptions.forEach((option, index) => {
     hits?.add({
       x1: left + 1, x2: left + boxWidth, y1: optionsTop + index + 1, y2: optionsTop + index + 1,
-      action: { type: 'dialogOption', index },
+      action: { type: 'dialogOption', index: firstOption + index },
     });
   });
 
@@ -727,17 +819,18 @@ function Dialog({ state, width, height, hits }) {
             .map((row, index) => h(Row, { key: index, spans: row }))),
         previewRows.length
           ? h(Box, { marginTop: 1, flexDirection: 'column' },
-            previewRows.map((line, index) => h(Row, {
-              key: index,
-              spans: truncateRow(previewSpans(line, p), boxWidth - 6),
-            })))
+            previewRows.map((row, index) => h(Row, { key: index, spans: row })))
           : null,
         h(Box, { marginTop: 1, flexDirection: 'column' },
-          dialog.options.map((option, index) => {
+          visibleOptions.map((option, i) => {
+            const index = firstOption + i;
             const selected = index === dialog.index;
-            return h(Box, { key: `${option.value}-${index}`, backgroundColor: selected ? p.raised : undefined },
-              h(Text, { color: selected ? accent : p.muted, bold: selected },
-                `${selected ? g(' ▸ ', ' > ') : '   '}${index + 1}. ${plain(option.label)}`));
+            const more = (i === 0 && firstOption > 0) ? ` ${g('↑', '^')}${firstOption} more`
+              : (i === visibleOptions.length - 1 && firstOption + optionCount < dialog.options.length) ? ` ${g('↓', 'v')}${dialog.options.length - firstOption - optionCount} more` : '';
+            return h(Box, { key: `${option.value}-${index}`, backgroundColor: selected ? p.raised : undefined, flexDirection: 'row' },
+              h(Text, { color: selected ? accent : p.muted, bold: selected, wrap: 'truncate-end' },
+                `${selected ? g(' ▸ ', ' > ') : '   '}${index < 9 ? `${index + 1}.` : '  '} ${plain(option.label)}`),
+              more ? h(Text, { color: p.faint }, more) : null);
           })),
         h(Box, { marginTop: 1 },
           h(Text, { color: p.faint }, `${g('↑↓', 'up/dn')} choose  ·  1-9 jump  ·  enter confirm  ·  esc ${dialog.hideComment ? 'cancel' : 'deny'}`)),
@@ -779,7 +872,7 @@ function Panel({ state, width, height, hits }) {
       const name = typeof option === 'string' ? option : option.name;
       const summary = typeof option === 'string' ? '' : option.summary || '';
       return h(Box, { key: `${name}-${index}`, backgroundColor: selected ? p.raised : undefined, flexDirection: 'row' },
-        h(Text, { color: selected ? p.brand : p.muted, bold: selected }, `${selected ? g(' ▸ ', ' > ') : '   '}${name.padEnd(Math.min(26, boxWidth - 10))}`),
+        h(Text, { color: selected ? p.brand : p.muted, bold: selected, wrap: 'truncate-end' }, `${selected ? g(' ▸ ', ' > ') : '   '}${name.padEnd(Math.min(26, boxWidth - 10))}`),
         summary ? h(Text, { color: p.faint, wrap: 'truncate-end' }, summary) : null,
       );
     });
@@ -788,12 +881,22 @@ function Panel({ state, width, height, hits }) {
       bodyRows = 1;
     }
   } else {
-    const rows = (panel.rows || []).slice(-maxRows);
-    const lines = (panel.lines || []).slice(-maxRows);
-    bodyRows = Math.max(1, rows.length || lines.length);
-    body = rows.length
-      ? [h(Rows, { key: 'rows', rows })]
-      : lines.map((line, index) => h(Text, { key: index, color: p.text, wrap: 'truncate-end' }, plain(line)));
+    // Scrollable. Only the last maxRows used to be drawn, with no way up — the top of a
+    // long /diff or /tasks was unreachable. `follow` (a live panel at its bottom) keeps
+    // showing the newest lines as they arrive.
+    const all = panel.rows?.length ? panel.rows : (panel.lines || []);
+    const total = all.length;
+    const maxStart = Math.max(0, total - maxRows);
+    panel._maxRows = maxRows;
+    panel._maxStart = maxStart;
+    const start = panel.follow ? maxStart : Math.max(0, Math.min(panel.scroll || 0, maxStart));
+    panel.scroll = start;
+    panel._range = total > maxRows ? `${start + 1}–${Math.min(total, start + maxRows)} of ${total}` : '';
+    const view = all.slice(start, start + maxRows);
+    bodyRows = Math.max(1, view.length);
+    body = panel.rows?.length
+      ? [h(Rows, { key: 'rows', rows: view })]
+      : view.map((line, index) => h(Text, { key: index, color: p.text, wrap: 'truncate-end' }, plain(line)));
   }
 
   // border 2 + padY 2 + title 1 + gap 1 + body + gap 1 + hint 1
@@ -830,8 +933,8 @@ function Panel({ state, width, height, hits }) {
         ),
         h(Box, { marginTop: 1, flexDirection: 'column' }, body),
         h(Box, { marginTop: 1 }, h(Text, { color: p.faint }, panel.palette
-          ? `type to filter  ·  ${g('↑↓', 'up/dn')} choose  ·  enter run  ·  esc close`
-          : `${g('↑↓', 'up/dn')} scroll  ·  esc close`)),
+          ? `type to filter  ·  ${g('↑↓', 'up/dn')} choose  ·  ${panel.onPick ? 'enter pick' : 'enter run'}  ·  esc close`
+          : `${panel._range ? `${panel._range}  ·  ${g('↑↓', 'up/dn')} pgup/pgdn scroll  ·  ` : ''}esc close`)),
       ),
     ),
   );
@@ -883,13 +986,15 @@ function App({ controller }) {
     + (state.menu.length ? state.menu.length + 1 : 0)
     + Math.max(0, composerTextRows(state, width) - 1)
     + (state.queued.length ? 2 : 0)
-    + (state.attachments.length ? 2 : 0);
+    + (liveAttachments(state).length ? 2 : 0);
   const workRows = state.busy || state.status ? 1 : 0;
   // A single pinned line showing what was last asked, while the transcript is scrolled
   // away from it. Scrolling back through a long answer and losing track of the question
   // it was answering is the specific thing this fixes.
   const stickyRows = state.viewingTranscript ? 1 : 0;
   const transcriptHeight = Math.max(3, height - CHROME.header - CHROME.status - composerRows - workRows - CHROME.gapAboveComposer - stickyRows);
+  state._transcriptHeight = transcriptHeight;
+  state._width = width;
 
   // The welcome stands until there is real conversation. Anything chrome-ish — a
   // notice, a stray pre-formatted print from an older code path — must not suppress it:
@@ -994,6 +1099,18 @@ function registerHeaderHits(state, width, hits) {
 
 export function createTui({ slashCommands = [], fileProvider = null, meta = {}, onModeCycle = null, settings = null } = {}) {
   publishSettings(settings);
+  // Settings changed during the session apply now, not at the next start.
+  onSettingsChange((next) => {
+    const mouseBefore = settings?.mouse !== false;
+    settings = next || {};
+    publishSettings(settings);
+    const mouseNow = settings.mouse !== false && !process.env.JAITUS_DISABLE_MOUSE;
+    if (state?.active && mouseBefore !== mouseNow) {
+      if (mouseNow) state.mouse = enableMouse(process.stdout);
+      else { disableMouse(process.stdout); state.mouse = false; }
+    }
+    if (state?.active) notifyNow();
+  });
 
   const commands = slashCommands.map((command) => (typeof command === 'string' ? { name: command, summary: '' } : command));
 
@@ -1094,6 +1211,9 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
   }
 
   function refreshMenu() {
+    // Dismissed with Esc (or a recalled history line): stays closed until the text changes.
+    if (state.menuDismissedFor !== undefined && state.menuDismissedFor === state.input) { state.menu = []; state.menuIndex = -1; return; }
+    state.menuDismissedFor = undefined;
     state.menu = state.dialog || state.panel ? [] : menuItemsFor(state.input, commands, fileProvider, state.cursor);
     state.menuIndex = state.menu.length ? clamp(state.menuIndex < 0 ? 0 : state.menuIndex, 0, state.menu.length - 1) : -1;
   }
@@ -1139,8 +1259,11 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
       return true;
     }
 
-    state.input = `${prefix}${item.value} ${suffix}`;
-    state.cursor = prefix.length + String(item.value).length + 1;
+    // A file keeps its `@`: without it the mention is plain text, so choosing a file
+    // from the menu used to attach nothing at all. (Command names carry their own `/`.)
+    const value = item.kind === 'file' ? `@${item.value}` : String(item.value);
+    state.input = `${prefix}${value} ${suffix}`;
+    state.cursor = prefix.length + value.length + 1;
     refreshMenu();
     notifyNow();
     return true;
@@ -1158,6 +1281,9 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
   function handlePaste(text) {
     const value = String(text ?? '').replace(/\r\n?/g, '\n');
     if (!value) return;
+    // Dragging image files onto the terminal pastes their paths: attach them instead.
+    const images = imagePathsIn(value);
+    if (images) { void attachImageFiles(images); return; }
     const lines = value.split('\n').length;
 
     if (lines <= 3 && value.length <= 240) {
@@ -1165,8 +1291,11 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
       return;
     }
 
-    const id = state.pastes.length + 1;
+    // Numbered for the whole session. `pastes.length + 1` reused a number after a chip was
+    // deleted, so two chips could share it and both expand to the same content.
+    const id = ++pasteSeq;
     state.pastes.push({ id, text: value });
+    remember(pasteStore, id, { id, text: value });
     // The token has to survive being typed around, so it is bracketed and carries its
     // own index; expansion matches on that rather than on position.
     insert(`[#${id} pasted ${lines} line${lines === 1 ? '' : 's'}, ${value.length} chars]`);
@@ -1179,28 +1308,19 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
    * no text, an image on the clipboard becomes an attachment.
    */
   let pasting = false;
+  let returnToLiveTimer = null;
   async function pasteFromClipboard({ imageOnly = false } = {}) {
     if (pasting) return;
     pasting = true;
     try {
       const text = imageOnly ? null : await (api._readClipboardText || readClipboardText)();
       if (text) { handlePaste(text); notifyNow(); return; }
-      const png = await (api._readClipboardImage || readClipboardImage)();
-      if (png?.length) {
-        const fs = await import('node:fs');
+      const img = await (api._readClipboardImage || readClipboardImage)();
+      if (img?.bytes?.length) {
         const os = await import('node:os');
-        const path = await import('node:path');
-        const file = path.join(os.tmpdir(), `jaitus-clip-${Date.now()}.png`);
-        fs.writeFileSync(file, png);
-        const { imageBlock } = await import('./agent/tools.js');
-        const block = await imageBlock(file).catch(() => null);
-        if (block) {
-          state.attachments.push({ name: `image ${state.attachments.length + 1}`, block });
-          flash('Image attached — it is sent with your next message', 'info', 2000);
-        } else {
-          flash('That image could not be read (png, jpg, gif or webp, up to about 3 MB)', 'warn', 2500);
-        }
-        notifyNow();
+        const file = path.join(os.tmpdir(), `jaitus-clip-${Date.now()}${img.ext || '.png'}`);
+        fs.writeFileSync(file, img.bytes);
+        await attachImageFiles([file], { name: 'clipboard image' });
         return;
       }
       flash(imageOnly ? 'No image on the clipboard' : 'The clipboard is empty', 'info', 1600);
@@ -1218,20 +1338,83 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
   // so the content it stands for is silently orphaned and the literal text is what gets
   // sent. Deleting it whole is both what you meant and the only way the placeholder and
   // the thing it holds cannot come apart.
-  const CHIP = /\[#(\d+) pasted [^\]]*\]/;
-  const chipBefore = (text, cursor) => new RegExp(`${CHIP.source}$`).exec(text.slice(0, cursor));
-  const chipAfter = (text, cursor) => new RegExp(`^${CHIP.source}`).exec(text.slice(cursor));
+  // An attached image is a chip too — `[Image #2]` — so it is removed the same way: one
+  // Backspace over it. There was no way at all to take an attachment back before.
+  const CHIP = /\[#(\d+) pasted [^\]]*\]|\[Image #(\d+)\]/;
+  const chipBefore = (text, cursor) => new RegExp(`(?:${CHIP.source})$`).exec(text.slice(0, cursor));
+  const chipAfter = (text, cursor) => new RegExp(`^(?:${CHIP.source})`).exec(text.slice(cursor));
 
   /** Forget the content a chip stood for, once the chip is gone. */
-  function dropPaste(id) {
-    state.pastes = state.pastes.filter((entry) => entry.id !== Number(id));
+  function dropPaste(match) {
+    if (match?.[1]) state.pastes = state.pastes.filter((entry) => entry.id !== Number(match[1]));
+    if (match?.[2]) {
+      const before = state.attachments.length;
+      state.attachments = state.attachments.filter((a) => a.id !== Number(match[2]));
+      if (state.attachments.length < before) flash(`Image #${match[2]} removed`, 'info', 1400);
+    }
+  }
+
+  // ── images ──
+  let imageSeq = 0;
+  let pasteSeq = 0;
+  // What earlier chips stood for, so a message recalled from history is sent whole.
+  // Bounded: images are the big part.
+  const pasteStore = new Map();
+  const imageStore = new Map();
+  state.imageStore = imageStore;
+  const remember = (store, id, value, max = store === imageStore ? 12 : 60) => {
+    store.set(id, value);
+    while (store.size > max) store.delete(store.keys().next().value);
+  };
+  /** Add an image: a chip at the cursor, the pixels kept aside until the message is sent. */
+  function attachImage({ name, block }) {
+    const id = ++imageSeq;
+    const bytes = Math.round((String(block?.source?.data || '').length * 3) / 4);
+    state.attachments.push({ id, name: name || `image ${id}`, block, bytes });
+    remember(imageStore, id, { id, name: name || `image ${id}`, block, bytes });
+    const before = state.input.slice(0, state.cursor);
+    insert(`${before && !/\s$/.test(before) ? ' ' : ''}[Image #${id}] `);
+    flash(`Image #${id} attached${bytes ? ` (${Math.max(1, Math.round(bytes / 1024))} KB)` : ''} — Backspace over it removes it`, 'info', 2400);
+    notifyNow();
+    return id;
+  }
+
+  /**
+   * A paste that is nothing but paths to image files — what dragging a screenshot onto a
+   * terminal window produces — attaches them instead of typing the paths. Quoted paths
+   * (Windows, with spaces) and backslash-escaped spaces (macOS) are both understood.
+   */
+  function imagePathsIn(text) {
+    const raw = String(text || '').trim();
+    if (!raw || raw.length > 4000) return null;
+    const parts = [];
+    const re = /"([^"]+)"|'([^']+)'|((?:\\ |[^\s"'])+)/g;
+    for (const m of raw.matchAll(re)) parts.push((m[1] ?? m[2] ?? m[3]).replace(/\\ /g, ' '));
+    if (!parts.length) return null;
+    const files = parts.map((p) => p.replace(/^file:\/\/\/?/, '')).map((p) => {
+      try { return /\.(png|jpe?g|gif|webp)$/i.test(p) && fs.statSync(p).isFile() ? p : null; } catch { return null; }
+    });
+    return files.every(Boolean) ? files : null;
+  }
+
+  async function attachImageFiles(files, { name = null } = {}) {
+    const { imageBlock } = await import('./agent/tools.js');
+    for (const file of files) {
+      const label = name || path.basename(file);
+      // Too big as it is (a 4K screenshot): a smaller copy is made first.
+      const ready = await shrinkImageFile(file).catch(() => null);
+      const block = ready ? await imageBlock(ready).catch(() => null) : null;
+      if (block) attachImage({ name: label, block });
+      else flash(`${label} could not be attached — it must be png, jpg, gif or webp, and it could not be made smaller than 3.5 MB`, 'warn', 3200);
+    }
   }
 
   /** Put the real content back in place of every placeholder. */
   function expandPastes(line) {
-    if (!state.pastes.length) return line;
     return line.replace(/\[#(\d+) pasted [^\]]*\]/g, (whole, id) => {
-      const blob = state.pastes.find((entry) => entry.id === Number(id));
+      // The current pastes, then earlier ones: a line recalled from history with Up still
+      // has its content — it used to send the literal placeholder text.
+      const blob = state.pastes.find((entry) => entry.id === Number(id)) || pasteStore.get(Number(id));
       return blob ? blob.text : whole;
     });
   }
@@ -1245,6 +1428,7 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
     // History keeps the TOKEN form. Pressing Up after sending a thousand-line paste
     // should bring back the sentence you wrote, not the thousand lines.
     if (state.history.at(-1) !== typed) state.history.push(typed);
+    state.lastTyped = typed;
     state.historyIndex = state.history.length;
     state.viewingTranscript = false;
     state.transcriptOffset = 0;
@@ -1260,6 +1444,9 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
     state.historyIndex = clamp(state.historyIndex + direction, 0, state.history.length);
     state.input = state.historyIndex === state.history.length ? (state.draft || '') : state.history[state.historyIndex];
     state.cursor = state.input.length;
+    // A recalled `/review` must not open the command menu: Up then moved inside the menu
+    // instead of on to the older prompt, and Enter ran whichever row was highlighted.
+    state.menuDismissedFor = state.input;
     refreshMenu();
     notifyNow();
   }
@@ -1408,7 +1595,7 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
       // Not "Ctrl+Shift+C": that is the TERMINAL's copy shortcut and it acts on the
       // terminal's own selection, which does not exist while the app owns the mouse.
       // Naming a shortcut that cannot work is worse than naming none.
-      flash(`${text.length} characters selected · jaitus config copyOnSelect on — to copy these automatically`, 'info', 4000);
+      flash(`${text.length} characters selected · Ctrl+C copies them`, 'info', 4000);
       return;
     }
     const ok = await (state.onCopy ? state.onCopy(text) : Promise.resolve(false));
@@ -1429,6 +1616,11 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
    */
   function dispatchClick(region, event) {
     if (!region) return;
+    // While a dialog or panel is open, only its own controls respond. A click on the
+    // header during a permission prompt opened the model picker OVER the prompt, which
+    // was never answered — the session was stuck until the terminal was closed.
+    const own = ['swallow', 'dialogOption', 'paletteRow', 'menuRow'];
+    if ((state.dialog || state.panel) && !own.includes(region.action.type)) return;
     switch (region.action.type) {
       case 'swallow':
         return;
@@ -1445,6 +1637,7 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
         const chosen = panel.options[panel.index];
         const name = typeof chosen === 'string' ? chosen : chosen?.name;
         state.panel = null;
+        if (panel.onPick) { if (chosen) panel.onPick(chosen); return notifyNow(); }
         refreshMenu();
         if (!name) return notifyNow();
         state.input = name;
@@ -1473,17 +1666,33 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
         return openPalette();
       case 'transcript':
         // A click in the body is how you get back to the live end after scrolling.
+        // Deferred, and cancelled by a second click: a double-click to select a word
+        // while scrolled back used to jump to the live end on the first click, so the
+        // second one selected whatever had moved under the pointer.
         if (state.viewingTranscript && event.button === 'left') {
-          state.viewingTranscript = false;
-          state.transcriptOffset = 0;
-          state.newMessages = 0;
-          notifyNow();
+          clearTimeout(returnToLiveTimer);
+          returnToLiveTimer = setTimeout(() => {
+            state.viewingTranscript = false;
+            state.transcriptOffset = 0;
+            state.newMessages = 0;
+            notifyNow();
+          }, 350);
         }
         return;
       default:
     }
   }
 
+  /** Scroll the open panel by `delta` rows; at the bottom it follows new output again. */
+  function scrollPanel(delta) {
+    const panel = state.panel;
+    if (!panel || panel.palette) return;
+    const max = panel._maxStart ?? 0;
+    panel.scroll = Math.max(0, Math.min(max, (panel.follow ? max : panel.scroll || 0) + delta));
+    panel.follow = panel.scroll >= max && !!panel.live;
+    notifyNow();
+  }
+
   function openPalette() {
     state.panel = {
       title: 'COMMAND PALETTE', palette: true, filter: '',
@@ -1510,13 +1719,24 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
       mouseFragment = { text: input, at: Date.now() };
       return;
     }
+    // A terminal that answers the startup probe late (over SSH, under a multiplexer)
+    // delivers the background-colour or device-attributes reply after the app has
+    // started; Ink passes it through as typed text.
+    if (TERMINAL_REPLY.test(input)) return;
     if (isMouse(input)) {
       mouseReports += 1;
       lastMouseAt = Date.now();
       const event = parseMouse(input);
       if (!event) return;
-      if (event.kind === 'wheelUp') return scroll(scrollStep());
-      if (event.kind === 'wheelDown') return scroll(-scrollStep());
+      // The wheel scrolls what is in front: a panel, the palette's list, or nothing under
+      // a dialog. It used to scroll the transcript hidden behind them.
+      if (event.kind === 'wheelUp' || event.kind === 'wheelDown') {
+        const up = event.kind === 'wheelUp';
+        if (state.dialog) return undefined;
+        if (state.panel?.palette) { state.panel.index = clamp(state.panel.index + (up ? -1 : 1), 0, Math.max(0, state.panel.options.length - 1)); return notifyNow(); }
+        if (state.panel) return scrollPanel(up ? -3 : 3);
+        return scroll(up ? scrollStep() : -scrollStep());
+      }
       // Right-click pastes, as it does in a Windows console — the terminal cannot do it
       // itself while the app has the mouse.
       if (event.kind === 'down' && event.button === 'right') {
@@ -1525,6 +1745,7 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
       }
 
       if (event.kind === 'down' && event.button === 'left') {
+        clearTimeout(returnToLiveTimer); // a second click: this is a double-click, stay put
         // A press starts a possible drag AND a possible click. Which it was is only
         // known on release, so nothing is dispatched yet — dispatching here made every
         // attempt to select text also press whatever was under the cursor.
@@ -1582,6 +1803,7 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
           const chosen = panel.options[panel.index];
           const name = typeof chosen === 'string' ? chosen : chosen?.name;
           state.panel = null;
+          if (panel.onPick) { if (chosen) panel.onPick(chosen); return notifyNow(); }
           refreshMenu();
           if (!name) return notifyNow();
           // Run it. Picking a command out of a palette and then being handed it to
@@ -1607,6 +1829,12 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
         return;
       }
       if (key.escape || key.return || key.enter) resolvePanel();
+      else if (key.upArrow || key.up) scrollPanel(-1);
+      else if (key.downArrow || key.down) scrollPanel(1);
+      else if (key.pageUp || key.pageup) scrollPanel(-(panel._maxRows || 10));
+      else if (key.pageDown || key.pagedown) scrollPanel(panel._maxRows || 10);
+      else if (key.home) scrollPanel(-1e9);
+      else if (key.end) scrollPanel(1e9);
       return;
     }
 
@@ -1614,18 +1842,30 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
     // Split here or the return becomes a literal character in the composer.
     const newlineAt = String(input || '').search(/[\r\n]/);
     if (newlineAt >= 0) {
-      const typed = String(input).slice(0, newlineAt);
-      const rest = String(input).slice(newlineAt + 1);
+      const text = String(input);
+      const typed = text.slice(0, newlineAt);
+      const sep = text[newlineAt];
+      let rest = text.slice(newlineAt + 1);
       if (typed) insert(typed);
-      if (key.shift) insert('\n');
-      // This path went straight to submit(), which is why `/re` + Enter sometimes ran
-      // `/re` instead of the highlighted `/review`. Whether Enter arrives on its own or
-      // glued to the typed text is a matter of how fast the keystrokes were batched by
-      // the PTY — so the two paths have to make the same decision, or the shortcut
-      // works or does not work depending on typing speed.
+      // Enter (\r) sends; a line feed (\n — Ctrl+J), Alt/Shift+Enter, or a `\` right
+      // before the cursor is a NEW LINE. This path used to send on every one of them, so
+      // no key in the README could add a line: each line went out as its own message.
+      // A \r\n pair is a line break inside pasted text, never a send.
+      let newline = key.shift || key.meta || sep === '\n';
+      if (sep === '\r' && rest.startsWith('\n')) { newline = true; rest = rest.slice(1); }
+      if (!newline && state.input[state.cursor - 1] === '\\') {
+        state.input = state.input.slice(0, state.cursor - 1) + state.input.slice(state.cursor);
+        state.cursor -= 1;
+        newline = true;
+      }
+      if (newline) insert('\n');
+      // Whether Enter arrives on its own or glued to the typed text depends on how the
+      // PTY batched the keystrokes — so both paths make the same decision, including
+      // taking the highlighted menu item (`/re` + Enter runs `/review`).
       else if (state.menu.length) chooseMenu({ run: true });
       else submit();
-      if (rest) insert(rest);
+      // The rest of the chunk goes through the same rules (it may hold more lines).
+      if (rest) handleKey(rest, {}, exit);
       return;
     }
 
@@ -1640,6 +1880,16 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
     const ctrlKey = key.ctrl ? String(key.name || input || '').toLowerCase() : '';
 
     if (ctrlKey === 'c') {
+      // With text selected, Ctrl+C copies it (as the README says) — including mid-turn,
+      // where it used to stop the turn instead. With copyOnSelect off it was the only way.
+      const selected = state.selection ? selectedText() : '';
+      if (selected.trim()) {
+        void (state.onCopy ? state.onCopy(selected) : Promise.resolve(false)).then((ok) => {
+          flash(ok ? `Copied ${selected.length} character${selected.length === 1 ? '' : 's'}` : 'Nothing could copy it — no clipboard tool found', ok ? 'ok' : 'warn', 1600);
+          clearSelection();
+        });
+        return;
+      }
       if (state.busy) state.onEscape?.();
       else if (state.input) clearInput();
       else flash('Type /exit to leave', 'info', 1500);
@@ -1649,6 +1899,8 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
     if (ctrlKey === 'l') { api.clearTranscript(); return; }
     if (ctrlKey === 'd') { api.toggleDebug(); return; }
     if (ctrlKey === 'p') return openPalette();
+    if (ctrlKey === 'r') return openHistorySearch();
+    if (ctrlKey === 'o') return openTranscriptSearch();
     // Ctrl+V reaches the app only in terminals that do not paste on it themselves (those
     // send the text as a bracketed paste instead). Alt+V is for an image — a screenshot
     // cannot be typed in, so no terminal pastes one.
@@ -1656,6 +1908,10 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
     if (key.meta && String(input).toLowerCase() === 'v') { void pasteFromClipboard({ imageOnly: true }); return; }
     if (key.escape) {
       if (state.busy) return state.onEscape?.();
+      // Esc closes the suggestion menu first, as the README says. It went straight to the
+      // rewind countdown, so a message ending in `@word` or `/word` could not be sent —
+      // Enter kept choosing a suggestion.
+      if (state.menu.length) { state.menu = []; state.menuIndex = -1; state.menuDismissedFor = state.input; return notifyNow(); }
       if (state.viewingTranscript) { state.viewingTranscript = false; state.transcriptOffset = 0; state.newMessages = 0; return notifyNow(); }
       const now = Date.now();
       if (lastEscapeAt && now - lastEscapeAt < 1200) {
@@ -1683,9 +1939,18 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
     if ((key.upArrow || key.up) && state.menu.length) { state.menuIndex = clamp(state.menuIndex - 1, 0, state.menu.length - 1); return notifyNow(); }
     if ((key.downArrow || key.down) && state.menu.length) { state.menuIndex = clamp(state.menuIndex + 1, 0, state.menu.length - 1); return notifyNow(); }
     if (key.tab && state.menu.length) return chooseMenu();
-    if (key.return || key.enter) {
-      if (!key.shift && state.menu.length) return chooseMenu({ run: true });
-      if (key.shift) return insert('\n');
+    if (key.return || key.enter || input === '\n') {
+      // A new line, not a send: Ctrl+J (a line feed, where Enter is a carriage return),
+      // Alt+Enter, Shift+Enter where the terminal reports it, or a `\` right before the
+      // cursor. Only Shift was checked, which almost no terminal reports — so every way
+      // the README advertised sent the half-written message instead.
+      if (key.shift || key.meta || input === '\n') return insert('\n');
+      if (state.input[state.cursor - 1] === '\\') {
+        state.input = state.input.slice(0, state.cursor - 1) + state.input.slice(state.cursor);
+        state.cursor -= 1;
+        return insert('\n');
+      }
+      if (state.menu.length) return chooseMenu({ run: true });
       return submit();
     }
 
@@ -1715,7 +1980,7 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
       // leave a broken token behind.
       const chip = chipBefore(state.input, state.cursor);
       const at = chip ? state.cursor - chip[0].length : wordLeft();
-      if (chip) dropPaste(chip[1]);
+      if (chip) dropPaste(chip);
       state.input = state.input.slice(0, at) + state.input.slice(state.cursor);
       state.cursor = at;
       refreshMenu();
@@ -1723,9 +1988,12 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
     }
     if (key.backspace) {
       if (state.cursor === 0) return;
-      const chip = chipBefore(state.input, state.cursor);
-      const eat = chip ? chip[0].length : 1;
-      if (chip) dropPaste(chip[1]);
+      // A chip is inserted with a space after it; Backspace right after that space means
+      // the chip, not the space — otherwise the first Backspace seemed to do nothing.
+      const spaced = state.input[state.cursor - 1] === ' ' ? chipBefore(state.input, state.cursor - 1) : null;
+      const chip = spaced || chipBefore(state.input, state.cursor);
+      const eat = chip ? chip[0].length + (spaced ? 1 : 0) : 1;
+      if (chip) dropPaste(chip);
       state.input = state.input.slice(0, state.cursor - eat) + state.input.slice(state.cursor);
       state.cursor -= eat;
       refreshMenu();
@@ -1734,7 +2002,7 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
     if (key.delete) {
       const chip = chipAfter(state.input, state.cursor);
       const eat = chip ? chip[0].length : 1;
-      if (chip) dropPaste(chip[1]);
+      if (chip) dropPaste(chip);
       state.input = state.input.slice(0, state.cursor) + state.input.slice(state.cursor + eat);
       refreshMenu();
       return notifyNow();
@@ -1743,12 +2011,93 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
     if (ctrlKey === 'k') { state.input = state.input.slice(0, state.cursor); refreshMenu(); return notifyNow(); }
     if (key.upArrow || key.up) return historyMove(-1);
     if (key.downArrow || key.down) return historyMove(1);
-    if (input && !key.ctrl && !key.meta) insert(input);
+    if (input && !key.ctrl && !key.meta) {
+      // Control characters are keys, never text. Two pressed quickly arrive as one chunk
+      // ("\x05\x15" — Ctrl+E, Ctrl+U) that Ink hands over as input; it used to be
+      // inserted as invisible characters, so the line no longer started with `/` and a
+      // command went to the model as a message. Ctrl+_ \ ] ^ (0x1c–0x1f) did the same.
+      if (/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(input)) {
+        let text = '';
+        const flushText = () => { if (text) { insert(text); text = ''; } };
+        for (const ch of input) {
+          const code = ch.charCodeAt(0);
+          if (code >= 1 && code <= 26 && code !== 9) { flushText(); handleKey(String.fromCharCode(96 + code), { ctrl: true }, exit); }
+          else if (code === 0x7f || code === 8) { flushText(); handleKey('', { backspace: true }, exit); }
+          else if (code < 32 && code !== 9) { /* 0x1c–0x1f and NUL: nothing to type */ }
+          else text += ch;
+        }
+        flushText();
+        return;
+      }
+      insert(input);
+    }
+  }
+
+  /**
+   * A searchable list whose choice goes to `onPick` — Ctrl+R (prompt history) and
+   * Ctrl+O (the conversation). Neither existed in this view; the README listed both.
+   * Matching is plain "contains" (case-insensitive): these are sentences, not names.
+   */
+  function openSearchPanel({ title, options, onPick, empty }) {
+    if (!options.length) { flash(empty, 'info', 1600); return; }
+    state.panel = { title, palette: true, contains: true, filter: '', all: options, options, index: 0, lines: [], onPick, resolve: () => {} };
+    state.menu = [];
+    notifyNow();
+  }
+
+  function openHistorySearch() {
+    const seen = new Set();
+    const options = [];
+    for (const entry of [...state.history].reverse()) {
+      if (!entry || seen.has(entry)) continue;
+      seen.add(entry);
+      options.push({ name: entry.replace(/\s+/g, ' ').slice(0, 110), value: entry });
+    }
+    openSearchPanel({
+      title: 'SEARCH YOUR PROMPTS', options, empty: 'No prompt history yet',
+      onPick: (o) => { state.input = o.value; state.cursor = o.value.length; state.menuDismissedFor = state.input; notifyNow(); },
+    });
+  }
+
+  function openTranscriptSearch() {
+    const inner = Math.max(24, (state._width || process.stdout.columns || 80) - 2);
+    const rows = [];
+    for (const entry of state.transcript) {
+      const built = rowsFor(entry, inner);
+      if (!built.length) continue;
+      if (rows.length) rows.push([]);
+      rows.push(...built);
+    }
+    const total = rows.length;
+    const options = [];
+    rows.forEach((row, i) => {
+      const text = rowText(row).trim();
+      if (text) options.push({ name: text.slice(0, 110), value: i });
+    });
+    openSearchPanel({
+      title: 'SEARCH THE CONVERSATION', options: options.reverse(), empty: 'Nothing in the conversation yet',
+      onPick: (o) => {
+        // Scroll so the chosen line sits mid-screen (the offset counts rows up from the
+        // bottom).
+        const half = Math.floor((state._transcriptHeight || 20) / 2);
+        const offset = Math.max(0, total - o.value - 1 - half);
+        state.viewingTranscript = offset > 0;
+        state.transcriptOffset = offset;
+        flash(`Line ${o.value + 1} of ${total} — Ctrl+End returns to the end`, 'info', 2200);
+        notifyNow();
+      },
+    });
   }
 
   function applyPaletteFilter(panel) {
     const filter = String(panel.filter || '');
     if (!filter) { panel.options = panel.all; panel.index = 0; return; }
+    if (panel.contains) {
+      const needle = filter.toLowerCase();
+      panel.options = panel.all.filter((o) => String(o.name).toLowerCase().includes(needle));
+      panel.index = 0;
+      return;
+    }
     panel.options = panel.all
       .map((command) => {
         const name = typeof command === 'string' ? command : command.name;
@@ -2012,13 +2361,50 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
 
     queue(line) { state.queued.push(line); notify(); },
     takeQueued() { const queued = state.queued; state.queued = []; notify(); return queued; },
+    /** Put text back into the composer (queued messages after an interrupt). */
+    /** The line as typed (chips, not their contents) — what goes into the history file. */
+    lastTyped() { const t = state.lastTyped; state.lastTyped = undefined; return t; },
+    restoreInput(text) {
+      const value = String(text || '');
+      if (!value) return;
+      state.input = state.input ? `${value}\n${state.input}` : value;
+      state.cursor = state.input.length;
+      refreshMenu();
+      notifyNow();
+    },
     hasQueued() { return state.queued.length > 0; },
 
-    addAttachment(attachment) { state.attachments.push(attachment); notify(); },
-    drainAttachments() { const list = state.attachments; state.attachments = []; notify(); return list.map((a) => a.block).filter(Boolean); },
+    /** Attach an image block (from /image, an @mention, a drop): returns its chip number. */
+    addAttachment(attachment) { return attachImage(attachment); },
+    /** Attach image files by path, shrinking any that are too big. */
+    addImageFiles(files) { return attachImageFiles(files); },
+    /**
+     * The images to send with `line`: only those whose chip is still in it, in the order
+     * the chips appear. A chip deleted, cleared with Ctrl+U or never sent is dropped —
+     * the chip in the text is the one source of truth for what goes with the message.
+     */
+    drainAttachments(line = '') {
+      const order = [...String(line).matchAll(/\[Image #(\d+)\]/g)].map((m) => Number(m[1]));
+      const blocks = order.map((id) => (state.attachments.find((a) => a.id === id) || imageStore.get(id))?.block).filter(Boolean);
+      state.attachments = [];
+      notify();
+      return blocks;
+    },
 
     askDialog(question, options, preview = [], opts = {}) {
       return new Promise((resolve) => {
+        // One dialog at a time, and a replaced one is ANSWERED (as cancelled), never left
+        // pending: whoever was awaiting it — a permission prompt, mid-turn — would
+        // otherwise wait forever.
+        if (state.dialog?.resolve) { const prev = state.dialog.resolve; state.dialog = null; prev(null); }
+        // The turn it belongs to was stopped (Esc): close it, as cancelled.
+        if (opts.signal) {
+          if (opts.signal.aborted) { resolve(null); return; }
+          opts.signal.addEventListener('abort', () => {
+            if (state.dialog?.resolve === resolve) { state.dialog = null; notifyNow(); }
+            resolve(null);
+          }, { once: true });
+        }
         state.dialog = {
           question: plain(question),
           options: options.map((option) => (option && typeof option === 'object'
@@ -2039,6 +2425,7 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
 
     showPanel(title, lines) {
       return new Promise((resolve) => {
+        if (state.panel?.resolve) { const prev = state.panel.resolve; state.panel = null; prev(null); }
         state.panel = {
           title: plain(title),
           lines: (Array.isArray(lines) ? lines : String(lines).split('\n')).map((line) => plain(line)),
@@ -2051,6 +2438,9 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
 
     updatePanel(lines) {
       if (!state.panel) return;
+      // A panel that is updated is live output: it follows the newest lines until the
+      // user scrolls up, and again once they scroll back to the bottom.
+      if (!state.panel.live) { state.panel.live = true; state.panel.follow = true; }
       state.panel.lines = (Array.isArray(lines) ? lines : String(lines).split('\n')).map((line) => plain(line));
       notify();
     },