jaitus 0.3.0

package/src/tui.js

@@ -0,0 +1,2555 @@
+// ─── Fullscreen Jaitus terminal application ────────────────────────────────────
+//
+// Renderer invariants (the last renderer violated all four and the cursor desynced):
+//
+//   1. NOTHING is ever written at or beyond the terminal's last column. Autowrap is
+//      even disabled (DECAWM off) for the session, so a too-wide row would truncate,
+//      never wrap — but every row is hard-capped below the width anyway.
+//   2. No trailing newline is EVER emitted. A `\n` on the bottom screen row scrolls
+//      the whole terminal one line — that was the "everything drifts up" bug. Frames
+//      are painted with absolute cursor addressing (`\x1b[r;1H`) only.
+//   3. ONE layout function produces the full frame AND the cursor position. The
+//      cursor is placed by row index inside the same array that was drawn, so the
+//      cursor cannot land somewhere the layout did not put content.
+//   4. The frame is always exactly `rows` tall and repainted from home; a resize
+//      simply repaints at the new size.
+//
+// Everything above the render layer (state machine, key handling, transcript,
+// search, dialogs) is unchanged from the version the tests already pin.
+
+import readline from 'node:readline';
+import path from 'node:path';
+import fs from 'node:fs';
+import os from 'node:os';
+import { PassThrough } from 'node:stream';
+import { spawn, spawnSync } from 'node:child_process';
+import { c, columns, visibleWidth, colorLevel, themeMap, glyph } from './ui.js';
+import { loadSettings } from './config.js';
+import { startupTip, badge } from './brand.js';
+
+const rawWrite = (text = '') => process.stdout.write(text);
+
+function cleanLine(text, width) {
+  const rows = [];
+  for (const part of String(text ?? '').split('\n')) {
+    if (!part) { rows.push(''); continue; }
+    let current = ''; let currentWidth = 0; let escape = false;
+    for (const char of part) {
+      if (escape) { current += char; if (char === 'm') escape = false; continue; }
+      if (char === '\x1b') { current += char; escape = true; continue; }
+      const charWidth = visibleWidth(char);
+      if (currentWidth + charWidth > width && current) {
+        rows.push(current); current = char; currentWidth = charWidth;
+      } else { current += char; currentWidth += charWidth; }
+    }
+    rows.push(current);
+  }
+  return rows;
+}
+
+export function wrapLine(text, width) { return cleanLine(text, Math.max(8, width)); }
+
+/**
+ * Split raw stdin bytes into complete mouse sequences vs everything else.
+ *
+ * Node's readline key parser does NOT understand SGR mouse — it shreds
+ * `\x1b[<64;10;10M` into junk keypresses (`6`, `4`, `;`, …), so the wheel can
+ * never work through the keypress path (and worse, it types garbage into the
+ * prompt). The TUI therefore frames mouse bytes here, on the raw stream, and
+ * forwards everything else byte-identical to readline.
+ *
+ * Returns { forward, events, hold }: bytes for readline, parsed mouse events,
+ * and a trailing maybe-partial prefix the caller retains for the next chunk.
+ */
+export function splitMouseSequences(buf) {
+  const events = [];
+  let forward = '';
+  let i = 0;
+  const sgrRe = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])/;
+  while (i < buf.length) {
+    const esc = buf.indexOf('\x1b', i);
+    if (esc === -1) { forward += buf.slice(i); i = buf.length; break; }
+    const rest = buf.slice(esc);
+    const sgr = sgrRe.exec(rest);
+    if (sgr) {
+      forward += buf.slice(i, esc);
+      events.push({ button: Number(sgr[1]), col: Number(sgr[2]), row: Number(sgr[3]), press: sgr[4] === 'M' });
+      i = esc + sgr[0].length;
+      continue;
+    }
+    if (rest.startsWith('\x1b[M')) {
+      if (rest.length >= 6) {
+        forward += buf.slice(i, esc);
+        events.push({ button: rest.charCodeAt(3) - 32, col: rest.charCodeAt(4) - 32, row: rest.charCodeAt(5) - 32, press: true, legacy: true });
+        i = esc + 6;
+        continue;
+      }
+      forward += buf.slice(i, esc);
+      break; // hold partial X10
+    }
+    // Terminal focus reports (?1004h): complete 3-byte sequences, never split
+    // past the lone-ESC hold below, so they can't leak as junk keypresses.
+    if (rest === '\x1b[I' || rest === '\x1b[O') {
+      forward += buf.slice(i, esc);
+      events.push({ focus: rest === '\x1b[I' });
+      i = esc + 3;
+      continue;
+    }
+    // Trailing lone ESC / partial CSI (possibly a mouse split across chunks,
+    // or a key like PgUp `\x1b[5~` split the same way): hold for more bytes.
+    if (/^\x1b(\[[0-9;<=>?]*)?$/.test(rest)) { forward += buf.slice(i, esc); break; }
+    forward += buf.slice(i, esc + 1);
+    i = esc + 1;
+  }
+  return { forward, events, hold: buf.slice(i) };
+}
+
+// ─── Code highlighting (§9, Tier 1) ───────────────────────────────────────────
+// Small regex tokenizer for fenced blocks in assistant/tool text: keywords in
+// brand coral, strings green, comments dim, numbers yellow, diffs line-tinted.
+// ANSI-safe (styles pre-existing escape runs untouched), toggleable via the
+// `highlight` setting. Not a tree-sitter — a readable terminal, cheaply.
+const CODE_WORDS = {
+  js: 'const let var function return if else for while do switch case break continue new class extends import export from default try catch finally throw async await typeof instanceof in of null undefined true false this super static get set yield delete void',
+  py: 'def return if elif else for while in not and or is None True False class import from as with lambda try except finally raise pass global nonlocal assert del yield async await',
+  bash: 'if then else elif fi for while do done case esac function select in time echo cd ls grep awk sed cat exit return export local readonly shift trap sudo',
+};
+const CODE_LANG = {
+  javascript: 'js', typescript: 'js', js: 'js', jsx: 'js', tsx: 'js', ts: 'js', json: 'js',
+  python: 'py', py: 'py', shell: 'bash', sh: 'bash', bash: 'bash', zsh: 'bash',
+};
+const CODE_COMMENT = { js: '//', py: '#', bash: '#' };
+const CODE_TOKEN = /("(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'|`(?:[^`\\\n]|\\.)*`|\/\/[^\n]*|#[^\n]*|\b\d+(?:\.\d+)?\b|\b[A-Za-z_][A-Za-z0-9_]*\b|.)/gs;
+const ANSI_RUN = /\x1b\[[0-9;]*m/g;
+const ANSI_SPLIT = /(\x1b\[[0-9;]*m)/g;
+
+function highlightEnabled() {
+  try { return loadSettings().highlight !== false; } catch { return true; }
+}
+function fenceOf(line, current) {
+  const m = /^\s*```(\w*)\s*$/.exec(String(line ?? '').replace(ANSI_RUN, ''));
+  if (!m) return current;
+  if (current) return null;
+  return CODE_LANG[(m[1] || '').toLowerCase()] || (m[1] ? 'txt' : null);
+}
+function paintDiffLine(text) {
+  const t = text;
+  if (/^\s*diff --git/.test(t) || /^\s*@@/.test(t)) return c.cyan(t);
+  if (/^\s*\+\+\+|^\s*---/.test(t)) return c.bold(t);
+  if (/^\s*\+/.test(t)) return c.green(t);
+  if (/^\s*-/.test(t)) return c.red(t);
+  return t;
+}
+function highlightCodeText(text, lang) {
+  const words = new Set((CODE_WORDS[lang] || '').split(' '));
+  const hashComment = CODE_COMMENT[lang] === '#';
+  return String(text).replace(CODE_TOKEN, (tok) => {
+    if (!tok) return tok;
+    if (tok.startsWith('"') || tok.startsWith("'") || tok.startsWith('`')) return c.green(tok);
+    if (tok.startsWith('//') && CODE_COMMENT[lang] === '//') return c.dim(tok);
+    if (tok.startsWith('#') && hashComment) return c.dim(tok);
+    if (/^\d/.test(tok)) return c.yellow(tok);
+    // Keywords wear the teal accent, never the red-family brand: brand red
+    // is reserved for errors and omissions.
+    if (words.has(tok)) return c.accent(tok);
+    return tok;
+  });
+}
+function highlightLine(line, fence, kind) {
+  if (!highlightEnabled()) return line;
+  if (kind !== 'assistant' && kind !== 'tool') return line;
+  if (colorLevel() === 0) return line;
+  if (fence === 'diff') return String(line).split('\n').map(paintDiffLine).join('\n');
+  if (fence && CODE_WORDS[fence]) {
+    // Highlight text runs only; pre-existing escape sequences pass through.
+    return String(line).split(ANSI_SPLIT).map((seg, i) => (i % 2 === 0 ? highlightCodeText(seg, fence) : seg)).join('');
+  }
+  if (!fence) {
+    // No bare-diff guessing outside ```diff fences: a `- ` markdown bullet
+    // is not a removed line, and painting every list red was exactly wrong.
+    // `inline code` in prose.
+    const plain = String(line).replace(ANSI_RUN, '');
+    if (plain.includes('`')) {
+      return String(line).split(ANSI_SPLIT).map((seg, i) => {
+        if (i % 2 === 1) return seg;
+        return seg.split(/(`[^`\n]+`)/g).map((part) => (part.startsWith('`') ? c.cyan(part) : part)).join('');
+      }).join('');
+    }
+  }
+  return line;
+}
+
+// Emoji shortcodes (§3.6): `:name:` live-replaces on the closing colon.
+const EMOJI = {
+  heart: '❤', thumbsup: '👍', thumbsdown: '👎', laugh: '😄', smile: '😊', wink: '😉',
+  fire: '🔥', star: '⭐', check: '✅', x: '❌', warning: '⚠️', info: 'ℹ️',
+  rocket: '🚀', tada: '🎉', eyes: '👀', thinking: '🤔', confused: '😕', cry: '😢',
+  clap: '👏', pray: '🙏', muscle: '💪', bug: '🐛', wrench: '🔧', package: '📦',
+  book: '📖', pencil: '✏️', memo: '📝', bulb: '💡', lock: '🔒', key: '🔑',
+  zap: '⚡', sparkles: '✨', white_check_mark: '✅', red_circle: '🔴', green_circle: '🟢',
+  arrow_right: '➡️', arrow_up: '⬆️', recycle: '♻️', wave: '👋', coffee: '☕',
+  computer: '💻', terminal: '💻', gear: '⚙️', hammer: '🔨', test_tube: '🧪',
+  party: '🥳', grimacing: '😬', sweat: '😅', sleep: '😴', poop: '💩',
+};
+
+export function menuItemsFor(input, slashCommands, fileProvider) {
+  const items = [];
+  const slash = /(?:^|\s)\/([^\s]*)$/.exec(input);
+  if (slash) {
+    const fragment = slash[1].toLowerCase();
+    for (const command of slashCommands) {
+      const name = command.replace(/^\//, '');
+      if (name.toLowerCase().startsWith(fragment)) items.push({ kind: 'command', value: `/${name}`, label: `/${name}`, hint: '' });
+      if (items.length === 8) break;
+    }
+    return items;
+  }
+  const at = input.lastIndexOf('@');
+  if (at >= 0 && !/\s/.test(input.slice(at + 1))) {
+    for (const file of (fileProvider?.(input.slice(at + 1)) || []).slice(0, 8)) items.push({ kind: 'file', value: file, label: file, hint: '' });
+  }
+  return items;
+}
+
+function modeLabel(mode) {
+  if (mode === 'acceptEdits') return 'accept edits';
+  if (mode === 'bypassPermissions') return 'bypass';
+  if (mode === 'plan') return 'plan';
+  return 'manual';
+}
+
+// The composer is an opencode-style left-border panel: a mode-colored │
+// beside every row, input on the bar, no box, no › prefix.
+// Prefixes are 4 cells wide — color codes take no screen cells.
+const PROMPT_PREFIX_WIDTH = 4;
+const PROMPT_USABLE_SLACK = PROMPT_PREFIX_WIDTH + 1; // usable = width - prefix - 1 guard col
+function boxChars() {
+  return process.env.JAITUS_ASCII ? { v: '|', tl: '+', tr: '+', bl: '+', br: '+', h: '-' } : { v: '│', tl: '┌', tr: '┐', bl: '└', br: '┘', h: '─' };
+}
+/** Edge styler for the input box (§5.1 tokens): shell cyan, plan amber,
+// bypass red, acceptedits teal, default neutral. */
+function edgeStyle(mode, shell) {
+  if (shell) return c.cyan;
+  if (mode === 'plan') return c.permission;
+  if (mode === 'bypassPermissions') return c.red;
+  if (mode === 'acceptEdits') return c.accent;
+  return c.grey;
+}
+function promptEdge(mode = 'default', shell = false) {
+  const { v } = boxChars();
+  return `  ${edgeStyle(mode, shell)(v)} `;
+}
+function promptPrefix(mode = 'default', shell = false) {
+  return promptEdge(mode, shell);
+}
+function promptCont(mode = 'default', shell = false) {
+  return promptEdge(mode, shell);
+}
+
+function promptRows(input, width, mode = 'default') {
+  const usable = Math.max(12, width - PROMPT_USABLE_SLACK);
+  const shell = String(input).startsWith('!');
+  if (!input) return [`${promptPrefix(mode, shell)}${c.dim(`Ask anything. "${startupTip()}"`)}`];
+  return cleanLine(input, usable).map((row, index) => `${index ? promptCont(mode, shell) : promptPrefix(mode, shell)}${row}`);
+}
+
+function composerTopRow(width, mode, model, shell) {
+  const { tl, tr, h } = boxChars();
+  const edge = edgeStyle(mode, shell);
+  const innerWidth = Math.max(8, width - 5);
+  const label = ` ${shell ? 'shell' : 'ask'} · ${modeLabel(mode)}${model ? ` · ${model}` : ''} `;
+  const safeLabel = label.slice(0, innerWidth);
+  return `  ${edge(tl)}${edge(safeLabel)}${edge(h.repeat(Math.max(0, innerWidth - visibleWidth(safeLabel))))}${edge(tr)}`;
+}
+
+function composerBottomRow(width, mode, shell) {
+  const { bl, br, h } = boxChars();
+  const edge = edgeStyle(mode, shell);
+  return `  ${edge(bl)}${edge(h.repeat(Math.max(8, width - 5)))}${edge(br)}`;
+}
+
+/** The meta row pinned inside the composer panel: mode posture, model,
+ * build marker — opencode's `Agent · model`, plus our version stamp. */
+function promptMetaRow(width, mode = 'default', model = '', shell = false, version = '') {
+  const bar = edgeStyle(mode, shell)(glyph('│', '|'));
+  const bits = [edgeStyle(mode, shell)(modeLabel(mode))];
+  if (model) bits.push(c.dim('·'), model);
+  if (version) bits.push(c.dim('·'), c.dim(`v${version}`));
+  return `  ${bar} ${bits.join(' ')}`;
+}
+
+/** Full-width quiet fill for panel rows (composer, permission) — opencode
+ * panels sit on backgroundElement; Jaitus reuses the theme's userBg token
+ * so light/daltonized/ocean stay coherent. Pads to the frame width. */
+function panelFill(line, w) {
+  if (colorLevel() === 0) return line;
+  let codes = null;
+  try { codes = themeMap().userBg; } catch { /* plain */ }
+  if (!codes) return line;
+  const target = Math.max(0, w - 1);
+  const pad = ' '.repeat(Math.max(0, target - visibleWidth(line)));
+  return `\x1b[${codes}m${line}${pad}\x1b[0m`;
+}
+
+/** Where inside the prompt rows the cursor sits — same usable width, same wrapping. */
+function promptCursor(input, cursor, width) {
+  const usable = Math.max(12, width - PROMPT_USABLE_SLACK);
+  const before = cleanLine(input.slice(0, cursor), usable);
+  // +1: the CUP column is 1-based and the caret sits AFTER the last rendered cell.
+  // Prefix is `  │ ` = 4 cells (edge is styled, zero-width codes aside).
+  return { row: Math.max(0, before.length - 1), column: PROMPT_PREFIX_WIDTH + visibleWidth(before.at(-1) || '') + 1 };
+}
+
+function menuRows(menu, menuIndex, width) {
+  return menu.map((item, index) => {
+    const selected = index === menuIndex;
+    const kind = c.dim(item.kind === 'command' ? 'command' : 'file');
+    const line = `  ${selected ? c.brand('›') : ' '} ${selected ? c.bold(item.label) : item.label}  ${kind}`;
+    // Pad the selected row for inverse video — but never to the full width (invariant 1).
+    return selected ? c.inverse(`${line}${' '.repeat(Math.max(0, width - 1 - visibleWidth(line)))}`) : line;
+  });
+}
+
+function composerRows({ input, menu, menuIndex, status, queued, width, mode, model = '', version = '' }) {
+  const rows = [];
+  if (menu.length) rows.push(...menuRows(menu, menuIndex, width));
+  if (queued.length) rows.push(c.dim(`  ↳ queued ${queued.length}: ${queued[0].slice(0, Math.max(12, width - 18))}`));
+  const shell = String(input).startsWith('!');
+  rows.push(panelFill(composerTopRow(width, mode, model, shell), width));
+  rows.push(...promptRows(input, width, mode).map((r) => panelFill(r, width)));
+  rows.push(panelFill(promptMetaRow(width, mode, model, shell, version), width));
+  rows.push(status || c.dim(`  ↵ send   ⇧↹ ${modeLabel(mode)}   PgUp/PgDn scroll   / commands   @ files`));
+  rows.push(panelFill(composerBottomRow(width, mode, shell), width));
+  return rows;
+}
+
+/** 0-based offset of the comment row inside dialogRows (-1 when hidden). */
+function dialogCommentOffset(dialog, width) {
+  if (dialog.hideComment) return -1;
+  const qLines = dialogQLines(dialog, width);
+  // Pills panels drop the divider row the list layout starts with.
+  return (isPills(dialog) ? 1 : 2) + qLines + (dialog.preview?.length ? 1 + Math.min(7, dialog.preview.length) : 0);
+}
+/** Question rows inside dialogRows, shared by render, cursor and click math. */
+function dialogQLines(dialog, width) {
+  // Icon panels prefix the first row, so the text wraps narrower.
+  if (dialog.icon) return cleanLine(dialog.question, Math.max(12, width - 8)).length;
+  return cleanLine(`  ${dialog.question}`, Math.max(12, width - 4)).length;
+}
+/** Inline option pills (the opencode permission shape) instead of the list. */
+function isPills(dialog) {
+  return !!dialog?.pills && dialog.options.length <= 3;
+}
+/** ASCII twins for the panel icon set. */
+const ICON_TWINS = { '→': '>', '←': '<', '✱': '*', '%': '%', '◈': 'o', '#': '#', '⚙': '*', '◉': 'o' };
+const iconFor = (ch) => glyph(ch, ICON_TWINS[ch] || '?');
+/** Visible column spans of each pill (1-based), for click/hover hit-testing. */
+function dialogPillSpans(dialog) {
+  const spans = [];
+  let col = 5; // `  │ ` occupies cols 1-4
+  dialog.options.forEach((option, i) => {
+    const w = visibleWidth(` ${option.label} `);
+    if (i > 0) col += 1; // gap
+    spans.push({ start: col, end: col + w - 1, index: i });
+    col += w;
+  });
+  return spans;
+}
+function dialogPillRow(dialog) {
+  const bar = c.permission(glyph('│', '|'));
+  // Selected pill glows amber-bold; the rest stay dim. No inverse video —
+  // inverse closes would shred the panel's background fill.
+  const pills = dialog.options.map((option, i) =>
+    i === dialog.index ? c.bold(c.permission(` ${option.label} `)) : c.dim(` ${option.label} `)).join(' ');
+  return `  ${bar} ${pills}`;
+}
+function dialogRows(dialog, width) {
+  if (isPills(dialog)) {
+    const bar = c.permission(glyph('│', '|'));
+    const title = dialog.title || 'Permission required';
+    const rows = [
+      `  ${bar} ${c.permission(glyph('△', '!'))} ${c.bold(title)}`,
+    ];
+    cleanLine(dialog.question, Math.max(12, width - 8)).forEach((line, i) =>
+      rows.push(`  ${bar} ${i === 0 && dialog.icon ? `${iconFor(dialog.icon)} ` : ''}${line}`));
+    if (dialog.preview?.length) {
+      rows.push(`  ${bar} ${c.dim('Preview')}`);
+      for (const line of dialog.preview.slice(0, 7)) rows.push(`  ${bar}   ${String(line).slice(0, Math.max(8, width - 10))}`);
+    }
+    // Inline comment the model reads with the decision (§11): `e` to write one.
+    if (!dialog.hideComment) {
+      const hint = dialog.editing ? '▏' : '';
+      rows.push(dialog.comment
+        ? `  ${bar} ${c.permission(glyph('✎', 'e'))} ${dialog.comment}${hint}`
+        : c.dim(`  ${glyph('│', '|')} ${glyph('✎', 'e')} ${dialog.editing ? '' : 'e to explain'}${hint}`));
+    }
+    rows.push(dialogPillRow(dialog));
+    rows.push(c.dim(`  ${glyph('│', '|')} ${glyph('⇆', '<->')} select · enter confirm · e explain · esc deny`));
+    // The whole panel sits on the quiet fill, opencode-style.
+    return rows.map((r) => panelFill(r, width));
+  }
+  const title = dialog.title || `${c.permission('!')} ${c.bold('Permission required')}`;
+  const rows = [
+    c.permission(`  ${'─'.repeat(Math.max(8, width - 4))}`),
+    `  ${title}`,
+    ...cleanLine(`  ${dialog.question}`, Math.max(12, width - 4)),
+  ];
+  if (dialog.preview?.length) {
+    rows.push(c.dim('  Preview'));
+    for (const line of dialog.preview.slice(0, 7)) rows.push(`    ${c.grey('│')} ${String(line).slice(0, Math.max(8, width - 8))}`);
+  }
+  // Inline comment the model reads with the decision (§11): `e` to write one.
+  // Plain pickers hide it so the list stays clean.
+  if (!dialog.hideComment) {
+    const hint = dialog.editing ? '▏' : '';
+    rows.push(dialog.comment
+      ? `  ${c.permission('✎')} ${dialog.comment}${hint}`
+      : c.dim(`  ✎ ${dialog.editing ? '' : 'e to explain'}${hint}`));
+  }
+  // Long lists scroll inside the dialog: 9 visible rows around the cursor.
+  const total = dialog.options.length;
+  const top = total <= 9 ? 0 : Math.max(0, Math.min(total - 9, dialog.index - 4));
+  const shown = Math.min(9, total - top);
+  if (top > 0) rows.push(c.dim(`  … ${top} more above`));
+  for (let k = 0; k < shown; k++) {
+    const index = top + k;
+    const option = dialog.options[index];
+    // The cursor row wears inverse video like the composer menu — padded to
+    // the width but never beyond it (renderer invariant 1).
+    const line = `  ${index === dialog.index ? c.brand('›') : ' '} ${index === dialog.index ? c.bold(option.label) : option.label}`;
+    rows.push(index === dialog.index
+      ? c.inverse(`${line}${' '.repeat(Math.max(0, width - 1 - visibleWidth(line)))}`)
+      : line);
+  }
+  if (top + shown < total) rows.push(c.dim(`  … ${total - top - shown} more below`));
+  rows.push(c.dim(dialog.hideComment
+    ? `  ↑↓ choose · 1-9 jump${total > 9 ? ' · list scrolls' : ''} · Enter confirm · Esc cancel`
+    : '  ↑↓ choose · e explain · Enter confirm · Esc deny'));
+  return rows;
+}
+
+
+function historySearchRows(search, width) {
+  return [
+    c.grey(`  ${'─'.repeat(Math.max(8, width - 4))}`),
+    `  ${c.brand('⌕')} ${c.bold('Reverse history')}  ${c.dim(search.query || 'type to search')}`,
+    ...search.matches.slice(0, 5).map((entry, index) => `  ${index === search.index ? c.brand('›') : ' '} ${index === search.index ? c.bold(entry.replace(/\n/g, ' ↵ ')) : entry.replace(/\n/g, ' ↵ ')}`),
+    c.dim('  ↑↓ choose   Enter insert   Esc cancel'),
+  ];
+}
+
+// Exported for layout tests: the pure lower-region rows, each hard-capped below width.
+export function renderRegion({ input = '', cursor = 0, menu = [], menuIndex = -1, status = null, width = 80, hint = '', queued = [], mode = 'default', model = '', version = '' }) {
+  const rows = composerRows({ input, menu, menuIndex, status: status || (hint ? c.dim(`  ${hint}`) : null), queued, width, mode, model, version });
+  return rows.map((row) => visibleWidth(row) > width - 2 ? cleanLine(row, width - 2)[0] : row);
+}
+
+export function createTui({ slashCommands = [], fileProvider = null, meta = {}, onModeCycle = null, onRewind = null } = {}) {
+  // Mouse capture in fullscreen: wheel + click/drag scroll and select inside the
+  // app, with env opt-outs that keep flicker-free rendering. JAITUS_DISABLE_MOUSE=1
+  // disables all capture so the terminal selects natively; JAITUS_DISABLE_MOUSE_CLICKS=1
+  // keeps wheel scrolling but ignores click/drag/hover. Copy-on-select defaults on,
+  // toggle via settings.json { "copyOnSelect": false } or /config.
+  const mouseDisabled = () =>
+    process.env.JAITUS_DISABLE_MOUSE === '1';
+  const mouseClicksDisabled = () =>
+    mouseDisabled() || process.env.JAITUS_DISABLE_MOUSE_CLICKS === '1';
+  const copyOnSelect = () => {
+    try {
+      return loadSettings().copyOnSelect !== false;
+    } catch { /* default on */ }
+    return true;
+  };
+  const scrollSpeed = () => {
+    try {
+      const s = loadSettings().scrollSpeed;
+      if (Number.isFinite(Number(s)) && Number(s) > 0 && Number(s) <= 20) return Number(s);
+    } catch { /* env fallback */ }
+    const raw = Number(process.env.JAITUS_SCROLL_SPEED ?? 1);
+    return Number.isFinite(raw) && raw > 0 && raw <= 20 ? raw : 1;
+  };
+  const state = {
+    input: '', cursor: 0, menu: [], menuIndex: -1, history: [], historyIndex: -1, draft: null,
+    queued: [], busy: false, statusText: null, customStatus: '', dialog: null, panel: null, commandPalette: null, activity: [], transcript: [], liveText: '', liveKind: null, liveUnseen: false,
+    transcriptOffset: 0, newMessages: 0, viewingTranscript: false, search: null, lastSearch: '', historySearch: null, shouldExit: false, exiting: null,
+    lastEscapeAt: null,
+    // In-app text selection: anchor/head are content
+    // coordinates { line, col } into the visible transcript content array.
+    selection: null, selectionMode: null,
+    lastClickAt: 0, lastClickPos: null, clickCount: 0,
+    // Readline editing state (§3.2): undo ring, kill ring, one-slot stash.
+    undoStack: [], redoStack: [], killRing: [], killIndex: -1, lastKill: '', stash: null,
+    // Vim modal editing (§3.2): off unless settings editorMode is 'vim'.
+    // vim: 'insert' | 'normal' | 'visual'; op: pending operator; num: count.
+    vim: 'insert', vimOp: null, vimNum: '', vimAnchor: 0, vimReplace: false,
+    vimPendingG: false, vimPendingObj: null, vimEx: null,
+    vimFind: null, vimFindTyping: false,
+    vimSession: 0, vimInsertActive: false, lastChange: null,
+    yankPos: -1, yankLen: 0, yankIndex: -1,
+    // Paste chips (§3.4): id → full pasted text; the input holds only the chip.
+    pastes: new Map(), pasteSeq: 0,
+    // Image chips (§3.5): blocks queued for the next submit, parallel to pastes.
+    attachments: [],
+    // Focus tracking (§15): true while the terminal reports focus-out (?1004h).
+    unfocused: false, awaySince: 0, awayNew: 0,
+    // Wheel acceleration (§4.2): fast spins cover more ground per notch.
+    lastWheelAt: 0, wheelStreak: 0,
+    // Animated working state (§8): frame tick + cached motion preference.
+    busyTick: 0, busyAnim: true,
+    meta: { product: 'jaitus', version: '', cwd: process.cwd(), model: '', mode: 'default', intent: 'build', ...meta },
+    // Home column: true from fresh open until first submit — the composer
+    // renders narrow and centered, opencode-home style. Set by the session.
+    home: false,
+    onLine: null, onEscape: null, onRewind: null,
+  };
+  const stdin = process.stdin;
+  let active = false; let onKeypress = null; let onResize = null;
+  let keyFilter = null; let onRawData = null; let mouseFlushTimer = null; let busyTimer = null;
+  // The widest visible row we will ever emit — two columns of slack against wrap.
+  const width = () => Math.max(28, (columns() || 80) - 2);
+  const height = () => Math.max(12, process.stdout.rows || 24);
+
+  // The browser preview's command centre is responsive in the same way: the
+  // session rail survives on ordinary terminals, the telemetry rail joins when
+  // there is room, and only genuinely small terminals collapse to one column.
+  function columnMetrics(w = width()) {
+    if (w < 96) return { left: 0, right: 0, center: w, divider: 0 };
+    const left = 30;
+    const right = w < 140 ? 0 : 30;
+    const divider = 1;
+    const dividerCount = (left ? 1 : 0) + (right ? 1 : 0);
+    return { left, right, divider, center: Math.max(52, w - left - right - dividerCount) };
+  }
+
+  function contentWidth(w = width()) { return columnMetrics(w).center; }
+
+  function padFrame(text, target, align = 'left') {
+    const value = String(text ?? '');
+    const clipped = visibleWidth(value) > target ? cleanLine(value, Math.max(1, target - 1))[0] : value;
+    const gap = Math.max(0, target - visibleWidth(clipped));
+    return align === 'right' ? `${' '.repeat(gap)}${clipped}` : `${clipped}${' '.repeat(gap)}`;
+  }
+
+  function frameRow(left, center, right, metrics) {
+    if (!metrics.left && !metrics.right) return center;
+    const leftPart = metrics.left ? `${padFrame(left, metrics.left)}${c.grey('│')}` : '';
+    const rightPart = metrics.right ? `${c.grey('│')}${padFrame(right, metrics.right, 'left')}` : '';
+    const centerWidth = metrics.center;
+    return `${leftPart}${padFrame(center, centerWidth)}${rightPart}`;
+  }
+
+  // Transcript entries carry their message kind so each renders in its own
+  // quiet background (user / assistant / tool), per §9 — not opaque bubbles,
+  // just enough fill to tell voices apart while scrolling fast.
+  // Startup brand rows are pinned: trimming drops everything after them, so
+  // the logo stays scrollable-back-to for the whole session.
+  const PINNED_ROWS = 12;
+  function addTranscript(text, kind = 'other') {
+    for (const row of cleanLine(text, contentWidth() - 2)) state.transcript.push({ text: row, kind });
+    if (state.transcript.length > 2400) state.transcript.splice(PINNED_ROWS, state.transcript.length - 2400);
+  }
+  function commitLive() {
+    if (!state.liveText) return;
+    addTranscript(state.liveText, state.liveKind || 'assistant');
+    state.liveText = ''; state.liveUnseen = false; state.liveKind = null;
+  }
+  function updateMenu() {
+    if (state.dialog) return;
+    state.menu = menuItemsFor(state.input, slashCommands, fileProvider);
+    // `!` shell history (§3.8): complete whole past shell lines.
+    if (state.input.startsWith('!')) {
+      const frag = state.input.slice(1).toLowerCase();
+      const seen = new Set();
+      for (const h of [...state.history].reverse()) {
+        if (state.menu.length >= 8) break;
+        if (!h.startsWith('!') || seen.has(h)) continue;
+        seen.add(h);
+        if (h.slice(1).toLowerCase().startsWith(frag)) state.menu.push({ kind: 'history', value: h, label: h, hint: 'history' });
+      }
+    }
+    // `:xx` emoji shortcodes (§3.6), live-filtered.
+    const em = /:([A-Za-z0-9_+-]{2,})$/.exec(state.input);
+    if (em) {
+      const frag = em[1].toLowerCase();
+      for (const [name, ch] of Object.entries(EMOJI)) {
+        if (state.menu.length >= 8) break;
+        if (name.startsWith(frag)) state.menu.push({ kind: 'emoji', value: ch, label: `:${name}: → ${ch}`, hint: 'emoji' });
+      }
+    }
+    state.menuIndex = state.menu.length ? 0 : -1;
+  }
+
+  function headerRows(w) {
+    const project = path.basename(state.meta.cwd || '') || state.meta.cwd || '.';
+    const model = state.meta.model || 'auto';
+    const context = state.meta.ctx || 'ready';
+    const mode = modeLabel(state.meta.mode);
+    const intent = state.meta.intent && state.meta.intent !== 'build' ? `  ${c.accent(state.meta.intent)}` : '';
+    const left = `  ${badge()} ${c.bold('jaitus')} ${c.dim(project)}`;
+    const session = state.meta.session ? String(state.meta.session).slice(0, 8) : 'active';
+    const middle = `${c.accent(glyph('●', '*'))} ${c.dim('SESSION')} ${c.dim(session)}`;
+    const right = `${c.dim(model)}  ${state.meta.mode === 'bypassPermissions' ? c.red(mode) : c.accent(mode)}${intent}  ${c.dim(context)}`;
+    const gapLeft = Math.max(1, Math.floor((w - visibleWidth(left) - visibleWidth(middle) - visibleWidth(right)) / 2));
+    const gapRight = Math.max(1, w - visibleWidth(left) - visibleWidth(middle) - visibleWidth(right) - gapLeft);
+    return [
+      `${left}${' '.repeat(gapLeft)}${middle}${' '.repeat(gapRight)}${right}`,
+      c.grey(`  ${boxChars().h.repeat(Math.max(8, w - 4))}`),
+    ];
+  }
+
+  const PALETTE_COMMANDS = [
+    ['/research ', 'Research with sources', 'web search + cited synthesis'],
+    ['/architect ', 'Architecture mode', 'compare designs without edits'],
+    ['/review ', 'Review the diff', 'bugs, security, maintainability'],
+    ['/tasks ', 'Task timeline', 'running jobs and checkpoints'],
+    ['/compact ', 'Compact context', 'free room without losing decisions'],
+    ['/model ', 'Switch model', 'change the active reasoning engine'],
+  ];
+
+  function paletteMatches() {
+    const query = String(state.commandPalette?.query || '').toLowerCase();
+    return PALETTE_COMMANDS.filter(([value, label, hint]) => `${value} ${label} ${hint}`.toLowerCase().includes(query));
+  }
+
+  function paletteRows(space, w) {
+    const palette = state.commandPalette || { query: '', index: 0 };
+    const matches = paletteMatches();
+    const rows = [
+      c.dim(`  ${glyph('⌘', 'Ctrl')}K  command palette   ${c.dim('Esc close')}`),
+      `  ${c.brand('/')} ${palette.query || c.dim('Search commands')}`,
+      c.grey(`  ${boxChars().h.repeat(Math.max(8, w - 4))}`),
+    ];
+    for (const [index, [, label, hint]] of matches.entries()) {
+      const selected = index === palette.index;
+      const mark = selected ? c.brand(glyph('›', '>')) : ' ';
+      const line = `  ${mark} ${selected ? c.bold(label) : label}  ${c.dim(hint)}`;
+      rows.push(selected ? c.inverse(`${line}${' '.repeat(Math.max(0, w - 1 - visibleWidth(line)))}`) : line);
+    }
+    rows.push('', c.dim('  ↑↓ navigate   Enter insert   Esc close'));
+    return rows.slice(0, Math.max(1, space));
+  }
+
+  function leftRailRows(total) {
+    const project = path.basename(state.meta.cwd || '') || '.';
+    const mode = state.meta.intent || 'build';
+    const top = [
+      `  ${c.brand('+')} ${c.bold('New session')}  ${c.dim('⌘ N')}`,
+      '',
+      `  ${c.bold('SESSIONS')}   ${c.dim('FILES')}   ${c.dim('COMMANDS')}`,
+      c.dim('  RECENT SESSIONS'),
+      `  ${c.accent('●')} ${c.bold(project.slice(0, 17))}`,
+      `    ${c.dim('current · ' + mode + ' mode')}`,
+      `  ${c.grey('●')} ${c.dim('Pricing guardrails')}`,
+      `  ${c.grey('●')} ${c.dim('Provider fallback map')}`,
+      '',
+      c.dim('  CAPABILITIES'),
+      `  ${c.accent(glyph('◌', 'o'))} Research       ${c.dim('/research')}`,
+      `  ${c.accent(glyph('◇', '*'))} Review         ${c.dim('/review')}`,
+      `  ${c.accent(glyph('☷', '#'))} Tasks          ${c.dim('/tasks')}`,
+      `  ${c.accent(glyph('⚡', '*'))} MCP tools      ${c.dim('/mcp')}`,
+    ];
+    const footer = [
+      '',
+      c.dim('  SETTINGS'),
+      `  ${c.dim(glyph('⚙', '*'))} Settings       ${c.dim('⌘ ,')}`,
+      `  ${c.dim(glyph('◉', 'o'))} Permissions     ${state.meta.mode === 'bypassPermissions' ? c.red('BYPASS') : c.dim('active')}`,
+    ];
+    const body = Array(Math.max(0, total - top.length - footer.length)).fill('');
+    return [...top, ...body, ...footer].slice(0, total);
+  }
+
+  function inspectorRows(total) {
+    const activity = state.activity.slice(-4).reverse();
+    const busy = state.busy ? c.brand('LIVE') : c.accent('READY');
+    const rows = [
+      c.dim('  SESSION INSPECTOR'),
+      `  ${c.bold('Live telemetry')}                         ${c.dim('☷')}`,
+      '',
+      `  ${c.dim('CONTEXT')}  ${c.bold(state.meta.ctx || 'ready')}`,
+      `  ${c.dim('MODE')}     ${c.accent(state.meta.intent || 'build')}  ${busy}`,
+      '',
+      c.dim('  ACTIVE TOOLS'),
+    ];
+    if (!activity.length) rows.push(`  ${c.dim('· no tools yet')}`);
+    for (const item of activity) {
+      const mark = item.status === 'ok' ? c.accent('●') : item.status === 'failed' ? c.red('●') : c.brand('●');
+      rows.push(`  ${mark} ${String(item.name || item.label).slice(0, 15)}  ${c.dim(item.status || 'ready')}`);
+    }
+    rows.push('', c.dim('  MODE CONTROL'), `  ${state.meta.intent === 'build' ? c.brand('Build') : c.dim('Build')}  ${state.meta.intent === 'ask' ? c.brand('Ask') : c.dim('Ask')}  ${state.meta.intent === 'architect' ? c.brand('Architect') : c.dim('Architect')}`);
+    rows.push('', c.dim('  VISIBLE APPROVALS'), `  ${state.meta.mode === 'bypassPermissions' ? c.red('● bypass active') : c.accent('● approval boundary active')}`);
+    return rows.slice(0, Math.max(1, total));
+  }
+
+  function sessionIntroRows(w) {
+    const project = path.basename(state.meta.cwd || '') || '.';
+    const intent = state.meta.intent || 'build';
+    return [
+      `  ${c.accent(glyph('●', '*'))} ${c.dim('ACTIVE SESSION')}`,
+      `  ${c.bold(project)}  ${c.dim('Trace the flow, find the risk, make the next move visible.')}`,
+      '',
+      c.dim(`  Session restored · Jaitus workspace · ${state.activity.length || 0} tools ready`),
+      c.dim(`  intent ${intent} · ${state.meta.model || 'auto'}`),
+    ].map((line) => padFrame(line, w));
+  }
+
+  /** Terminal-correct bypass key for one-off native selection. */
+  function nativeSelectKey() {
+    if (process.platform === 'darwin') {
+      if (process.env.TERM_PROGRAM === 'Apple_Terminal') return 'Fn';
+      if (process.env.TERM_PROGRAM === 'iTerm.app') return 'Option';
+      if (process.env.TERM_PROGRAM === 'vscode') return 'Shift';
+      return 'Option';
+    }
+    if (process.env.TERM_PROGRAM === 'vscode') return 'Shift';
+    return 'Shift';
+  }
+
+  function transcriptContent(w) {
+    return [...state.transcript.map((e) => e.text), ...(state.liveText ? cleanLine(state.liveText, w - 2) : [])];
+  }
+  /** Message kind for a content index (live tail counts as assistant). */
+  function kindAt(idx) {
+    if (idx < state.transcript.length) return state.transcript[idx]?.kind || 'other';
+    return state.liveKind || 'assistant';
+  }
+  /** Quiet full-width background per message kind (§9). Skipped without color,
+   * on empty rows, and for kinds without a token — never louder than dim text. */
+  function paintRow(line, kind, w) {
+    const token = kind === 'error' ? 'errorBg' : kind === 'user' ? 'userBg' : kind === 'assistant' ? 'assistantBg' : kind === 'tool' ? 'toolBg' : kind === 'memory' ? 'memoryBg' : null;
+    if (!token || !String(line).trim()) return line;
+    if (colorLevel() === 0) return line;
+    let codes = null;
+    try { codes = themeMap()[token]; } catch { /* plain */ }
+    if (!codes) return line;
+    const target = Math.max(0, w - 1);
+    const pad = ' '.repeat(Math.max(0, target - visibleWidth(line)));
+    return `\x1b[${codes}m${line}${pad}\x1b[0m`;
+  }
+
+  function inSelection(lineIndex, w) {
+    const sel = state.selection;
+    if (!sel) return null;
+    const a = sel.anchor.line <= sel.head.line ? sel.anchor : sel.head;
+    const b = sel.anchor.line <= sel.head.line ? sel.head : sel.anchor;
+    if (lineIndex < a.line || lineIndex > b.line) return null;
+    const startCol = lineIndex === a.line ? a.col : 0;
+    const endCol = lineIndex === b.line ? b.col : Number.MAX_SAFE_INTEGER;
+    return { startCol, endCol };
+  }
+
+  function applySelection(line, lineIndex) {
+    const range = inSelection(lineIndex);
+    if (!range) return line;
+    // ANSI-aware slice by visible columns; selected span renders inverse.
+    const plain = String(line ?? '').replace(/\x1b\[[0-9;]*m/g, '');
+    const chars = [...plain];
+    const s = Math.max(0, Math.min(chars.length, range.startCol));
+    const e = Math.max(s, Math.min(chars.length, range.endCol));
+    if (s >= e) return line;
+    return chars.slice(0, s).join('') + c.inverse(chars.slice(s, e).join('')) + chars.slice(e).join('');
+  }
+
+  function transcriptRows(space, w) {
+    const content = transcriptContent(w);
+    if (!content.length && !state.viewingTranscript) return [c.dim('  Start with a task, question, / command, ! shell command, or @ file.')];
+    const end = Math.max(0, content.length - state.transcriptOffset);
+    const start = Math.max(0, end - space);
+    const query = state.search?.query || state.lastSearch;
+    // Fence state is positional: scan from the top so a block opened above the
+    // viewport still highlights inside it.
+    let fence = null;
+    for (let i = 0; i < start; i++) fence = fenceOf(content[i], fence);
+    return content.slice(start, end).map((line, i) => {
+      const idx = start + i;
+      const kind = kindAt(idx);
+      const marked = query && line.toLowerCase().includes(query.toLowerCase()) ? `${c.brand('›')} ${line}` : line;
+      // Highlight code, then selection (re-slices plain text), background last.
+      const code = highlightLine(marked, fence, kind);
+      fence = fenceOf(line, fence);
+      const selected = state.selection ? applySelection(code, idx) : code;
+      return paintRow(selected, kind, w);
+    });
+  }
+
+  function selectedText() {
+    const sel = state.selection;
+    if (!sel) return '';
+    const w = contentWidth();
+    const content = transcriptContent(w).map((l) => String(l ?? '').replace(/\x1b\[[0-9;]*m/g, ''));
+    const a = sel.anchor.line <= sel.head.line ? sel.anchor : sel.head;
+    const b = sel.anchor.line <= sel.head.line ? sel.head : sel.anchor;
+    const parts = [];
+    for (let i = a.line; i <= b.line && i < content.length; i++) {
+      if (i < 0) continue;
+      const chars = [...(content[i] || '')];
+      const s = i === a.line ? Math.max(0, a.col) : 0;
+      const e = i === b.line ? Math.min(chars.length, b.col) : chars.length;
+      parts.push(chars.slice(s, Math.max(s, e)).join(''));
+    }
+    return parts.join('\n').replace(/[ \t]+\n/g, '\n').trim();
+  }
+
+  /** Clipboard write: tmux, native tools, then OSC 52; returns the path used or ''. */
+  function copyText(text) {
+    if (!text) return '';
+    // Inside tmux also feed the paste buffer so tmux copy-mode sees it.
+    if (process.env.TMUX) {
+      try {
+        const child = spawnSync('tmux', ['load-buffer', '-'], { input: text });
+        if (child.status === 0) return 'tmux';
+      } catch { /* fall through to native tools */ }
+    }
+    const candidates = process.platform === 'win32'
+      ? [{ cmd: 'clip', args: [] }]
+      : process.platform === 'darwin'
+        ? [{ cmd: 'pbcopy', args: [] }]
+        : [{ cmd: 'wl-copy', args: [] }, { cmd: 'xclip', args: ['-selection', 'clipboard'] }, { cmd: 'xsel', args: ['--clipboard', '--input'] }];
+    for (const { cmd, args } of candidates) {
+      try {
+        const child = spawnSync(cmd, args, { input: text, stdio: ['pipe', 'ignore', 'ignore'] });
+        if (child.status === 0) {
+          // X11: also feed PRIMARY so middle-click paste works.
+          if (cmd === 'xclip') {
+            try { spawnSync('xclip', ['-selection', 'primary'], { input: text, stdio: ['pipe', 'ignore', 'ignore'] }); } catch { /* clipboard already set */ }
+          }
+          if (cmd === 'xsel') {
+            try { spawnSync('xsel', ['--primary', '--input'], { input: text, stdio: ['pipe', 'ignore', 'ignore'] }); } catch { /* clipboard already set */ }
+          }
+          // Windows/WSL without a console tool: PowerShell Set-Clipboard.
+          return cmd;
+        }
+      } catch { /* next candidate */ }
+    }
+    if (process.platform === 'win32') {
+      try {
+        const ps = spawnSync('powershell.exe', ['-NoProfile', '-Command', '$i=[Console]::In.ReadToEnd(); Set-Clipboard -Value $i'], { input: text });
+        if (ps.status === 0) return 'clipboard';
+      } catch { /* fall to OSC 52 */ }
+    }
+    // Over SSH / anywhere else: OSC 52. Some terminals block it until
+    // "applications may access clipboard" is enabled (iTerm2: /terminal-setup).
+    try {
+      const b64 = Buffer.from(text, 'utf8').toString('base64');
+      rawWrite(`\x1b]52;c;${b64}\x07`);
+      return 'OSC 52';
+    } catch { return ''; }
+  }
+
+  function toastCopied(pathUsed, chars) {
+    // Copy confirmations read as a highlighted badge, not footnote dim text.
+    state.statusText = chars
+      ? `${c.inverse(` Copied ${chars} chars via ${pathUsed} `)}${c.dim(`  ${nativeSelectKey()}+drag for native select`)}`
+      : c.dim(`  Clipboard unavailable — [ writes the conversation to scrollback, v opens it in an editor`);
+    draw();
+    setTimeout(() => { if (state.statusText?.includes('Copied') || state.statusText?.includes('Clipboard unavailable')) { state.statusText = null; draw(); } }, 2200);
+  }
+
+  /** Focus tracking (§15): bell only ever fires while the terminal is away. */
+  function onFocus(focused) {
+    if (focused && state.unfocused) {
+      state.unfocused = false;
+      const awayMs = Date.now() - state.awaySince;
+      if (awayMs > 30000 && state.awayNew > 0) {
+        state.statusText = c.dim(`  Welcome back — ${state.awayNew} new line${state.awayNew === 1 ? '' : 's'} while away`);
+        draw();
+        setTimeout(() => { if (state.statusText?.includes('Welcome back')) { state.statusText = null; draw(); } }, 2600);
+      }
+      state.awayNew = 0;
+    } else if (!focused && !state.unfocused) {
+      state.unfocused = true; state.awaySince = Date.now(); state.awayNew = 0;
+    }
+  }
+  function bellIfAway() { if (state.unfocused) { try { rawWrite('\x07'); } catch { /* headless */ } } }
+
+  /** Image chips (§3.5): clipboard pixels become a positional `[Image #N]`. */
+  function clipboardImageBytes() {
+    try {
+      if (process.platform === 'win32') {
+        const ps = spawnSync('powershell.exe', ['-NoProfile', '-Command',
+          '$i=Get-Clipboard -Format Image; if(!$i){exit 1}; $m=New-Object IO.MemoryStream; $i.Save($m,[Drawing.Imaging.ImageFormat]::Png); [Convert]::ToBase64String($m.ToArray())'],
+          { encoding: 'utf8', timeout: 8000 });
+        if (ps.status === 0 && ps.stdout.trim()) return Buffer.from(ps.stdout.trim(), 'base64');
+      } else if (process.platform === 'darwin') {
+        const r = spawnSync('pngpaste', ['-'], { timeout: 8000 });
+        if (r.status === 0 && r.stdout?.length) return Buffer.from(r.stdout);
+      } else {
+        for (const [cmd, args] of [['wl-paste', ['--type', 'image/png']], ['xclip', ['-selection', 'clipboard', '-t', 'image/png', '-o']]]) {
+          const r = spawnSync(cmd, args, { timeout: 8000 });
+          if (r.status === 0 && r.stdout?.length) return Buffer.from(r.stdout);
+        }
+      }
+    } catch { /* no image available */ }
+    return null;
+  }
+  async function pasteImageFromClipboard() {
+    const bytes = clipboardImageBytes();
+    if (!bytes?.length) {
+      state.statusText = c.dim('  No image in the clipboard');
+      draw(); setTimeout(() => { if (state.statusText?.includes('No image')) { state.statusText = null; draw(); } }, 1500);
+      return;
+    }
+    try {
+      const file = path.join(os.tmpdir(), `jaitus-clip-${Date.now()}.png`);
+      fs.writeFileSync(file, bytes);
+      const { imageBlock } = await import('./agent/tools.js');
+      const block = await imageBlock(file);
+      if (!block) throw new Error('unreadable');
+      const chip = `[Image #${state.attachments.length + 1}]`;
+      state.attachments.push({ chip, block });
+      insert(`${chip} `);
+    } catch {
+      state.statusText = c.dim('  Clipboard image unreadable (png/jpg/gif/webp, max ~3 MB)');
+      draw(); setTimeout(() => { state.statusText = null; draw(); }, 1800);
+    }
+  }
+
+  function isWordChar(ch) {
+    // iTerm2-style boundaries so a file path selects as one unit; URL scheme included.
+    return /[A-Za-z0-9_./\-:@+%]/.test(ch);
+  }
+
+  function wordAt(line, col) {
+    const chars = [...line];
+    let s = Math.max(0, Math.min(col, chars.length));
+    let e = s;
+    if (s < chars.length && !isWordChar(chars[s]) && /\s/.test(chars[s] || '')) {
+      while (s > 0 && /\s/.test(chars[s - 1])) s--;
+      while (e < chars.length && /\s/.test(chars[e])) e++;
+      return { s, e };
+    }
+    while (s > 0 && isWordChar(chars[s - 1])) s--;
+    while (e < chars.length && isWordChar(chars[e])) e++;
+    // Double-clicking a URL selects the whole URL including the scheme.
+    const joined = chars.join('');
+    const urlRe = /https?:\/\/[^\s]+/g;
+    let m;
+    while ((m = urlRe.exec(joined))) {
+      if (s >= m.index && e <= m.index + m[0].length) return { s: m.index, e: m.index + m[0].length };
+    }
+    return { s, e };
+  }
+
+  /** Map a screen row (1-based) to a transcript content index. */
+  function screenRowToContent(row1, w, h) {
+    const cw = contentWidth(w);
+    const bottom = bottomRows(cw);
+    const browsing = !state.panel && !state.viewingTranscript && state.transcriptOffset > 0;
+    const headLen = 2;
+    const space = Math.max(1, h - headLen - bottom.length - (browsing ? 1 : 0));
+    const content = transcriptContent(cw);
+    const end = Math.max(0, content.length - state.transcriptOffset);
+    const start = Math.max(0, end - space);
+    const bodyFirst = headLen + (browsing ? 1 : 0) + 1; // 1-based first body row
+    const idx = start + (row1 - bodyFirst);
+    if (idx < start || idx >= end) return -1;
+    return idx;
+  }
+
+  function stickyPromptRow(w) {
+    const content = transcriptContent(w);
+    const end = Math.max(0, content.length - state.transcriptOffset);
+    let prompt = '';
+    for (let i = Math.min(end, content.length) - 1; i >= 0; i--) {
+      const m = /^\s*›\s*(.*)$/.exec(String(content[i] ?? '').replace(/\x1b\[[0-9;]*m/g, ''));
+      if (m) { prompt = m[1].trim(); break; }
+    }
+    const fresh = state.newMessages ? `${state.newMessages} new · ` : '';
+    if (!prompt) return c.dim(`  ↑ Browsing earlier messages · ${fresh}Jump to bottom: Ctrl+End / click here`);
+    const max = Math.max(20, w - fresh.length - 34);
+    const short = prompt.length > max ? `${prompt.slice(0, max - 1)}…` : prompt;
+    return c.dim(`  ↑ ${short} · ${fresh}Jump to bottom: Ctrl+End / click here`);
+  }
+
+  function panelRows(space, w) {
+    const lines = state.panel?.lines || [];
+    const end = Math.max(0, lines.length - (state.panel?.offset || 0));
+    return lines.slice(Math.max(0, end - space), end).flatMap((line) => cleanLine(line, w - 2));
+  }
+
+  function vimTag() {
+    if (vimMode() !== 'vim' || state.viewingTranscript) return '';
+    if (state.vim === 'normal') return c.yellow(' -- NORMAL --');
+    if (state.vim === 'visual') return c.yellow(' -- VISUAL --');
+    return c.dim(' -- INSERT --');
+  }
+  // Braille spinner with a shimmer sweep across the label (§8.1): the base
+  // coral and its lighter twin trade places as the tick advances. Static ◆
+  // when animations are off (§8.3).
+  const SPIN_FRAMES = process.env.JAITUS_ASCII
+    ? ['|', '/', '-', '\\']
+    : ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  const BUSY_TIPS = [
+    'Esc interrupts',
+    'type + Enter queues',
+    '/diff reviews the changes',
+    'Ctrl+O opens the transcript',
+    'Shift+Tab changes modes',
+    '/research digs with sources',
+    '/test --fix repairs failures',
+    '/commit writes the message',
+    '/explain reads the code for you',
+    '/code-review --fix ships cleaner',
+    '/rewind un-breaks the timeline',
+    '/btw asks off the record',
+    '/branch tries the other way',
+  ];
+  function shimmer(text, tick) {
+    const chars = [...text];
+    const half = Math.max(1, Math.ceil(chars.length / 2));
+    return chars.map((ch, i) => ((i + tick) % chars.length < half ? c.brand(ch) : c.shimmer(ch))).join('');
+  }
+  function statusLine(w = width()) {
+    if (state.statusText !== null) return state.statusText;
+    if (state.busy) {
+      if (!state.busyAnim) return `${c.brand('  ◆ Working…')}  ${c.dim('Esc interrupt · type and Enter to queue')}${vimTag()}`;
+      const frame = SPIN_FRAMES[state.busyTick % SPIN_FRAMES.length];
+      const tip = BUSY_TIPS[Math.floor(state.busyTick / 30) % BUSY_TIPS.length];
+      return `${c.brand(`  ${frame} `)}${shimmer('Working…', state.busyTick)}  ${c.dim(`${tip} · type and Enter to queue`)}${vimTag()}`;
+    }
+    // opencode-style prompt footer: model and approval posture lead,
+    // key hints follow.
+    return idleFooter(w);
+  }
+  function idleFooter(w) {
+    // opencode bottom-row shape: directory leads muted on the left, key
+    // hints close on the right (bright key, muted purpose). Model, approval
+    // and version live in the composer meta row instead. Bypass is never
+    // quiet (§11) — its badge replaces the hints.
+    const project = path.basename(state.meta.cwd || '') || state.meta.cwd || '.';
+    const bypass = state.meta.mode === 'bypassPermissions';
+    const left = `  ${c.dim(project)}`;
+    const sep = c.dim(' · ');
+    const hints = `${glyph('⇧↹', 'Shift+Tab')} ${c.dim('modes')}${sep}/ ${c.dim('commands')}${sep}@ ${c.dim('files')}`;
+    const right = bypass ? c.red(c.bold('● BYPASS — no checks')) : hints;
+    if (visibleWidth(left) + visibleWidth(right) + 3 > w) {
+      return `${right}${vimTag()}`;
+    }
+    const pad = Math.max(1, w - visibleWidth(left) - visibleWidth(right));
+    return `${left}${' '.repeat(pad)}${right}${vimTag()}`;
+  }
+
+  /** opencode home: on a brand-new session the composer is a narrow
+   * centered column, not full width. Active only while state.home is set
+   * (fresh open until first submit) and nothing else owns the bottom.
+   * Returns {cw, pad} or null for the session layout. */
+  function homeMetrics(w) {
+    if (!state.home || state.dialog || state.panel || state.viewingTranscript
+      || state.historySearch || state.search || state.busy) return null;
+    const cw = Math.min(w, 90);
+    return { cw, pad: Math.max(0, Math.floor((w - cw) / 2)) };
+  }
+
+  /** The fixed lower block for the current mode — the frame's bottom rows. */
+  function bottomRows(w) {
+    if (state.panel) {
+      return [
+        c.grey(`  ${'─'.repeat(Math.max(8, w - 4))}`),
+        `  ${c.bold(state.panel.title)}`,
+        c.dim('  ↑↓ scroll   PgUp/PgDn page   Ctrl+Home/End ends   Esc close'),
+      ];
+    }
+    if (state.commandPalette) {
+      return [c.dim(`  ${glyph('⌘', 'Ctrl')}K command palette · ${paletteMatches().length} commands · Esc close`)];
+    }
+    if (state.viewingTranscript) {
+      if (state.search) {
+        return [
+          c.grey(`  ${'─'.repeat(Math.max(8, w - 4))}`),
+          `  ${c.brand('/')} ${state.search.query}`,
+          c.dim('  Enter keep search   Esc cancel   ↑↓ navigate'),
+        ];
+      }
+      return [c.grey(`  ${'─'.repeat(Math.max(8, w - 4))}`), c.dim(`  Transcript · / search${state.lastSearch ? ' · n/N match' : ''} · j/k line · s select/y copy · PgUp/PgDn half · g/G ends · {/} prompt · [ scrollback · v editor · Esc return`)];
+    }
+    if (state.historySearch) return historySearchRows(state.historySearch, w);
+    if (state.dialog) return dialogRows(state.dialog, w);
+    const hm = homeMetrics(w);
+    const cw = hm ? hm.cw : w;
+    const cr = composerRows({ input: state.input, menu: state.menu, menuIndex: state.menuIndex, status: statusLine(cw), queued: state.queued, width: cw, mode: state.meta.mode, model: state.meta.model, version: state.meta.version });
+    // Scripted status line (§13) renders verbatim just above the hint footer.
+    if (state.customStatus) cr.splice(cr.length - 1, 0, state.customStatus);
+    if (!hm) return cr;
+    // Home column: every composer row rides centered, footer included.
+    return cr.map((r) => ' '.repeat(hm.pad) + r);
+  }
+
+  /**
+   * THE single source of truth. Builds every row of the frame and the cursor cell.
+   * The cursor is an index inside the same `rows` array that gets painted, so the
+   * two can never disagree.
+   */
+  function layout() {
+    const w = width(); const h = height();
+    const metrics = columnMetrics(w);
+    const cw = metrics.center;
+    const bottom = bottomRows(cw);
+    const browsing = !state.panel && !state.viewingTranscript && state.transcriptOffset > 0;
+    // Sticky section header (§4.2): the most recent prompt scrolled out of view,
+    // clickable to jump back to the bottom. Falls back to the generic banner
+    // when no prompt is above the viewport.
+    const browsingRow = browsing ? stickyPromptRow(cw) : null;
+
+    const head = headerRows(w);
+    const space = Math.max(1, h - head.length - bottom.length - (browsingRow ? 1 : 0));
+    const intro = metrics.left && !state.panel && !state.commandPalette && !state.viewingTranscript
+      ? sessionIntroRows(cw)
+      : [];
+    let body = state.panel
+      ? panelRows(space, cw)
+      : state.commandPalette
+        ? paletteRows(space, cw)
+        : [...intro, ...transcriptRows(Math.max(1, space - intro.length), cw)];
+    // Self-healing viewport: an empty body while content exists is never a
+    // valid view (it used to happen scrolling to the exact top). Snap back to
+    // live rather than show a black hole.
+    if (!state.panel && !state.commandPalette && !body.length && transcriptContent(cw).length > 0) {
+      state.transcriptOffset = 0; state.newMessages = 0;
+      body = transcriptRows(space, cw);
+    }
+
+    const middle = [
+      ...(browsingRow ? [browsingRow] : []),
+      ...body,
+      ...Array(Math.max(0, space - body.length - (browsingRow ? 1 : 0))).fill(''),
+      ...bottom,
+    ].slice(0, h - head.length);
+    const railLeft = leftRailRows(middle.length);
+    const railRight = inspectorRows(middle.length);
+    const rows = [
+      ...head,
+      ...middle.map((line, index) => frameRow(railLeft[index] || '', line, railRight[index] || '', metrics)),
+    ].slice(0, h);
+
+    // Cursor placement — derived from row indices inside this same array.
+    let cursor = null;
+    if (state.panel) {
+      cursor = null; // hidden while a modal owns the screen
+    } else if (state.commandPalette) {
+      cursor = { row: Math.min(h, head.length + 2), col: Math.min(w, metrics.left + (metrics.left ? 1 : 0) + 5 + String(state.commandPalette.query || '').length) };
+    } else if (state.dialog) {
+      // Visible only while writing the decision comment.
+      if (state.dialog.editing) {
+        const off = dialogCommentOffset(state.dialog, cw);
+        if (off >= 0) cursor = { row: rows.length - bottom.length + off + 1, col: Math.min(w, metrics.left + (metrics.left ? 1 : 0) + 5 + [...(state.dialog.comment || '')].length) };
+        else cursor = null;
+      } else cursor = null;
+    } else if (state.historySearch) {
+      // Query lives on the second bottom row, after `  ⌕ Reverse history  `.
+      cursor = { row: rows.length - bottom.length + 2, col: Math.min(w, 22 + state.historySearch.query.length) };
+    } else if (state.viewingTranscript && state.search) {
+      // Query lives on the second bottom row, after `  / `.
+      cursor = { row: rows.length - bottom.length + 2, col: Math.min(w, 5 + state.search.query.length) };
+    } else if (!state.viewingTranscript) {
+      const hm = homeMetrics(cw);
+      const composerWidth = hm ? hm.cw : cw;
+      const pad = hm ? hm.pad : 0;
+      const promptCount = promptRows(state.input, composerWidth).length;
+      // 0-based: the three rows after the prompt are meta, status and the box edge.
+      const firstPrompt = rows.length - 3 - promptCount;
+      const cell = promptCursor(state.input, state.cursor, composerWidth);
+      cursor = {
+        row: Math.min(h, Math.max(1, firstPrompt + cell.row + 1)),
+        col: Math.min(w, Math.max(1, cell.column + pad + (metrics.left ? metrics.left + 1 : 0))),
+      };
+    }
+    return { rows, cursor, w, h };
+  }
+
+  /** Hard cap any row below the terminal width (invariant 1), ANSI-aware. */
+  function safeRow(line, w) {
+    return visibleWidth(line) > w ? cleanLine(line, w - 1)[0] : line;
+  }
+
+  function draw() {
+    if (!active) return;
+    const { rows, cursor, w, h } = layout();
+    // Synchronized output (§8.4): the frame lands atomically, no line-by-line
+    // flash. Terminals without support ignore the wrapper. (Every frame here
+    // is already a full repaint, so ConPTY hosts stay correct.)
+    const parts = ['\x1b[?2026h\x1b[?7l\x1b[?25l'];
+    for (let i = 0; i < h; i++) {
+      parts.push(`\x1b[${i + 1};1H\x1b[0K${safeRow(rows[i] ?? '', w)}`);
+    }
+    if (cursor) parts.push(`\x1b[${cursor.row};${cursor.col}H\x1b[?25h`);
+    parts.push('\x1b[?2026l');
+    rawWrite(parts.join(''));
+  }
+
+  function noteNewMessage() { if (state.transcriptOffset > 0) state.newMessages += 1; }
+  function print(text, kind = 'other') {
+    if (!active) { rawWrite(`${text}\n`); return; }
+    commitLive(); noteNewMessage(); addTranscript(text, kind);
+    if (state.unfocused) state.awayNew += cleanLine(text, width() - 2).length;
+    draw();
+  }
+  function printStream(text) {
+    if (!active) { rawWrite(String(text)); return; }
+    if (state.transcriptOffset > 0 && !state.liveUnseen) { state.newMessages += 1; state.liveUnseen = true; }
+    if (state.unfocused) state.awayNew += 1;
+    if (!state.liveText) state.liveKind = 'assistant';
+    state.liveText += String(text); draw();
+  }
+  function flushStream() { commitLive(); draw(); }
+  function insert(value) {
+    snapshotUndo('type');
+    // `.` repeatable change: coalesce one insert run into a single change.
+    if (state.vimInsertActive && state.lastChange?.t === 'i' && state.lastChange.session === state.vimSession) {
+      state.lastChange.text += value;
+    } else {
+      state.lastChange = { t: 'i', text: value, session: state.vimInsertActive ? state.vimSession : -1 };
+    }
+    state.input = state.input.slice(0, state.cursor) + value + state.input.slice(state.cursor); state.cursor += value.length; updateMenu(); draw();
+  }
+  /** Begin an insert run (every i/a/o/... entry point calls this). */
+  function beginInsert() { state.vimSession += 1; state.vimInsertActive = true; state.vim = 'insert'; }
+  function endInsert() { state.vimInsertActive = false; }
+  /** Push the pre-edit buffer for Ctrl+_ undo (cap 50, coalesce typing runs). */
+  function snapshotUndo(kind = 'edit') {
+    const top = state.undoStack[state.undoStack.length - 1];
+    if (top && top.input === state.input && top.cursor === state.cursor) return;
+    // A typing run is one undo step: skip if the top is a recent typing snapshot.
+    if (kind === 'type' && top?.kind === 'type' && Date.now() - (top.at || 0) < 1500) return;
+    state.undoStack.push({ input: state.input, cursor: state.cursor, kind, at: Date.now() });
+    if (state.undoStack.length > 50) state.undoStack.shift();
+  }
+  function recallUndo() {
+    const prev = state.undoStack.pop();
+    if (!prev) return;
+    state.redoStack.push({ input: state.input, cursor: state.cursor });
+    state.input = prev.input; state.cursor = Math.min(prev.cursor, prev.input.length);
+    updateMenu(); draw();
+  }
+  function recallRedo() {
+    const next = state.redoStack.pop();
+    if (!next) return;
+    state.undoStack.push({ input: state.input, cursor: state.cursor, kind: 'edit', at: Date.now() });
+    state.input = next.input; state.cursor = Math.min(next.cursor, next.input.length);
+    updateMenu(); draw();
+  }
+  function vimMode() {
+    try {
+      const m = process.env.JAITUS_EDITOR || loadSettings().editorMode;
+      return m === 'vim' ? 'vim' : 'emacs';
+    } catch { return 'emacs'; }
+  }
+  /** Kill-ring (§3.2): every Ctrl+K/U/W deletion is paste-back-able via Ctrl+Y. */
+  function kill(text, dir) {
+    if (!text) return;
+    state.lastKill = text;
+    if (dir === 'back') state.killRing.unshift(text);
+    else state.killRing.push(text);
+    if (state.killRing.length > 20) state.killRing.pop();
+    state.killIndex = -1;
+  }
+  function yank() {
+    if (!state.killRing.length) return;
+    state.killIndex = (state.killIndex + 1) % state.killRing.length;
+    insert(state.killRing[state.killIndex]);
+  }
+  // Word = run of letters/digits; _ . / and friends are boundaries (§3.2).
+  const isWordCharEdit = (ch) => /[A-Za-z0-9]/.test(ch || '');
+  /** Visual rows of the draft with raw-input offsets (wrapping-aware). */
+  function visualRows(usable = Math.max(12, width() - PROMPT_USABLE_SLACK)) {
+    const rows = [];
+    let raw = 0;
+    for (const logical of state.input.split('\n')) {
+      const chars = [...logical];
+      if (!chars.length) { rows.push({ start: raw, text: '' }); }
+      else {
+        let vRow = ''; let vWidth = 0; let rowStart = raw;
+        for (const ch of chars) {
+          const cw = visibleWidth(ch);
+          if (vWidth + cw > usable && vRow) { rows.push({ start: rowStart, text: vRow }); rowStart += [...vRow].length; vRow = ''; vWidth = 0; }
+          vRow += ch; vWidth += cw;
+        }
+        rows.push({ start: rowStart, text: vRow });
+      }
+      raw += chars.length + 1; // +1 for the \n itself
+    }
+    return rows;
+  }
+  function lineStartAt(pos) {
+    const i = state.input.lastIndexOf('\n', Math.max(0, pos - 1));
+    return i === -1 ? 0 : i + 1;
+  }
+  function lineEndAt(pos) {
+    const i = state.input.indexOf('\n', Math.max(0, pos));
+    return i === -1 ? state.input.length : i;
+  }
+  function wordBack(from) {
+    let i = Math.max(0, Math.min(from, state.input.length));
+    while (i > 0 && !isWordCharEdit(state.input[i - 1])) i--;
+    while (i > 0 && isWordCharEdit(state.input[i - 1])) i--;
+    return i;
+  }
+  function wordForward(from) {
+    // `w`: start of the next word (from mid-word, that means past this one).
+    const s = state.input;
+    let i = Math.max(0, Math.min(from, s.length));
+    if (isWordCharEdit(s[i])) while (i < s.length && isWordCharEdit(s[i])) i++;
+    while (i < s.length && !isWordCharEdit(s[i])) i++;
+    return i;
+  }
+  function wordEnd(from) {
+    const s = state.input;
+    const len = s.length;
+    let i = Math.max(0, Math.min(from, len));
+    if (i >= len) return len;
+    // On the last char of a word (or past the end): head for the next word.
+    if (isWordCharEdit(s[i]) && (i + 1 >= len || !isWordCharEdit(s[i + 1]))) i++;
+    while (i < len && !isWordCharEdit(s[i])) i++;
+    while (i + 1 < len && isWordCharEdit(s[i + 1])) i++;
+    return Math.min(i, len);
+  }
+  /** Paste chips (§3.4): big pastes collapse, full text cached for submit. */
+  function addPaste(text) {
+    const id = ++state.pasteSeq;
+    state.pastes.set(id, text);
+    const lines = text.split('\n').length;
+    return `[Pasted text #${id} +${lines} line${lines === 1 ? '' : 's'}]`;
+  }
+  function expandPastes(text) {
+    return String(text).replace(/\[Pasted text #(\d+) \+\d+ lines?\]/g, (m, id) => state.pastes.get(Number(id)) ?? m);
+  }
+  // Image chips (§3.5): only chips still present in the submitted line attach.
+  function takeAttachments(line = '') {
+    const kept = state.attachments.filter((a) => line.includes(a.chip));
+    state.attachments = [];
+    return kept.map((a) => a.block);
+  }
+  function submit() {
+    // Paste chips expand to their full cached text; history keeps the full
+    // paste so recalling it still sends everything (§3.4).
+    const line = expandPastes(state.input);
+    state.input = ''; state.cursor = 0; state.menu = []; state.menuIndex = -1;
+    state.vimOp = null; state.vimNum = ''; state.vimReplace = false; state.vimPendingG = false; state.vimPendingObj = null; endInsert();
+    // Auto-scroll off stays where you left it; otherwise show the new exchange.
+    let autoScroll = true;
+    try { autoScroll = loadSettings().autoScroll !== false; } catch { /* default on */ }
+    if (autoScroll) { state.transcriptOffset = 0; state.newMessages = 0; }
+    if (line.trim()) { state.history.push(line); state.historyIndex = -1; state.draft = null; }
+    draw(); if (state.onLine) Promise.resolve(state.onLine(line)).catch((error) => print(c.red(`  ${error?.message || error}`)));
+  }
+  function acceptMenu() {
+    const item = state.menu[state.menuIndex]; if (!item) return false;
+    snapshotUndo();
+    if (item.kind === 'command') { const slash = state.input.lastIndexOf('/'); state.input = `${state.input.slice(0, slash)}${item.value} `; }
+    else if (item.kind === 'emoji') { const m = /:([A-Za-z0-9_+-]*)$/.exec(state.input); state.input = m ? `${state.input.slice(0, m.index)}${item.value} ` : state.input + item.value; }
+    else if (item.kind === 'history') { state.input = item.value; }
+    else { const at = state.input.lastIndexOf('@'); state.input = `${state.input.slice(0, at)}@${item.value} `; }
+    state.cursor = state.input.length; updateMenu(); draw(); return true;
+  }
+  function historyMove(direction) {
+    if (!state.history.length) return;
+    if (direction > 0) {
+      if (state.historyIndex < 0) return;
+      state.historyIndex += 1;
+      state.input = state.historyIndex >= state.history.length ? (state.historyIndex = -1, state.draft || '') : state.history[state.historyIndex];
+    } else {
+      if (state.historyIndex < 0) state.draft = state.input;
+      state.historyIndex = Math.max(0, state.historyIndex < 0 ? state.history.length - 1 : state.historyIndex - 1);
+      state.input = state.history[state.historyIndex];
+    }
+    state.cursor = state.input.length; updateMenu(); draw();
+  }
+  function refreshHistorySearch() {
+    const query = state.historySearch.query.toLowerCase();
+    state.historySearch.matches = state.history.filter((entry) => entry.toLowerCase().includes(query)).reverse();
+    state.historySearch.index = state.historySearch.matches.length ? Math.min(state.historySearch.index, state.historySearch.matches.length - 1) : -1;
+    draw();
+  }
+  function beginHistorySearch() {
+    state.historySearch = { query: '', matches: [...state.history].reverse().slice(0, 5), index: 0 };
+    draw();
+  }
+  function finishHistorySearch(accept = false) {
+    if (accept && state.historySearch?.matches[state.historySearch.index]) {
+      state.input = state.historySearch.matches[state.historySearch.index]; state.cursor = state.input.length; updateMenu();
+    }
+    state.historySearch = null; draw();
+  }
+  // Overscroll fix: the viewport window is [end-space, end) with
+  // end = len - offset. Clamping to len-1 still lands on slivers — one line
+  // plus a screen of blanks, which reads as broken. Instead the offset may
+  // never exceed len - space, so a scrolled view is always a FULL screen of
+  // content; when the history is shorter than the viewport there is simply
+  // nothing to scroll (offset stays 0).
+  function maxScrollOffset() {
+    const w = contentWidth(); const h = height();
+    const space = Math.max(1, h - 2 - bottomRows(w).length - 1);
+    return Math.max(0, transcriptContent(w).length - space);
+  }
+  function clampOffset(offset) {
+    return Math.max(0, Math.min(offset, maxScrollOffset()));
+  }
+  function scrollBy(lines) {
+    // Wheel speed multiplier (JAITUS_SCROLL_SPEED, or scrollSpeed in settings).
+    const scaled = Math.round(lines * scrollSpeed()) || (lines > 0 ? 1 : -1);
+    state.transcriptOffset = clampOffset(state.transcriptOffset + scaled);
+    if (state.transcriptOffset === 0) state.newMessages = 0;
+    draw();
+  }
+  function scrollTo(position) {
+    state.transcriptOffset = position === 'top' ? clampOffset(transcriptContent(width()).length) : 0;
+    if (state.transcriptOffset === 0) state.newMessages = 0;
+    draw();
+  }
+  function jumpToPrompt(direction) {
+    // { / } jump to previous / next user prompt, vim-paragraph style.
+    const content = transcriptContent(width());
+    const marks = [];
+    content.forEach((line, i) => { if (/^\s*›/.test(String(line ?? '').replace(/\x1b\[[0-9;]*m/g, ''))) marks.push(i); });
+    if (!marks.length) return;
+    const end = Math.max(0, content.length - state.transcriptOffset);
+    const cur = end - 1;
+    const target = direction < 0 ? [...marks].reverse().find((m) => m < cur - 1) : marks.find((m) => m > cur + 1);
+    if (target === undefined) return;
+    state.transcriptOffset = clampOffset(content.length - target - 1);
+    draw();
+  }
+  function dumpToScrollback() {
+    // '[': write full conversation to native scrollback so Cmd+F,
+    // tmux copy mode and native selection can search it. Exit alt screen,
+    // dump expanded, return to fullscreen on Esc/q.
+    const lines = transcriptContent(width()).map((l) => String(l ?? '').replace(/\x1b\[[0-9;]*m/g, ''));
+    const detail = state.activity.flatMap((a) => [`$ ${a.label} [${a.status}]`, ...(a.detail ? String(a.detail).split('\n') : [])]);
+    const body = [...lines, '', ...detail].join('\n');
+    rawWrite('\x1b[?1049l');
+    try { fs.writeSync(1, `\n${body}\n\n[Fullscreen paused — native scrollback now holds the conversation. Press q/Esc then Enter to return: ]\n`); } catch { /* stdout gone */ }
+  }
+  function openInEditor() {
+    // 'v': conversation to a temp file in $VISUAL/$EDITOR.
+    const editor = process.env.VISUAL || process.env.EDITOR || (process.platform === 'win32' ? 'notepad' : 'vi');
+    const file = path.join(os.tmpdir(), `jaitus-conversation-${Date.now()}.md`);
+    try {
+      const lines = transcriptContent(width()).map((l) => String(l ?? '').replace(/\x1b\[[0-9;]*m/g, ''));
+      fs.writeFileSync(file, `# Jaitus conversation — ${new Date().toISOString()}\n\n${lines.join('\n')}\n`);
+      rawWrite('\x1b[?1049l');
+      // timeout guards headless/test runs where the editor would wait forever.
+      const res = spawnSync(editor, [file], { stdio: 'inherit', timeout: 120000 });
+      rawWrite('\x1b[?1049h\x1b[2J\x1b[H');
+      draw();
+      return res.status ?? 0;
+    } catch (e) {
+      try { rawWrite('\x1b[?1049h\x1b[2J\x1b[H'); } catch { /* restore */ }
+      state.statusText = c.dim(`  Could not open editor (${e.message})`);
+      draw();
+      setTimeout(() => { state.statusText = null; draw(); }, 1800);
+      return 1;
+    }
+  }
+  function clearSelectionUnlessKeeps(key, name, str) {
+    // Esc / PgUp / PgDn / Ctrl+Home/End / modified nav keep selection;
+    // any other key (plain arrows, Enter, typed chars) clears it.
+    if (!state.selection) return;
+    // Transcript-mode navigation and selection keys never clear the selection.
+    if (state.viewingTranscript && !state.search) {
+      if (['up', 'down', 'pageup', 'pagedown', 'home', 'end', 'escape'].includes(name)) return;
+      if (['/', 'n', 'N', 'j', 'k', 'g', 'G', '{', '}', '[', 'v', 's', 'y', 'c', 'b', ' '].includes(str)) return;
+      if (key.ctrl && ['u', 'd', 'b', 'f', 'o'].includes(name)) return;
+    }
+    const keeps = name === 'escape'
+      || name === 'pageup' || name === 'pagedown'
+      || (key.ctrl && (name === 'home' || name === 'end'))
+      || ((key.shift || key.alt || key.meta || key.ctrl) && ['up', 'down', 'left', 'right', 'home', 'end'].includes(name));
+    if (!keeps) { state.selection = null; state._kbSelect = false; }
+  }
+  function panelScrollBy(lines) {
+    if (!state.panel) return;
+    const len = state.panel.lines.length;
+    const space = Math.max(1, height() - 2 - 3);
+    state.panel.offset = Math.max(0, Math.min(Math.max(0, len - space), state.panel.offset + lines));
+    draw();
+  }
+  function closePanel() { const panel = state.panel; state.panel = null; draw(); panel?.resolve?.(); }
+  function searchMatches(query) {
+    const needle = query.toLowerCase();
+    return state.transcript.reduce((hits, entry, index) => {
+      if (needle && entry.text.toLowerCase().includes(needle)) hits.push(index);
+      return hits;
+    }, []);
+  }
+  function focusSearch(search, direction = 0) {
+    search.matches = searchMatches(search.query);
+    if (!search.matches.length) { search.index = -1; draw(); return; }
+    if (direction) search.index = (search.index + direction + search.matches.length) % search.matches.length;
+    else search.index = 0;
+    state.transcriptOffset = clampOffset(state.transcript.length - search.matches[search.index] - 1);
+    draw();
+  }
+  function beginSearch() {
+    state.search = { query: '', matches: [], index: -1, restoreOffset: state.transcriptOffset };
+    draw();
+  }
+  function finishSearch(cancel = false) {
+    if (cancel) state.transcriptOffset = state.search?.restoreOffset || 0;
+    else state.lastSearch = state.search?.query || state.lastSearch;
+    state.search = null; draw();
+  }
+  /**
+   * Vim modal editing (§3.2, /vim): insert/normal/visual with motions (h j k l
+   * w e b 0 $ ^ g g G), operators (d x D C s S y p), counts, text object iw/aw,
+   * and r{eplace}. Returns true when the key was consumed. Insert mode falls
+   * through to the normal readline handling below.
+   */
+  function handleVim(str, key = {}) {
+    if (vimMode() !== 'vim') return false;
+    const name = key.name;
+    if (state.vim === 'insert') {
+      if (name === 'escape') {
+        state.vim = 'normal'; state.vimOp = null; state.vimNum = ''; state.vimReplace = false;
+        state.vimEx = null; state.vimFindTyping = false;
+        endInsert();
+        state.cursor = Math.max(0, state.cursor - 1);
+        updateMenu(); draw();
+        return true;
+      }
+      return false;
+    }
+    // Ex line (`:q`) and draft find (`/`) capture typing while open.
+    if (state.vimEx !== null) {
+      if (name === 'escape') { state.vimEx = null; state.statusText = null; draw(); return true; }
+      if (name === 'backspace') { state.vimEx = state.vimEx.slice(0, -1); state.statusText = c.dim(`  :${state.vimEx}▏`); draw(); return true; }
+      if (name === 'return' || name === 'enter') {
+        const cmd = state.vimEx.trim(); state.vimEx = null;
+        if (cmd === 'q' || cmd === 'q!') { state.shouldExit = true; return true; }
+        if (cmd === 'h' || cmd === 'help') { print(c.dim('  Vim: h j k l w e b · 0 $ ^ gg G · d x D C S s · y p P · v · r · . · / · :q :h')); state.statusText = null; draw(); return true; }
+        state.statusText = cmd ? c.dim(`  Not an ex command: ${cmd} (:q quits, :h helps)`) : null;
+        draw();
+        setTimeout(() => { if (state.statusText?.includes('Not an ex')) { state.statusText = null; draw(); } }, 1800);
+        return true;
+      }
+      if (str && !key.ctrl && !key.meta && str >= ' ' && state.vimEx.length < 40) {
+        state.vimEx += str; state.statusText = c.dim(`  :${state.vimEx}▏`); draw();
+      }
+      return true;
+    }
+    if (state.vimFindTyping) {
+      if (name === 'escape') { state.vimFindTyping = false; state.statusText = null; draw(); return true; }
+      if (name === 'backspace') { state.vimFind.pattern = state.vimFind.pattern.slice(0, -1); state.statusText = c.dim(`  /${state.vimFind.pattern}▏`); draw(); return true; }
+      if (name === 'return' || name === 'enter') {
+        state.vimFindTyping = false; state.statusText = null;
+        vimFindNext(1); return true;
+      }
+      if (str && !key.ctrl && !key.meta && str >= ' ' && state.vimFind.pattern.length < 60) {
+        state.vimFind.pattern += str; state.statusText = c.dim(`  /${state.vimFind.pattern}▏`); draw();
+      }
+      return true;
+    }
+    // normal + visual: app chords keep working, and Esc still interrupts work.
+    if (name === 'escape' && state.busy) return false;
+    if (key.ctrl || key.meta) {
+      if (key.ctrl && name === 'r' && !state.busy) { recallRedo(); return true; }
+      return false;
+    }
+    const n = Math.max(1, Number(state.vimNum) || 1);
+    const clearVim = () => { state.vimOp = null; state.vimNum = ''; state.vimReplace = false; state.vimPendingG = false; };
+    const clamp = (p) => Math.max(0, Math.min(state.input.length, p));
+    const repeat = (fn) => { let p = state.cursor; for (let i = 0; i < n; i++) p = fn(p); return clamp(p); };
+    const motions = {
+      h: (p) => p - 1,
+      l: (p) => p + 1,
+      j: (p) => vimRowMove(p, 1),
+      k: (p) => vimRowMove(p, -1),
+      w: (p) => wordForward(p),
+      e: (p) => wordEnd(p),
+      b: (p) => wordBack(p),
+      0: () => lineStartAt(state.cursor),
+      $: () => lineEndAt(state.cursor),
+      '^': () => { const s = lineStartAt(state.cursor); const m = /^[ \t]*/.exec(state.input.slice(s)); return s + (m ? m[0].length : 0); },
+      G: () => state.input.length,
+    };
+    const deleteRange = (a, b, toInsert, kind = 'chars') => {
+      snapshotUndo();
+      const gone = state.input.slice(a, b);
+      kill(gone, 'back');
+      state.lastChange = { t: 'd', kind, text: gone };
+      state.input = state.input.slice(0, a) + state.input.slice(b);
+      state.cursor = clamp(a);
+      if (toInsert) beginInsert();
+      updateMenu(); draw();
+    };
+    // Enclosing delimiters around the cursor (nesting-aware). inner excludes
+    // the pair itself. Quotes pair with themselves. Null when unbalanced.
+    const pairRange = (open, close, inner) => {
+      const s = state.input;
+      const p = state.cursor;
+      if (open === close) {
+        // On a quote preceded by start/space/opener it opens, else it closes.
+        let a; let b;
+        if (s[p] === open && (p === 0 || /[\s([{]/.test(s[p - 1]))) {
+          a = p; b = s.indexOf(open, p + 1);
+        } else {
+          b = s[p] === open ? p : s.indexOf(open, p);
+          a = b === -1 ? -1 : s.lastIndexOf(open, b - 1);
+        }
+        if (a === -1 || b === -1 || a === b) return null;
+        return inner ? { a: a + 1, b } : { a, b: b + 1 };
+      }
+      let a = -1; let depth = 0;
+      for (let i = Math.min(p, s.length - 1); i >= 0; i--) {
+        if (s[i] === close) depth++;
+        else if (s[i] === open) { if (depth === 0) { a = i; break; } depth--; }
+      }
+      if (a === -1) return null;
+      let b = -1; depth = 0;
+      for (let i = Math.max(p, a); i < s.length; i++) {
+        if (s[i] === open && i !== a) depth++;
+        else if (s[i] === close) { if (depth === 0) { b = i; break; } depth--; }
+      }
+      if (b === -1) return null;
+      return inner ? { a: a + 1, b } : { a, b: b + 1 };
+    };
+    if (state.vimReplace) {
+      if (str && str.length === 1 && str >= ' ') {
+        snapshotUndo();
+        state.input = state.input.slice(0, state.cursor) + str + state.input.slice(state.cursor + 1);
+      }
+      clearVim(); draw();
+      return true;
+    }
+    // In visual mode y/d act at once — before the operator capture below.
+    if (state.vim === 'visual') {
+      if (name === 'escape' || str === 'v') { state.vim = 'normal'; clearVim(); draw(); return true; }
+      if ((str === 'y' || str === 'd') && !state.vimOp) {
+        // Anchor is inclusive: include the char under it.
+        const a = Math.min(state.vimAnchor, state.cursor);
+        const b = Math.max(state.vimAnchor, state.cursor) + 1;
+        if (str === 'y') { kill(state.input.slice(a, Math.min(b, state.input.length)), 'back'); state.vim = 'normal'; state.cursor = clamp(a); clearVim(); draw(); }
+        else { deleteRange(a, Math.min(b, state.input.length), false); state.vim = 'normal'; clearVim(); }
+        return true;
+      }
+      const mvOnly = motions[str];
+      if (mvOnly && !/^[0-9]$/.test(str)) { state.cursor = repeat(mvOnly); clearVim(); draw(); return true; }
+      return true; // swallow the rest in visual
+    }
+    // dd / yy line-wise doubling.
+    if ((str === 'd' || str === 'y') && state.vimOp === str) {
+      const a = lineStartAt(state.cursor);
+      let b = lineEndAt(state.cursor);
+      const takeNl = state.input[b] === '\n' ? 1 : 0;
+      if (str === 'd') deleteRange(a, b + takeNl, false, 'line');
+      else { kill(state.input.slice(a, b + takeNl), 'back'); state.cursor = clamp(a); draw(); }
+      clearVim();
+      return true;
+    }
+    if ((str === 'd' || str === 'y' || str === 'c') && !state.vimOp) { state.vimOp = str; return true; }
+    if (str === 'g' && !state.vimPendingG && !state.vimOp && state.vim === 'normal') { state.vimPendingG = true; return true; }
+    if (str === 'i' && state.vimOp === null && state.vimNum === '') { beginInsert(); clearVim(); draw(); return true; }
+    if (str === 'v' && !state.vimOp) { state.vim = 'visual'; state.vimAnchor = state.cursor; clearVim(); draw(); return true; }
+    // iw / aw after d/y/c.
+    if (state.vimOp && (str === 'i' || str === 'a')) {
+      state.vimPendingObj = str;
+      return true;
+    }
+    if (state.vimPendingObj && (str === 'w')) {
+      const obj = state.vimPendingObj; state.vimPendingObj = null;
+      const p = state.cursor;
+      let a; let b;
+      if (isWordCharEdit(state.input[p]) || (obj === 'a' && p < state.input.length)) {
+        a = wordBack(p); b = wordEnd(p) + 1;
+        if (obj === 'a') { while (b < state.input.length && /[ \t]/.test(state.input[b])) b++; }
+      } else { a = p; b = wordForward(p); }
+      a = clamp(a); b = clamp(b);
+      if (state.vimOp === 'y') { kill(state.input.slice(a, b), 'back'); state.cursor = a; draw(); }
+      else deleteRange(a, b, state.vimOp === 'c', 'word');
+      clearVim();
+      return true;
+    }
+    // Quote/paren text objects: i" a" i' i( a( i[ i{ and kin.
+    if (state.vimPendingObj && ['"', "'", '(', ')', '[', ']', '{', '}'].includes(str)) {
+      const obj = state.vimPendingObj; state.vimPendingObj = null;
+      const pairs = { '(': ['(', ')'], ')': ['(', ')'], '[': ['[', ']'], ']': ['[', ']'], '{': ['{', '}'], '}': ['{', '}'], '"': ['"', '"'], "'": ["'", "'"] };
+      const [open, close] = pairs[str];
+      const range = pairRange(open, close, obj === 'i');
+      if (!range) { state.statusText = c.dim('  No enclosing pair'); draw(); setTimeout(() => { if (state.statusText?.includes('No enclosing')) { state.statusText = null; draw(); } }, 1400); clearVim(); return true; }
+      state.statusText = null;
+      if (state.vimOp === 'y') { kill(state.input.slice(range.a, range.b), 'back'); state.cursor = clamp(range.a); draw(); }
+      else deleteRange(range.a, range.b, state.vimOp === 'c', 'chars');
+      clearVim();
+      return true;
+    }
+    state.vimPendingObj = null;
+    if (/^[0-9]$/.test(str)) {
+      if (str === '0' && !state.vimNum && !state.vimOp) { state.cursor = lineStartAt(state.cursor); draw(); return true; }
+      state.vimNum += str;
+      return true;
+    }
+    const mv = motions[str];
+    if (mv && !state.vimOp) {
+      if (str === 'G' && state.vimNum === '') { state.cursor = state.input.length; }
+      else if (str === 'G') {
+        const lines = state.input.split('\n');
+        const li = Math.max(0, Math.min(lines.length - 1, (Number(state.vimNum) || lines.length) - 1));
+        state.cursor = lines.slice(0, li).join('\n').length + (li ? 1 : 0);
+      }
+      else state.cursor = repeat(mv);
+      clearVim(); draw();
+      return true;
+    }
+    if (str === 'g' && state.vimPendingG) { state.cursor = 0; clearVim(); draw(); return true; }
+    if (mv && state.vimOp) {
+      let target = repeat(mv);
+      let a = Math.min(state.cursor, target);
+      let b = Math.max(state.cursor, target);
+      if (str === 'e') b = Math.min(state.input.length, b + 1);
+      if (str === 'w' && state.vimOp === 'c') { b = Math.min(state.input.length, wordEnd(state.cursor) + 1); a = Math.min(state.cursor, b); }
+      if (state.vimOp === 'y') { kill(state.input.slice(a, b), 'back'); state.cursor = a; draw(); }
+      else deleteRange(a, b, state.vimOp === 'c', str === 'w' ? 'word' : 'chars');
+      clearVim();
+      return true;
+    }
+    switch (str) {
+      case 'x': if (state.cursor < state.input.length) deleteRange(state.cursor, Math.min(state.input.length, state.cursor + n), false); clearVim(); return true;
+      case 'D': deleteRange(state.cursor, lineEndAt(state.cursor), false); clearVim(); return true;
+      case 'C': deleteRange(state.cursor, lineEndAt(state.cursor), true); clearVim(); return true;
+      case 'S': { const a = lineStartAt(state.cursor); let b = lineEndAt(state.cursor); deleteRange(a, b + (state.input[b] === '\n' ? 1 : 0), true, 'line'); clearVim(); return true; }
+      case 's': if (state.input.length) deleteRange(state.cursor, Math.min(state.input.length, state.cursor + 1), true); else { beginInsert(); draw(); } clearVim(); return true;
+      case 'u': recallUndo(); clearVim(); return true;
+      case 'p': if (state.lastKill) { snapshotUndo(); const at = Math.min(state.input.length, state.cursor + (state.input.length ? 1 : 0)); state.input = state.input.slice(0, at) + state.lastKill + state.input.slice(at); state.cursor = at + state.lastKill.length - 1; state.lastChange = { t: 'i', text: state.lastKill, session: -1 }; updateMenu(); draw(); } clearVim(); return true;
+      case 'P': if (state.lastKill) { snapshotUndo(); state.input = state.input.slice(0, state.cursor) + state.lastKill + state.input.slice(state.cursor); state.cursor += state.lastKill.length; state.lastChange = { t: 'i', text: state.lastKill, session: -1 }; updateMenu(); draw(); } clearVim(); return true;
+      case 'r': state.vimReplace = true; return true;
+      case 'A': state.cursor = state.input.length; beginInsert(); clearVim(); draw(); return true;
+      case 'I': state.cursor = lineStartAt(state.cursor); beginInsert(); clearVim(); draw(); return true;
+      case 'a': state.cursor = clamp(state.cursor + 1); beginInsert(); clearVim(); draw(); return true;
+      case 'o': { const e = lineEndAt(state.cursor); snapshotUndo(); state.input = state.input.slice(0, e) + '\n' + state.input.slice(e); state.cursor = e + 1; beginInsert(); clearVim(); updateMenu(); draw(); return true; }
+      case 'O': { const s = lineStartAt(state.cursor); snapshotUndo(); state.input = state.input.slice(0, s) + '\n' + state.input.slice(s); state.cursor = s; beginInsert(); clearVim(); updateMenu(); draw(); return true; }
+      case '.': { // repeat last change
+        const last = state.lastChange;
+        if (last?.t === 'i' && last.text) { snapshotUndo(); state.input = state.input.slice(0, state.cursor) + last.text + state.input.slice(state.cursor); state.cursor += last.text.length; updateMenu(); }
+        else if (last?.t === 'd') {
+          if (last.kind === 'word') deleteRange(state.cursor, wordForward(state.cursor), false, 'word');
+          else if (last.kind === 'line') { const a = lineStartAt(state.cursor); let b = lineEndAt(state.cursor); deleteRange(a, b + (state.input[b] === '\n' ? 1 : 0), false, 'line'); }
+          else if (last.text) deleteRange(state.cursor, Math.min(state.input.length, state.cursor + [...last.text].length), false);
+        }
+        clearVim(); draw(); return true;
+      }
+      case ':': state.vimEx = ''; state.statusText = c.dim('  :▏'); draw(); return true;
+      case '/': state.vimFind = state.vimFind || { pattern: '' }; state.vimFindTyping = true; state.statusText = c.dim(`  /${state.vimFind.pattern}▏`); draw(); return true;
+      case 'n': if (state.vimFind?.pattern && !state.vimFindTyping) { vimFindNext(1); clearVim(); return true; } break;
+      case 'N': if (state.vimFind?.pattern && !state.vimFindTyping) { vimFindNext(-1); clearVim(); return true; } break;
+      default: break;
+    }
+    state.vimPendingG = false;
+    return true; // swallow unknown keys in normal mode (never type raw text)
+  }
+  /** Draft find (`/pattern`, n/N): wraps once around the input. */
+  function vimFindNext(dir) {
+    const pat = state.vimFind?.pattern || '';
+    if (!pat) return;
+    const s = state.input;
+    let idx = -1;
+    if (dir > 0) {
+      idx = s.indexOf(pat, state.cursor + 1);
+      if (idx === -1) idx = s.indexOf(pat, 0);
+    } else {
+      idx = s.lastIndexOf(pat, state.cursor - 1);
+      if (idx === -1) idx = s.lastIndexOf(pat);
+    }
+    if (idx === -1) {
+      state.statusText = c.dim(`  Pattern not found: ${pat}`);
+      draw();
+      setTimeout(() => { if (state.statusText?.includes('Pattern not found')) { state.statusText = null; draw(); } }, 1500);
+      return;
+    }
+    state.cursor = idx;
+    state.statusText = null;
+    draw();
+  }
+  function vimRowMove(pos, dir) {
+    const rows = visualRows();
+    let idx = 0;
+    for (let i = 0; i < rows.length; i++) {
+      if (pos >= rows[i].start && pos <= rows[i].start + [...rows[i].text].length) { idx = i; break; }
+      if (i === rows.length - 1) idx = i;
+    }
+    const next = Math.max(0, Math.min(rows.length - 1, idx + dir));
+    const col = pos - rows[idx].start;
+    return Math.max(0, Math.min(rows[next].start + [...rows[next].text].length, rows[next].start + col));
+  }
+  function finishDialog(value) {
+    const dialog = state.dialog; state.dialog = null; draw();
+    // Null stays null (cancel / keep-current) — only undefined means deny.
+    dialog?.resolve({ value: value === undefined ? 'deny' : value, comment: (dialog.comment || '').trim() });
+  }
+  function parseMouse(seq) {
+    // SGR: ESC [ < Cb ; Cx ; Cy M/m — M press/drag/wheel, m release.
+    let m = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/.exec(seq || '');
+    if (m) {
+      const [, b, x, y, s] = m;
+      return { button: Number(b), col: Number(x), row: Number(y), press: s === 'M' };
+    }
+    // Legacy X10: ESC [ M Cb Cx Cy (bytes +32). Wheel = 64/65.
+    if (seq && seq.startsWith('\x1b[M') && seq.length >= 6) {
+      const b = seq.charCodeAt(3) - 32; const x = seq.charCodeAt(4) - 32; const y = seq.charCodeAt(5) - 32;
+      return { button: b, col: x, row: y, press: true, legacy: true };
+    }
+    return null;
+  }
+
+  /** Which menu row a bottom-region row points at (-1 = none). */
+  function menuIndexAtRow(row, w, h) {
+    if (!state.menu.length || state.dialog || state.panel || state.viewingTranscript) return -1;
+    const bottom = bottomRows(contentWidth(w));
+    const rel = row - (h - bottom.length + 1);
+    return (rel >= 0 && rel < state.menu.length) ? rel : -1;
+  }
+  /** Which dialog option a bottom-region cell points at (-1 = none).
+   * Pills panels hit-test by column inside their single row; lists by row. */
+  function dialogOptionAt(dialog, row, col, w, h) {
+    if (!dialog) return -1;
+    if (isPills(dialog)) {
+      const bottom = bottomRows(contentWidth(w));
+      const rel = row - (h - bottom.length + 1);
+      const qLines = dialogQLines(dialog, contentWidth(w));
+      const previewLines = dialog.preview?.length ? 1 + Math.min(7, dialog.preview.length) : 0;
+      const pillsRel = 1 + qLines + previewLines + (dialog.hideComment ? 0 : 1);
+      if (rel !== pillsRel) return -1;
+      for (const s of dialogPillSpans(dialog)) if (col >= s.start && col <= s.end) return s.index;
+      return -1;
+    }
+    return dialogIndexAtRow(row, w, h);
+  }
+  /** Which dialog option a bottom-region row points at (-1 = none). */
+  function dialogIndexAtRow(row, w, h) {
+    if (!state.dialog) return -1;
+    const cw = contentWidth(w);
+    const bottom = bottomRows(cw);
+    const rel = row - (h - bottom.length + 1);
+    const qLines = cleanLine(`  ${state.dialog.question}`, Math.max(12, cw - 4)).length;
+    const previewLines = state.dialog.preview?.length ? 1 + Math.min(7, state.dialog.preview.length) : 0;
+    let optStart = 2 + qLines + previewLines + (state.dialog.hideComment ? 0 : 1);
+    const total = state.dialog.options.length;
+    const top = total <= 9 ? 0 : Math.max(0, Math.min(total - 9, state.dialog.index - 4));
+    if (top > 0) optStart += 1; // "more above" hint row
+    const idx = top + (rel - optStart);
+    return (rel - optStart >= 0 && idx >= top && idx < Math.min(total, top + 9)) ? idx : -1;
+  }
+  function handleMouse(ev) {
+    const w = width(); const h = height();
+    const metrics = columnMetrics(w);
+    const cw = metrics.center;
+    const { button, col, row } = ev;
+    const centerCol = col - (metrics.left ? metrics.left + 1 : 0);
+    // Wheel always scrolls (even with clicks disabled), with
+    // acceleration: fast spins cover more ground (§4.2, off via wheelAccel).
+    if (button === 64 || button === 65) {
+      const dir = button === 64 ? 1 : -1;
+      let per = 3;
+      try {
+        if (loadSettings().wheelAccel !== false) {
+          const now = Date.now();
+          state.wheelStreak = now - state.lastWheelAt < 200 ? Math.min(state.wheelStreak + 1, 6) : 0;
+          state.lastWheelAt = now;
+          per = Math.round(3 * (1 + state.wheelStreak * 0.2));
+        }
+      } catch { /* base rate */ }
+      if (state.panel) panelScrollBy(dir * per);
+      else scrollBy(dir * per);
+      return true;
+    }
+    if (mouseClicksDisabled()) return true; // swallow clicks, keep wheel
+    const btn = button & 0x43; // strip modifier bits for press/drag
+    // Hover (any-motion, no button held) highlights rows without acting.
+    if (ev.press && (button & 32) && ((button & 3) === 3) && !state._dragging) {
+      const mi = menuIndexAtRow(row, w, h);
+      if (mi >= 0 && mi !== state.menuIndex) { state.menuIndex = mi; draw(); return true; }
+      const di = state.dialog ? dialogOptionAt(state.dialog, row, centerCol, w, h) : -1;
+      if (di >= 0 && state.dialog && di !== state.dialog.index) { state.dialog.index = di; draw(); return true; }
+      return true;
+    }
+    // Click an option in a dialog to choose it (permission prompts, pickers).
+    if (ev.press && btn === 0 && state.dialog) {
+      const optIdx = dialogOptionAt(state.dialog, row, centerCol, w, h);
+      if (optIdx >= 0) finishDialog(state.dialog.options[optIdx].value);
+      return true;
+    }
+    // Click a suggestion in the / command or @ file list to accept it.
+    if (ev.press && btn === 0 && state.menu.length && !state.dialog && !state.panel && !state.viewingTranscript) {
+      const rel = menuIndexAtRow(row, w, h);
+      if (rel >= 0) {
+        state.menuIndex = rel;
+        acceptMenu();
+        return true;
+      }
+    }
+    // Drag motion while a press is held: extend, never re-anchor. Dragging
+    // past the viewport edge scrolls that way with the head pinned to the
+    // newly revealed edge, so selecting-while-scrolling just works.
+    const dragScrollEdge = () => {
+      if (state.panel || state.viewingTranscript) return false;
+      const bottom = bottomRows(cw);
+      const browsing = state.transcriptOffset > 0;
+      const bodyFirst = 2 + (browsing ? 1 : 0) + 1; // 1-based first body row
+      const space = Math.max(1, h - 2 - bottom.length - (browsing ? 1 : 0));
+      const step = Math.max(2, Math.floor(space / 4));
+      if (row < bodyFirst) {
+        const before = state.transcriptOffset;
+        scrollBy(step);
+        if (state.transcriptOffset === before) return false;
+        const content = transcriptContent(cw);
+        const end = Math.max(0, content.length - state.transcriptOffset);
+        state.selection.head = { line: Math.max(0, end - space), col: 0 };
+        draw();
+        return true;
+      }
+      if (row > bodyFirst + space - 1 && state.transcriptOffset > 0) {
+        scrollBy(-step);
+        const content = transcriptContent(cw);
+        const last = Math.max(0, content.length - state.transcriptOffset - 1);
+        state.selection.head = { line: last, col: [...String(content[last] || '')].length };
+        draw();
+        return true;
+      }
+      return false;
+    };
+    if (ev.press && state._dragging && state.selection) {
+      const idx = screenRowToContent(row, w, h);
+      if (idx < 0 && dragScrollEdge()) return true;
+      if (idx >= 0) {
+        const content = transcriptContent(contentWidth(w));
+        const plain = String(content[Math.min(idx, content.length - 1)] ?? '').replace(/\x1b\[[0-9;]*m/g, '');
+        const colIdx = Math.max(0, Math.min([...plain].length, centerCol - 1));
+        if (state.selectionMode === 'word') {
+          const { s, e } = wordAt(plain, colIdx);
+          const anchorFirst = state.selection.anchor.line < idx || (state.selection.anchor.line === idx && state.selection.anchor.col <= s);
+          state.selection.head = anchorFirst ? { line: idx, col: e } : { line: idx, col: s };
+        } else if (state.selectionMode === 'line') {
+          state.selection.head = { line: idx, col: colIdx < state.selection.anchor.col ? 0 : [...plain].length };
+        } else {
+          state.selection.head = { line: idx, col: colIdx };
+        }
+        draw();
+      }
+      return true;
+    }
+    // The floating Jump-to-bottom pill is clickable (§4.2).
+    if (ev.press && btn === 0 && !state.panel && !state.viewingTranscript && state.transcriptOffset > 0 && row === 3) {
+      scrollTo('bottom');
+      return true;
+    }
+    // Press / drag start.
+    if (ev.press && (btn === 0 || (button & 64))) {
+      const now = Date.now();
+      const sameSpot = state.lastClickPos && Math.abs(state.lastClickPos.col - col) <= 1 && Math.abs(state.lastClickPos.row - row) <= 1;
+      state.clickCount = (sameSpot && now - state.lastClickAt < 500) ? state.clickCount + 1 : 1;
+      state.lastClickAt = now; state.lastClickPos = { col, row };
+      // Click in the prompt input positions the cursor (wrap-aware).
+      if (!state.viewingTranscript && !state.panel && !state.dialog) {
+        const bottom = bottomRows(cw);
+        const menuN = state.menu.length;
+        const queuedN = state.queued.length ? 1 : 0;
+        const firstPrompt = h - bottom.length + 1 + menuN + queuedN + 1; // 1-based
+        if (row >= firstPrompt && row < h) {
+          const usable = Math.max(12, cw - PROMPT_USABLE_SLACK);
+          if (!state.input) { state.cursor = 0; draw(); return true; }
+          const rows = visualRows(usable);
+          const rowIdx = Math.max(0, Math.min(rows.length - 1, row - firstPrompt));
+          const prefix = rowIdx === 0 ? PROMPT_PREFIX_WIDTH : [...PROMPT_CONT].length;
+          const colInRow = Math.max(0, centerCol - 1 - prefix);
+          const target = rows[rowIdx];
+          state.cursor = Math.max(0, Math.min(state.input.length, target.start + Math.min([...target.text].length, colInRow)));
+          state.clickCount = 0;
+          draw();
+          return true;
+        }
+      }
+      const idx = screenRowToContent(row, w, h);
+      if (idx < 0) return true;
+      const content = transcriptContent(cw);
+      const plain = String(content[idx] ?? '').replace(/\x1b\[[0-9;]*m/g, '');
+      const colIdx = Math.max(0, Math.min([...plain].length, centerCol - 1));
+      if (state.clickCount === 2) {
+        const { s, e } = wordAt(plain, colIdx);
+        state.selection = { anchor: { line: idx, col: s }, head: { line: idx, col: e } };
+        state.selectionMode = 'word';
+      } else if (state.clickCount >= 3) {
+        state.selection = { anchor: { line: idx, col: 0 }, head: { line: idx, col: [...plain].length } };
+        state.selectionMode = 'line';
+        state.clickCount = 0;
+      } else {
+        state.selection = { anchor: { line: idx, col: colIdx }, head: { line: idx, col: colIdx } };
+        state.selectionMode = 'char';
+      }
+      state._dragging = true;
+      draw();
+      return true;
+    }
+    // Release: copy automatically, toast the path.
+    if (!ev.press || btn === 3) {
+      state._dragging = false;
+      if (state.selection) {
+        const text = selectedText();
+        if (text && copyOnSelect()) {
+          const via = copyText(text);
+          toastCopied(via, [...text].length);
+        } else if (text) {
+          state.statusText = `${c.inverse(` Selected ${[...text].length} chars `)}${c.dim('  Ctrl+Shift+C to copy')}`;
+          draw();
+          setTimeout(() => { if (state.statusText?.includes('Selected')) { state.statusText = null; draw(); } }, 2200);
+        } else {
+          state.selection = null;
+          draw();
+        }
+      }
+      return true;
+    }
+    return true;
+  }
+
+  async function handleKey(str, key = {}) {
+    const name = key.name;
+    const rawSequence = key.sequence || str || '';
+    const mouse = parseMouse(rawSequence);
+    if (mouse && !mouseDisabled()) return handleMouse(mouse);
+    if (mouse && mouseDisabled()) {
+      // Capture off: wheel still scrolls via terminal? No — let terminal handle
+      // natively. Swallow nothing so Shift+wheel reaches the terminal.
+      if (mouse.button === 64 || mouse.button === 65) {
+        if (state.panel) panelScrollBy(mouse.button === 64 ? 3 : -3);
+        else scrollBy(mouse.button === 64 ? 3 : -3);
+      }
+      return;
+    }
+    if (key.ctrl && name === 'k' && !state.dialog && !state.panel) {
+      state.commandPalette = state.commandPalette ? null : { query: '', index: 0 };
+      state.menu = []; state.menuIndex = -1;
+      draw();
+      return;
+    }
+    if (state.commandPalette) {
+      const matches = paletteMatches();
+      if (name === 'escape') { state.commandPalette = null; draw(); return; }
+      if (name === 'up') { state.commandPalette.index = Math.max(0, state.commandPalette.index - 1); draw(); return; }
+      if (name === 'down') { state.commandPalette.index = Math.min(Math.max(0, matches.length - 1), state.commandPalette.index + 1); draw(); return; }
+      if (name === 'backspace') { state.commandPalette.query = state.commandPalette.query.slice(0, -1); state.commandPalette.index = 0; draw(); return; }
+      if (name === 'return' || name === 'enter') {
+        const picked = matches[state.commandPalette.index];
+        if (picked) {
+          state.input = picked[0]; state.cursor = state.input.length;
+          state.commandPalette = null; updateMenu(); draw();
+        }
+        return;
+      }
+      if (str && !key.ctrl && !key.meta && str >= ' ') {
+        state.commandPalette.query += str; state.commandPalette.index = 0; draw();
+      }
+      return;
+    }
+    // Selection keep/clear: Esc + paging + modified nav keep, else clear.
+    clearSelectionUnlessKeeps(key, name, str);
+    if (state.panel) {
+      if (name === 'escape' || name === 'q') return closePanel();
+      if (name === 'up' || name === 'k') return panelScrollBy(1);
+      if (name === 'down' || name === 'j') return panelScrollBy(-1);
+      if (name === 'pageup') return panelScrollBy(Math.max(4, Math.floor(height() / 2)));
+      if (name === 'pagedown') return panelScrollBy(-Math.max(4, Math.floor(height() / 2)));
+      if (key.ctrl && name === 'home') { state.panel.offset = Math.max(0, state.panel.lines.length - Math.max(1, height() - 5)); draw(); return; }
+      if (key.ctrl && name === 'end') { state.panel.offset = 0; draw(); return; }
+      if (str === ' ') return panelScrollBy(-Math.max(4, height()));
+      return;
+    }
+    if (state.historySearch) {
+      if (name === 'escape') return finishHistorySearch(false);
+      if (name === 'return' || name === 'enter') return finishHistorySearch(true);
+      if (name === 'up') { state.historySearch.index = Math.max(0, state.historySearch.index - 1); draw(); return; }
+      if (name === 'down') { state.historySearch.index = Math.min(state.historySearch.matches.length - 1, state.historySearch.index + 1); draw(); return; }
+      if (name === 'backspace') { state.historySearch.query = state.historySearch.query.slice(0, -1); refreshHistorySearch(); return; }
+      if (str && !key.ctrl && !key.meta && str >= ' ') { state.historySearch.query += str; refreshHistorySearch(); }
+      return;
+    }
+    if (state.viewingTranscript) {
+      if (state.search) {
+        if (name === 'escape') return finishSearch(true);
+        if (name === 'return' || name === 'enter') return finishSearch(false);
+        if (name === 'backspace') { state.search.query = state.search.query.slice(0, -1); focusSearch(state.search); return; }
+        if (name === 'up') return focusSearch(state.search, -1);
+        if (name === 'down') return focusSearch(state.search, 1);
+        if (str && !key.ctrl && !key.meta && str >= ' ') { state.search.query += str; focusSearch(state.search); }
+        return;
+      }
+      if (name === 'escape' || name === 'q' || (key.ctrl && name === 'o')) {
+        // Keyboard selection cancels first (stays in view); second press exits.
+        if (state.selection && state._kbSelect) { state.selection = null; state._kbSelect = false; draw(); return; }
+        // Returning from a '[' scrollback dump re-enters fullscreen.
+        const wasDumped = state._dumped;
+        state._dumped = false;
+        state.viewingTranscript = false; state.transcriptOffset = 0;
+        if (wasDumped) rawWrite('\x1b[?1049h\x1b[2J\x1b[H');
+        draw(); return;
+      }
+      // Keyboard selection: no mouse needed (conhost never forwards mouse).
+      // 's' starts on the newest visible line, j/k/↑↓ extend, Enter/y/c copies.
+      if (str === 's') {
+        const content = transcriptContent(width());
+        if (!content.length) { state.statusText = c.dim('  Nothing to select yet'); draw(); setTimeout(() => { state.statusText = null; draw(); }, 1400); return; }
+        if (state.selection && state._kbSelect) { state.selection = null; state._kbSelect = false; draw(); return; }
+        const end = Math.max(0, content.length - state.transcriptOffset);
+        const idx = Math.max(0, end - 1);
+        const plain = String(content[idx] ?? '').replace(/\x1b\[[0-9;]*m/g, '');
+        state.selection = { anchor: { line: idx, col: 0 }, head: { line: idx, col: [...plain].length } };
+        state.selectionMode = 'line';
+        state._kbSelect = true;
+        state.statusText = c.dim('  j/k extend · Enter/y copy · Esc cancel');
+        draw();
+        setTimeout(() => { if (state.statusText?.includes('j/k extend')) { state.statusText = null; draw(); } }, 2200);
+        return;
+      }
+      if ((str === 'y' || str === 'c' || name === 'return' || name === 'enter') && state.selection) {
+        const text = selectedText();
+        if (text) { const via = copyText(text); toastCopied(via, [...text].length); }
+        else { state.selection = null; state._kbSelect = false; draw(); }
+        return;
+      }
+      if (str === '/') return beginSearch();
+      if (str === '[') { state._dumped = true; dumpToScrollback(); return; }
+      if (str === 'v') { openInEditor(); return; }
+      if (str === '?' && !state.input) {
+        print(c.dim('  Keys: / search · n/N match · j/k/↑↓ line · Ctrl+u/d half · Ctrl+b/f/Space full · {/} prompt · [ scrollback · v editor · q/Esc return'));
+        return;
+      }
+      if (str === 'n' && state.lastSearch) { const search = { query: state.lastSearch, matches: searchMatches(state.lastSearch), index: -1 }; return focusSearch(search, 1); }
+      if (str === 'N' && state.lastSearch) { const search = { query: state.lastSearch, matches: searchMatches(state.lastSearch), index: 0 }; return focusSearch(search, -1); }
+      if (name === 'up' || name === 'k') return scrollBy(1);
+      if (name === 'down' || name === 'j') return scrollBy(-1);
+      if (name === 'pageup' || (key.ctrl && name === 'u')) return scrollBy(Math.max(4, Math.floor(height() / 2)));
+      if (name === 'pagedown' || (key.ctrl && name === 'd')) return scrollBy(-Math.max(4, Math.floor(height() / 2)));
+      if ((key.ctrl && name === 'b') || (str === 'b')) return scrollBy(Math.max(4, height()));
+      if ((key.ctrl && name === 'f') || str === ' ') return scrollBy(-Math.max(4, height()));
+      if (str === '{') return jumpToPrompt(-1);
+      if (str === '}') return jumpToPrompt(1);
+      if (name === 'home' || name === 'g') return scrollTo('top');
+      if (name === 'end' || name === 'G') return scrollTo('bottom');
+      // Manual copy in transcript mode.
+      if ((key.ctrl && key.shift && (name === 'c' || name === 'C')) || (key.ctrl && name === 'c' && state.selection)) {
+        const text = selectedText();
+        if (text) { const via = copyText(text); toastCopied(via, [...text].length); }
+        return;
+      }
+      return;
+    }
+    if (state.dialog) {
+      const dialog = state.dialog;
+      if (dialog.editing) {
+        if (name === 'escape' || (key.ctrl && name === 'c')) { dialog.editing = false; draw(); return; }
+        if (name === 'return' || name === 'enter') { dialog.editing = false; draw(); return; }
+        if (name === 'backspace') { dialog.comment = (dialog.comment || '').slice(0, -1); draw(); return; }
+        if (str && !key.ctrl && !key.meta && str >= ' ') { dialog.comment = (dialog.comment || '') + str; draw(); }
+        return;
+      }
+      if (/^[1-9]$/.test(str)) {
+        // 1-9 address the visible window when the list scrolls.
+        const total = dialog.options.length;
+        const top = total <= 9 ? 0 : Math.max(0, Math.min(total - 9, dialog.index - 4));
+        const opt = dialog.options[top + Number(str) - 1];
+        if (opt && top + Number(str) - 1 < top + Math.min(9, total - top)) return finishDialog(opt.value);
+      }
+      if (str === 'e' && !dialog.hideComment) { dialog.editing = true; draw(); return; }
+      if (name === 'up') { dialog.index = Math.max(0, dialog.index - 1); draw(); return; }
+      if (name === 'down') { dialog.index = Math.min(dialog.options.length - 1, dialog.index + 1); draw(); return; }
+      // Pills panels also travel sideways, opencode-style.
+      if (isPills(dialog) && (name === 'left' || str === 'h')) { dialog.index = (dialog.index + dialog.options.length - 1) % dialog.options.length; draw(); return; }
+      if (isPills(dialog) && (name === 'right' || str === 'l')) { dialog.index = (dialog.index + 1) % dialog.options.length; draw(); return; }
+      if (name === 'return' || name === 'enter') return finishDialog(dialog.options[dialog.index].value);
+      // Esc denies where denial is an option, otherwise it cancels (null).
+      if (name === 'escape') return finishDialog(dialog.options.find((option) => option.value === 'deny')?.value ?? null); return;
+    }
+    if (!state.panel && !state.viewingTranscript && !state.historySearch && !state.dialog && handleVim(str, key)) return;
+    if (key.ctrl && name === 'o') { state.viewingTranscript = true; draw(); return; }
+    if (key.ctrl && name === 'r') return beginHistorySearch();
+    const shiftTab = (key.shift && name === 'tab') || key.sequence === '\x1b[Z' || key.sequence === '\x1b[OT';
+    if (shiftTab && onModeCycle) {
+      const mode = await onModeCycle();
+      state.statusText = mode === 'bypassPermissions'
+        ? c.red(`  ● BYPASS ON — writes and commands run with no permission checks`)
+        : `${c.brand(`  ${glyph('◈', '*')}`)} Permission mode: ${c.bold(modeLabel(mode))}`;
+      draw();
+      setTimeout(() => { if (state.statusText?.includes('Permission mode:') || state.statusText?.includes('BYPASS ON')) { state.statusText = null; draw(); } }, 2200);
+      return;
+    }
+    if (name === 'pageup') return scrollBy(Math.max(4, Math.floor(height() / 2)));
+    if (name === 'pagedown') return scrollBy(-Math.max(4, Math.floor(height() / 2)));
+    if (key.ctrl && name === 'home') return scrollTo('top');
+    if (key.ctrl && name === 'end') return scrollTo('bottom');
+    // '?' on empty input toggles the shortcut help.
+    if (str === '?' && !state.input.trim() && !state.menu.length) {
+      print(c.dim('  Keys: Enter send · Ctrl+J / \\+Enter newline · Up/Down history · Ctrl+R search · PgUp/PgDn scroll · wheel scroll · drag select (auto-copy) · Shift+arrows extend · Ctrl+Shift+C copy · [ scrollback (in Ctrl+O) · v editor · ? help · Shift+Tab modes · Esc interrupt · Esc Esc rewind'));
+      return;
+    }
+    // Shift+arrows extend an active selection from the keyboard.
+    if (key.shift && ['up', 'down', 'left', 'right', 'home', 'end'].includes(name) && state.selection) {
+      const content = transcriptContent(width());
+      const head = { ...state.selection.head };
+      if (name === 'left') head.col = Math.max(0, head.col - 1);
+      if (name === 'right') head.col = head.col + 1;
+      if (name === 'home') head.col = 0;
+      if (name === 'end') head.col = [...(String(content[head.line] || '').replace(/\x1b\[[0-9;]*m/g, ''))].length;
+      if (name === 'up') { head.line = Math.max(0, head.line - 1); }
+      if (name === 'down') { head.line = Math.min(content.length - 1, head.line + 1); }
+      state.selection.head = head;
+      // Shift+Up/Down at the edge scrolls the viewport.
+      if (name === 'up' || name === 'down') {
+        const end = Math.max(0, content.length - state.transcriptOffset);
+        if (head.line < end - height() || head.line >= end) scrollBy(name === 'up' ? 1 : -1);
+        else draw();
+      } else draw();
+      return;
+    }
+    if (key.ctrl && name === 'c') {
+      // Ctrl+C copies the selection when one is active, interrupts a running
+      // turn while busy, clears a draft otherwise — and never exits. Leaving
+      // happens only through /exit.
+      if (state.selection) {
+        const text = selectedText();
+        if (text) { const via = copyText(text); toastCopied(via, [...text].length); return; }
+      }
+      if (state.busy) return state.onEscape?.();
+      if (state.input) { snapshotUndo(); state.input = ''; state.cursor = 0; updateMenu(); draw(); return; }
+      state.statusText = c.dim('  Type /exit to leave');
+      draw();
+      setTimeout(() => { if (state.statusText?.includes('/exit to leave')) { state.statusText = null; draw(); } }, 1500);
+      return;
+    }
+    if (key.ctrl && name === 'b') {
+      // Detach an `!` shell line into the background (§16): same as `! cmd &`.
+      if (state.input.startsWith('!') && state.input.trim().length > 1) {
+        if (!/\s&\s*$/.test(state.input)) state.input = `${state.input.trimEnd()} &`;
+        state.cursor = state.input.length;
+        return submit();
+      }
+      return;
+    }
+    // Manual copy when Copy-on-select is off (Ctrl+Shift+C).
+    if (key.ctrl && key.shift && (name === 'c' || name === 'C')) {
+      const text = selectedText();
+      if (text) { const via = copyText(text); toastCopied(via, [...text].length); }
+      else { state.statusText = c.dim(`  Nothing selected — drag to select, ${nativeSelectKey()}+drag for native`); draw(); setTimeout(() => { state.statusText = null; draw(); }, 1600); }
+      return;
+    }
+    if (key.ctrl && name === 'd') {
+      if (state.input) { state.input = state.input.slice(0, state.cursor) + state.input.slice(state.cursor + 1); draw(); return; }
+      // No double-press exit: leaving happens only through /exit.
+      state.statusText = c.dim('  Type /exit to leave');
+      draw();
+      setTimeout(() => { if (state.statusText?.includes('/exit to leave')) { state.statusText = null; draw(); } }, 1500);
+      return;
+    }
+    if (key.ctrl && name === 'l') { draw(); return; }
+    // Ctrl+V pastes a clipboard image as a positional chip (§3.5);
+    // Alt+V where the terminal steals Ctrl+V (Windows/WSL).
+    if ((key.ctrl && name === 'v') || (key.meta && name === 'v')) { pasteImageFromClipboard(); return; }
+    if (key.ctrl && name === 'g') {
+      // Ctrl+G: open the draft in $VISUAL/$EDITOR.
+      const editor = process.env.VISUAL || process.env.EDITOR;
+      if (editor) {
+        const file = path.join(os.tmpdir(), `jaitus-prompt-${Date.now()}.md`);
+        try {
+          fs.writeFileSync(file, state.input);
+          rawWrite('\x1b[?1049l');
+          spawnSync(editor, [file], { stdio: 'inherit' });
+          rawWrite('\x1b[?1049h\x1b[2J\x1b[H');
+          state.input = fs.readFileSync(file, 'utf8');
+          state.cursor = state.input.length;
+          try { fs.rmSync(file); } catch { /* temp */ }
+          updateMenu(); draw();
+        } catch { draw(); }
+        return;
+      }
+    }
+    if (key.ctrl && name === 't') {
+      // Ctrl+T: toggle the task/activity view.
+      const activity = state.activity.map((item) => ({ ...item }));
+      if (!activity.length) { state.statusText = c.dim('  No agent tool activity in this session yet'); draw(); setTimeout(() => { state.statusText = null; draw(); }, 1600); return; }
+      const lines = activity.flatMap((item) => [
+        `${item.status === 'ok' ? '✓' : item.status === 'failed' ? '✗' : '…'} ${item.label}`,
+        ...(item.detail ? String(item.detail).split('\n').slice(0, 12).map((l) => `  ${l}`) : []),
+        '',
+      ]);
+      showPanel('Session activity', lines);
+      return;
+    }
+    if (key.ctrl && name === 'a') { state.cursor = 0; draw(); return; }
+    if (key.ctrl && name === 'e') { state.cursor = state.input.length; draw(); return; }
+    if (key.ctrl && name === 'u') { snapshotUndo(); kill(state.input.slice(0, state.cursor), 'back'); state.input = state.input.slice(state.cursor); state.cursor = 0; updateMenu(); draw(); return; }
+    if (key.ctrl && name === 'k') { snapshotUndo(); kill(state.input.slice(state.cursor), 'forward'); state.input = state.input.slice(0, state.cursor); updateMenu(); draw(); return; }
+    if ((key.meta && name === 'backspace') || (key.ctrl && name === 'w')) { snapshotUndo(); const previous = state.input.slice(0, state.cursor).replace(/\s*\S+\s*$/, ''); kill(state.input.slice(previous.length, state.cursor), 'back'); state.input = previous + state.input.slice(state.cursor); state.cursor = previous.length; updateMenu(); draw(); return; }
+    if (key.ctrl && name === 'j') return insert('\n');
+    // Shift+Enter (kitty `CSI 13;2 u`) and Alt+Enter insert a newline anywhere.
+    if (rawSequence === '\x1b[13;2u' || rawSequence === '\x1b[13u' || (key.meta && (name === 'return' || name === 'enter'))) return insert('\n');
+    if (key.meta && name === 'b') { state.cursor = wordBack(state.cursor); draw(); return; }
+    if (key.meta && name === 'f') { state.cursor = wordForward(state.cursor); draw(); return; }
+    if (key.meta && name === 'd') {
+      snapshotUndo();
+      let i = state.cursor;
+      while (i < state.input.length && !isWordCharEdit(state.input[i])) i++;
+      const start = i;
+      while (i < state.input.length && isWordCharEdit(state.input[i])) i++;
+      kill(state.input.slice(start, i), 'forward');
+      state.input = state.input.slice(0, state.cursor) + state.input.slice(i);
+      updateMenu(); draw(); return;
+    }
+    if (key.ctrl && name === 'y') return yank();
+    if (key.ctrl && name === '_') return recallUndo();
+    if (key.ctrl && (name === 'p' || name === 'n')) { /* fall through to up/down below */ }
+    else if (key.ctrl && name === 's') {
+      // Stash the draft; again on empty restores it (§3.9).
+      if (state.input) { state.stash = { input: state.input, cursor: state.cursor }; state.input = ''; state.cursor = 0; updateMenu(); draw(); }
+      else if (state.stash) { state.input = state.stash.input; state.cursor = Math.min(state.stash.cursor, state.input.length); state.stash = null; updateMenu(); draw(); }
+      return;
+    }
+    if (name === 'backspace') {
+      if (state.cursor) {
+        snapshotUndo('type');
+        // A paste chip deletes as one unit (and stays paste-back-able, §3.4).
+        const before = state.input.slice(0, state.cursor);
+        const chip = /(\[Pasted text #\d+ \+\d+ lines?\]|\[Image #\d+\])$/.exec(before);
+        if (chip) {
+          kill(chip[1], 'back');
+          state.input = before.slice(0, -chip[1].length) + state.input.slice(state.cursor);
+          state.cursor -= chip[1].length;
+        } else {
+          state.input = before.slice(0, -1) + state.input.slice(state.cursor);
+          state.cursor -= 1;
+        }
+        updateMenu(); draw();
+      }
+      return;
+    }
+    if (name === 'delete') { snapshotUndo('type'); state.input = state.input.slice(0, state.cursor) + state.input.slice(state.cursor + 1); updateMenu(); draw(); return; }
+    if (name === 'left') { state.cursor = Math.max(0, state.cursor - 1); draw(); return; }
+    if (name === 'right') { state.cursor = Math.min(state.input.length, state.cursor + 1); draw(); return; }
+    if (name === 'home') { state.cursor = 0; draw(); return; }
+    if (name === 'end') { state.cursor = state.input.length; draw(); return; }
+    if (name === 'up' || (key.ctrl && name === 'p')) {
+      if (state.menu.length) { state.menuIndex = Math.max(0, state.menuIndex - 1); draw(); return; }
+      if (!state.input && state.queued.length) { state.input = state.queued.pop(); state.cursor = state.input.length; updateMenu(); draw(); return; }
+      // Multiline first: move within the prompt, then history at the edges.
+      if (state.input.includes('\n')) {
+        const w = width(); const usable = Math.max(12, w - PROMPT_USABLE_SLACK);
+        const rows = cleanLine(state.input.slice(0, state.cursor), usable);
+        if (rows.length > 1) {
+          const lastLen = visibleWidth(rows[rows.length - 1] || '');
+          const prevLen = visibleWidth(rows[rows.length - 2] || '');
+          state.cursor = Math.max(0, state.cursor - Math.max(1, lastLen) - 1);
+          void prevLen;
+          draw(); return;
+        }
+      }
+      historyMove(-1); return;
+    }
+    if (name === 'down' || (key.ctrl && name === 'n')) {
+      if (state.menu.length) { state.menuIndex = Math.min(state.menu.length - 1, state.menuIndex + 1); draw(); return; }
+      if (state.input.includes('\n')) {
+        const after = state.input.slice(state.cursor);
+        if (after.includes('\n')) { state.cursor = Math.min(state.input.length, state.cursor + 1 + visibleWidth(cleanLine(state.input.slice(0, state.cursor), 80).at(-1) || '')); draw(); return; }
+      }
+      historyMove(1); return;
+    }
+    if (name === 'tab') { if (state.menu.length) acceptMenu(); return; }
+    if (name === 'escape') {
+      if (state.busy) return state.onEscape?.();
+      // Esc first dismisses the suggestion menu.
+      if (state.menu.length) { state.menu = []; state.menuIndex = -1; draw(); return; }
+      if (state.input) { state.input = ''; state.cursor = 0; updateMenu(); draw(); return; }
+      // Esc+Esc when idle: rewind to an earlier turn.
+      if (state.lastEscapeAt && Date.now() - state.lastEscapeAt < 1200 && onRewind) {
+        state.lastEscapeAt = null;
+        Promise.resolve(onRewind()).catch((error) => print(c.red(`  ${error?.message || error}`)));
+        return;
+      }
+      state.lastEscapeAt = Date.now();
+      state.statusText = `${c.dim('  ↩')} Press Esc again to rewind…`;
+      draw();
+      setTimeout(() => { if (state.statusText?.includes('Press Esc again')) { state.statusText = null; draw(); } }, 1200);
+      return;
+    }
+    if (name === 'return' || name === 'enter') {
+      if (state.input.endsWith('\\')) { state.input = `${state.input.slice(0, -1)}\n`; state.cursor = state.input.length; updateMenu(); draw(); return; }
+      if (state.busy) { if (state.input.trim()) { state.queued.push(state.input); state.input = ''; state.cursor = 0; state.menu = []; state.menuIndex = -1; draw(); } return; }
+      // Tab accepts, Enter runs the highlighted suggestion in ONE press.
+      if (state.menu.length && state.menuIndex >= 0) {
+        const item = state.menu[state.menuIndex];
+        // An emoji pick lands in the draft; everything else sends immediately.
+        if (item?.kind === 'emoji' && !/(?:^|\s)\//.test(state.input)) return acceptMenu();
+        if (item && (item.kind === 'command' || item.kind === 'history' || /(?:^|\s)\//.test(state.input))) {
+          snapshotUndo();
+          if (item.kind === 'command') { const slash = state.input.lastIndexOf('/'); state.input = `${state.input.slice(0, slash)}${item.value} `; }
+          else if (item.kind === 'history') { state.input = item.value; }
+          else { const at = state.input.lastIndexOf('@'); state.input = `${state.input.slice(0, at)}@${item.value} `; }
+          state.cursor = state.input.length;
+          state.menu = []; state.menuIndex = -1;
+        }
+      }
+      return submit();
+    }
+    if (str && !key.ctrl && !key.meta && str >= ' ') {
+      insert(str);
+      // `:name:` live-replaces the moment the closing colon lands (§3.6).
+      if (str === ':') {
+        const m = /:([A-Za-z0-9_+-]+):$/.exec(state.input.slice(0, state.cursor));
+        if (m && EMOJI[m[1].toLowerCase()]) {
+          state.input = state.input.slice(0, state.cursor - m[0].length) + EMOJI[m[1].toLowerCase()] + state.input.slice(state.cursor);
+          state.cursor += EMOJI[m[1].toLowerCase()].length - m[0].length;
+          updateMenu(); draw();
+        }
+      }
+    }
+  }
+  return {
+    state,
+    onEscape(fn) { state.onEscape = fn; }, onRewind(fn) { state.onRewind = fn; }, setMeta(next) { Object.assign(state.meta, next); draw(); },
+    start({ onLine, history = [] }) {
+      state.onLine = onLine; state.history = history.slice(); active = true;
+      // Keys go through readline, but on a filtered stream: raw mouse bytes are
+      // framed out first (see splitMouseSequences) because readline would shred
+      // them into junk keypresses that can never scroll and pollute the prompt.
+      keyFilter = new PassThrough();
+      readline.emitKeypressEvents(keyFilter);
+      let pending = '';
+      let inPaste = false;
+      const PASTE_MAX = 2 * 1024 * 1024;
+      const pumpBytes = (text, force) => {
+        if (!text) return '';
+        const { forward, events, hold } = splitMouseSequences(text);
+        for (const ev of events) {
+          if (ev.focus !== undefined) { onFocus(ev.focus); continue; }
+          if (mouseDisabled()) continue; // terminal owns the mouse; drop ours
+          try { handleMouse(ev); } catch (error) { print(c.red(`  ${error?.message || error}`)); }
+        }
+        keyFilter.write(forward + (force ? hold : ''));
+        return force ? '' : hold;
+      };
+      /** A paste over ~800 chars or 3+ lines collapses to a chip (§3.4). */
+      const handlePaste = (content) => {
+        if (!content) return;
+        if (content.length > 800 || content.split('\n').length > 3) insert(`${addPaste(content)} `);
+        else insert(content);
+      };
+      const pump = (force) => {
+        for (;;) {
+          if (!inPaste) {
+            const s = pending.indexOf('\x1b[200~');
+            const head = s === -1 ? pending : pending.slice(0, s);
+            pending = s === -1 ? pumpBytes(head, force) : pending.slice(s + 6);
+            if (s === -1) break;
+            inPaste = true;
+          } else {
+            const e = pending.indexOf('\x1b[201~');
+            if (e === -1) {
+              if (pending.length > PASTE_MAX) { const bulk = pending; pending = ''; inPaste = false; pumpBytes(bulk, true); }
+              break;
+            }
+            const content = pending.slice(0, e);
+            pending = pending.slice(e + 6);
+            inPaste = false;
+            handlePaste(content);
+          }
+        }
+      };
+      const armFlush = () => {
+        if (mouseFlushTimer) clearTimeout(mouseFlushTimer);
+        mouseFlushTimer = setTimeout(() => { mouseFlushTimer = null; pump(true); }, 25);
+      };
+      onRawData = (chunk) => {
+        pending += String(chunk);
+        if (mouseFlushTimer) { clearTimeout(mouseFlushTimer); mouseFlushTimer = null; }
+        pump(false);
+        if (pending) armFlush();
+      };
+      if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(true); stdin.resume();
+      stdin.on('data', onRawData);
+      // ?1049h alt screen · ?1000h basic + ?1002h button-event (drag) + ?1006h SGR ext
+      // ?1003h any-motion (hover highlight) · ?2004h bracketed paste (§3.4) ·
+      // ?1004 focus reports (§15) · ?7l autowrap OFF (invariant 1) · clear+home.
+      // Mouse modes skipped when capture is off so Shift+drag / native selection
+      // keeps working; hover goes with clicks-only mode.
+      if (mouseDisabled()) rawWrite('\x1b[?1049h\x1b[?2004h\x1b[?1004h\x1b[?7l\x1b[?25l\x1b[2J\x1b[H');
+      else if (mouseClicksDisabled()) rawWrite('\x1b[?1049h\x1b[?1000h\x1b[?1006h\x1b[?2004h\x1b[?1004h\x1b[?7l\x1b[?25l\x1b[2J\x1b[H');
+      else rawWrite('\x1b[?1049h\x1b[?1000h\x1b[?1002h\x1b[?1003h\x1b[?1006h\x1b[?2004h\x1b[?1004h\x1b[?7l\x1b[?25l\x1b[2J\x1b[H');
+      onKeypress = (str, key) => { Promise.resolve(handleKey(str, key)).catch((error) => print(c.red(`  ${error?.message || error}`))); };
+      keyFilter.on('keypress', onKeypress); onResize = () => draw(); process.stdout.on('resize', onResize); draw();
+      // One-time hint when mouse is captured (names the bypass key).
+      if (!mouseDisabled() && !process.env.JAITUS_HIDE_MOUSE_HINT) {
+        state.statusText = c.dim(`  Mouse captured: drag selects (auto-copy) · ${nativeSelectKey()}+drag for native · wheel scrolls`);
+        draw();
+        setTimeout(() => { if (state.statusText?.includes('Mouse captured')) { state.statusText = null; draw(); } }, 3200);
+      }
+    },
+    stop() {
+      active = false; commitLive();
+      if (busyTimer) { clearInterval(busyTimer); busyTimer = null; }
+      if (mouseFlushTimer) { clearTimeout(mouseFlushTimer); mouseFlushTimer = null; }
+      if (onRawData) stdin.removeListener('data', onRawData);
+      if (onKeypress && keyFilter) keyFilter.removeListener('keypress', onKeypress);
+      keyFilter = null; onRawData = null;
+      if (onResize) process.stdout.removeListener('resize', onResize);
+      if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(false); stdin.pause();
+      rawWrite('\x1b[?7h\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?2004l\x1b[?1004l\x1b[?25h\x1b[?1049l');
+    },
+    print, printStream, flushStream, bellIfAway,
+    animationsOn() { return state.busyAnim && active; },
+    drainAttachments: (line) => takeAttachments(line),
+    clearTranscript() {
+      state.transcript = []; state.liveText = ''; state.liveKind = null;
+      state.liveUnseen = false; state.transcriptOffset = 0; state.newMessages = 0;
+      state.selection = null;
+      draw();
+    },
+    setStatusLine(value) { state.customStatus = String(value || '').split('\n')[0]; draw(); },
+    updatePanel(lines) {
+      if (!state.panel) return;
+      state.panel.lines = Array.isArray(lines) ? lines : String(lines).split('\n');
+      state.panel.offset = Math.max(0, Math.min(state.panel.lines.length, state.panel.offset));
+      draw();
+    },
+    setBusy(value) {
+      state.busy = value;
+      if (!value) {
+        state.statusText = null;
+        if (busyTimer) { clearInterval(busyTimer); busyTimer = null; }
+      } else {
+        // Cache the motion preference once per run, not once per frame.
+        try {
+          state.busyAnim = process.env.JAITUS_NO_ANIMATION ? false : loadSettings().animations !== false;
+        } catch { state.busyAnim = true; }
+        state.busyTick = 0;
+        if (!busyTimer && state.busyAnim) {
+          busyTimer = setInterval(() => {
+            if (!active || !state.busy) { if (busyTimer) { clearInterval(busyTimer); busyTimer = null; } return; }
+            // Explicit tool status already moves; animate the waiting row only.
+            if (state.statusText === null) { state.busyTick += 1; draw(); }
+          }, 120);
+          if (busyTimer.unref) busyTimer.unref();
+        }
+      }
+      draw();
+    },
+    setStatus(value) { state.statusText = value; draw(); }, clearStatus() { state.statusText = null; draw(); },
+    queue(line) { state.queued.push(line); draw(); }, takeQueued() { const queued = state.queued; state.queued = []; draw(); return queued; }, hasQueued: () => state.queued.length > 0,
+    askDialog(question, options, preview = [], opts = {}) {
+      return new Promise((resolve) => {
+        state.dialog = {
+          question, options, preview, index: 0, resolve, comment: '', editing: false,
+          title: opts.title || null, hideComment: !!opts.hideComment,
+          icon: opts.icon || null, pills: !!opts.pills,
+        };
+        draw();
+      });
+    }, redraw: draw,
+    setHome(on) { state.home = !!on; draw(); },
+    showPanel(title, lines) { return new Promise((resolve) => { state.panel = { title, lines: Array.isArray(lines) ? lines : String(lines).split('\n'), offset: 0, resolve }; draw(); }); },
+    recordActivity(event) {
+      const existing = event.id ? state.activity.find((item) => item.id === event.id) : null;
+      if (existing) Object.assign(existing, event, { updatedAt: Date.now() });
+      else {
+        const item = { id: `${Date.now()}-${state.activity.length}`, name: event.name, label: String(event.label || event.name), status: event.status || 'running', detail: event.detail || '', updatedAt: Date.now() };
+        state.activity.push(item);
+        if (state.activity.length > 100) state.activity.shift();
+        return item.id;
+      }
+      return existing.id;
+    },
+    activitySnapshot() { return state.activity.map((item) => ({ ...item })); },
+    get exited() { return state.shouldExit; }, _handleKey: handleKey, _drawRegion: draw,
+  };
+}