@andorra-labs/code 0.0.0-stage → 0.1.5

package/dist/src/terminal-ui.js

@@ -0,0 +1,3012 @@
+import { EventEmitter } from 'node:events';
+import { emitKeypressEvents } from 'node:readline';
+import { PassThrough } from 'node:stream';
+import { StringDecoder } from 'node:string_decoder';
+import { stripVTControlCharacters } from 'node:util';
+import stringWidth from 'string-width';
+import { DashboardMetrics } from './dashboard.js';
+import { dashboardRows } from './dashboard-view.js';
+import { transcriptColor } from './transcript.js';
+import { ToolCallClock, toolHeaderRows } from './tool-call-clock.js';
+import { formatDuration } from './duration.js';
+import { PagedTranscript } from './paged-transcript.js';
+import { accentSgr, ATTACHMENT_TOKEN, DIM, FAINT, GRAY, STATUS, SUBTLE, WHITE } from './palette.js';
+import { isCustomGraph, panelRowText, panelWidth, PANEL_MIN_COLUMNS, PANEL_MIN_ROWS, sidePanelRows } from './side-panel.js';
+import { TokenRateMeter } from './token-rate.js';
+import { attachmentLabel, droppedPaths, formatBytes, isLargePaste, MAX_ATTACHMENTS } from './attachments.js';
+const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+const graphemes = (text) => [...segmenter.segment(text)].map(part => part.segment);
+/**
+ * Attachment tokens live in the composer draft as one code point each from Supplementary
+ * Private Use Area-B, which no font or input method emits. `clean` strips that plane from
+ * everything typed or pasted, so only `addAttachment` can put a token into the draft.
+ */
+const TOKEN_BASE = 0x100000;
+const isToken = (part) => (part.codePointAt(0) ?? 0) >= TOKEN_BASE;
+/** Graphemes of a draft, keeping each token its own element even when a combining mark follows it. */
+const composerGraphemes = (text) => graphemes(text).flatMap(part => isToken(part) && part.length > 2 ? [part.slice(0, 2), part.slice(2)] : [part]);
+const clean = (text) => stripVTControlCharacters(text).replace(/\r\n?/g, '\n').replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f\u202a-\u202e\u2066-\u2069]/g, '').replace(/[\u{100000}-\u{10FFFF}]/gu, '').replace(/\t/g, '  ');
+const oneLine = (text) => clean(text).replace(/\n/g, ' ');
+const commands = ['/model', '/providers', '/subagent', '/reasoning', '/graph', '/codegraph', '/dashboard', '/browser', '/attach', '/skills', '/plugins', '/mcp', '/usage', '/permissions', '/yolo', '/jev', '/feedback', '/tools', '/session', '/status', '/clear', '/compact', '/help', '/login', '/logout', '/auth status', '/auth logout', '/exit', '/quit'];
+/**
+ * The arguments the popup offers once a command and a space are typed. The read-only choice comes
+ * first wherever there is one, so a second Enter on a freshly opened list reports rather than
+ * changes a setting.
+ */
+const argumentCompletions = {
+    '/jev': ['/jev status', '/jev on', '/jev off'],
+    '/feedback': ['/feedback status', '/feedback on', '/feedback off'],
+    '/yolo': ['/yolo off', '/yolo on'],
+    '/reasoning': ['default', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'].map(level => `/reasoning ${level}`),
+    '/codegraph': ['/codegraph status', '/codegraph enable', '/codegraph disable', '/codegraph rebuild', '/codegraph enable --global', '/codegraph disable --global'],
+    '/attach': [],
+    '/logout': ['/logout codex'],
+};
+/**
+ * Commands that do nothing useful bare. Enter or Tab on one fills in the command and a space and
+ * waits for the argument instead of running it; `/logout` is complete on its own.
+ */
+const argumentRequired = new Set(['/jev', '/feedback', '/yolo', '/reasoning', '/codegraph', '/attach']);
+const completionOptions = (query) => {
+    const command = /^(\/\S+)\s/.exec(query)?.[1];
+    return (command === undefined ? commands : argumentCompletions[command] ?? []).filter(option => option.startsWith(query));
+};
+/**
+ * Whether the composer text is a command name, or a command with arguments, that the popup completes.
+ * A command that is complete on its own lists its arguments only once one is being typed: `/logout `
+ * must submit the bare sign-out, not have Enter pick `/logout codex` from a list nobody asked for.
+ */
+const completable = (query) => {
+    if (/^\/\S*$/.test(query))
+        return true;
+    const [, command, argument] = /^(\/\S+) (\S*)$/.exec(query) ?? [];
+    return command !== undefined && Object.hasOwn(argumentCompletions, command) && (argument !== '' || argumentRequired.has(command));
+};
+/** A fixed-width, two-line terminal wordmark for the default Andorra CLI. */
+const ANDORRA_WORDMARK = [
+    '▄▀█ █▄ █ █▀▄ █▀█ █▀█ █▀█ ▄▀█',
+    '█▀█ █ ▀█ █▄▀ █▄█ █▀▄ █▀▄ █▀█',
+];
+/** Said under the workflow name while the selected graph cannot bind to this machine's providers. */
+const OVERRIDE_HINT = 'Choose a model to override the nodes with · /model';
+const commandDescriptions = {
+    '/browser': 'Open the browser workspace',
+    '/attach': 'Attach a file or folder to your next task',
+    '/session': 'Browse and resume saved sessions',
+    '/login': 'Sign in or create an Andorra account', '/logout': 'Sign out of the Andorra account', '/logout codex': 'Sign out of every Codex account', '/auth logout': 'Sign out of the Andorra account', '/auth status': 'Account and membership status',
+    '/model': 'Choose a model', '/providers': 'Choose or edit providers',
+    '/subagent': 'Choose the provider and model external hosts run Andorra with',
+    '/reasoning': 'Choose thinking effort', '/dashboard': 'Toggle live dashboard / transcript',
+    '/skills': 'Manage and install skills', '/plugins': 'Manage and install plugins',
+    '/mcp': 'Manage MCP servers',
+    '/jev': 'Turn Jev on or off for nodes that enable it', '/jev on': 'Enable Jev', '/jev off': 'Disable Jev', '/jev status': 'Show saved Jev setting',
+    '/feedback': 'Show the anonymous-feedback setting; Paid accounts can turn it off', '/feedback on': 'Allow anonymous product feedback', '/feedback off': 'Stop anonymous product feedback (Paid plan)', '/feedback status': 'Show saved feedback setting',
+    '/graph': 'Choose a graph', '/codegraph': 'Code intelligence status and actions', '/usage': 'Usage and token totals', '/yolo': 'Turn automatic approvals on or off', '/yolo on': 'Approve everything for this session', '/yolo off': 'Restore Ask for approval',
+    '/permissions': 'Choose workspace permissions',
+    '/tools': 'Available coding tools', '/status': 'Workspace and settings', '/clear': 'Clear conversation',
+    '/compact': 'Compact conversation history',
+    '/help': 'Show command help', '/exit': 'Exit Andorra', '/quit': 'Alias for /exit',
+};
+/**
+ * The session command a submitted line starts with, if any.
+ *
+ * The first whitespace-delimited token must match a known command's root exactly. A leading-slash
+ * test alone would swallow legitimate steering text that merely mentions a path such as
+ * `/src/app.ts`, and an unknown `/notacommand` is not a session command either.
+ * @param value - the submitted composer text.
+ * @returns the command token, or undefined when the text is ordinary input.
+ */
+const submittedCommand = (value) => {
+    const [token] = value.trim().split(/\s+/);
+    return commands.some(command => command.split(/\s+/)[0] === token) ? token : undefined;
+};
+/**
+ * The hint shown when a session command is typed while a task is working.
+ *
+ * Commands run between tasks: a started run has its history snapshotted and stays pinned to
+ * its graph revision, so executing one mid-run would misreport what the run actually used.
+ * The hint names the command and the way out instead of queueing the text as an instruction
+ * the model would then follow.
+ * @param command - the recognized command token that was submitted.
+ */
+const workingCommandHint = (command) => `${command} doesn't run while a task is working. Press Ctrl+C to stop this task, then run ${command}.`
+    + (command === '/graph' ? ' Switching graphs clears the previous graph progress and starts fresh.' : '');
+/** Commands the run input handler executes live during a run, plus its exits; they must reach it. */
+const liveRunCommands = ['/browser', '/attach', '/yolo', '/permissions', '/jev', '/help', '/status', '/usage', '/tools', '/exit', '/quit'];
+const paint = (text, color = GRAY) => typeof color === 'number'
+    ? `\x1b[38;5;${color}m${text}\x1b[0m`
+    : `\x1b[${color}m${text}\x1b[0m`;
+/**
+ * Foreground sequence for the Andorra accent.
+ *
+ * Resolved per render rather than at module load: truecolor support is read from the
+ * environment, which a test or embedder may set after this module is imported, and
+ * caching the first answer would pin the fallback for the whole process.
+ */
+const accentPaint = () => accentSgr();
+/** Thousands as `1.2k`, the shape both footer token readouts need to stay on one row. */
+const compactNumber = (value) => Intl.NumberFormat('en', { notation: 'compact', maximumFractionDigits: 1 }).format(value);
+const MAX_INPUT = 65_536;
+/**
+ * Bracketed-paste accumulation ceiling. An in-flight paste may exceed the inline limit because
+ * a large paste never inlines: it spools to an attachment, whose own cap this matches.
+ */
+const PASTE_ACCUMULATE_LIMIT = 1_048_576;
+const INPUT_BURST_MS = 40;
+/** Rows an echoed prompt may occupy before the tail is replaced by an omission marker. */
+const MAX_PROMPT_ROWS = 200;
+/** Long submitted prompts collapse in chat history until the user expands them with Ctrl+O. */
+const PROMPT_COLLAPSE_AFTER_ROWS = 12;
+const PROMPT_COLLAPSED_BODY_ROWS = 6;
+/**
+ * Characters of streamed reasoning retained for the live preview. Only the tail ever
+ * renders, so the buffer is a bounded window, not the full reasoning transcript.
+ */
+const THINKING_KEEP = 4_000;
+/** Rows the reasoning preview expands to when opened. */
+const THINKING_ROWS = 6;
+/** Minimum milliseconds between preview repaints; faster streams coalesce into one render. */
+const THINKING_PAINT_MS = 80;
+/**
+ * Ownership token for the composer while steering.
+ *
+ * A deferred Enter is only delivered when the surface that armed it still owns the
+ * composer, so this stands in for `pending` when the steering composer is the owner.
+ */
+const STEERING_OWNER = Symbol('steering');
+const commandPopupRows = (width, height, inputRows, matches) => width < 12 || height < 9
+    ? 0 : Math.min(6, Math.max(1, matches), Math.max(0, height - inputRows - 11));
+function clip(text, width, ellipsis = true) {
+    if (width <= 0)
+        return '';
+    if (stringWidth(text) <= width)
+        return text;
+    const room = width - (ellipsis ? 1 : 0);
+    let result = '', used = 0;
+    for (const character of graphemes(text)) {
+        const size = stringWidth(character);
+        if (used + size > room)
+            break;
+        result += character;
+        used += size;
+    }
+    return result + (ellipsis ? '…' : '');
+}
+function pad(text, width) { const value = clip(text, width); return value + ' '.repeat(Math.max(0, width - stringWidth(value))); }
+function wrap(text, width) {
+    const result = [];
+    for (const paragraph of text.split('\n')) {
+        let line = '', used = 0;
+        const tokens = paragraph.match(/\s+|\S+/gu) ?? [];
+        for (const [index, token] of tokens.entries()) {
+            const tokenWidth = stringWidth(token);
+            const separator = !/\S/u.test(token) && index > 0 && index < tokens.length - 1;
+            if (/\S/u.test(token) && tokenWidth <= width && used + tokenWidth > width && line) {
+                result.push(line);
+                line = '';
+                used = 0;
+            }
+            for (const character of graphemes(token)) {
+                const size = stringWidth(character);
+                if (separator && used + size > width)
+                    continue;
+                if (used + size > width && line) {
+                    result.push(line);
+                    line = '';
+                    used = 0;
+                }
+                if (size > width) {
+                    result.push('…');
+                    continue;
+                }
+                line += character;
+                used += size;
+            }
+        }
+        result.push(line);
+    }
+    return result;
+}
+/** Display-column span [start, end) of the selected graphemes on one wrapped composer row. */
+function selectedColumns(text, positions, [from, to], row) {
+    let start = Infinity, end = -Infinity;
+    for (let index = from; index < to; index++) {
+        const position = positions[index];
+        if (position?.row !== row || text[index] === '\n')
+            continue;
+        start = Math.min(start, position.column);
+        end = Math.max(end, position.column + stringWidth(text[index]));
+    }
+    return start < end ? [start, end] : undefined;
+}
+/**
+ * Paint one composer row: attachment token columns in amber, and the selected column span in
+ * reverse video over whichever color it covers.
+ */
+function composerRow(text, color, selection, tokens) {
+    let painted = '', run = '', style = '';
+    let column = 0;
+    const flush = () => { if (run)
+        painted += paint(style[1] === 'r' ? `\x1b[7m${run}` : run, style[0] === 't' ? ATTACHMENT_TOKEN : color); run = ''; };
+    for (const part of graphemes(text)) {
+        const token = tokens.some(([start, end]) => column >= start && column < end);
+        const selected = !!selection && column >= selection[0] && column < selection[1];
+        const next = `${token ? 't' : 'p'}${selected ? 'r' : '-'}`;
+        if (next !== style) {
+            flush();
+            style = next;
+        }
+        run += part;
+        column += stringWidth(part);
+    }
+    flush();
+    return painted;
+}
+/** The display-column spans the draft's tokens occupy on one composer row. */
+function tokenColumns(draft, visible, positions, row) {
+    const spans = [];
+    draft.forEach((part, index) => { const position = positions[index]; if (isToken(part) && position?.row === row)
+        spans.push([position.column, position.column + stringWidth(visible[index])]); });
+    return spans;
+}
+/** Whitespace as one editor element; a token label is a single element that contains spaces. */
+const blank = (part) => /^\s+$/u.test(part);
+function editor(text, width) {
+    const lines = [''];
+    const positions = [];
+    const wordWidths = new Map();
+    const separators = new Set();
+    for (let index = 0; index < text.length;) {
+        if (text[index] === '\n') {
+            index++;
+            continue;
+        }
+        if (blank(text[index])) {
+            const start = index;
+            while (index < text.length && text[index] !== '\n' && blank(text[index]))
+                index++;
+            if (start > 0 && !blank(text[start - 1]) && index < text.length && !blank(text[index]))
+                for (let offset = start; offset < index; offset++)
+                    separators.add(offset);
+            continue;
+        }
+        const start = index;
+        let size = 0;
+        while (index < text.length && !blank(text[index]))
+            size += stringWidth(text[index++]);
+        wordWidths.set(start, size);
+    }
+    let column = 0;
+    for (let index = 0; index <= text.length; index++) {
+        const character = text[index];
+        if (separators.has(index) && column + stringWidth(character) > width) {
+            positions.push({ row: lines.length - 1, column: Math.min(column, width - 1) });
+            continue;
+        }
+        const wordWidth = wordWidths.get(index);
+        if (wordWidth !== undefined && wordWidth <= width && column > 0 && column + wordWidth > width) {
+            lines.push('');
+            column = 0;
+        }
+        if (column === width && character !== '\n') {
+            lines.push('');
+            column = 0;
+        }
+        if (character !== undefined && character !== '\n' && column + stringWidth(character) > width) {
+            lines.push('');
+            column = 0;
+        }
+        positions.push({ row: lines.length - 1, column: Math.min(column, width - 1) });
+        if (character === undefined)
+            break;
+        if (character === '\n') {
+            lines.push('');
+            column = 0;
+        }
+        else {
+            lines[lines.length - 1] += character;
+            column += stringWidth(character);
+        }
+    }
+    return { lines, positions };
+}
+/** Full-screen terminal presentation; provider/runtime behavior remains owned by the CLI. */
+export class TerminalUI extends EventEmitter {
+    input;
+    output;
+    workspace;
+    version;
+    appName;
+    keys = new PassThrough();
+    decoder = new StringDecoder('utf8');
+    status;
+    /**
+     * Graph nodes the user currently has running, in the order they started.
+     *
+     * `provider` and `model` are what each node's own executor reported, not what the graph file
+     * configured, so a retry that falls back to another profile moves the footer with it.
+     *
+     * `resolved` carries the reasoning effort and context window of that same resolution. It stays
+     * absent until a run reports them, and an absent `resolved` keeps the session's own numbers on
+     * the footer; a present one whose fields are undefined means that node's model has no effort or
+     * window of its own, which the footer shows as `provider default` and as no window at all
+     * rather than falling back to the session's unrelated values.
+     */
+    activeNodes = new Map();
+    /**
+     * Node ids the current run has finished, in visit order.
+     *
+     * The side panel's zoom marks the run's trail with it, so it survives the run's end - a
+     * reader looking at a finished run can still see where it went - and is cleared only when
+     * the next run starts, which is the point the trail stops describing what is on screen.
+     */
+    /** Whether the last frame drew without the panel, so its return can be announced once. */
+    panelWasHidden = true;
+    visitedNodes = new Set();
+    /** The node a stopped run ended on, kept as the panel's position until the next run starts. */
+    stoppedNode;
+    toolClock = new ToolCallClock();
+    toolClockTimer;
+    updateToolClock() {
+        if (this.toolClock.running && !this.closed && !this.toolClockTimer) {
+            this.toolClockTimer = setInterval(() => this.scheduleRender(), 100);
+            this.toolClockTimer.unref?.();
+        }
+        else if ((!this.toolClock.running || this.closed) && this.toolClockTimer) {
+            clearInterval(this.toolClockTimer);
+            this.toolClockTimer = undefined;
+        }
+    }
+    dashboard = false;
+    dashboardMetrics = new DashboardMetrics();
+    dashboardModel = 0;
+    dashboardGraphOffset = 0;
+    dashboardNotices = [];
+    nodeModels = new Map();
+    toggleDashboard() { this.dashboard = !this.dashboard; this.scroll = 0; this.scheduleRender(); }
+    /** Start of a run: open the dashboard's run window. */
+    startTask() { this.runActive = true; this.updateAlternateScroll(); this.dashboardMetrics.startTask(); this.dashboardNotices = []; this.nodeModels.clear(); this.scheduleRender(); }
+    /** End of a run: close the dashboard's run window. */
+    finishTask() { this.runActive = false; this.updateAlternateScroll(); this.dashboardMetrics.finishTask(); this.scheduleRender(); }
+    resetDashboardSession(usage) { this.dashboardMetrics.resetSession(usage); this.dashboardModel = 0; this.dashboardGraphOffset = 0; this.nodeModels.clear(); this.dashboardNotices = []; this.scheduleRender(); }
+    /** Clock backing the per-node speed meters; see {@link TerminalOptions.tokenClock}. */
+    tokenClock;
+    /**
+     * One cumulative speed meter per generating identity, each stamped with the provider, model
+     * and reasoning effort its requests were measured under.
+     *
+     * Parallel nodes interleave model calls (`src/graph-runner.ts` runs branch workers side by
+     * side), so a single shared meter would have one node's first request discard the other's
+     * in-flight window and both nodes' totals alternate between wipes. Keys extend the nodeId
+     * with the parallel `copy` number the modifier stamps on every forwarded event, because two
+     * copies of one node can resolve different models and retry independently. Keeping the
+     * accumulation per identity means a switch simply displays the new identity's own average,
+     * and returning to an earlier one resumes the average it built.
+     */
+    speedMeters = new Map();
+    /** The executor's `invocationId` → the meter key whose marker opened that request's window. */
+    speedInvocations = new Map();
+    /** The node whose requests the readout currently follows: the most recent to open a call. */
+    activeSpeedNode;
+    /** The parallel copy of {@link activeSpeedNode} the readout follows, when one is named. */
+    activeSpeedCopy;
+    /** The exact meter key the readout displays - a node, a node's copy, or a distillation. */
+    activeSpeedKey;
+    handleRuntimeEvent(event) {
+        if (this.closed)
+            return;
+        this.dashboardMetrics.handle(event);
+        if (event.type === 'agent.session.started' && !event.data.subagentId) {
+            const session = event.data;
+            const nodeId = session.nodeId, provider = session.provider, model = session.model;
+            if (typeof nodeId !== 'string' || (typeof provider !== 'string' && typeof model !== 'string'))
+                return;
+            const providerLabel = typeof provider === 'string' ? oneLine(provider) : undefined;
+            const modelLabel = typeof model === 'string' ? oneLine(model) : undefined;
+            const effort = typeof session.reasoningEffort === 'string' ? oneLine(session.reasoningEffort) : undefined;
+            if (providerLabel !== undefined && modelLabel !== undefined)
+                this.nodeModels.set(nodeId, oneLine(`${providerLabel}/${modelLabel}`));
+            // The executor re-announces a node's resolution when a whole-agent retry falls back to
+            // the node's other profile: same nodeId, different provider, model or effort. The
+            // accumulated average measured the previous resolution, so it is rebuilt from zero
+            // under the new one - while a repeat of the same resolution, which every ordinary run
+            // emits, keeps it. Parallel copies carry their own `copy` number, so one copy's
+            // fallback never resets a sibling copy still running on the primary model.
+            this.stampSpeedMeter(this.speedKey(nodeId, typeof session.copy === 'number' ? session.copy : undefined), providerLabel, modelLabel, effort);
+        }
+        if (event.type.startsWith('dashboard.'))
+            this.scheduleRender();
+        this.toolClock.accept(event);
+        this.updateToolClock();
+        if (event.type.startsWith('node.tool.'))
+            this.scheduleRender();
+        const data = event.data;
+        // The executor emits `agent.turn.started` and `agent.iteration.started` back-to-back
+        // around one model call (`src/hardened-runtime.ts`), so they are aliases of a single
+        // boundary: opening a window for both would queue two per request, and since a completion
+        // closes only one, the leftover start would be consumed by a *later* completion and every
+        // reading would age against an ever-longer window. `iteration.started` is the marker every
+        // other consumer already uses, so it alone opens the window the main call's tokens spread
+        // across. Context compaction runs its own model calls between iterations and emits no
+        // iteration marker (the next one belongs to the main request): its batch-level start
+        // event opens the first window, and because a rejected summary attempt has already spent
+        // that window on its usage, every attempt re-emits
+        // `agent.context.compaction.attempt.started` so the retry gets a fresh one. All of these
+        // events carry the executor's `invocationId`, and the same id names the request on its
+        // usage delta, so each window is keyed by it: concurrent requests (branch workers,
+        // parallel copies, subagents) completing out of order each spread over their own window
+        // instead of the oldest one still open.
+        // Goal verification calls the adapter outside every iteration marker with this run's
+        // invocationId - the id whose iteration window the main response already closed - so its
+        // own boundary re-opens the key and its completion spreads over the verification request
+        // instead of the one-second synthetic fallback, whose false spike would then be held.
+        if (event.type === 'agent.iteration.started' || event.type === 'agent.context.compaction.started' || event.type === 'agent.context.compaction.attempt.started' || event.type === 'agent.completion.verification.started') {
+            // The speed readout averages one generating identity at a time. Every marker above
+            // carries the `nodeId` the emit wrapper stamped on it - and, inside a parallel copy,
+            // the `copy` number the modifier added - so the readout follows the copy generating
+            // now, and because the accumulation lives per identity a switch neither wipes the
+            // previous one's totals nor its still-open request window.
+            const nodeId = typeof data.nodeId === 'string' ? data.nodeId : 'engineer';
+            const invocationId = typeof data.invocationId === 'string' ? data.invocationId : undefined;
+            const copy = typeof data.copy === 'number' ? data.copy : undefined;
+            const key = this.speedKey(nodeId, copy);
+            const entry = this.ensureSpeedMeter(key);
+            this.activeSpeedNode = nodeId;
+            this.activeSpeedCopy = copy;
+            this.activeSpeedKey = key;
+            if (invocationId !== undefined) {
+                this.speedInvocations.set(invocationId, key);
+                while (this.speedInvocations.size > 64) {
+                    const oldest = this.speedInvocations.keys().next();
+                    if (oldest.done)
+                        break;
+                    this.speedInvocations.delete(oldest.value);
+                }
+            }
+            entry.meter.beginRequest(invocationId);
+            // The focus moved: the node row and the speed readout now describe another copy or node, so
+            // the frame is repainted even though no token reading has arrived yet.
+            this.scheduleRender();
+            return;
+        }
+        // Memory distillation calls the adapter directly, outside every executor marker, so the
+        // dashboard adapter's start event is the only boundary it emits. Its metadata names the
+        // operation and carries the invocation id the distiller stamps on its usage deltas, plus
+        // the provider and model that actually perform it - finalization runs on the graph's own
+        // resolution, not inside any node's iteration, so without a nodeId of its own it is keyed
+        // by that resolution instead of whichever node generated last. Main model calls also pass
+        // through the dashboard adapter but are already covered by their iteration marker, so
+        // only the distillation operation opens a window here.
+        if (event.type === 'dashboard.model.started' && data.operation === 'memory.distillation') {
+            const invocationId = typeof data.invocationId === 'string' ? data.invocationId : undefined;
+            const provider = typeof data.provider === 'string' ? oneLine(data.provider) : undefined;
+            const model = typeof data.model === 'string' ? oneLine(data.model) : undefined;
+            const key = typeof data.nodeId === 'string' ? this.speedKey(data.nodeId, undefined)
+                : provider !== undefined || model !== undefined ? `distillation ${provider ?? '?'}/${model ?? '?'}`
+                    : this.speedKey(this.activeSpeedNode ?? 'engineer', this.activeSpeedCopy);
+            if (invocationId !== undefined)
+                this.speedInvocations.set(invocationId, key);
+            const entry = this.ensureSpeedMeter(key);
+            if (provider !== undefined)
+                entry.provider = provider;
+            if (model !== undefined)
+                entry.model = model;
+            entry.meter.beginRequest(invocationId);
+            // Distillation is work the user can watch decode: the readout follows the meter that
+            // performed it, whether or not an iteration marker already named one.
+            this.activeSpeedKey = key;
+            if (typeof data.nodeId === 'string') {
+                this.activeSpeedNode = data.nodeId;
+                this.activeSpeedCopy = undefined;
+            }
+            return;
+        }
+        // Run boundaries no longer reset the speed readout: each node's cumulative average stays
+        // up across runs, and the readout simply follows whichever node generates next.
+        if (['graph.started', 'graph.completed', 'graph.stopped'].includes(event.type)) {
+            this.activeNodes.clear();
+            // The trail belongs to the run that walked it, and so does the position it stopped at:
+            // a new run starts over from its own entry.
+            if (event.type === 'graph.started') {
+                this.visitedNodes.clear();
+                this.stoppedNode = undefined;
+            }
+            // A run that was cancelled, exhausted or failed names the node it stopped on. That node
+            // never completes, so without keeping it the zoom would show the last completed
+            // predecessor as the position and the node the run actually died on as untouched.
+            if (event.type === 'graph.stopped')
+                this.stoppedNode = typeof data.nodeId === 'string' ? data.nodeId : undefined;
+            this.scheduleRender();
+            return;
+        }
+        if (typeof data.nodeId !== 'string')
+            return;
+        if (event.type === 'graph.node.completed') {
+            this.activeNodes.delete(data.nodeId);
+            // A node reached twice (a bounded cycle) is moved to the end of the trail rather than left
+            // where it was first inserted: the set's order is the visit order the panel's focus reads,
+            // so a repeated visit has to be the last one recorded even though the id stays unique.
+            this.visitedNodes.delete(data.nodeId);
+            this.visitedNodes.add(data.nodeId);
+            this.scheduleRender();
+            return;
+        }
+        // The executor reports the provider and model a node is actually running on, including the
+        // profile a retry falls back to, so the footer follows a mid-node switch. A delegated child
+        // repeats its parent's nodeId, and an ordinary prompt run reports the synthetic 'engineer'
+        // id with no graph node behind it, so only a node the graph already reported as started is
+        // updated: nothing else may put a node name on the footer.
+        if (event.type === 'agent.session.started') {
+            const progress = this.activeNodes.get(data.nodeId);
+            if (!progress || typeof data.subagentId === 'string')
+                return;
+            const provider = typeof data.provider === 'string' ? oneLine(data.provider) : undefined;
+            const model = typeof data.model === 'string' ? oneLine(data.model) : undefined;
+            if (!provider && !model)
+                return;
+            // The CLI adds the effort and window of that same resolution (`withNodeModelResolution` in
+            // cli.ts). `contextWindow` being present at all - even as undefined - marks the node's own
+            // resolution as authoritative, so its unknown window cannot inherit the session's.
+            const resolved = Object.hasOwn(data, 'contextWindow')
+                ? { reasoningEffort: typeof data.reasoningEffort === 'string' ? oneLine(data.reasoningEffort) : undefined,
+                    contextWindow: typeof data.contextWindow === 'number' && Number.isFinite(data.contextWindow) && data.contextWindow > 0 ? data.contextWindow : undefined }
+                : progress.resolved;
+            // Parallel copies of one node can resolve different profiles - one falls back while another
+            // stays on the primary model - so the resolution is kept per copy as well as for the node:
+            // the last announcement must not become the whole node's model.
+            const copiesResolved = new Map(progress.copiesResolved ?? []);
+            const copyIndex = typeof data.copy === 'number' ? data.copy : 0;
+            // The copy keeps the *complete* resolution it announced - effort and window alongside the
+            // provider and model - because the footer names one model, and a copy's thinking settings
+            // belong to that same resolution: inheriting the node's would describe this copy with a
+            // sibling's effort, which the rate comparison then reads as a mismatch and suppresses.
+            const ownResolution = Object.hasOwn(data, 'contextWindow')
+                ? resolved
+                : typeof data.reasoningEffort === 'string' ? { reasoningEffort: oneLine(data.reasoningEffort), contextWindow: undefined } : undefined;
+            copiesResolved.set(copyIndex, {
+                ...copiesResolved.get(copyIndex),
+                ...(provider ? { provider } : {}), ...(model ? { model } : {}),
+                ...(ownResolution ? { resolved: ownResolution } : {}),
+            });
+            this.activeNodes.set(data.nodeId, { ...progress, provider: provider ?? progress.provider, model: model ?? progress.model, resolved, copiesResolved });
+            this.scheduleRender();
+            return;
+        }
+        if (!['graph.node.started', 'agent.modifier.iteration.started', 'agent.modifier.copy.started', 'agent.modifier.copy.completed'].includes(event.type))
+            return;
+        const progress = this.activeNodes.get(data.nodeId) ?? { name: oneLine(String(data.nodeName ?? this.status.graph?.nodes[data.nodeId]?.name ?? data.nodeId)), copies: new Set() };
+        if (event.type === 'agent.modifier.iteration.started' && typeof data.iteration === 'number' && typeof data.maxIterations === 'number' && data.maxIterations > 1)
+            progress.loop = `loop ${data.iteration}/${data.maxIterations}`;
+        if (typeof data.copy === 'number' && typeof data.copies === 'number' && data.copies > 1) {
+            progress.totalCopies = data.copies;
+            if (event.type === 'agent.modifier.copy.started')
+                progress.copies.add(data.copy);
+            else
+                progress.copies.delete(data.copy);
+        }
+        this.activeNodes.set(data.nodeId, progress);
+        this.scheduleRender();
+    }
+    nodeProgress() {
+        const nodes = [...this.activeNodes.values()];
+        return nodes.slice(0, 2).map(node => [node.name, node.loop, node.copies.size ? `copy ${[...node.copies].sort((a, b) => a - b).join(',')}/${node.totalCopies}` : ''].filter(Boolean).join(' - ')).join(' + ') + (nodes.length > 2 ? ` +${nodes.length - 2} more` : '');
+    }
+    /**
+     * The columns the chat column actually draws in, panel and gutter excluded.
+     *
+     * Everything that measures chat content outside the render pass - input navigation, the
+     * echoed-prompt frame, the docked selection card, the command popup's own visibility gate -
+     * has to measure against this rather than the terminal width, or a draft that the composer
+     * wrapped onto two rows is treated as one by the arrow keys, and a stored card is built
+     * wider than the transcript that must re-wrap it.
+     */
+    chatColumns() {
+        const columns = Math.max(1, this.output.columns || 80), height = Math.max(1, this.output.rows || 24);
+        const panel = this.panelColumns(columns, height);
+        return Math.max(1, columns - panel - (panel ? 1 : 0));
+    }
+    /**
+     * Columns the transcript itself would have with the panel drawn.
+     *
+     * A prompt echo is stored in the transcript and re-wrapped there, so its frame has to be built for
+     * that column rather than for whatever surface is on screen when the text is submitted: a task sent
+     * from the Ctrl+B dashboard (or from a modal) would otherwise freeze a full-width box whose rows the
+     * transcript splits as soon as the panel returns. This is `chatColumns()` with the two full-screen
+     * surfaces ignored.
+     */
+    transcriptColumns() {
+        const columns = Math.max(1, this.output.columns || 80), height = Math.max(1, this.output.rows || 24);
+        const panel = columns < PANEL_MIN_COLUMNS || height < PANEL_MIN_ROWS ? 0 : panelWidth(columns);
+        return Math.max(1, columns - panel - (panel ? 1 : 0));
+    }
+    /**
+     * Columns the side panel occupies this frame, or 0 when it is not drawn.
+     *
+     * The panel is a second column of the same frame, so its width has to be known before the
+     * chat column renders: below {@link PANEL_MIN_COLUMNS} the chat column would be squeezed
+     * past the point where its own wrapping and the command popup still read well, and the two
+     * full-screen surfaces - the dashboard (which already reports the same state) and a modal
+     * screen (which is a focused flow) - keep the frame to themselves.
+     */
+    /**
+     * Whether the side panel is on screen for the current terminal and surface.
+     *
+     * Exposed because the panel is the only consumer of the CLI's Git summary: a caller that would
+     * spawn processes to fill it can ask first, and skip the work while nothing can display it.
+     */
+    panelVisible() {
+        return this.panelColumns(Math.max(1, this.output.columns || 80), Math.max(1, this.output.rows || 24)) > 0;
+    }
+    panelColumns(width, height) {
+        if (this.dashboard || this.modal || width < PANEL_MIN_COLUMNS || height < PANEL_MIN_ROWS)
+            return 0;
+        return panelWidth(width);
+    }
+    /**
+     * The side panel's rows for this frame.
+     *
+     * Assembled per render rather than cached: the rows carry a clock (how long a background
+     * terminal has been running) and follow the node set the run is publishing, and the packing
+     * only ever walks a handful of sections.
+     * @param columns - total columns the panel occupies, divider and gutter included.
+     * @param height - rows the panel may use, the whole frame height.
+     */
+    panelRows(columns, height) {
+        if (!columns)
+            return [];
+        const entries = [...this.activeNodes.entries()];
+        // The node the reader is watching - the one the speed readout follows - leads the section,
+        // and the rest follow so a parallel run still names every node that is working.
+        const focus = this.activeSpeedNode !== undefined && this.activeNodes.has(this.activeSpeedNode) ? this.activeSpeedNode : entries[0]?.[0];
+        const nodes = entries
+            .sort(([left], [right]) => (left === focus ? -1 : right === focus ? 1 : 0))
+            .map(([id, node]) => {
+            const detail = [node.loop, node.copies.size ? `copy ${[...node.copies].sort((a, b) => a - b).join(',')}/${node.totalCopies}` : ''].filter(Boolean).join(' · ');
+            // The row describes the copy the reader is watching: when the speed readout follows a
+            // parallel copy, that copy's own resolution is the one to name - another copy's fallback
+            // must not be reported as this one's model.
+            const perCopy = id === focus && this.activeSpeedCopy !== undefined ? node.copiesResolved?.get(this.activeSpeedCopy) : undefined;
+            const provider = perCopy?.provider ?? node.provider;
+            const model = perCopy?.model ?? node.model;
+            const label = provider !== undefined || model !== undefined ? `${provider ?? this.status.provider} / ${model ?? this.status.model}` : '';
+            return { id, name: node.name, ...(detail ? { detail } : {}), ...(label ? { model: label } : {}) };
+        });
+        return sidePanelRows({
+            branch: this.status.branch,
+            changes: this.status.changes,
+            nodes,
+            graph: this.status.graph,
+            customGraph: isCustomGraph(this.status.graphSelection, this.status.graph),
+            visited: [...this.visitedNodes],
+            ...(this.stoppedNode ? { stoppedNode: this.stoppedNode } : {}),
+            todos: this.todos,
+            terminals: this.status.terminals ?? [],
+            now: this.tokenClock ? this.tokenClock() : Date.now(),
+        }, Math.max(8, columns - 2), height);
+    }
+    /**
+     * Compose the chat column's rows with the panel's into the frame's rows.
+     *
+     * Each row is padded to the chat width so the divider column stays unbroken, then carries
+     * the panel cell for that row. A painted row is measured with `stringWidth`, which ignores
+     * escape sequences, so padding cannot be confused by the color the chat row already holds.
+     */
+    composePanel(lines, rows, columns, chatWidth) {
+        if (!columns)
+            return lines;
+        const divider = paint('│', FAINT);
+        return Array.from({ length: Math.max(lines.length, rows.length) }, (_, index) => {
+            const left = lines[index] ?? '';
+            const size = stringWidth(left);
+            const padded = size >= chatWidth ? left : left + ' '.repeat(chatWidth - size);
+            const cell = rows[index];
+            const text = cell ? cell.segments.map(segment => paint(segment.text, segment.color ?? GRAY)).join('') : '';
+            return padded + (text ? ` ${divider} ${text}` : ` ${divider}`);
+        });
+    }
+    /**
+     * The model currently answering, as its footer label plus the thinking effort and context window
+     * that belong to it.
+     *
+     * While a graph node is active this names the node the user is watching - the one whose
+     * requests the speed readout follows, or the first-started one when no speed identity is
+     * named - followed by the provider and model that node actually resolved and by the effort
+     * and window of that same resolution, so the whole line describes one model. With no active
+     * node it is the session's own selection, and no node is named for an idle prompt or for a
+     * plain run that never started a graph node.
+     */
+    activeModel() {
+        const node = this.displayNode();
+        if (!node)
+            return { label: oneLine(`${this.status.provider} / ${this.status.model}`), reasoningEffort: this.status.reasoningEffort, contextWindow: this.status.contextWindow };
+        const more = this.activeNodes.size > 1 ? ` +${this.activeNodes.size - 1} more` : '';
+        // The row names the copy the readout follows, so it names that copy's resolution too: two
+        // copies of one node can run different profiles, and the last announcement is not the model
+        // generating now.
+        const perCopy = this.activeSpeedCopy !== undefined ? node.copiesResolved?.get(this.activeSpeedCopy) : undefined;
+        const provider = perCopy?.provider ?? node.provider ?? this.status.provider;
+        const model = perCopy?.model ?? node.model ?? this.status.model;
+        // The whole line describes one resolution: when the followed copy announced its own, that one
+        // answers for the effort and the window too, not the node's last announcement from a sibling.
+        const resolved = perCopy?.resolved ?? node.resolved;
+        return {
+            label: oneLine(`${node.name}${more} · ${provider} / ${model}`),
+            reasoningEffort: resolved ? resolved.reasoningEffort : this.status.reasoningEffort,
+            contextWindow: resolved ? resolved.contextWindow : this.status.contextWindow,
+        };
+    }
+    started = false;
+    closed = false;
+    wasRaw = false;
+    wasPaused = false;
+    scheduled = false;
+    pending;
+    value = [];
+    cursor = 0;
+    transcript = new PagedTranscript();
+    expandedTranscript = false;
+    todos = [];
+    expandedTodos = false;
+    todoOffset = 0;
+    todoPageSize = 0;
+    scroll = 0;
+    /** Whether a run is streaming: with no prompt pending, the wheel may scroll the transcript. */
+    runActive = false;
+    /**
+     * Whether alternate scroll mode (?1007) is currently armed.
+     *
+     * The app never takes mouse reporting, so the terminal keeps drag-to-select and its
+     * clipboard in every state. In the alternate screen a terminal instead turns the wheel
+     * into Up/Down sequences when alternate scroll is on — byte-identical to the arrow keys,
+     * and on by default in Windows Terminal, VTE and iTerm2 — so the app arms that mode only
+     * where Up/Down cannot recall history: while a screen is open, or while a run streams with
+     * no question pending. At the resting prompt it is switched off and the wheel is inert.
+     */
+    alternateScroll = false;
+    /**
+     * Live reasoning preview state. `thinkingActive` marks a stream in progress; the text
+     * is the bounded tail the preview renders from.
+     */
+    thinking = '';
+    thinkingActive = false;
+    /** The preview opens expanded on every stream; Ctrl+Y collapses the current one. */
+    thinkingExpanded = true;
+    expandedPromptIds = new Set();
+    /** Prompts the reader explicitly collapsed; an explicit toggle wins over Ctrl+O (see promptExpanded). */
+    collapsedPromptIds = new Set();
+    /** Every prompt box the transcript currently holds, so Ctrl+O can invert each one on screen. */
+    promptBoxIds = new Set();
+    expandedPromptVisible = false;
+    nextPromptId = 1;
+    thinkingPaintedAt = 0;
+    thinkingFlush;
+    /**
+     * The rows currently on screen, so a repaint can rewrite only what changed.
+     *
+     * See {@link writeFrame}: a terminal drops an in-progress drag selection when the app
+     * rewrites the cells under it, and a run repaints eight times a second for its animation.
+     */
+    drawn = [];
+    /** Terminal size `drawn` was produced at; a resize invalidates the comparison. */
+    drawnSize = '';
+    /** The caret sequence last emitted, so an unmoved caret costs no extra write. */
+    drawnCursor = '';
+    history = [];
+    historyIndex = 0;
+    draft = '';
+    completion;
+    dismissedCompletion;
+    incoming = '';
+    pasting = false;
+    paste = '';
+    pasteQuestion;
+    plainTimer;
+    pendingBreak = '';
+    plainPaste = false;
+    plainTrailingCR = false;
+    plainQuestion;
+    modal;
+    modalInput = false;
+    /**
+     * The last selection screen that was answered.
+     *
+     * Setup closes a selection screen and then asks for a value, which used to leave the home
+     * card where the list had been: the reader lost both the list and the entry it led to the
+     * moment they started typing. The card is kept here so a typed field can be answered with
+     * the list still on screen (see selectionCard).
+     */
+    lastSelection;
+    escapeTimer;
+    workingTimer;
+    /** The panel's one-second age clock; see render(). */
+    panelTimer;
+    workingSince;
+    workingElapsed = 0;
+    /**
+     * Whether the composer accepts input while a run is active.
+     *
+     * Enabled for the duration of an interactive run so the user can steer it. Text
+     * submitted in this mode is queued rather than resolved as a question answer.
+     */
+    steering = false;
+    runInputHandler;
+    localCommandHandler;
+    commandInput = false;
+    /** Handle active commands and resumed direction synchronously; true consumes the input. */
+    setRunInputHandler(handler) { this.runInputHandler = handler; }
+    /** Observe slash commands consumed by the view without submitting them to the run. */
+    setLocalCommandHandler(handler) { this.localCommandHandler = handler; }
+    /** Settle the current approval after an explicit session permission change. */
+    resolveQuestion(value) {
+        const pending = this.pending;
+        if (!pending)
+            return;
+        this.finishQuestion();
+        pending.resolve(value);
+        this.scheduleRender();
+    }
+    /** Submit from the browser only while the terminal is accepting a conversation prompt. */
+    acceptConversationPrompt(value) {
+        if (!this.pending?.conversationPrompt || this.modal)
+            return false;
+        this.resolveQuestion(value);
+        return true;
+    }
+    /** Current runtime question for connected GUI surfaces. Conversation prompts stay in the composer. */
+    browserPendingIdentity;
+    browserQuestionNumber = 0;
+    browserQuestion() {
+        const pending = this.pending;
+        if (!pending || pending.conversationPrompt)
+            return undefined;
+        if (pending !== this.browserPendingIdentity) {
+            this.browserPendingIdentity = pending;
+            this.browserQuestionNumber++;
+        }
+        const question = pending.dashboardQuestion || pending.choiceTitle || pending.title || pending.label;
+        return { id: `terminal-${this.browserQuestionNumber}`, kind: pending.kind, question, approvalDetailsRequired: pending.kind === 'approval', approvalDetails: pending.approvalDetails, choices: pending.choices?.map(item => ({ id: item.id, label: item.label })) };
+    }
+    steered = [];
+    /**
+     * Attachments queued in the composer draft — large pastes spooled to text, dropped file
+     * paths, clipboard images. Each sits in the draft as an inline token (its `marker` code
+     * point), drawn as an amber label and edited as one character. They ride the next submitted
+     * task (or the next queued steer) and are drained by the CLI, mirroring how `steered` is
+     * drained at turn boundaries.
+     */
+    attachments = [];
+    attachmentSeq = 0;
+    /**
+     * Generation of the composer's attachment surface. Advanced by every draft clear and steer
+     * submission: an asynchronous clipboard probe that started before one of those lands nowhere,
+     * because the composer it was reading for is gone (steering keeps the same owner all run).
+     */
+    clipboardProbe = 0;
+    clipboardImageProbe;
+    clipboardTextWriter;
+    /**
+     * Where the composer's Shift+Arrow selection started; it runs from here to the cursor.
+     * `selectionValue` is the draft it was made in: replacing the draft (a submission, history
+     * recall, a completion) swaps the array, which drops the selection without bookkeeping.
+     */
+    selectionAnchor;
+    selectionValue;
+    /**
+     * A half-typed steer parked while a question temporarily takes the composer.
+     *
+     * Questions and steering share `value`; without this a partially typed steer would be
+     * wiped the moment the runtime asks for an approval or clarification.
+     */
+    steerDraft;
+    steerCursor = 0;
+    constructor(options) {
+        super();
+        this.input = options.input ?? process.stdin;
+        this.output = options.output ?? process.stdout;
+        this.workspace = oneLine(options.workspace);
+        this.version = oneLine(options.version);
+        this.appName = oneLine(options.appName ?? 'ANDORRA CODE');
+        this.status = { ...options };
+        this.tokenClock = options.tokenClock;
+        this.clipboardImageProbe = options.clipboardImageProbe;
+        this.clipboardTextWriter = options.clipboardTextWriter;
+        emitKeypressEvents(this.keys);
+        this.keys.on('keypress', this.onKey);
+    }
+    start() {
+        if (this.closed)
+            throw new Error('Terminal is closed');
+        if (this.started)
+            return;
+        this.wasRaw = this.input.isRaw;
+        this.wasPaused = this.input.readableFlowing !== true;
+        this.input.setRawMode?.(true);
+        this.input.ref?.();
+        this.started = true;
+        this.input.on('data', this.onData);
+        this.input.on('end', this.onEnd);
+        this.output.on('resize', this.onResize);
+        this.input.resume();
+        // The app never takes mouse reporting (?1000h/?1006h): the terminal keeps its own
+        // drag-to-select and clipboard in every state, at rest and while a run streams alike, with
+        // no modifier bypass to learn. What the wheel does is governed by alternate scroll mode
+        // (?1007) instead. In the alternate screen a terminal with that mode on turns the wheel
+        // into Up/Down sequences byte-identical to the arrow keys, and Windows Terminal, VTE and
+        // iTerm2 have it on by default — which is how an uncaptured wheel once recalled the
+        // previous prompt. The mode is therefore switched off explicitly here, and
+        // `updateAlternateScroll` arms it only where Up/Down cannot reach history: while a
+        // screen is open (its keys scroll or move the highlight) or while a run streams with no
+        // question pending (Up/Down scroll the transcript, see onKey). At the resting prompt the
+        // wheel is inert and Up/Down stay purely keyboard: input history, or cursor movement in a
+        // draft. The collapsed long-prompt boxes open with Ctrl+O and the live reasoning preview
+        // toggles with Ctrl+Y; neither needs a click. writeFrame only rewrites rows that changed,
+        // so the working animation does not repaint cells under a drag selection either. Entering
+        // the alternate screen blanks it, so nothing drawn before is still there to diff.
+        this.drawn = [];
+        this.drawnSize = '';
+        this.drawnCursor = '';
+        this.output.write('\x1b[?1049h\x1b[?2004h\x1b[?25l\x1b[?1007l');
+        this.alternateScroll = false;
+        this.updateAlternateScroll();
+        this.render();
+    }
+    question(prompt = '', options = {}) {
+        if (this.closed)
+            return Promise.reject(new Error('Terminal is closed'));
+        if (this.pending)
+            return Promise.reject(new Error('A terminal question is already active'));
+        if (this.modal)
+            return Promise.reject(new Error('A terminal screen is already active'));
+        if (options.signal?.aborted)
+            return Promise.reject(new DOMException('Question aborted', 'AbortError'));
+        if (!this.started)
+            this.start();
+        // A question (approval or clarification) can interrupt a run while a steer is half typed.
+        // Park it, so taking the composer for the question does not silently discard the draft.
+        if (this.steering && this.value.length) {
+            this.steerDraft = this.value.join('');
+            this.steerCursor = this.cursor;
+        }
+        this.value = [];
+        this.cursor = 0;
+        this.historyIndex = this.history.length;
+        this.completion = undefined;
+        this.dismissedCompletion = undefined;
+        const label = clean(prompt).trim();
+        const regular = options.kind !== 'approval';
+        if (!regular)
+            this.print(label);
+        return new Promise((resolve, reject) => {
+            const pending = { kind: options.kind ?? 'question', resolve, reject, signal: options.signal, label: oneLine(label), title: options.title ? oneLine(options.title).trim() : undefined, regular, cancelOnEscape: options.cancelOnEscape, conversationPrompt: options.conversationPrompt === true, secret: options.secret, history: regular && options.history !== false && !options.secret };
+            pending.abort = () => { if (this.pending !== pending)
+                return; this.finishQuestion(); reject(new DOMException('Question aborted', 'AbortError')); this.scheduleRender(); };
+            this.pending = pending;
+            this.updateAlternateScroll();
+            this.updateWorkingClock();
+            pending.signal?.addEventListener('abort', pending.abort, { once: true });
+            this.scheduleRender();
+        });
+    }
+    async chooseQuestion(prompt, items, options = {}) {
+        if (!items.length || items.some(item => !item.id))
+            throw new Error('Question choices require nonempty IDs');
+        if (this.pending || this.modal)
+            throw new Error('A terminal question or screen is already active');
+        const displayedPrompt = prompt === 'Choose an answer' ? this.dashboardNotices.at(-1) ?? prompt : prompt;
+        if (options.printPrompt !== false)
+            this.print(prompt);
+        const answer = this.question('↑↓ Choose · Enter confirm · Esc cancel', { ...options, history: false });
+        const pending = this.pending;
+        // Keep tool identity alongside its arguments so the browser snapshot sanitizer
+        // can apply tool-specific privacy rules before any details leave the CLI.
+        if (pending && options.kind === 'approval')
+            pending.approvalDetails = options.approvalDetails;
+        if (pending) {
+            pending.choices = items.map(item => ({ ...item }));
+            pending.choiceIndex = 0;
+            pending.choiceTitle = oneLine(prompt).trim();
+            pending.dashboardQuestion = clean(displayedPrompt).trim();
+        }
+        this.scheduleRender();
+        return (await answer) || undefined;
+    }
+    select(title, items, options = {}) {
+        let selected = Math.max(0, items.findIndex(item => item.id === options.selectedId));
+        while (items[selected]?.separator)
+            selected++;
+        return this.openModal({ kind: 'select', title, items: [...items], lines: [], selected, selectedId: options.selectedId, ...options });
+    }
+    /** Move the select highlight, carrying the movement past separator rows: separators are visual line breaks, never choices. */
+    moveSelection(modal, movement, homeEnd) {
+        const selectable = (index) => index >= 0 && index < modal.items.length && !modal.items[index].separator;
+        let target = homeEnd === 'home' ? 0 : homeEnd === 'end' ? modal.items.length - 1 : Math.max(0, Math.min(modal.items.length - 1, modal.selected + movement));
+        if (selectable(target)) {
+            modal.selected = target;
+            return;
+        }
+        const direction = Math.sign(movement) || (homeEnd === 'end' ? -1 : 1);
+        for (let probe = target; probe >= 0 && probe < modal.items.length; probe += direction)
+            if (selectable(probe)) {
+                modal.selected = probe;
+                return;
+            }
+        for (let probe = target; probe >= 0 && probe < modal.items.length; probe -= direction)
+            if (selectable(probe)) {
+                modal.selected = probe;
+                return;
+            }
+    }
+    async showScreen(title, lines, options = {}) { await this.openModal({ kind: 'text', title, items: [], lines: [...lines], selected: 0, ...options }); }
+    loadScreen(title, load, options = {}) {
+        const controller = new AbortController();
+        const promise = this.openModal({ kind: 'loading', title, items: [], lines: [], selected: 0, controller, ...options });
+        const modal = this.modal;
+        if (modal?.controller === controller)
+            Promise.resolve().then(() => { controller.signal.throwIfAborted(); return load(controller.signal); }).then(value => { if (this.modal === modal)
+                this.finishModal(value); }, error => { if (this.modal === modal)
+                this.finishModal(undefined, error instanceof Error ? error : new Error(String(error))); });
+        return promise;
+    }
+    openModal(options) {
+        if (this.closed)
+            return Promise.reject(new Error('Terminal is closed'));
+        if (this.modal)
+            return Promise.reject(new Error('A terminal screen is already active'));
+        if (options.signal?.aborted)
+            return Promise.reject(new DOMException('Screen aborted', 'AbortError'));
+        if (!this.started)
+            this.start();
+        this.clearPlainInput();
+        this.pasteQuestion = undefined;
+        return new Promise((resolve, reject) => {
+            const modal = { ...options, title: oneLine(options.title), description: options.description ? clean(options.description) : undefined, offset: 0, resolve, reject };
+            modal.abort = () => { if (this.modal === modal)
+                this.finishModal(undefined, new DOMException('Screen aborted', 'AbortError')); };
+            this.modal = modal;
+            this.updateAlternateScroll();
+            this.updateWorkingClock();
+            modal.signal?.addEventListener('abort', modal.abort, { once: true });
+            this.scheduleRender();
+        });
+    }
+    finishModal(value, error) {
+        const modal = this.modal;
+        if (!modal)
+            return;
+        this.modal = undefined;
+        this.updateAlternateScroll();
+        // Only a selection that was actually made is worth docking: a cancelled list leads to no
+        // field, and the caller returns to the conversation instead.
+        if (modal.kind === 'select' && !error && typeof value === 'string')
+            this.lastSelection = { title: modal.title, description: modal.description, items: modal.items.map(item => ({ ...item })), selected: modal.selected };
+        this.updateWorkingClock();
+        if (modal.abort)
+            modal.signal?.removeEventListener('abort', modal.abort);
+        modal.controller?.abort();
+        this.clearPlainInput();
+        this.pasteQuestion = undefined;
+        if (error)
+            modal.reject(error);
+        else
+            modal.resolve(value);
+        this.scheduleRender();
+    }
+    print(text, detail, toolCall, conversation = false, notice = true, alignRight = false) {
+        if (notice) {
+            this.dashboardNotices.push(clean(String(text)).slice(0, 100_000));
+            this.dashboardNotices = this.dashboardNotices.slice(-12);
+        }
+        const lines = clean(String(text)).split('\n');
+        if (this.modal?.kind === 'loading')
+            this.modal.lines = [...this.modal.lines, ...lines].slice(-100);
+        const entry = { text: lines.join('\n'), ...(detail ? { detail: clean(detail) } : {}),
+            ...(toolCall ? { toolCall, timing: this.toolClock.get(toolCall.key) } : {}), ...(conversation ? { conversation: true } : {}), ...(alignRight ? { alignRight: true } : {}) };
+        if (this.scroll)
+            this.scroll += this.transcriptRows(entry, this.chatColumns()).length;
+        this.transcript.append(entry);
+        this.scheduleRender();
+    }
+    /**
+     * Echo submitted text as its own bordered box.
+     *
+     * The box mirrors the live input field's frame and color so the text reads as the
+     * same surface the user typed into, rather than a `You >` transcript prefix. The
+     * frame itself identifies the text as user input, so a submitted prompt is left
+     * untitled; only a surface that is genuinely something other than a task prompt —
+     * a clarification answer — passes a title. The frame is sized to the terminal at
+     * echo time; a later resize re-wraps the body but keeps the original box, which is
+     * an accepted trade for not rewriting history on resize. The finished box is drawn right-aligned against the transcript's right margin (see wrapTranscript), so a submission reads as the user's speech bubble and re-aligns when the window is resized.
+     * @param text - the submitted text to echo.
+     * @param title - optional top-border label; omitted draws a plain frame.
+     */
+    printPrompt(text, title = '') {
+        // The width the transcript will show this box at, not the width of the surface submitting it.
+        const width = Math.max(12, this.transcriptColumns()) - 4;
+        // Reserve the four frame characters ('│ ', ' │') plus the two-space transcript indent,
+        // so a body row can never exceed the width the render pass wraps at.
+        const bodyWidth = Math.max(1, width - 4);
+        const titleBudget = Math.max(0, width - 4);
+        const label = oneLine(title).trim();
+        const frameTitle = label ? clip(` ${label} `, titleBudget) : '';
+        const rows = clean(String(text)).slice(0, 100_000).split('\n').flatMap(line => wrap(line, bodyWidth));
+        // Expansion preserves the existing bounded-history contract: the model still receives the
+        // full submitted input, while the transcript stores at most MAX_PROMPT_ROWS rendered rows.
+        const omitted = rows.length - MAX_PROMPT_ROWS;
+        const marker = omitted > 0 ? wrap(`… ${omitted + 1} more rows omitted`, bodyWidth) : [];
+        const fullBody = omitted > 0 ? [...rows.slice(0, MAX_PROMPT_ROWS - marker.length), ...marker] : rows;
+        const frame = (body) => {
+            const widest = body.reduce((max, line) => Math.max(max, stringWidth(line)), 0);
+            const inner = Math.max(widest, stringWidth(frameTitle) - 2);
+            const rule = Math.max(0, inner + 2 - stringWidth(frameTitle));
+            const top = '╭' + frameTitle + '─'.repeat(rule) + '╮';
+            const bottom = '╰' + '─'.repeat(inner + 2) + '╯';
+            return [top, ...body.map(line => '│ ' + pad(line, inner) + ' │'), bottom].join('\n');
+        };
+        if (rows.length <= PROMPT_COLLAPSE_AFTER_ROWS) {
+            // Positional call, so name the last flag: the echo is the user's speech bubble (alignRight).
+            this.print(frame(fullBody), undefined, undefined, true, true, true);
+            return;
+        }
+        // Reserve the entire wrapped disclosure before choosing preview rows. On a narrow terminal
+        // the marker itself may need more than six rows; in that case the marker wins and the preview
+        // shrinks to zero rather than hiding the actionable "Ctrl+O to expand" text.
+        let previewRows = Math.max(0, PROMPT_COLLAPSED_BODY_ROWS - 1);
+        let disclosure = [];
+        for (let pass = 0; pass < 3; pass++) {
+            const hidden = Math.max(1, rows.length - previewRows);
+            const suffix = omitted > 0 ? ` · ${omitted + 1} more rows omitted from expanded view` : '';
+            disclosure = wrap(`… ${hidden} more rows · Ctrl+O to expand${suffix}`, bodyWidth);
+            previewRows = Math.max(0, PROMPT_COLLAPSED_BODY_ROWS - disclosure.length);
+        }
+        const collapsedBody = [...rows.slice(0, previewRows), ...disclosure];
+        const promptDisclosure = {
+            id: this.nextPromptId++,
+            collapsedText: frame(collapsedBody),
+            expandedText: frame([...fullBody, 'Ctrl+O to collapse']),
+        };
+        this.promptBoxIds.add(promptDisclosure.id);
+        const entry = { text: promptDisclosure.collapsedText, detail: promptDisclosure.expandedText, conversation: true, promptDisclosure, alignRight: true };
+        if (this.scroll)
+            this.scroll += this.transcriptRows(entry, this.chatColumns()).length;
+        this.transcript.append(entry);
+        this.scheduleRender();
+    }
+    /**
+     * Stream one reasoning delta into the live preview line.
+     *
+     * The preview always shows the tail of what has arrived, so each call only has to grow
+     * the bounded buffer; rendering stays on the working clock's repaint cadence, with a
+     * small throttle so a token firehose cannot trigger a full-frame render per network
+     * chunk.
+     * @param delta - the reasoning fragment that just arrived; empty fragments are ignored.
+     */
+    appendThinking(delta) {
+        if (this.closed || !delta)
+            return;
+        this.thinking = (this.thinking + clean(delta)).slice(-THINKING_KEEP);
+        if (!this.thinkingActive)
+            this.thinkingActive = true;
+        if (Date.now() - this.thinkingPaintedAt >= THINKING_PAINT_MS) {
+            this.thinkingPaintedAt = Date.now();
+            this.scheduleRender();
+        }
+        else {
+            this.thinkingFlush ??= setTimeout(() => { this.thinkingFlush = undefined; this.thinkingPaintedAt = Date.now(); this.scheduleRender(); }, THINKING_PAINT_MS);
+            this.thinkingFlush.unref?.();
+        }
+    }
+    /**
+     * Wipe the on-screen conversation so the display reads as a freshly started session.
+     *
+     * Only the transcript entries, the scroll position and the live reasoning preview are dropped:
+     * the welcome card is rebuilt as the scrollback prefix on the next render, so the frame returns
+     * to its startup shape without re-emitting a banner or a terminal clear escape. The composer's
+     * prompt-recall history is deliberately kept — it is input history, not chat output.
+     */
+    clearConversation() {
+        if (this.closed)
+            return;
+        this.transcript.clear();
+        this.expandedTranscript = false;
+        this.expandedPromptIds.clear();
+        this.collapsedPromptIds.clear();
+        this.promptBoxIds.clear();
+        this.expandedPromptVisible = false;
+        // A cleared conversation abandons its pending attachments with it: they were queued for a
+        // task in this conversation, and silently attaching them to the next one would submit files
+        // the user never re-chose.
+        this.attachments = [];
+        // The scroll offset is clamped against the transcript, so a stale offset would draw an empty
+        // or misplaced window over the cleared list instead of the live tail.
+        this.scroll = 0;
+        this.clearThinking();
+        this.scheduleRender();
+    }
+    /** Retract the preview: the stream ended, was retried, or the whole run finished. */
+    clearThinking() {
+        if (this.thinkingFlush) {
+            clearTimeout(this.thinkingFlush);
+            this.thinkingFlush = undefined;
+        }
+        if (!this.thinkingActive && !this.thinking)
+            return;
+        this.thinking = '';
+        this.thinkingActive = false;
+        this.thinkingExpanded = true;
+        this.scheduleRender();
+    }
+    setStatus(partial) {
+        // The CLI reloads and re-validates the selected graph before every run, handing setStatus
+        // a fresh object for an unchanged selection. Display bookkeeping treats any new graph
+        // object as a change (its node identities repopulate from the run's own events anyway),
+        // while the speed readout identifies the graph by id and revision: a reload of the same
+        // graph keeps its average, a genuinely different or re-edited graph starts over.
+        const graphIdentity = (graph) => graph === undefined ? undefined : `${graph.id}@${graph.revision}`;
+        const modelChanged = (partial.provider !== undefined && partial.provider !== this.status.provider)
+            || (partial.model !== undefined && partial.model !== this.status.model)
+            || (partial.reasoningEffort !== undefined && partial.reasoningEffort !== this.status.reasoningEffort)
+            || (partial.providerModels !== undefined && JSON.stringify(partial.providerModels) !== JSON.stringify(this.status.providerModels));
+        const graphObjectChanged = partial.graph !== undefined && partial.graph !== this.status.graph;
+        const graphChanged = partial.graph !== undefined && graphIdentity(partial.graph) !== graphIdentity(this.status.graph);
+        if (modelChanged || graphObjectChanged) {
+            this.nodeModels.clear();
+            this.dashboardGraphOffset = 0;
+        }
+        if (modelChanged || graphChanged) {
+            // The nodes now decode under a different model or inference configuration, so every
+            // accumulated average describes something the footer no longer shows.
+            this.speedMeters.clear();
+            this.speedInvocations.clear();
+            this.activeSpeedNode = undefined;
+            this.activeSpeedCopy = undefined;
+            this.activeSpeedKey = undefined;
+        }
+        // A trail of node ids means nothing in another graph: the panel's zoom would focus an id
+        // that does not exist there and count visits against the new graph's total, so a changed
+        // selection starts it over - including the position a stopped run ended on, which is a node
+        // id from that same graph. Reloading the same graph (same id and revision) keeps both.
+        if (graphChanged) {
+            this.visitedNodes.clear();
+            this.stoppedNode = undefined;
+        }
+        this.status = { ...this.status, ...partial };
+        // A run ending returns the footer to idle but does not retire the speed readout: each
+        // node's cumulative average keeps describing the node that just ran, and it is the
+        // baseline the next run of that node continues from.
+        if (partial.activity === 'Ready') {
+            this.activeNodes.clear();
+            this.toolClock.stop();
+            this.updateToolClock();
+            this.clearThinking();
+        }
+        this.updateWorkingClock();
+        this.scheduleRender();
+    }
+    /**
+     * Feed the footer's token-speed readout with one finished model request.
+     *
+     * Providers report a request's tokens only when it completes. A streamed request carries its
+     * measured decode window, which is the time the tokens are credited with; otherwise the
+     * number is measured over the window opened by the call's `agent.iteration.started` event
+     * rather than credited to the instant it arrived, which would leave the readout no duration
+     * to divide by. The completion also replaces the live estimate {@link noteStreamedOutput}
+     * kept for the same request. `invocationId` - the id the executor stamps on both the start
+     * event and the usage delta - selects that window and, through the marker that opened it,
+     * the node whose average the measurement belongs to, so a completion from a concurrent request cannot
+     * borrow another request's window or another node's average. The measurement folds into
+     * that node's cumulative average, which only a changed selection or a changed model
+     * resolution for the node resets. Deltas that carry no tokens (the adapter's per-attempt
+     * request counting, retries included) are not completions and are passed through to the
+     * meter, which ignores them for window pairing. A final delta without tokens - a provider
+     * that omits usage - still closes its request's window but leaves the average untouched:
+     * it describes the requests that did report.
+     * @param tokens - output tokens the provider reported for that single request.
+     * @param invocationId - request identity from the executor, when one is known.
+     * @param final - true when the delta closes its request, per the runtime's origin flag.
+     * @param decodeMs - the adapter's measured decode window for the request, when it has one.
+     */
+    noteGeneratedTokens(tokens, invocationId, final, decodeMs) {
+        const key = this.speedRoute(invocationId);
+        // Attempt bookkeeping (zero tokens, not final) keeps its routing entry, so the completion
+        // that follows the retries still finds its meter; a completion consumes the entry.
+        if (invocationId !== undefined && (tokens > 0 || final))
+            this.speedInvocations.delete(invocationId);
+        this.ensureSpeedMeter(key).meter.report(tokens, invocationId, final, decodeMs);
+        this.scheduleRender();
+    }
+    /**
+     * Feed the footer's token-speed readout with a fragment a request is still streaming.
+     *
+     * A thinking model can stream for minutes before its usage arrives, and a readout that moved
+     * only on completions sat on the previous number the whole time. The fragment is estimated
+     * into the same meter the completion will report to, and repaints only when the number on
+     * screen changes - a stream from a node the footer does not follow costs nothing.
+     * @param text - the streamed reasoning or answer fragment.
+     * @param invocationId - request identity from the executor, when one is known.
+     */
+    noteStreamedOutput(text, invocationId) {
+        const before = this.displayRate();
+        this.ensureSpeedMeter(this.speedRoute(invocationId)).meter.stream(text, invocationId);
+        if (this.displayRate() !== before)
+            this.scheduleRender();
+    }
+    /** Drop a request's live estimate: the attempt failed, is about to be retried, or was aborted. */
+    noteStreamEnded(invocationId) {
+        const before = this.displayRate();
+        this.speedMeters.get(this.speedRoute(invocationId))?.meter.endStream(invocationId);
+        if (this.displayRate() !== before)
+            this.scheduleRender();
+    }
+    /** The meter a request's measurements belong to: the one its start marker named, else the followed one. */
+    speedRoute(invocationId) {
+        const routed = invocationId !== undefined ? this.speedInvocations.get(invocationId) : undefined;
+        return routed ?? this.activeSpeedKey ?? 'engineer';
+    }
+    /** The meter key for a node's requests: parallel copies each keep their own meter. */
+    speedKey(nodeId, copy) {
+        return copy === undefined ? nodeId : `${nodeId}#copy${copy}`;
+    }
+    /** The meter's speed entry, created on first sight so no measurement is ever dropped. */
+    ensureSpeedMeter(key) {
+        let entry = this.speedMeters.get(key);
+        if (!entry) {
+            entry = { meter: new TokenRateMeter(this.tokenClock) };
+            this.speedMeters.set(key, entry);
+        }
+        return entry;
+    }
+    /**
+     * Stamp a meter with the resolution its generating identity announced.
+     *
+     * A resolution different from the one the meter already measured under rebuilds the meter:
+     * its average described the previous model or reasoning effort, which is exactly the
+     * whole-agent-fallback case. Learning the identity for a meter that had none (the session
+     * event merely arrives before the meter was stamped) never discards measurements.
+     */
+    stampSpeedMeter(key, provider, model, reasoningEffort) {
+        const entry = this.ensureSpeedMeter(key);
+        const changed = (provider !== undefined && entry.provider !== undefined && provider !== entry.provider)
+            || (model !== undefined && entry.model !== undefined && model !== entry.model)
+            || (reasoningEffort !== undefined && entry.reasoningEffort !== undefined && reasoningEffort !== entry.reasoningEffort);
+        if (changed)
+            this.speedMeters.set(key, { meter: new TokenRateMeter(this.tokenClock), provider: provider ?? entry.provider, model: model ?? entry.model, reasoningEffort: reasoningEffort ?? entry.reasoningEffort });
+        else {
+            if (provider !== undefined)
+                entry.provider = provider;
+            if (model !== undefined)
+                entry.model = model;
+            if (reasoningEffort !== undefined)
+                entry.reasoningEffort = reasoningEffort;
+        }
+    }
+    /**
+     * The footer's token speed: the cumulative average of the generating identity the readout
+     * currently follows, unchanged between completions.
+     *
+     * Exposed for callers and tests that need the exact number the readout is based on. The
+     * footer draws {@link displayRate}, which adds the model-identity check.
+     */
+    tokenSpeed() { return this.activeSpeedKey === undefined ? 0 : this.speedMeters.get(this.activeSpeedKey)?.meter.rate() ?? 0; }
+    /**
+     * The node whose resolution the model row and the speed readout describe.
+     *
+     * This is the identity the readout follows - the most recent node or parallel copy to open
+     * a model call - so the row names the same node whose average is drawn, not whichever node
+     * happened to start first. Without a followed identity it falls back to the first active
+     * node, and with no active node at all the session's own selection answers.
+     */
+    displayNode() {
+        return (this.activeSpeedNode !== undefined ? this.activeNodes.get(this.activeSpeedNode) : undefined)
+            ?? [...this.activeNodes.values()][0];
+    }
+    /**
+     * The speed the footer shows: the followed identity's cumulative average, but only while
+     * the model row names the resolution the average was measured under.
+     *
+     * After a run ends the row reverts to the session's own selection, so an average measured
+     * on a node with a provider, model or effort override would otherwise sit beside a
+     * different resolution's name; the segment disappears instead of misdescribing it.
+     */
+    displayRate() {
+        const entry = this.activeSpeedKey === undefined ? undefined : this.speedMeters.get(this.activeSpeedKey);
+        if (!entry)
+            return 0;
+        const node = this.displayNode();
+        const perCopy = this.activeSpeedCopy !== undefined ? node?.copiesResolved?.get(this.activeSpeedCopy) : undefined;
+        const provider = perCopy?.provider ?? node?.provider ?? this.status.provider;
+        const model = perCopy?.model ?? node?.model ?? this.status.model;
+        // The followed copy's own effort comes first: comparing the meter's reading against a
+        // sibling's effort suppressed a rate that was measured on this copy's own resolution.
+        const effort = perCopy?.resolved?.reasoningEffort ?? node?.resolved?.reasoningEffort ?? this.status.reasoningEffort;
+        if ((entry.provider !== undefined && entry.provider !== provider)
+            || (entry.model !== undefined && entry.model !== model)
+            || (entry.reasoningEffort !== undefined && entry.reasoningEffort !== effort))
+            return 0;
+        return entry.meter.rate();
+    }
+    /**
+     * Let the composer accept steering input for the duration of a run.
+     *
+     * Called with `true` when an interactive run starts and `false` when it ends, so the
+     * normal question flow owns the composer outside a run.
+     * @param enabled - whether submitted text should be queued as a steer.
+     * @returns when disabling, any queued steers that can no longer be injected. The
+     *   executor's last poll happens before finalization, so a steer submitted in that
+     *   window is visibly accepted but has nowhere to go; returning it lets the caller say
+     *   so instead of dropping it silently.
+     */
+    setSteering(enabled) {
+        if (this.steering === enabled)
+            return [];
+        this.steering = enabled;
+        // A parked draft belongs to the run that parked it.
+        if (!enabled) {
+            this.steerDraft = undefined;
+            this.steerCursor = 0;
+        }
+        this.scheduleRender();
+        if (enabled)
+            return [];
+        // A steer that reached the executor's finalization window has nowhere to go: its text is
+        // returned for the caller to report, and its chips return to the queue so they can ride the
+        // next task. The queue itself survives too — a paste is draft material like typed text.
+        const undelivered = this.takeSteeringTurns();
+        for (const turn of undelivered)
+            for (const pending of turn.attachments)
+                this.addAttachment(pending);
+        return undelivered.map(turn => turn.text);
+    }
+    /** The surface that currently owns the composer, if any. */
+    composerOwner() {
+        return this.pending ?? (this.steering ? STEERING_OWNER : undefined);
+    }
+    /**
+     * Whether a captured composer owner is still the owner.
+     *
+     * Deferred input (a paste, or an Enter held back by the input-burst window) is only
+     * delivered when the surface that armed it still owns the composer. Steering is an
+     * owner too, so a pasted steer must not be discarded just because no question is
+     * pending.
+     * @param token - the owner captured when the input arrived.
+     * @returns whether that owner may still accept the deferred input.
+     */
+    ownsComposer(token) {
+        // Object identity against a module-private sentinel, compared by reference and never by
+        // value. A static analyser flags `===` near the word "token" as a secret comparison; there
+        // is no secret here -- `STEERING_OWNER` is this module's own marker object and `token` is
+        // never a string, so no constant-time byte comparison applies or would mean anything.
+        if (token === STEERING_OWNER)
+            return this.steering && !this.pending;
+        return token !== undefined && token === this.pending;
+    }
+    /**
+     * Take every queued steer message, without blocking.
+     *
+     * The hardened executor polls this at turn boundaries; returning immediately with an
+     * empty array is what lets a run continue when the user has typed nothing.
+     * @returns the queued messages, oldest first.
+     */
+    takeSteering() {
+        return this.takeSteeringTurns().map(turn => turn.text);
+    }
+    /** The queued steers with their attachments, oldest first; each turn is one injected user message. */
+    takeSteeringTurns() {
+        const queued = this.steered;
+        this.steered = [];
+        return queued;
+    }
+    setTodos(todos) { this.todos = todos.map(todo => ({ ...todo, text: oneLine(todo.text) })); this.todoOffset = Math.min(this.todoOffset, Math.max(0, todos.length - 1)); if (!todos.length)
+        this.expandedTodos = false; this.scheduleRender(); }
+    todoLines(maxRows) {
+        if (!this.todos.length || maxRows < 1)
+            return [];
+        const done = this.todos.filter(todo => todo.status === 'completed').length;
+        // While scrolled back the todo block stays pinned but collapses to one line, so it
+        // never competes with the transcript the user is reading. Scrolling to the live tail
+        // restores the full list without changing the expand/collapse state.
+        if (this.scroll > 0 && !this.expandedTodos) {
+            const active = this.todos.find(todo => todo.status === 'in_progress');
+            const label = `${done}/${this.todos.length} done${active ? ` · ${active.text}` : ''}`;
+            return [`Todo  ${label} · ctrl+t to expand`];
+        }
+        // The expanded form needs a header, at least one item and a summary; the collapsed form
+        // above needs only one row, so this guard sits after it rather than hiding both.
+        if (maxRows < 3)
+            return [];
+        const count = Math.min(this.todos.length, this.expandedTodos ? maxRows - 2 : Math.min(5, maxRows - 2));
+        this.todoPageSize = count;
+        this.todoOffset = this.expandedTodos ? Math.min(this.todoOffset, this.todos.length - count) : 0;
+        const visible = this.todos.slice(this.todoOffset, this.todoOffset + count);
+        const hidden = this.todos.length - count;
+        const summary = this.expandedTodos && hidden ? `${this.todoOffset + 1}-${this.todoOffset + count}/${this.todos.length} · Page Up/Down · ` : hidden ? `… +${hidden} more ` : '';
+        return ['Todo', ...visible.map(todo => `  ${todo.status === 'completed' ? '✓' : todo.status === 'in_progress' ? '●' : '○'} ${todo.text}`), `${summary}(${done} done) · ctrl+t to ${this.expandedTodos ? 'collapse' : 'expand'}`];
+    }
+    /**
+     * Rows for the live reasoning preview, standing in for the plain working line.
+     *
+     * Collapsed it keeps the latest reasoning on one row and pins elapsed time plus the
+     * expand control on the row directly beneath it, so a growing reasoning tail cannot push
+     * the control off to the right. Expanded, the default for every new stream, it opens a
+     * fixed {@link THINKING_ROWS}-row window on the tail, padded at the top with the marker on
+     * the first reasoning row, with the same control row beneath it. `maxRows`
+     * is the room the terminal offers once the transcript keeps at least its last row; a
+     * one-row budget still shows the reasoning row.
+     */
+    thinkingLines(width, seconds, maxRows) {
+        if (!this.thinkingActive || maxRows < 1)
+            return [];
+        const inner = Math.max(1, width - 4);
+        const stamp = seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+        const trace = clip(`◌ ${this.thinkingTail() || 'Thinking…'}`, inner);
+        const controls = clip(`◌ ${stamp} · ctrl+y`, inner);
+        const collapsed = maxRows === 1 ? [trace] : [trace, controls];
+        if (!this.thinkingExpanded || maxRows === 1)
+            return collapsed;
+        const traceCount = Math.min(THINKING_ROWS, Math.max(1, maxRows - 1));
+        const wrapped = wrap(this.thinking.trimEnd(), inner - 2).slice(-traceCount);
+        const rows = [...Array.from({ length: traceCount - wrapped.length }, () => ''), ...wrapped];
+        const first = traceCount - wrapped.length;
+        return [...rows.map((row, index) => clip(`${index === first ? '◌ ' : '  '}${row}`, inner)), clip(`◌ ${stamp} · ctrl+y`, inner)];
+    }
+    /** The last nonempty line of the retained reasoning, flattened for one row. */
+    thinkingTail() {
+        const rows = this.thinking.split('\n');
+        for (let index = rows.length - 1; index >= 0; index--)
+            if (rows[index].trim())
+                return oneLine(rows[index]);
+        return '';
+    }
+    updateWorkingClock() {
+        if (!this.status.activity || this.status.activity === 'Ready') {
+            this.workingSince = undefined;
+            this.workingElapsed = 0;
+        }
+        else if (this.status.activity === 'Paused' || this.pending || this.modal || this.closed) {
+            if (this.workingSince !== undefined)
+                this.workingElapsed += Date.now() - this.workingSince;
+            this.workingSince = undefined;
+        }
+        else
+            this.workingSince ??= Date.now();
+    }
+    /**
+     * Recompute whether the wheel may act: alternate scroll mode is armed while a screen is
+     * open, or while a run streams with no question pending, and off everywhere else.
+     *
+     * Only transitions write anything. Entering the alternate screen resets the flag first
+     * (`start`), because that screen begins with the mode explicitly switched off.
+     */
+    updateAlternateScroll() {
+        const armed = Boolean(this.modal) || (this.runActive && !this.pending);
+        if (armed === this.alternateScroll)
+            return;
+        this.alternateScroll = armed;
+        if (!this.started || this.closed)
+            return;
+        this.output.write(armed ? '\x1b[?1007h' : '\x1b[?1007l');
+    }
+    close() {
+        this.transcript.close();
+        this.toolClock.stop();
+        if (this.thinkingFlush) {
+            clearTimeout(this.thinkingFlush);
+            this.thinkingFlush = undefined;
+        }
+        if (this.toolClockTimer)
+            clearInterval(this.toolClockTimer);
+        this.toolClockTimer = undefined;
+        if (this.panelTimer)
+            clearInterval(this.panelTimer);
+        this.panelTimer = undefined;
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.workingTimer)
+            clearInterval(this.workingTimer);
+        this.workingTimer = undefined;
+        if (this.escapeTimer)
+            clearTimeout(this.escapeTimer);
+        this.finishModal(undefined, new DOMException('Terminal closed', 'AbortError'));
+        const pending = this.pending;
+        this.finishQuestion();
+        pending?.reject(new DOMException('Terminal closed', 'AbortError'));
+        this.input.off('data', this.onData);
+        this.input.off('end', this.onEnd);
+        this.output.off('resize', this.onResize);
+        this.keys.off('keypress', this.onKey);
+        this.keys.destroy();
+        if (this.started) {
+            try {
+                this.input.setRawMode?.(this.wasRaw);
+            }
+            finally {
+                if (this.wasPaused) {
+                    this.input.pause();
+                    this.input.unref?.();
+                }
+                this.output.write('\x1b[?1007h\x1b[?2004l\x1b[?25h\x1b[0m\x1b[?1049l');
+            }
+        }
+        this.emit('close');
+    }
+    finishQuestion() {
+        this.commandInput = false;
+        this.clearPlainInput();
+        if (this.pending?.abort)
+            this.pending.signal?.removeEventListener('abort', this.pending.abort);
+        this.pending = undefined;
+        this.updateAlternateScroll();
+        this.updateWorkingClock();
+        this.value = [];
+        this.cursor = 0;
+        this.paste = '';
+        this.pasteQuestion = undefined;
+        this.completion = undefined;
+        this.dismissedCompletion = undefined;
+        // Put back a steer the question interrupted, so the user resumes where they left off.
+        if (this.steering && this.steerDraft !== undefined) {
+            this.value = this.restoredDraft(this.steerDraft);
+            this.cursor = Math.min(this.steerCursor, this.value.length);
+            this.steerDraft = undefined;
+            this.steerCursor = 0;
+        }
+    }
+    onEnd = () => this.close();
+    onResize = () => this.scheduleRender();
+    onData = (chunk) => {
+        if (this.escapeTimer)
+            clearTimeout(this.escapeTimer);
+        this.escapeTimer = undefined;
+        this.modalInput = !!this.modal;
+        this.incoming += this.decoder.write(typeof chunk === 'string' ? Buffer.from(chunk, 'utf8') : chunk);
+        this.consumeIncoming();
+    };
+    /** Drain the decoded stream: paste markers and ordinary keys. */
+    consumeIncoming() {
+        const start = '\x1b[200~', end = '\x1b[201~';
+        while (this.incoming) {
+            const marker = this.pasting ? end : start;
+            const found = this.incoming.indexOf(marker);
+            if (found >= 0) {
+                const before = this.incoming.slice(0, found);
+                this.incoming = this.incoming.slice(found + marker.length);
+                if (this.pasting) {
+                    this.paste += before;
+                    if (this.ownsComposer(this.pasteQuestion))
+                        this.landPaste(this.paste);
+                    this.paste = '';
+                    this.pasting = false;
+                    this.pasteQuestion = undefined;
+                }
+                else {
+                    this.normalData(before);
+                    if (this.pendingBreak && this.ownsComposer(this.plainQuestion))
+                        this.insert(clean(this.pendingBreak));
+                    this.clearPlainInput();
+                    this.pasting = true;
+                    this.pasteQuestion = this.composerOwner();
+                }
+                continue;
+            }
+            let suffix = 0;
+            for (let length = 1; length < marker.length; length++)
+                if (this.incoming.endsWith(marker.slice(0, length)))
+                    suffix = length;
+            const ready = this.incoming.slice(0, this.incoming.length - suffix);
+            this.incoming = this.incoming.slice(this.incoming.length - suffix);
+            if (this.pasting)
+                this.paste = (this.paste + ready).slice(0, PASTE_ACCUMULATE_LIMIT);
+            else
+                this.normalData(ready);
+            if (this.incoming === '\x1b') {
+                const modal = this.modal, question = this.pending;
+                this.escapeTimer = setTimeout(() => { this.escapeTimer = undefined; this.incoming = ''; if (!this.closed && this.modal === modal && this.pending === question)
+                    this.onKey(undefined, { name: 'escape', sequence: '\x1b' }); }, INPUT_BURST_MS);
+            }
+            break;
+        }
+    }
+    /**
+     * The effective disclosure state of one prompt box.
+     *
+     * An explicit per-prompt toggle wins over the Ctrl+O default, and Ctrl+O clears those
+     * toggles when it is pressed (see onKey), so the keyboard always remains a way out of
+     * either state.
+     */
+    promptExpanded(id) {
+        if (this.expandedPromptIds.has(id))
+            return true;
+        if (this.collapsedPromptIds.has(id))
+            return false;
+        return this.expandedTranscript;
+    }
+    /**
+     * Scroll the transcript (or the active screen). Positive `direction` scrolls up (toward
+     * older output), which is what an Up key means — typed, or sent by the wheel under
+     * alternate scroll mode.
+     */
+    scrollBy(direction) {
+        if (this.modal) {
+            if (this.modal.kind === 'text')
+                this.modal.offset = Math.max(0, this.modal.offset - direction * 3);
+            else if (this.modal.kind === 'select')
+                this.moveSelection(this.modal, -direction);
+        }
+        else if (this.dashboard)
+            return;
+        else
+            this.scroll = Math.max(0, this.scroll + direction * 3);
+        this.scheduleRender();
+    }
+    normalData(text) {
+        if (!text || this.closed)
+            return;
+        const control = text.search(/[\x03\x04]/);
+        if (control >= 0) {
+            this.normalData(text.slice(0, control));
+            this.clearPlainInput();
+            this.keys.write(text[control]);
+            this.normalData(text.slice(control + 1));
+            return;
+        }
+        if (this.modal) {
+            if (/[\r\n]/.test(text) && !/^(?:\r\n|[\r\n])$/.test(text))
+                return;
+            this.keys.write(text === '\r\n' ? '\r' : text);
+            return;
+        }
+        if (this.modalInput)
+            return;
+        if (!this.pending && !this.steering) {
+            this.keys.write(text);
+            return;
+        }
+        if (text.startsWith('\x1b')) {
+            if (this.pendingBreak)
+                this.insert(clean(this.pendingBreak));
+            this.clearPlainInput();
+            this.keys.write(text);
+            return;
+        }
+        if (this.plainPaste) {
+            this.insertPlain(text);
+            this.armPlainInput();
+            return;
+        }
+        if (this.pendingBreak) {
+            if (this.pendingBreak === '\r' && text === '\n') {
+                this.pendingBreak = '\r\n';
+                this.armPlainInput();
+                return;
+            }
+            this.insertPlain(this.pendingBreak + text);
+            this.pendingBreak = '';
+            this.plainPaste = true;
+            this.armPlainInput();
+            return;
+        }
+        // Steering shares the plain-input path so a pasted steer is handled like pasted text,
+        // but the deferred Enter must fire even with no pending question, so the ownership
+        // token carries whichever surface currently owns the composer.
+        const owner = this.composerOwner();
+        if (/^[\r\n]$|^\r\n$/.test(text)) {
+            this.pendingBreak = text;
+            this.plainQuestion = owner;
+            this.armPlainInput();
+        }
+        else if (/[\r\n]/.test(text)) {
+            this.plainQuestion = owner;
+            this.plainPaste = true;
+            this.insertPlain(text);
+            this.armPlainInput();
+        }
+        else
+            this.keys.write(text);
+    }
+    insertPlain(text) { if (this.plainTrailingCR && text.startsWith('\n'))
+        text = text.slice(1); if (!text) {
+        this.plainTrailingCR = false;
+        return;
+    } this.plainTrailingCR = text.endsWith('\r'); this.insert(clean(text)); }
+    clearPlainInput() { if (this.plainTimer)
+        clearTimeout(this.plainTimer); this.plainTimer = undefined; this.pendingBreak = ''; this.plainPaste = false; this.plainTrailingCR = false; this.plainQuestion = undefined; }
+    armPlainInput() { if (this.plainTimer)
+        clearTimeout(this.plainTimer); const question = this.plainQuestion; this.plainTimer = setTimeout(() => { const enter = this.pendingBreak; this.clearPlainInput(); if (enter && this.ownsComposer(question) && !this.closed)
+        this.keys.write('\r'); }, INPUT_BURST_MS); }
+    insert(text) { if ((this.pending?.choices && !this.commandInput && !(this.runInputHandler && text.startsWith('/'))) || (!this.pending && !this.steering) || this.modal || !text)
+        return; if (this.pending?.choices && text.startsWith('/'))
+        this.commandInput = true; const selected = this.selectionRange(); if (selected)
+        this.deleteSelection(selected); const before = this.value.slice(0, this.cursor).join(''), after = this.value.slice(this.cursor).join(''); const insertion = clean(text).slice(0, Math.max(0, MAX_INPUT - before.length - after.length)); this.value = composerGraphemes(before + insertion + after); this.cursor = composerGraphemes(before + insertion).length; this.completion = undefined; this.dismissedCompletion = undefined; this.scroll = 0; this.scheduleRender(); }
+    /** Whether the surface that owns the composer accepts task input — the only place attachments mean anything. */
+    conversationComposer() {
+        // Steering owns the conversation only while no question holds the composer: an approval or
+        // clarification owns it the moment it appears, and a queued attachment would then ride a
+        // later model turn while the visible question receives an empty Enter. This mirrors the
+        // `steering && !pending` owner rule in ownsComposer's STEERING_OWNER branch.
+        return (this.steering && !this.pending) || this.pending?.conversationPrompt === true;
+    }
+    /**
+     * Land a completed bracketed paste. Terminal drag-and-drop arrives as one or more existing
+     * filesystem paths, which become file references; a paste past the inline threshold becomes a
+     * spooled text attachment instead of flooding the composer; everything else inlines as before.
+     */
+    landPaste(text) {
+        const cleaned = clean(text);
+        if (this.conversationComposer()) {
+            const paths = droppedPaths(cleaned);
+            if (paths) {
+                for (const path of paths)
+                    this.addAttachment({ kind: 'file', path });
+                return;
+            }
+            if (isLargePaste(cleaned)) {
+                this.addAttachment({ kind: 'text', content: cleaned });
+                return;
+            }
+        }
+        this.insert(cleaned);
+    }
+    /**
+     * Queue one attachment as an inline token at the composer cursor; false means the per-turn cap
+     * refused it. Outside the conversation composer the token waits, and `adoptTokens` appends it
+     * to the draft once that composer is armed again.
+     */
+    addAttachment(pending) {
+        if (this.attachments.length >= MAX_ATTACHMENTS) {
+            this.print(`Attachment limit reached (${MAX_ATTACHMENTS}). Submit, or press Ctrl+X to remove the last one.`);
+            return false;
+        }
+        const seq = ++this.attachmentSeq;
+        if (pending.kind === 'text' && !pending.name)
+            pending = { ...pending, name: `pasted-${seq}.txt` };
+        if (pending.kind === 'image' && !pending.name)
+            pending = { ...pending, name: `clipboard-${seq}.png` };
+        // One code point per attachment for the session: a marker parked in a history or steer draft
+        // after its attachment was dropped must never come back as a reference to a newer one.
+        const marker = String.fromCodePoint(TOKEN_BASE + seq % 0xFFFFE);
+        this.attachments.push({ marker, seq, pending });
+        // The token replaces a selection, as a small paste does; a space follows it unless one
+        // already does, so typing on reads as a new word.
+        if (this.conversationComposer()) {
+            const selected = this.selectionRange();
+            if (selected)
+                this.deleteSelection(selected);
+            const spaced = blank(this.value[this.cursor] ?? '');
+            this.value.splice(this.cursor, 0, ...(spaced ? [marker] : [marker, ' ']));
+            this.cursor += spaced ? 1 : 2;
+            this.selectionAnchor = undefined;
+        }
+        this.scroll = 0;
+        this.scheduleRender();
+        return true;
+    }
+    /** Take every queued attachment in draft order, without blocking — the CLI drains this when a task is submitted. */
+    takeAttachments() { const queued = this.attachments.map(entry => entry.pending); this.attachments = []; this.scheduleRender(); return queued; }
+    /** The amber label a token draws as in the composer. */
+    tokenLabel({ seq, pending }) {
+        if (pending.kind === 'text') {
+            const lines = pending.content.split('\n').length;
+            return `[Pasted text #${seq} · ${lines} line${lines === 1 ? '' : 's'}]`;
+        }
+        if (pending.kind === 'image')
+            return `[Image #${seq} · ${formatBytes(Math.floor(pending.dataBase64.length * 3 / 4))}]`;
+        const label = attachmentLabel(pending);
+        const folder = /[\\/]$/.test(label);
+        return `[${folder ? 'Folder' : 'File'} #${seq} · ${label.replace(/[\\/]+$/, '').split(/[\\/]/).pop() || label}${folder ? '/' : ''}]`;
+    }
+    /** The draft as display elements: each token replaced by its label, clipped to the composer. */
+    visibleDraft(width) {
+        if (this.pending?.secret)
+            return this.value.map(() => '*');
+        const labels = new Map(this.attachments.map(entry => [entry.marker, clip(this.tokenLabel(entry), Math.max(1, width))]));
+        return this.value.map(part => labels.get(part) ?? (isToken(part) ? '' : part));
+    }
+    /**
+     * The draft as submitted text. Tokens become `[name]` references the model can match against
+     * the attachment block, and the queue is put in the order the tokens appear. A draft that is
+     * only tokens submits empty, so the CLI keeps its attachment-only task text, and a slash
+     * command submits without them, so the command runs and the attachments stay queued.
+     */
+    submittedDraft() {
+        const order = new Map(this.value.map((part, index) => [part, index]));
+        this.attachments.sort((left, right) => (order.get(left.marker) ?? Infinity) - (order.get(right.marker) ?? Infinity));
+        const typed = this.value.filter(part => !isToken(part)).join('');
+        if (!typed.trim())
+            return '';
+        if (typed.trimStart().startsWith('/'))
+            return typed.trimStart();
+        const names = new Map(this.attachments.map(({ marker, pending }) => [marker, `[${pending.kind === 'file' ? pending.path : pending.name}]`]));
+        return this.value.map(part => isToken(part) ? names.get(part) ?? '' : part).join('');
+    }
+    /** A parked draft brought back into the composer, keeping only tokens whose attachment is still queued. */
+    restoredDraft(text) {
+        const live = new Set(this.attachments.map(entry => entry.marker));
+        return composerGraphemes(text).filter(part => !isToken(part) || live.has(part));
+    }
+    /** Remove draft elements, dropping the attachment behind every token they held. */
+    removeDraft(start, count) {
+        const removed = new Set(this.value.splice(start, count).filter(isToken));
+        if (removed.size)
+            this.attachments = this.attachments.filter(entry => !removed.has(entry.marker));
+    }
+    /**
+     * Put every queued token that is missing from the armed conversation draft back at its end. A
+     * submitted prompt clears the composer before the CLI drains the queue, and `/attach` queues a
+     * file between prompts, so a token can be queued while no draft holds it.
+     */
+    adoptTokens() {
+        if (!this.conversationComposer() || this.historyIndex !== this.history.length)
+            return;
+        const present = new Set(this.value);
+        const atEnd = this.cursor === this.value.length;
+        for (const { marker } of this.attachments)
+            if (!present.has(marker))
+                this.value.push(...(this.value.length && !blank(this.value.at(-1)) ? [' ', marker, ' '] : [marker, ' ']));
+        if (atEnd)
+            this.cursor = this.value.length;
+    }
+    /** Whether attachments are queued, without draining them (the CLI decides whether a submission carries them). */
+    hasQueuedAttachments() { return this.attachments.length > 0; }
+    /** Read the system clipboard for an image and attach it (Ctrl+V; terminals cannot paste images as text). */
+    pasteClipboardImage() {
+        if (!this.conversationComposer())
+            return;
+        if (!this.clipboardImageProbe) {
+            this.print('Clipboard image paste is unavailable here.');
+            return;
+        }
+        // The probe is asynchronous (a shell-out on Windows): bind the result to the composer that
+        // initiated it — and to its generation, so a steer submitted while the probe ran cannot be
+        // overtaken by an image the user pasted for a draft that no longer exists.
+        const owner = this.composerOwner();
+        const generation = this.clipboardProbe;
+        void this.clipboardImageProbe().then(buffer => {
+            if (this.closed)
+                return;
+            if (this.clipboardProbe !== generation || !this.ownsComposer(owner)) {
+                this.print('The clipboard image arrived after the composer changed; press Ctrl+V again to attach it.');
+                return;
+            }
+            if (!buffer?.length) {
+                this.print('No image on the clipboard.');
+                return;
+            }
+            this.addAttachment({ kind: 'image', mimeType: 'image/png', dataBase64: buffer.toString('base64') });
+        }).catch(() => this.print('Could not read an image from the clipboard.'));
+    }
+    clearDraft() { this.clipboardProbe += 1; this.value = []; this.cursor = 0; this.historyIndex = this.history.length; this.draft = ''; this.commandInput = false; this.completion = undefined; this.dismissedCompletion = undefined; this.attachments = []; this.scroll = 0; this.scheduleRender(); }
+    onKey = (text, key) => {
+        if (key.ctrl && key.name === 'b' && !this.modal) {
+            this.toggleDashboard();
+            return;
+        }
+        if (key.ctrl && key.name === 'g' && this.dashboard && !this.modal) {
+            this.dashboardGraphOffset++;
+            this.scheduleRender();
+            return;
+        }
+        if (key.ctrl && key.name === 'n' && this.dashboard && !this.modal) {
+            this.dashboardModel++;
+            this.scheduleRender();
+            return;
+        }
+        // Expanding from the collapsed summary must not throw the reader back to the live tail:
+        // the summary advertises ctrl+t precisely while scrolled back, so the position is kept.
+        if (key.ctrl && key.name === 't' && !this.modal) {
+            this.expandedTodos = !this.expandedTodos;
+            this.todoOffset = 0;
+            this.scheduleRender();
+            return;
+        }
+        if (key.ctrl && key.name === 'o' && !this.modal && this.dashboard) {
+            // Leaving the dashboard always lands on the expanded transcript, and no prompt box is on
+            // screen to invert: inverting stored boxes the reader cannot see would silently change
+            // rows behind their back, so every box simply follows the expanded flag.
+            this.dashboard = false;
+            this.expandedTranscript = true;
+            this.expandedPromptIds.clear();
+            this.collapsedPromptIds.clear();
+            this.scroll = 0;
+            this.scheduleRender();
+            return;
+        }
+        if (key.ctrl && key.name === 'o' && !this.modal) {
+            // Ctrl+O inverts exactly what is on screen: the details flag flips, and every prompt box
+            // flips relative to the state the reader could see, so one press performs the action each
+            // row advertises ("Ctrl+O to expand" / "Ctrl+O to collapse"). A box
+            // whose state contradicts the flipped flag keeps an explicit override, because no single
+            // global value can express per-box inversion; boxes created later follow the flag.
+            const expandedBefore = new Set([...this.promptBoxIds].filter(id => this.expandedPromptIds.has(id)
+                || (this.expandedTranscript && !this.collapsedPromptIds.has(id))));
+            this.expandedTranscript = this.dashboard || !this.expandedTranscript;
+            this.dashboard = false;
+            this.expandedPromptIds.clear();
+            this.collapsedPromptIds.clear();
+            for (const id of this.promptBoxIds) {
+                const target = !expandedBefore.has(id);
+                if (target === this.expandedTranscript)
+                    continue;
+                (target ? this.expandedPromptIds : this.collapsedPromptIds).add(id);
+            }
+            this.scroll = 0;
+            this.scheduleRender();
+            return;
+        }
+        // The reasoning preview collapses and reopens from the keyboard; no click reaches the app.
+        if (key.ctrl && key.name === 'y' && !this.modal) {
+            if (this.thinkingActive) {
+                this.thinkingExpanded = !this.thinkingExpanded;
+                this.scheduleRender();
+            }
+            return;
+        }
+        // Composer attachments: Ctrl+X removes the last queued chip, Ctrl+V reads the system
+        // clipboard for an image (a terminal's own paste cannot deliver one). Both are no-ops
+        // without queued attachments / a clipboard probe, so they never shadow other intents.
+        // Over a composer selection Ctrl+C copies and Ctrl+X cuts, ahead of their other meanings
+        // (clearing the draft, interrupting, removing a chip). A secret prompt never copies.
+        if (key.ctrl && (key.name === 'c' || key.name === 'x') && !this.modal && !this.pending?.secret && this.selectionRange()) {
+            this.copySelection(key.name === 'x');
+            return;
+        }
+        if (key.ctrl && key.name === 'x' && !this.modal) {
+            const last = this.attachments.at(-1);
+            if (last) {
+                const at = this.value.indexOf(last.marker);
+                if (at < 0)
+                    this.attachments.pop();
+                else {
+                    this.removeDraft(at, 1);
+                    if (at < this.cursor)
+                        this.cursor--;
+                    this.selectionAnchor = undefined;
+                }
+                this.scheduleRender();
+            }
+            return;
+        }
+        if (key.ctrl && key.name === 'v' && !this.modal) {
+            this.pasteClipboardImage();
+            return;
+        }
+        // Ctrl+C clears a non-empty draft before it interrupts anything: the draft is the
+        // user's unfinished work, and one stray press should not pause a run or exit the
+        // session and take the draft with it. An empty composer escalates as before. Only a
+        // modal screen truly hides the composer — the dashboard keeps it drawn and editable,
+        // so a draft there clears like any other. Ctrl+C inside a paste payload is unreachable
+        // here: while a bracketed paste is in flight the bytes accumulate in the paste buffer
+        // and are stripped by clean() when the paste lands.
+        if (key.ctrl && key.name === 'c') {
+            if (!this.modal && (this.value.length || this.hasQueuedAttachments())) {
+                this.clearDraft();
+                return;
+            }
+            this.emit('SIGINT');
+            return;
+        }
+        if (key.ctrl && key.name === 'd') {
+            if (this.modal || !this.value.length)
+                this.close();
+            else {
+                this.removeDraft(this.cursor, 1);
+                this.scheduleRender();
+            }
+            return;
+        }
+        if (this.modal) {
+            this.modalKey(key);
+            return;
+        }
+        if (this.modalInput)
+            return;
+        if (key.name === 'escape' && this.commandMatches(true)) {
+            this.dismissedCompletion = this.value.join('');
+            this.completion = undefined;
+            this.scheduleRender();
+            return;
+        }
+        if (key.name === 'escape' && this.pending?.cancelOnEscape) {
+            const question = this.pending;
+            this.finishQuestion();
+            question.reject(new DOMException('Question canceled', 'AbortError'));
+            this.scheduleRender();
+            return;
+        }
+        // Enter runs what the popup is highlighting: the popup promises that the selected row is
+        // the command that runs, and a prefix such as `/prov` is not itself a command, so sending
+        // it verbatim only ever produced an unknown-command notice. A plain Enter (Alt+Enter keeps
+        // inserting a newline) substitutes the visible selection for the draft and then falls
+        // through to the ordinary submit path below, so a single press is enough and the
+        // substituted text is submitted, echoed and recorded exactly as if it had been typed.
+        if ((key.name === 'return' || key.name === 'enter') && !key.meta && !key.shift) {
+            const selected = this.selectedCompletion();
+            if (selected) {
+                this.value = graphemes(selected);
+                this.cursor = this.value.length;
+                this.completion = undefined;
+                this.dismissedCompletion = undefined;
+            }
+            const waiting = this.argumentPending();
+            if (waiting) {
+                this.awaitArgument(waiting);
+                this.scheduleRender();
+                return;
+            }
+        }
+        if ((key.name === 'return' || key.name === 'enter') && !this.modal && !key.meta && !key.shift && (this.pending?.conversationPrompt || this.steering) && (!this.pending?.choices || this.commandInput) && this.value.filter(part => !isToken(part)).join('').trim() === '/dashboard') {
+            const started = Date.now();
+            const mode = this.steering || this.runInputHandler ? 'in-run' : 'interactive';
+            this.commandInput = false;
+            this.value = [];
+            this.cursor = 0;
+            this.completion = undefined;
+            this.toggleDashboard();
+            this.localCommandHandler?.('/dashboard', mode, Math.max(0, Date.now() - started));
+            return;
+        }
+        if (key.name === 'pageup' || key.name === 'pagedown') {
+            if (this.dashboard) {
+                this.todoOffset = Math.max(0, Math.min(Math.max(0, this.todos.length - 1), this.todoOffset + (key.name === 'pageup' ? -1 : 1)));
+                this.scheduleRender();
+                return;
+            }
+            if (this.expandedTodos && this.todoPageSize > 0 && this.todos.length > this.todoPageSize) {
+                this.todoOffset = Math.max(0, Math.min(this.todos.length - 1, this.todoOffset + (key.name === 'pageup' ? -1 : 1) * this.todoPageSize));
+                this.scheduleRender();
+                return;
+            }
+            this.scroll = Math.max(0, this.scroll + (key.name === 'pageup' ? 1 : -1) * Math.max(1, (this.output.rows || 24) - 10));
+            this.scheduleRender();
+            return;
+        }
+        // While no prompt is pending — a run streaming output — there is no history to
+        // navigate, so Up/Down scroll the transcript, alongside Page Up/Down. This is also the
+        // state in which alternate scroll mode is armed (`updateAlternateScroll`), so the wheel
+        // arrives here as Up/Down and scrolls too. Steering keeps the composer editable, so a
+        // draft rebinds the arrows to cursor movement inside it.
+        if ((key.name === 'up' || key.name === 'down') && !this.pending && (!this.steering || !this.value.length)) {
+            this.scrollBy(key.name === 'up' ? 1 : -1);
+            return;
+        }
+        // Steering owns the composer for the duration of a run: submitted text is queued for
+        // the executor instead of resolving a question, and a real question (approval,
+        // clarification) still takes precedence because it sets `pending`.
+        if (this.steering && !this.pending && !this.modal) {
+            if ((key.name === 'return' || key.name === 'enter') && (key.meta || key.shift)) {
+                this.insert('\n');
+                return;
+            }
+            if (key.name === 'return' || key.name === 'enter') {
+                const value = this.submittedDraft().trim();
+                // An attachment-only steer submits too: the tokens are the message, and the CLI names
+                // them with the same stand-in text an attachment-only task gets. Enter with neither
+                // text nor tokens stays a no-op.
+                if (value || this.hasQueuedAttachments()) {
+                    const drainAttachments = () => {
+                        const queuedAttachments = this.takeAttachments();
+                        if (queuedAttachments.length)
+                            this.print(`⌷ attached: ${queuedAttachments.map(attachmentLabel).join('  ·  ')}`);
+                        return queuedAttachments;
+                    };
+                    if (value) {
+                        if (this.history.at(-1) !== value) {
+                            this.history.push(value);
+                            this.history = this.history.slice(-100);
+                        }
+                        // Steering is the composer for the live run, so a slash command typed here would
+                        // otherwise be delivered to the model as an instruction. Session commands that cannot
+                        // run mid-run say so immediately rather than queueing text the run would treat as a
+                        // prompt; the live subset, exits, and paused runs fall through to the run input
+                        // handler, which owns them.
+                        const command = submittedCommand(value);
+                        const hinted = command && !liveRunCommands.includes(command) && this.status.activity !== 'Paused' ? command : undefined;
+                        if (hinted)
+                            this.print(workingCommandHint(hinted));
+                        else {
+                            this.printPrompt(value);
+                            // Attachments leave the queue only when the text actually becomes a steer. A live
+                            // command (`/status`, `/attach`, …) is consumed by the run input handler, and a
+                            // paused run turns the text into a resume direction: both keep the queue for the
+                            // next submission, so running a command never discards queued files.
+                            if (!this.runInputHandler?.(value))
+                                this.steered.push({ text: value, attachments: drainAttachments() });
+                        }
+                    }
+                    else {
+                        this.steered.push({ text: '', attachments: drainAttachments() });
+                    }
+                    // The submission ends this draft: a clipboard probe still running belongs to it.
+                    this.clipboardProbe += 1;
+                    this.value = [];
+                    this.cursor = 0;
+                    this.historyIndex = this.history.length;
+                    this.completion = undefined;
+                    this.dismissedCompletion = undefined;
+                    this.scroll = 0;
+                }
+                this.scheduleRender();
+                return;
+            }
+            if (this.selectionKey(key, text))
+                return;
+            if (key.name === 'left')
+                this.cursor = Math.max(0, this.cursor - 1);
+            else if (key.name === 'right')
+                this.cursor = Math.min(this.value.length, this.cursor + 1);
+            else if (key.name === 'home' || (key.ctrl && key.name === 'a')) {
+                while (this.cursor > 0 && this.value[this.cursor - 1] !== '\n')
+                    this.cursor--;
+            }
+            else if (key.name === 'end' || (key.ctrl && key.name === 'e')) {
+                while (this.cursor < this.value.length && this.value[this.cursor] !== '\n')
+                    this.cursor++;
+            }
+            else if (key.name === 'backspace') {
+                if (this.cursor)
+                    this.removeDraft(--this.cursor, 1);
+            }
+            else if (key.name === 'delete')
+                this.removeDraft(this.cursor, 1);
+            else if (key.name === 'up' || key.name === 'down')
+                this.navigate(key.name === 'up' ? -1 : 1);
+            else if (key.name === 'tab')
+                this.complete();
+            else if (!key.ctrl && !key.meta && text)
+                this.insert(text);
+            this.scheduleRender();
+            return;
+        }
+        if (!this.pending)
+            return;
+        if (!this.pending.secret && this.runInputHandler && (this.commandInput || this.value[0] === '/')) {
+            if (key.name === 'escape') {
+                this.commandInput = false;
+                this.value = [];
+                this.cursor = 0;
+                this.scheduleRender();
+                return;
+            }
+            if (key.name === 'return' || key.name === 'enter') {
+                const command = this.submittedDraft().trim();
+                this.value = [];
+                this.cursor = 0;
+                this.commandInput = false;
+                // Clarification cancellation belongs to the question, not the live-run command
+                // router. Never settle an approval or resume a paused run with this command.
+                if (command.toLowerCase() === '/cancel') {
+                    if (this.pending.choices?.some(choice => choice.id === 'cancel')) {
+                        this.resolveQuestion('cancel');
+                        return;
+                    }
+                    if (!this.pending.choices && this.pending.cancelOnEscape) {
+                        this.resolveQuestion(command);
+                        return;
+                    }
+                }
+                this.runInputHandler(command);
+                this.scheduleRender();
+                return;
+            }
+        }
+        if (this.pending.choices && !this.commandInput && text === '/' && this.runInputHandler) {
+            this.commandInput = true;
+            this.insert('/');
+            return;
+        }
+        if (this.pending.choices && !this.commandInput) {
+            const pending = this.pending;
+            if (key.name === 'escape') {
+                this.finishQuestion();
+                pending.resolve('');
+            }
+            else if (key.name === 'return' || key.name === 'enter') {
+                const id = pending.choices[pending.choiceIndex ?? 0].id;
+                this.finishQuestion();
+                pending.resolve(id);
+            }
+            else if (key.name === 'up' || key.name === 'down')
+                pending.choiceIndex = Math.max(0, Math.min(pending.choices.length - 1, (pending.choiceIndex ?? 0) + (key.name === 'up' ? -1 : 1)));
+            this.scheduleRender();
+            return;
+        }
+        if ((key.name === 'return' || key.name === 'enter') && (key.meta || key.shift)) {
+            this.insert('\n');
+            return;
+        }
+        if (key.name === 'return' || key.name === 'enter') {
+            const pending = this.pending;
+            const value = this.submittedDraft();
+            if (value.trim() && pending.history && this.history.at(-1) !== value) {
+                this.history.push(value);
+                this.history = this.history.slice(-100);
+            }
+            this.finishQuestion();
+            pending.resolve(value);
+            this.scheduleRender();
+            return;
+        }
+        if (this.selectionKey(key, text))
+            return;
+        if (key.name === 'left')
+            this.cursor = Math.max(0, this.cursor - 1);
+        else if (key.name === 'right')
+            this.cursor = Math.min(this.value.length, this.cursor + 1);
+        else if (key.name === 'home' || (key.ctrl && key.name === 'a')) {
+            while (this.cursor > 0 && this.value[this.cursor - 1] !== '\n')
+                this.cursor--;
+        }
+        else if (key.name === 'end' || (key.ctrl && key.name === 'e')) {
+            while (this.cursor < this.value.length && this.value[this.cursor] !== '\n')
+                this.cursor++;
+        }
+        else if (key.name === 'backspace') {
+            if (this.cursor)
+                this.removeDraft(--this.cursor, 1);
+        }
+        else if (key.name === 'delete')
+            this.removeDraft(this.cursor, 1);
+        else if (key.name === 'up' || key.name === 'down')
+            this.navigate(key.name === 'up' ? -1 : 1);
+        else if (key.name === 'tab')
+            this.complete();
+        else if (!key.ctrl && !key.meta && text)
+            this.insert(text);
+        this.scheduleRender();
+    };
+    modalKey(key) {
+        const modal = this.modal;
+        if (modal.kind === 'select' && modal.editPrefix && (key.name === 'right' || (key.name === 'e' && !key.ctrl && !key.meta))) {
+            const item = modal.items[modal.selected];
+            if (item && !item.separator)
+                this.finishModal(item.id.startsWith(':') ? item.id : modal.editPrefix + item.id);
+            return;
+        }
+        if (key.name === 'escape') {
+            this.finishModal();
+            return;
+        }
+        if (key.name === 'return' || key.name === 'enter' || (modal.kind === 'select' && key.name === 'space')) {
+            if (modal.kind === 'select') {
+                const choice = modal.items[modal.selected];
+                if (choice && !choice.separator)
+                    this.finishModal(choice.id);
+            }
+            else if (modal.kind === 'text')
+                this.finishModal();
+            return;
+        }
+        if (modal.kind === 'loading')
+            return;
+        const page = Math.max(1, (this.output.rows || 24) - 10);
+        const movement = key.name === 'up' ? -1 : key.name === 'down' ? 1 : key.name === 'pageup' ? -page : key.name === 'pagedown' ? page : 0;
+        if (modal.kind === 'select')
+            this.moveSelection(modal, movement, key.name === 'home' ? 'home' : key.name === 'end' ? 'end' : undefined);
+        else
+            modal.offset = key.name === 'home' ? 0 : key.name === 'end' ? Number.MAX_SAFE_INTEGER : Math.max(0, modal.offset + movement);
+        this.scheduleRender();
+    }
+    navigate(direction) {
+        const completion = this.commandMatches(true);
+        if (completion) {
+            if (completion.options.length)
+                completion.index = (completion.index + direction + completion.options.length) % completion.options.length;
+            return;
+        }
+        if (this.moveRow(direction))
+            return;
+        const historyAt = this.pending?.history ? Math.max(0, Math.min(this.history.length, this.historyIndex + direction)) : this.historyIndex;
+        // The wheel never reaches this method: alternate scroll mode is off whenever a question
+        // is pending (`updateAlternateScroll`), so the terminal sends nothing for it. Up/Down are
+        // therefore purely the keyboard — cursor movement above, history recall here — and never
+        // scroll, so there is no exhaustion heuristic reconciling the two gestures.
+        if (this.pending?.history) {
+            if (this.historyIndex === this.history.length)
+                this.draft = this.value.join('');
+            this.historyIndex = historyAt;
+            this.value = this.restoredDraft(this.history[this.historyIndex] ?? this.draft);
+            this.cursor = this.value.length;
+        }
+    }
+    /** Move the caret one wrapped row up or down inside the draft; false on the first/last row. */
+    moveRow(direction) {
+        // Lay out the draft as it is drawn: a token is one element but spans its whole label.
+        const columns = Math.max(1, this.chatColumns() - 4);
+        const layout = editor(this.visibleDraft(columns), columns);
+        const current = layout.positions[this.cursor];
+        const row = current.row + direction;
+        if (row < 0 || row >= layout.lines.length)
+            return false;
+        const candidates = layout.positions.map((position, index) => ({ ...position, index })).filter(position => position.row === row);
+        candidates.sort((a, b) => Math.abs(a.column - current.column) - Math.abs(b.column - current.column));
+        this.cursor = candidates[0]?.index ?? this.cursor;
+        return true;
+    }
+    /** The composer's selected grapheme range, or undefined when nothing is selected. */
+    selectionRange() {
+        const anchor = this.selectionAnchor;
+        if (anchor === undefined || this.selectionValue !== this.value || anchor === this.cursor || anchor > this.value.length)
+            return undefined;
+        return anchor < this.cursor ? [anchor, this.cursor] : [this.cursor, anchor];
+    }
+    deleteSelection([start, end]) {
+        this.removeDraft(start, end - start);
+        this.cursor = start;
+        this.selectionAnchor = undefined;
+        this.completion = undefined;
+        this.dismissedCompletion = undefined;
+    }
+    /**
+     * Selection keys for the prompt and steering editors. Shift with an arrow, Home or End
+     * extends the selection from where it started (Shift+Up/Down past the first or last row runs
+     * to that end of the draft, never into history). Over a selection a plain Left/Right
+     * collapses it to that edge and Backspace/Delete remove it; typed or pasted text replaces it
+     * in `insert`. Any other key drops it. True when the key was consumed.
+     */
+    selectionKey(key, text) {
+        if (key.shift && !key.ctrl && !key.meta && ['left', 'right', 'home', 'end', 'up', 'down'].includes(key.name ?? '')) {
+            if (this.selectionAnchor === undefined || this.selectionValue !== this.value) {
+                this.selectionAnchor = this.cursor;
+                this.selectionValue = this.value;
+            }
+            if (key.name === 'left')
+                this.cursor = Math.max(0, this.cursor - 1);
+            else if (key.name === 'right')
+                this.cursor = Math.min(this.value.length, this.cursor + 1);
+            else if (key.name === 'home') {
+                while (this.cursor > 0 && this.value[this.cursor - 1] !== '\n')
+                    this.cursor--;
+            }
+            else if (key.name === 'end') {
+                while (this.cursor < this.value.length && this.value[this.cursor] !== '\n')
+                    this.cursor++;
+            }
+            else if (!this.moveRow(key.name === 'up' ? -1 : 1))
+                this.cursor = key.name === 'up' ? 0 : this.value.length;
+            this.scheduleRender();
+            return true;
+        }
+        const range = this.selectionRange();
+        if (!range) {
+            this.selectionAnchor = undefined;
+            return false;
+        }
+        if (key.name === 'left' || key.name === 'right') {
+            this.cursor = key.name === 'left' ? range[0] : range[1];
+            this.selectionAnchor = undefined;
+            this.scheduleRender();
+            return true;
+        }
+        if (key.name === 'backspace' || key.name === 'delete') {
+            this.deleteSelection(range);
+            this.scheduleRender();
+            return true;
+        }
+        const typed = !!text && !key.ctrl && !key.meta && !['return', 'enter', 'tab', 'escape'].includes(key.name ?? '');
+        if (!typed)
+            this.selectionAnchor = undefined;
+        return false;
+    }
+    /**
+     * Copy the composer selection to the clipboard; a cut also removes it from the draft.
+     *
+     * The system writer is preferred; without one, or when it fails, an OSC 52 sequence asks
+     * the terminal to set the clipboard instead.
+     */
+    copySelection(cut) {
+        const range = this.selectionRange();
+        if (!range)
+            return;
+        // A token copies as what it stands for: the pasted text itself, a file's path, an image's name.
+        const tokens = new Map(this.attachments.map(({ marker, pending }) => [marker, pending.kind === 'text' ? pending.content : pending.kind === 'file' ? pending.path : `[${pending.name}]`]));
+        const text = this.value.slice(range[0], range[1]).map(part => tokens.get(part) ?? part).join('');
+        const osc52 = () => { if (this.started && !this.closed)
+            this.output.write(`\x1b]52;c;${Buffer.from(text, 'utf8').toString('base64')}\x07`); };
+        if (this.clipboardTextWriter)
+            void this.clipboardTextWriter(text).catch(osc52);
+        else
+            osc52();
+        if (cut)
+            this.deleteSelection(range);
+        this.scheduleRender();
+    }
+    complete() { this.dismissedCompletion = undefined; const completion = this.commandMatches(true); const selected = completion?.options[completion.index]; if (!selected)
+        return; if (argumentRequired.has(selected)) {
+        this.awaitArgument(selected);
+        return;
+    } this.value = graphemes(selected); this.cursor = this.value.length; const options = completionOptions(selected); this.completion = { query: selected, options, index: options.indexOf(selected) }; }
+    /** Put `command ` in the composer and open its argument list, without submitting anything. */
+    awaitArgument(command) { this.value = graphemes(`${command} `); this.cursor = this.value.length; this.completion = undefined; this.dismissedCompletion = undefined; }
+    /**
+     * The command Enter must not run yet: the draft is only the name of a command that needs an
+     * argument, so it is completed to `command ` and the argument list opens. Applies wherever the
+     * popup does — the conversation prompt and the live-run composer — and never to a question,
+     * a secret, or a modal.
+     */
+    argumentPending() {
+        if (this.pending?.secret || (!this.pending?.conversationPrompt && !this.runInputHandler) || this.modal)
+            return undefined;
+        const draft = this.value.join('').trim();
+        return argumentRequired.has(draft) ? draft : undefined;
+    }
+    /**
+     * The popup entry Enter should run, or undefined when there is nothing runnable.
+     *
+     * Re-derived from the composer text on every call rather than read from the cached
+     * completion: that cache is shared with the renderer, and a resize or an edit outside the
+     * popup's own key handling can leave it stale, which would let Enter run a row that is no
+     * longer highlighted or no longer drawn. `commandMatches(true)` applies the same visibility
+     * gate the renderer uses, so a candidate that is off-screen on a short terminal reports
+     * nothing, and an entry identical to the draft is not a completion at all.
+     */
+    selectedCompletion() {
+        const completion = this.commandMatches(true);
+        const selected = completion?.options[completion.index];
+        return selected && selected !== this.value.join('') ? selected : undefined;
+    }
+    commandMatches(visibleOnly = false) {
+        const query = this.value.join('');
+        if (this.pending?.secret || (!this.pending?.conversationPrompt && !this.runInputHandler) || this.modal || query === this.dismissedCompletion || !completable(query))
+            return undefined;
+        if (this.completion?.query !== query)
+            this.completion = { query, options: completionOptions(query), index: 0 };
+        if (visibleOnly) {
+            const width = this.chatColumns(), height = Math.max(1, this.output.rows || 24);
+            const inputRows = Math.min(editor(this.visibleDraft(width - 4), Math.max(1, width - 4)).lines.length, Math.min(6, Math.max(1, height - 9)));
+            if (!commandPopupRows(width, height, inputRows, this.completion.options.length))
+                return undefined;
+        }
+        return this.completion;
+    }
+    scheduleRender() { if (!this.started || this.closed || this.scheduled)
+        return; this.scheduled = true; queueMicrotask(() => { this.scheduled = false; if (!this.closed)
+        this.render(); }); }
+    /**
+     * Paint a frame, rewriting only the rows whose content actually changed.
+     *
+     * The app never takes the mouse (`start`), so the terminal keeps drag-to-select and the
+     * clipboard in every state. What defeated those selections was output churn: a run repaints eight times a second for the working animation alone, and an
+     * emulator abandons the cells under a drag as soon as the app rewrites them. Diffing
+     * against what is already drawn means an unchanged screen writes nothing at all, and every
+     * *contiguous run* of changed rows gets its own write: when two separated rows change (the
+     * animated working row and the footer counters after a request completes, say) the
+     * unchanged rows between them are left alone, so a selection over the transcript, the
+     * composer or the model line survives a footer update. The composed picture is identical
+     * either way - the row diff is a delivery detail, never a change in what is drawn.
+     * @param lines - the frame's rows, top to bottom, exactly as they should read.
+     * @param cursor - optional caret sequence; re-emitted after any painted row, because painting
+     *   hides the caret and only this sequence brings it back. A frame that paints nothing and
+     *   leaves the caret where it was still writes zero bytes, so the caret can ride along with
+     *   the frame without breaking the settled-frame contract.
+     */
+    writeFrame(lines, cursor = '') {
+        const size = `${this.output.columns || 80}x${this.output.rows || 24}`;
+        const previous = this.drawnSize === size ? this.drawn : undefined;
+        const rows = Math.max(lines.length, previous?.length ?? 0);
+        const unchanged = (index) => (previous?.[index] ?? '') === (lines[index] ?? '');
+        let painted = false;
+        if (!previous) {
+            // The first frame has nothing trustworthy to compare against, so it draws every row and
+            // clears the rest of the screen, byte for byte what an undiffed frame writes.
+            this.output.write('\x1b[?25l\x1b[H' + lines.map(line => '\x1b[2K' + line).join('\r\n') + '\x1b[J');
+            painted = true;
+        }
+        else {
+            // One write per contiguous run of changed rows, never one write spanning the unchanged
+            // rows that separate two runs: rewriting those cells is what breaks a drag selection.
+            const spans = [];
+            for (let index = 0; index < rows; index++) {
+                if (unchanged(index))
+                    continue;
+                let end = index;
+                while (end + 1 < rows && !unchanged(end + 1))
+                    end++;
+                spans.push(`\x1b[${index + 1};1H${lines.slice(index, end + 1).map(line => '\x1b[2K' + line).join('\r\n')}`);
+                index = end;
+            }
+            if (spans.length) {
+                // A frame shorter than the one on screen is the only way content can linger underneath,
+                // so that is the one case that still needs an erase-below.
+                const tail = lines.length < previous.length ? `\x1b[${lines.length + 1};1H\x1b[J` : '';
+                this.output.write('\x1b[?25l' + spans.join('') + tail);
+                painted = true;
+            }
+        }
+        this.drawn = [...lines];
+        this.drawnSize = size;
+        if (cursor) {
+            if (painted || cursor !== this.drawnCursor)
+                this.output.write(cursor);
+            this.drawnCursor = cursor;
+        }
+        else
+            this.drawnCursor = '';
+    }
+    /** A quiet startup identity, never a full-width alert-colored diagnostics panel. */
+    welcome(width, viewportHeight) {
+        const status = this.status;
+        const available = Math.max(1, width - 4); // the transcript adds two columns of inset
+        const graph = status.graph;
+        const selected = status.graphSelection ?? (graph?.id === 'software-engineer' ? 'default' : graph?.id);
+        const graphName = selected === 'default' ? 'Default · Software Engineer' : oneLine(graph?.name ?? 'Not selected');
+        const nodes = graph ? Object.keys(graph.nodes).length : 0;
+        const nodeCount = graph && selected !== 'default' ? ` · ${nodes} ${nodes === 1 ? 'node' : 'nodes'}` : '';
+        const activity = oneLine(status.activity || 'Ready');
+        // Compact terminals and setup screens use a legible single-line label.
+        const showArt = this.appName === 'ANDORRA CODE'
+            && viewportHeight >= 10
+            && ANDORRA_WORDMARK.every(row => stringWidth(row) <= available);
+        const brand = showArt
+            ? [...ANDORRA_WORDMARK, `CODE · v${this.version}`]
+            : [`${this.appName} · v${this.version}`];
+        // A short terminal must not scroll the fallback label out of its own welcome.
+        if (viewportHeight < 9)
+            return [
+                clip(brand.at(-1), available),
+                ...(viewportHeight >= 2 ? [clip(`● ${activity}`, available)] : []),
+                ...(viewportHeight >= 3 ? [clip(`Workflow · ${graphName}`, available)] : []),
+                ...(status.graphNeedsOverride && viewportHeight >= 4 ? [paint(clip(OVERRIDE_HINT, available), STATUS.warn)] : []),
+            ];
+        return [
+            '', ...brand, '',
+            clip(`● ${activity}`, available),
+            clip(`Workflow · ${graphName}${nodeCount}`, available),
+            ...(status.graphNeedsOverride ? [paint(clip(OVERRIDE_HINT, available), STATUS.warn)] : []),
+            '',
+            ...(viewportHeight >= 10 ? ['Describe a task to get started.'] : []),
+            '',
+        ];
+    }
+    /**
+     * The selection screen to dock above the composer while a typed field is being answered.
+     *
+     * A plain question that follows a selection screen is a field belonging to that screen, so
+     * the card is drawn where the home card would otherwise be. Run-time questions (approvals,
+     * clarifications) keep their own surface, and the card is windowed around the highlighted
+     * entry so a long list cannot eat the composer's rows on a short terminal.
+     * @param rows - the transcript rows the render pass left for this card.
+     * @returns the card's lines, or undefined when the home card belongs there instead.
+     */
+    selectionCard(rows) {
+        const selection = this.lastSelection;
+        if (!selection || !this.pending || this.pending.choices || this.pending.conversationPrompt)
+            return undefined;
+        // A run's own questions (approval, clarification) are not fields of a selection screen,
+        // so the docked card stays with the idle configuration flow it belongs to.
+        if (this.status.activity && this.status.activity !== 'Ready')
+            return undefined;
+        const width = Math.max(8, this.chatColumns() - 4);
+        const description = selection.description ? wrap(clean(selection.description), Math.max(1, width - 4)).slice(0, 2) : [];
+        const count = Math.max(1, Math.min(selection.items.length, rows - description.length - 4));
+        const first = Math.max(0, Math.min(selection.selected - count + 1, selection.items.length - count));
+        const items = selection.items.slice(first, first + count).map((item, index) => `${first + index === selection.selected ? '›' : ' '} ${oneLine(item.label)}`);
+        if (count < selection.items.length)
+            items.push(`… ${selection.items.length - count} more`);
+        const title = clip(` ${oneLine(selection.title)} `, Math.max(0, width - 2));
+        const head = '╭' + title + '─'.repeat(Math.max(0, width - 2 - stringWidth(title))) + '╮';
+        const body = [...description, ...items].map(line => '│ ' + pad(line, width - 4) + ' │');
+        return ['', head, ...body, '╰' + '─'.repeat(width - 2) + '╯', ''];
+    }
+    renderModal(width, height) {
+        const modal = this.modal;
+        if (width < 16 || height < 8) {
+            const content = modal.kind === 'select' ? modal.items[modal.selected]?.label || 'No choices' : modal.kind === 'loading' ? 'Loading…' : modal.lines[modal.offset] || '';
+            const compact = height === 1 ? [oneLine(content)] : height === 2 ? [modal.title, oneLine(content)] : [this.appName, modal.title, oneLine(content), 'Esc: back'];
+            const rows = compact.slice(0, height).map(line => clip(line, width));
+            this.writeFrame(rows);
+            return;
+        }
+        const cardWidth = width - 4, innerWidth = width - 8, bodyHeight = height - 7;
+        const descriptionLines = modal.description ? wrap(modal.description, innerWidth).slice(0, Math.max(0, Math.min(3, bodyHeight - 2))) : [];
+        const description = descriptionLines.length ? [...descriptionLines, ''] : [];
+        const viewport = Math.max(1, bodyHeight - description.length);
+        const content = [];
+        let selectedStart = 0, selectedEnd = 0;
+        if (modal.kind === 'select') {
+            for (const [index, item] of modal.items.entries()) {
+                if (item.separator) {
+                    content.push({ text: '' });
+                    continue;
+                }
+                const selected = index === modal.selected;
+                if (selected)
+                    selectedStart = content.length;
+                content.push({ text: `${selected ? '›' : ' '} ${oneLine(item.label)}${item.id === modal.selectedId ? '  ✓' : ''}`, selected, bold: item.bold });
+                if (item.description)
+                    for (const line of wrap(clean(item.description), Math.max(1, innerWidth - 2)))
+                        content.push({ text: `  ${line}`, selected, dim: true });
+                if (selected)
+                    selectedEnd = content.length;
+            }
+            if (!content.length)
+                content.push({ text: 'No choices available. Press Escape to return.', dim: true });
+            if (selectedStart < modal.offset)
+                modal.offset = selectedStart;
+            if (selectedEnd > modal.offset + viewport)
+                modal.offset = Math.min(selectedStart, selectedEnd - viewport);
+        }
+        else if (modal.kind === 'loading') {
+            content.push({ text: '◌ Loading…', selected: true }, { text: '' });
+            for (const line of modal.lines)
+                for (const wrapped of wrap(clean(line), innerWidth))
+                    content.push({ text: wrapped });
+            modal.offset = Math.max(0, content.length - viewport);
+        }
+        else {
+            for (const line of modal.lines)
+                for (const wrapped of wrap(clean(line), innerWidth))
+                    content.push({ text: wrapped });
+            if (!content.length)
+                content.push({ text: 'No information available.', dim: true });
+        }
+        modal.offset = Math.max(0, Math.min(modal.offset, Math.max(0, content.length - viewport)));
+        const visible = content.slice(modal.offset, modal.offset + viewport);
+        const title = clip(` ${modal.title} `, cardWidth - 2);
+        const rows = [paint(clip(`◈  ${this.appName}`, width), GRAY), '', paint(`  ╭${title}${'─'.repeat(Math.max(0, cardWidth - 2 - stringWidth(title)))}╮`, GRAY)];
+        for (const line of description)
+            rows.push(paint('  │ ', GRAY) + paint(pad(line, innerWidth), GRAY) + paint(' │', GRAY));
+        for (let index = 0; index < viewport; index++) {
+            const row = visible[index];
+            const value = pad(row?.text ?? '', innerWidth);
+            const emphasized = row?.bold ? `\x1b[1m${value}\x1b[22m` : value;
+            const styled = row?.selected ? `\x1b[48;5;236m${paint(emphasized, row.dim ? SUBTLE : WHITE)}\x1b[0m` : paint(emphasized, row?.dim ? GRAY : DIM);
+            rows.push(paint('  │ ', GRAY) + styled + paint(' │', GRAY));
+        }
+        rows.push(paint('  ╰' + '─'.repeat(cardWidth - 2) + '╯', GRAY));
+        const help = modal.footer ?? (modal.kind === 'select' ? '↑↓ Move · Enter/Space Select · Esc Back' : modal.kind === 'loading' ? 'Esc Cancel' : '↑↓ Scroll · Page Up/Down · Esc Back');
+        const position = modal.kind === 'select' ? `${modal.items.filter(item => !item.separator).length ? modal.items.slice(0, modal.selected + 1).filter(item => !item.separator).length : 0}/${modal.items.filter(item => !item.separator).length}` : `${Math.min(content.length, modal.offset + viewport)}/${content.length}`;
+        const helpWidth = Math.max(0, width - position.length - 2);
+        rows.push(paint(pad(help, helpWidth) + '  ' + position));
+        rows.push(paint(clip(`Graph: ${(this.status.graphSelection ?? (this.status.graph?.id === 'software-engineer' ? 'default' : this.status.graph?.id)) === 'default' ? 'Default' : this.status.graph?.name ?? 'Not selected'}`, width - 1), GRAY));
+        const yolo = this.status.permissions ? `Permissions: ${this.status.permissions}` : this.status.yolo ? 'Permissions: automatic approvals' : 'Permissions: ask before writes/shell';
+        const footerWidth = width - 1;
+        const labelWidth = Math.min(footerWidth, yolo.length + 2);
+        rows.push(paint(pad(yolo, labelWidth), this.status.yolo ? STATUS.warn : STATUS.ok) + paint(clip(this.activeModel().label, footerWidth - labelWidth)));
+        this.writeFrame(rows);
+    }
+    /**
+     * Wrap transcript text into drawn rows.
+     * @param alignRight - pad each stored row that fits the transcript allowance onto its right margin,
+     *   which is what makes a user submission read as a speech bubble. The decision is made on the
+     *   stored row rather than on the fragments: wrapping a row that does not fit leaves short tails
+     *   (the last cells of a split border) that would otherwise be pushed into the margin, smearing
+     *   the frame across the screen, so no fragment of an over-wide row is padded.
+     */
+    wrapTranscript(text, width, alignRight = false) {
+        return text.split('\n').flatMap(line => {
+            const diff = /^\s*[+-]\s+\d+\s*\|/.test(line), box = /^[╭╰│]/.test(line);
+            const isBrand = ANDORRA_WORDMARK.includes(line) || line === this.appName || line.startsWith(`${this.appName} · v`);
+            const color = isBrand ? WHITE : box ? GRAY : !diff && line.includes(this.appName) ? accentPaint() : transcriptColor(line);
+            const allowance = Math.max(1, width - 4);
+            const aligned = alignRight && stringWidth(line) <= allowance;
+            return wrap(line, allowance).map(text => ({ text: aligned && text ? ' '.repeat(allowance - stringWidth(text)) + text : text, color }));
+        });
+    }
+    transcriptRows(entry, width) {
+        const disclosure = entry.promptDisclosure;
+        // Ctrl+O expands the whole transcript, collapsed prompt boxes included: the app never
+        // takes the mouse, so the keyboard is the way to the stored rows. An explicit per-prompt
+        // toggle wins.
+        const promptExpanded = disclosure ? this.promptExpanded(disclosure.id) : false;
+        const text = disclosure
+            ? promptExpanded && entry.detail ? entry.detail : entry.text
+            : this.expandedTranscript && entry.detail ? entry.detail : entry.text + (entry.detail ? ' (Ctrl+O to expand)' : '');
+        if (!entry.toolCall) {
+            const rows = this.wrapTranscript(text + '\n', width, entry.alignRight === true);
+            if (!disclosure)
+                return rows;
+            return rows.map(row => {
+                if (!row.text)
+                    return row;
+                const isDisclosure = row.text.toLowerCase().includes(promptExpanded ? 'ctrl+o to collapse' : 'ctrl+o to expand');
+                return {
+                    ...row,
+                    ...(isDisclosure ? { color: WHITE } : {}),
+                    promptId: disclosure.id,
+                    promptExpanded,
+                };
+            });
+        }
+        const rows = text.split('\n');
+        const elapsed = entry.timing ? formatDuration(this.toolClock.elapsed(entry.timing)) : undefined;
+        const right = [entry.toolCall.timestamp, elapsed].filter(Boolean).join(' · ');
+        return [...toolHeaderRows(rows[0], right, Math.max(1, width - 4)), ...rows.slice(1), ''].flatMap(row => this.wrapTranscript(row, width));
+    }
+    render() {
+        if (!this.started || this.closed)
+            return;
+        this.todoPageSize = 0;
+        const working = Boolean(this.status.activity && this.status.activity !== 'Ready' && this.status.activity !== 'Paused' && !this.pending && !this.modal);
+        this.updateWorkingClock();
+        const columns = Math.max(1, this.output.columns || 80), height = Math.max(1, this.output.rows || 24);
+        // The token speed needs no refresh of its own: its reading is captured when a request
+        // finishes and held static between calls, so the frame already on screen stays correct
+        // across a paused run or an approval prompt, and `noteGeneratedTokens` schedules the one
+        // render that reveals a new reading. Only the animations need the ticker.
+        const ticking = working || (this.dashboard && this.dashboardMetrics.snapshot().running);
+        if (ticking && !this.workingTimer) {
+            this.workingTimer = setInterval(() => this.scheduleRender(), 120);
+            this.workingTimer.unref?.();
+        }
+        else if (!ticking && this.workingTimer) {
+            clearInterval(this.workingTimer);
+            this.workingTimer = undefined;
+        }
+        // A running background terminal ages on screen, but its age changes once a second: the panel
+        // gets its own one-second clock rather than riding the animation timer's eight frames a second
+        // for a string that is not changing. Only a visible panel arms it, and only while a displayed
+        // session runs.
+        const ages = this.panelColumns(columns, height) > 0 && (this.status.terminals?.some(session => session.running) ?? false);
+        if (ages && !this.panelTimer) {
+            this.panelTimer = setInterval(() => this.scheduleRender(), 1_000);
+            this.panelTimer.unref?.();
+        }
+        else if (!ages && this.panelTimer) {
+            clearInterval(this.panelTimer);
+            this.panelTimer = undefined;
+        }
+        if (this.modal) {
+            // A modal screen takes the frame, so the panel is hidden for as long as it is open - and a
+            // render that returns here never reaches the visibility bookkeeping below. Recording it here
+            // is what lets the render after the modal closes announce the panel's return, so its data is
+            // read again instead of showing what was true before the screen opened.
+            this.panelWasHidden = true;
+            this.expandedPromptVisible = false;
+            this.renderModal(columns, height);
+            return;
+        }
+        // The panel is composed alongside the chat column rather than reflowing it: everything
+        // below keeps its own arithmetic at the reduced chat width, and the frame carries both
+        // columns once the rows are built (composePanel). One more column is the gutter that
+        // keeps the chat column's own frame - the composer's border, the header's right edge -
+        // from touching the divider.
+        const panelColumns = this.panelColumns(columns, height);
+        // A resize or a closed screen can bring the panel back: tell the embedder so a summary it
+        // skipped while nothing could show it is read now instead of at the next run boundary.
+        if (panelColumns > 0 && this.panelWasHidden) {
+            this.panelWasHidden = false;
+            this.emit('panel');
+        }
+        else if (panelColumns === 0)
+            this.panelWasHidden = true;
+        const width = columns - panelColumns - (panelColumns ? 1 : 0);
+        this.adoptTokens();
+        const visibleValue = this.visibleDraft(width - 4);
+        const layout = editor(visibleValue, Math.max(1, width - 4));
+        const cursor = layout.positions[this.cursor];
+        const selection = this.selectionRange();
+        const choices = this.commandInput ? undefined : this.pending?.choices;
+        const choiceIndex = this.pending?.choiceIndex ?? 0;
+        if (height < 9 || width < 12) {
+            this.expandedPromptVisible = false;
+            const label = choices ? oneLine(`› ${choiceIndex + 1}. ${choices[choiceIndex].label}`) : this.pending ? visibleValue.join('').replace(/\n/g, ' ') || 'Ask Andorra…' : this.steering ? visibleValue.join('').replace(/\n/g, ' ') || 'Steer this run…' : oneLine(this.nodeProgress() || this.status.activity || this.appName);
+            const lines = height > 1 ? [clip(this.appName, width), clip(label, width, false)] : [clip(label, width, false)];
+            const caret = (this.pending || this.steering) && !choices ? `\x1b[${lines.length};${Math.min(width, 1 + stringWidth(visibleValue.slice(0, this.cursor).join('').replace(/\n/g, ' ')))}H\x1b[?25h` : '';
+            this.writeFrame(lines, caret);
+            return;
+        }
+        const inputRows = Math.min(choices?.length ?? layout.lines.length, Math.min(6, Math.max(1, height - 9)));
+        const firstInput = Math.max(0, Math.min((choices ? choiceIndex : cursor.row) - inputRows + 1, (choices?.length ?? layout.lines.length) - inputRows));
+        const completion = this.commandMatches();
+        const popupRows = completion ? commandPopupRows(width, height, inputRows, completion.options.length) : 0;
+        const popupHeight = popupRows ? popupRows + 2 : 0; // The composer's own todo block stands down while the panel is drawn: the panel's Plan and
+        // Progress sections carry the same list, and one plan should not be reported twice on the
+        // same screen. The panel is the copy that survives a wide terminal.
+        const todoLines = this.dashboard || panelColumns ? [] : this.todoLines(Math.max(0, height - inputRows - 10 - popupHeight));
+        const elapsed = this.workingElapsed + (this.workingSince === undefined ? 0 : Date.now() - this.workingSince);
+        const seconds = Math.floor(elapsed / 1000);
+        const thinkingLines = this.dashboard ? [] : this.thinkingLines(width, seconds, this.thinkingActive ? Math.max(1, Math.min(THINKING_ROWS + 1, height - inputRows - 8 - popupHeight - todoLines.length)) : 0);
+        const transcriptHeight = height - inputRows - 8 - popupHeight - todoLines.length - Math.max(0, thinkingLines.length - 1);
+        const prefix = [...(this.selectionCard(transcriptHeight) ?? this.welcome(width, transcriptHeight)), ...(this.transcript.diagnostics.omitted ? ['Some transcript entries are unavailable because session storage failed.'] : [])].flatMap(text => this.wrapTranscript(text, width));
+        const page = this.transcript.window({ prefix, height: transcriptHeight, scroll: this.scroll,
+            key: `${width}:${this.expandedTranscript}`, render: entry => this.transcriptRows(entry, width),
+            revision: entry => entry.timing ? formatDuration(this.toolClock.elapsed(entry.timing)) ?? ''
+                // The effective state, not just the explicit set: a box expanded by Ctrl+O and then
+                // collapsed by hand must invalidate the cached row count, or the window would slice
+                // against the taller expanded rendering and drop the box entirely.
+                : entry.promptDisclosure ? (this.promptExpanded(entry.promptDisclosure.id) ? 'expanded' : 'collapsed') : '' });
+        this.scroll = page.scroll;
+        const visible = this.dashboard ? dashboardRows({ metrics: this.dashboardMetrics.snapshot(), selectedModel: this.dashboardModel, provider: this.status.provider, model: this.status.model, graph: this.status.graph, providerModels: this.status.providerModels, activeNodes: [...this.activeNodes.keys()], nodeModels: this.nodeModels, todos: this.todos, todoOffset: this.todoOffset, onTodoOffset: offset => { this.todoOffset = offset; }, graphOffset: this.dashboardGraphOffset, notices: this.dashboardNotices, question: this.pending && !this.pending.conversationPrompt ? this.pending.dashboardQuestion ?? this.pending.choiceTitle ?? this.pending.title ?? this.pending.label : undefined }, Math.max(2, width - 4), transcriptHeight).map(line => ({ text: panelRowText(line), color: DIM, segments: line.segments })) : page.rows;
+        while (visible.length < transcriptHeight)
+            visible.push({ text: '', color: DIM });
+        if (!this.dashboard && this.scroll && visible.length)
+            visible[0] = { text: `? Scrollback ? ${this.scroll} lines below ? Page Down to return`, color: DIM };
+        this.expandedPromptVisible = visible.some(row => row.promptExpanded);
+        const status = this.status;
+        const top = this.dashboard ? `\u25c8  ${this.appName} \u00b7 Dashboard \u00b7 Ctrl+B transcript` : `\u25c8  ${this.appName}`;
+        const version = clip(`v${this.version}`, Math.floor(width / 3));
+        const header = paint(pad(top, width - stringWidth(version)), DIM) + paint(version, FAINT);
+        const label = choices ? this.pending?.choiceTitle || 'Choose an answer' : this.pending?.title ? this.pending.title : this.pending && !this.pending.regular ? 'Your approval' : this.pending?.conversationPrompt && this.value[0] === '/' ? 'Commands · Enter runs · Tab completes' : this.steering && status.activity && status.activity !== 'Ready' ? status.activity === 'Paused' ? 'Paused - Send direction to resume' : 'Steer this run · Enter to send' : '';
+        const borderLabel = label ? clip(` ${label} `, Math.max(0, width - 4)) : '';
+        const timestamp = seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+        const progress = this.nodeProgress();
+        const workingLabel = clip(`Working · ${progress ? `${progress} - ` : ''}${timestamp}`, width - 2);
+        const wave = Math.floor(elapsed / 120) % 11;
+        const workingLine = working ? '  ' + [...workingLabel].map((character, index) => paint(character, index < 7 && Math.abs(index - wave) <= 1 ? 255 : GRAY)).join('') : '';
+        const lines = [header, paint(clip(`  ${status.account ? `Account: ${oneLine(status.account.label)} | ` : ''}${oneLine(this.workspace)}`, width), FAINT), ...visible.map(line => line.segments ? '  ' + line.segments.map(segment => paint(segment.text, segment.color ?? GRAY)).join('') : paint('  ' + clip(line.text, width - 2), line.color)), ...(thinkingLines.length ? thinkingLines.map(line => paint('  ' + pad(line, width - 4), GRAY)) : [workingLine]), ...todoLines.map(line => paint('  ' + clip(line, width - 2), GRAY))];
+        if (completion && popupRows) {
+            const cardWidth = width - 4;
+            const popupTitle = clip(' Commands · ↑↓ move · Enter runs · Tab completes ', cardWidth - 2);
+            lines.push(paint('  ╭' + popupTitle + '─'.repeat(Math.max(0, cardWidth - 2 - stringWidth(popupTitle))) + '╮', GRAY));
+            const first = Math.max(0, Math.min(completion.index - popupRows + 1, completion.options.length - popupRows));
+            for (let index = 0; index < popupRows; index++) {
+                const item = completion.options[first + index];
+                const selected = !!item && first + index === completion.index;
+                const label = item ? `${selected ? '›' : ' '} ${item}  ${commandDescriptions[item]}` : 'No matching commands';
+                const value = pad(label, cardWidth - 4);
+                lines.push(paint('  │ ', GRAY) + (selected ? `\x1b[48;5;236m${paint(value, DIM)}\x1b[0m` : paint(value)) + paint(' │', GRAY));
+            }
+            lines.push(paint('  ╰' + '─'.repeat(cardWidth - 2) + '╯', GRAY));
+        }
+        lines.push(paint('╭' + borderLabel + '─'.repeat(Math.max(0, width - 2 - stringWidth(borderLabel))) + '╮', GRAY));
+        for (let index = 0; index < inputRows; index++) {
+            if (choices) {
+                const item = choices[firstInput + index], selected = firstInput + index === choiceIndex;
+                const text = oneLine(`${selected ? '›' : ' '} ${firstInput + index + 1}. ${item.label}${item.description ? ` — ${item.description}` : ''}`);
+                lines.push(paint('│ ', GRAY) + paint(pad(text, width - 4), selected ? WHITE : DIM) + paint(' │', GRAY));
+                continue;
+            }
+            const value = layout.lines[firstInput + index];
+            const placeholder = !this.value.length && this.pending ? this.pending.regular ? this.pending.label || 'Describe a task…  / for commands' : 'Type y to approve, or n to decline' : !this.value.length ? status.activity && status.activity !== 'Ready' ? this.steering ? status.activity === 'Paused' ? 'Paused - Send direction to resume, Ctrl+C again to exit' : 'Steer this run with a message… (Ctrl+C to pause)' : 'Ctrl+C to stop' : 'Ready for your next task' : '';
+            const span = value && selection ? selectedColumns(visibleValue, layout.positions, selection, firstInput + index) : undefined;
+            const tokens = value ? tokenColumns(this.value, visibleValue, layout.positions, firstInput + index) : [];
+            lines.push(paint('│ ', GRAY) + (span || tokens.length ? composerRow(pad(value, width - 4), DIM, span, tokens) : paint(pad(value || placeholder, width - 4), value ? DIM : FAINT)) + paint(' │', GRAY));
+        }
+        const choiceHint = choices ? clip(' ↑↓ Choose · Enter confirm · Esc cancel ', width - 4) : this.attachments.length && this.conversationComposer() ? clip(` ${this.attachments.length} attached · Ctrl+X removes last · Ctrl+V pastes image `, width - 4) : '';
+        lines.push(paint('╰' + choiceHint + '─'.repeat(Math.max(0, width - 2 - stringWidth(choiceHint))) + '╯', GRAY));
+        const active = this.activeModel();
+        const model = oneLine(`${active.label} · Thinking: ${active.reasoningEffort ?? 'provider default'}`);
+        const branch = oneLine(status.branch || 'no branch');
+        const branchWidth = Math.min(Math.floor(width / 3), stringWidth(branch) + 3);
+        const jev = oneLine(status.account?.jevQuota ?? 'Jev unavailable').replace(/^Jev(?= )/, status.jevEnabled === false ? 'Jev [Disabled] ·' : status.jevEnabled === true ? 'Jev [Enabled] ·' : 'Jev');
+        const jevWidth = Math.min(stringWidth(jev), width - 1);
+        lines.push(paint(pad(model, Math.max(0, width - jevWidth - 2)) + (width - jevWidth > 1 ? ' ' : '') + clip(jev, jevWidth), GRAY));
+        const graph = oneLine(`Graph: ${(status.graphSelection ?? (status.graph?.id === 'software-engineer' ? 'default' : status.graph?.id)) === 'default' ? 'Default' : status.graph?.name ?? 'Not selected'}${status.codeIntel ? ` · CodeGraph: ${status.codeIntel}` : ''}`);
+        lines.push(paint(pad(graph, width - branchWidth) + clip(`⎇ ${branch}`, branchWidth), GRAY));
+        const count = (value) => Number.isFinite(value) && value >= 0 ? value : 0;
+        const compactTokens = Intl.NumberFormat('en', { notation: 'compact', maximumFractionDigits: 1 });
+        const activeWindow = active.contextWindow;
+        const context = activeWindow && Number.isFinite(activeWindow) && activeWindow > 0 ? ` · context: ${Math.floor((count(status.contextUsed) / activeWindow) * 100)}% (${compactTokens.format(count(status.contextUsed))}/${compactTokens.format(activeWindow)})` : '';
+        const rate = this.displayRate();
+        // The reading is the cumulative average decoding speed of the node currently shown:
+        // totals only grow, so it holds unchanged between calls, across a pause, and after the
+        // run ends - and it is drawn only while the model row names the model the average was
+        // measured under. A session that has not finished one measured request reads 0 and the
+        // row stays byte for byte the footer it was before this segment existed. The usage row
+        // has one fixed allowance, and a permanent zero would spend it on a number that carries
+        // no information - and it is what pushes the context percentage out of the row on an
+        // 80-column terminal.
+        const measured = rate > 0 ? ` · ${compactTokens.format(rate)} tok/s` : '';
+        const counts = `${count(status.requests)} req · ${count(status.inputTokens)} in · ${count(status.outputTokens)} out`;
+        const usage = `${counts}${measured}${context}`;
+        const approval = status.permissions ? `Permissions: ${status.permissions}` : status.yolo ? 'Permissions: automatic approvals' : 'Permissions: ask before writes/shell';
+        const footerWidth = width - 1;
+        // Under width pressure the optional tail is dropped first - the context segment, as
+        // documented. But the cumulative counts are unbounded and can spend the whole allowance
+        // before the speed segment even starts, clipping it mid-word (`1K to`). While a speed is
+        // being shown, the counts switch to the compact whole-number form the context segment
+        // already uses so the complete `N tok/s` segment keeps its room; without a speed the
+        // row behaves exactly as it did before this segment existed.
+        const wholeTokens = Intl.NumberFormat('en', { notation: 'compact', maximumFractionDigits: 0 });
+        const compactCounts = `${wholeTokens.format(count(status.requests))} req · ${wholeTokens.format(count(status.inputTokens))} in · ${wholeTokens.format(count(status.outputTokens))} out`;
+        const usageCap = Math.floor(footerWidth * 0.6);
+        let usageText = usage;
+        let usageWidth;
+        if (stringWidth(approval) + 1 + stringWidth(usage) <= footerWidth)
+            usageWidth = stringWidth(usage);
+        else if (measured) {
+            usageText = [`${counts}${measured}`, `${compactCounts}${measured}`].find(candidate => stringWidth(candidate) <= usageCap) ?? compactCounts;
+            usageWidth = Math.min(stringWidth(usageText), usageCap);
+        }
+        else
+            usageWidth = Math.min(stringWidth(usage), usageCap);
+        lines.push(paint(clip(pad(approval, footerWidth - usageWidth), footerWidth - usageWidth), status.yolo ? STATUS.warn : STATUS.ok) + paint(clip(usageText, usageWidth), WHITE));
+        // The caret travels through the same diff as the rows: writing it straight to the output
+        // would put an absolute cursor move and a show-cursor sequence on the wire every 120 ms
+        // for the whole of an interactive run (cli.ts keeps steering on), and terminals that clear
+        // or move a selection on cursor traffic would lose a drag over an otherwise untouched
+        // frame. As a frame input it is suppressed whenever nothing was painted and the caret has
+        // not moved, and re-emitted whenever a row repaint hid it.
+        const caret = (this.pending || this.steering) && !choices ? `\x1b[${transcriptHeight + todoLines.length + popupHeight + Math.max(0, thinkingLines.length - 1) + 5 + cursor.row - firstInput};${3 + cursor.column}H\x1b[?25h` : '';
+        this.writeFrame(this.composePanel(lines, this.panelRows(panelColumns, height), panelColumns, width), caret);
+    }
+}