moderado 0.4.34 → 0.4.50

package/dist/ui/welcome.js

@@ -1,13 +1,13 @@
 import fs from 'node:fs';
-import readline from 'node:readline';
-import { displayWidth } from './box.js';
+import { displayWidth, sliceTailToWidth, sliceToWidth, truncateToWidth } from './box.js';
+import { renderChartBlock } from './chart.js';
+import { SUMMARY_FENCE } from '../turn_summary.js';
 import { closeHttpConnections } from '../http_shutdown.js';
 import { overlayCentered, dimLines, shadowUnder } from './popup.js';
-import { activeMentionToken, filterMentionCandidates } from './file_mentions.js';
 import { getHelpCommandGroups } from './help_content.js';
 export const MODERADO_ASCII_LOGO = [
     '\x1b[38;5;75m    __  _______  ____  __________  ___    ____  ____ \x1b[0m',
-    '\x1b[38;5;75m   /  |/  / __ \\/ __ \\/ ____/ __ \\/   |  / __ \\/ __ \\\x1b[0m',
+    '\x1b[38;5;75m   /  |/  / __ \\/ __ \\/ ____/ __ \\/   |  / __ \\/ __ \x1b[0m',
     '\x1b[38;5;81m  / /|_/ / / / / / / / __/ / /_/ / /| | / / / / / / /\x1b[0m',
     '\x1b[38;5;81m / /  / / /_/ / /_/ / /___/ _, _/ ___ |/ /_/ / /_/ / \x1b[0m',
     '\x1b[38;5;87m/_/  /_/\\____/_____/_____/_/ |_/_/  |_/_____/\\____/  \x1b[0m',
@@ -20,16 +20,147 @@ export function stripAnsi(str) {
 function visibleLen(str) {
     return displayWidth(str);
 }
-function composerInputWindow(input, caret, width) {
-    const capacity = Math.max(1, width - 3);
-    const start = Math.max(0, Math.min(caret, input.length - capacity));
-    return { text: input.slice(start, start + capacity), caretColumn: caret - start };
+/**
+ * SGR mouse report, e.g. "\x1b[<0;12;5M" for a primary-button press on column 12
+ * of row 5. readline splits that escape into several keypress events ("0", ";",
+ * "5", "M"), so the raw data chunk is parsed instead of the derived keystrokes.
+ *
+ * These live here rather than in the composer because enabling and disabling
+ * mouse reporting is terminal state: `exitCleanly` has to turn it off too.
+ */
+export const MOUSE_REPORT_PATTERN = /\x1b\[<(\d+);(\d+);(\d+)([Mm])/g;
+export const MOUSE_REPORT_ON = '\x1b[?1000h\x1b[?1006h';
+export const MOUSE_REPORT_OFF = '\x1b[?1000l\x1b[?1006l';
+/**
+ * Ask the terminal to report keys whose legacy encoding is ambiguous
+ * (XTMODKEYS level 1), which is the only way Shift+Enter can be told apart from
+ * Enter. Level 1 leaves unambiguous keys — plain Ctrl+C, Shift+Tab, shifted
+ * letters — on their legacy bytes, so nothing else changes behaviour.
+ */
+export const KEY_MODIFIER_REPORT_ON = '\x1b[>4;1m';
+export const KEY_MODIFIER_REPORT_OFF = '\x1b[>4;0m';
+/**
+ * Cells a composer row spends on its `❯ ` marker, plus one spare so a full row
+ * never reaches the last column (a terminal that wraps on the final cell would
+ * push the whole card down a row).
+ */
+const COMPOSER_ROW_OVERHEAD = 3;
+/** Split the composer text into the rows the card paints, wrapping at words. */
+export function wrapComposerInput(input, width) {
+    const capacity = Math.max(1, width - COMPOSER_ROW_OVERHEAD);
+    const rows = [];
+    let segmentStart = 0;
+    for (;;) {
+        const newline = input.indexOf('\n', segmentStart);
+        const segmentEnd = newline === -1 ? input.length : newline;
+        if (segmentStart === segmentEnd) {
+            // An empty line (a bare line feed, or the tail after a trailing one) is
+            // still a row: the caret has to have somewhere to sit.
+            rows.push({ text: '', start: segmentStart, end: segmentStart });
+        }
+        else {
+            let cursor = segmentStart;
+            while (cursor < segmentEnd) {
+                let end = cursor;
+                let cells = 0;
+                let lastSpace = -1;
+                while (end < segmentEnd) {
+                    const char = String.fromCodePoint(input.codePointAt(end));
+                    const charWidth = displayWidth(char);
+                    if (cells + charWidth > capacity)
+                        break;
+                    cells += charWidth;
+                    end += char.length;
+                    if (char === ' ')
+                        lastSpace = end;
+                }
+                if (end >= segmentEnd) {
+                    rows.push({ text: input.slice(cursor, segmentEnd), start: cursor, end: segmentEnd });
+                    break;
+                }
+                // Break after the last space so words stay whole; the space itself is
+                // swallowed by the break rather than trailing the row. A row that would
+                // come out empty (a space at the wrap point) falls through to a hard
+                // break instead of emitting a blank row.
+                if (lastSpace - 1 > cursor) {
+                    rows.push({ text: input.slice(cursor, lastSpace - 1), start: cursor, end: lastSpace - 1 });
+                    cursor = lastSpace;
+                }
+                else {
+                    rows.push({ text: input.slice(cursor, end), start: cursor, end });
+                    cursor = end;
+                }
+            }
+        }
+        if (newline === -1)
+            return rows;
+        segmentStart = newline + 1;
+    }
+}
+/**
+ * Resolve the composer text into painted rows plus the caret's place in them.
+ * The window follows the caret, so a long prompt scrolls inside the box instead
+ * of growing the card past the bottom of the terminal.
+ */
+export function composerView(input, caret, width, maxRows = Number.POSITIVE_INFINITY) {
+    const all = wrapComposerInput(input, width);
+    const clampedCaret = Math.max(0, Math.min(caret, input.length));
+    // The last row whose slice contains the caret: at a hard wrap the caret
+    // belongs to the row that starts there, at a swallowed space to the row that
+    // ends there.
+    let caretRow = 0;
+    for (let index = 0; index < all.length; index += 1) {
+        if (all[index].start <= clampedCaret && clampedCaret <= all[index].end)
+            caretRow = index;
+    }
+    const limit = Math.max(1, Math.floor(maxRows));
+    const start = Math.max(0, Math.min(caretRow - limit + 1, all.length - limit));
+    const rows = all.slice(start, start + limit);
+    const row = all[caretRow];
+    return {
+        rows,
+        caretRow: caretRow - start,
+        caretColumn: Math.min(Math.max(1, width - COMPOSER_ROW_OVERHEAD), displayWidth(input.slice(row.start, clampedCaret))),
+        hiddenAbove: start,
+        hiddenBelow: all.length - start - rows.length,
+    };
+}
+/** Caret index for a click `cells` into a painted row. */
+export function composerCaretIndex(input, rows, rowOffset, cells) {
+    const row = rows[Math.max(0, Math.min(rows.length - 1, rowOffset))];
+    let index = row.start;
+    let used = 0;
+    while (index < row.end) {
+        const char = String.fromCodePoint(input.codePointAt(index));
+        const charWidth = displayWidth(char);
+        if (used + charWidth > cells)
+            break;
+        used += charWidth;
+        index += char.length;
+    }
+    return index;
+}
+/**
+ * Input rows the composer may show before it scrolls in place.
+ *
+ * The chat frame needs eight rows above the card (header, question, status,
+ * answer) and the card keeps four rows of its own furniture, so anything taller
+ * than this would scroll the composer off the screen.
+ */
+export function getComposerInputMaxRows(height) {
+    const terminalHeight = height ?? process.stdout.rows ?? 24;
+    return Math.max(1, terminalHeight - 13);
 }
 /** Card width: nearly full terminal width, like OpenCode/Cline. */
 export function getWelcomeCardWidth(width) {
     const terminalWidth = width ?? (process.stdout.columns || 80);
     return Math.max(70, Math.min(terminalWidth - 2, 120));
 }
+/** Chat fills the available columns; the startup Welcome card keeps its own width. */
+export function getChatCardWidth(width) {
+    const terminalWidth = width ?? (process.stdout.columns || 80);
+    return Math.max(1, terminalWidth - 2);
+}
 /** Left indent that centers a block of `blockWidth` visible columns on the terminal. */
 export function getWelcomeIndent(blockWidth, width) {
     const terminalWidth = width ?? (process.stdout.columns || 80);
@@ -52,11 +183,156 @@ function centerBlock(lines, width) {
  */
 export function getChatAnswerArea(width) {
     const terminalWidth = width ?? (process.stdout.columns || 80);
-    const cardWidth = getWelcomeCardWidth(terminalWidth);
+    const cardWidth = getChatCardWidth(terminalWidth);
     const indent = getWelcomeIndent(cardWidth, terminalWidth);
-    const textWidth = Math.max(20, cardWidth - 2);
+    const textWidth = Math.max(1, cardWidth - 2);
     return { indent, cardWidth, textWidth, startColumn: indent + 1, wrapWidth: indent + textWidth };
 }
+/** The chat header is a single compact brand row. */
+export const CHAT_HEADER_ROWS = 1;
+/** Rows the composer card occupies: blank surface, input, blank surface, mode, workspace. */
+export const CHAT_COMPOSER_ROWS = 5;
+/**
+ * Fixed row geometry for the chat window. The answer area is bounded by the
+ * composer: a long answer is windowed instead of pushing the input card, the
+ * mode row, and the workspace row off screen (or painting over them).
+ */
+export function getChatLayout(width, height, question = '', composerRows = CHAT_COMPOSER_ROWS) {
+    const terminalWidth = width ?? (process.stdout.columns || 80);
+    // Honor the real viewport: a hard floor here would emit a frame taller than a
+    // short terminal and scroll the composer away. A very short terminal simply
+    // shows fewer sections (the composer always wins — see renderChatScreen).
+    const terminalHeight = Math.max(2, height ?? (process.stdout.rows || 24));
+    const area = getChatAnswerArea(terminalWidth);
+    const wrappedQuestion = wrapText(question, Math.max(1, area.textWidth - 2)).length;
+    const questionTop = CHAT_HEADER_ROWS + 2;
+    // Rows above the answer: header, blank, question rows, status, blank.
+    const answerTopOffset = CHAT_HEADER_ROWS + 4;
+    // The frame has to end on the second-to-last row: a trailing newline written
+    // on the bottom row scrolls the viewport and drags the composer out of place.
+    // So the composer is pinned to the viewport bottom and keeps every row it
+    // needs — a queued-commands box makes it taller, and the answer area gives up
+    // those rows instead of pushing the card off screen.
+    const composerTop = Math.max(2, terminalHeight - Math.max(CHAT_COMPOSER_ROWS, composerRows));
+    // A pathological question must never starve the answer or the composer; when
+    // a tall composer leaves no room at all the question is dropped, not the card.
+    const questionRows = Math.max(0, Math.min(wrappedQuestion, composerTop - answerTopOffset - 2));
+    const statusRow = questionTop + questionRows;
+    const answerTop = statusRow + 2;
+    return {
+        area,
+        questionTop,
+        questionRows,
+        statusRow,
+        answerTop,
+        answerRows: Math.max(0, composerTop - 1 - answerTop),
+        composerTop,
+        terminalWidth,
+    };
+}
+/** Rows the composer card occupies for a given layout, including any queued-commands box. */
+export function getChatComposerRows(options) {
+    return renderWelcomeCard(options).split('\n').length;
+}
+/** Invisible prefix that marks a rendered line as part of the turn summary. */
+const SUMMARY_MARK = '\u0001';
+/**
+ * Wrap an answer for the card, marking the turn summary as it goes.
+ *
+ * The fence has to be resolved *before* wrapping, not after: a summary line that
+ * wraps would lose its marker on the continuation, and a block whose opening
+ * marker scrolled off the top would stop being styled exactly when it is
+ * longest. Every wrapped line inside the fence carries `SUMMARY_MARK`, so the
+ * renderer can tint any row on its own.
+ */
+export function wrapAnswerLines(text, textWidth) {
+    const lines = [];
+    let inSummary = false;
+    const answerLines = text.split('\n');
+    for (let index = 0; index < answerLines.length; index += 1) {
+        const rawLine = answerLines[index];
+        const trimmed = rawLine.trim();
+        if (trimmed === '```chart') {
+            const closing = answerLines.findIndex((line, lineIndex) => lineIndex > index && line.trim() === '```');
+            if (closing !== -1) {
+                const chartLines = renderChartBlock(answerLines.slice(index + 1, closing).join('\n'), textWidth);
+                if (chartLines) {
+                    lines.push(...chartLines);
+                    index = closing;
+                    continue;
+                }
+            }
+        }
+        if (!inSummary && trimmed === SUMMARY_FENCE) {
+            inSummary = true;
+            continue;
+        }
+        if (inSummary && trimmed === '```') {
+            inSummary = false;
+            continue;
+        }
+        if (!inSummary) {
+            lines.push(...wrapText(rawLine, textWidth));
+            continue;
+        }
+        // The rail and its gap cost two cells, so summary prose wraps two cells early.
+        for (const wrapped of wrapText(rawLine, Math.max(8, textWidth - 2)))
+            lines.push(SUMMARY_MARK + wrapped);
+    }
+    return lines;
+}
+/**
+ * Window the answer around an offset, measured in rows scrolled up from the
+ * tail. `offset = 0` is the live view (newest rows). One row is reserved for the
+ * "earlier lines hidden" note whenever anything is above the window.
+ */
+export function windowChatAnswerAt(text, maxRows, textWidth, offsetFromBottom = 0) {
+    const wrapped = wrapAnswerLines(text.trimEnd(), textWidth);
+    if (wrapped.length <= maxRows)
+        return { lines: wrapped, hiddenAbove: 0, hiddenBelow: 0 };
+    // The note costs a row, so the content capacity is one row smaller — and the
+    // maximum offset follows from that capacity, not from the raw row count.
+    const capacity = Math.max(1, maxRows - 1);
+    const maxOffset = Math.max(0, wrapped.length - capacity);
+    const offset = Math.max(0, Math.min(Math.round(offsetFromBottom), maxOffset));
+    const end = wrapped.length - offset;
+    const start = Math.max(0, end - capacity);
+    return { lines: wrapped.slice(start, end), hiddenAbove: start, hiddenBelow: wrapped.length - end };
+}
+/**
+ * Style one answer row.
+ *
+ * Inside the turn-summary fence every row becomes a band: a rail in the accent
+ * colour, a tinted background that reaches the right edge of the card, and
+ * headings in warm bold. This is what makes the report read as a different kind
+ * of thing from the prose above it, rather than three more paragraphs.
+ */
+export function renderAnswerLine(line, textWidth) {
+    // Activity-log rows share the window with the answer but read as a record of
+    // what happened: dim, no rail, no band. One function, two kinds of row.
+    if (line.startsWith(LOG_MARK)) {
+        return `\x1b[38;5;244m${truncateToWidth(line.slice(LOG_MARK.length), textWidth)}\x1b[0m`;
+    }
+    if (!line.startsWith(SUMMARY_MARK)) {
+        const heading = line.match(/^\s*(?:#{1,6}\s+([^#]+?)|\*\*(.+?)\*\*)\s*$/);
+        return heading
+            ? `\x1b[1;38;5;25m${(heading[1] ?? heading[2]).trim()}\x1b[0m`
+            : `\x1b[38;5;253m${line}\x1b[0m`;
+    }
+    const body = line.slice(SUMMARY_MARK.length);
+    const heading = body.match(/^#{1,6}\s+(.+)$/);
+    const bullet = body.match(/^[-*]\s+(.+)$/);
+    const text = heading ? heading[1].trim() : bullet ? `· ${bullet[1].trim()}` : body;
+    const tone = heading ? '1;38;5;222' : '38;5;253';
+    // Pad to the card so the tint is a solid band instead of a ragged highlight.
+    const padded = `${text}${' '.repeat(Math.max(0, textWidth - 2 - displayWidth(text)))}`;
+    return `\x1b[48;5;236m\x1b[38;5;75m▍\x1b[0;48;5;236m\x1b[${tone}m ${padded}\x1b[0m`;
+}
+export function chatAnswerOverflowNote(hidden) {
+    // Short on purpose: the status row carries the scroll position, and this row
+    // has to fit a 70-column card without wrapping.
+    return `… +${hidden} earlier line${hidden === 1 ? '' : 's'} hidden · PgUp`;
+}
 export function renderQueuedCommandsBox(commands, width) {
     if (!commands || commands.length === 0)
         return [];
@@ -84,13 +360,18 @@ export function renderQueuedCommandsBox(commands, width) {
     return lines;
 }
 export function renderWelcomeCard(options) {
-    const width = getWelcomeCardWidth(options.width);
+    const width = options.chatQuestion === undefined
+        ? getWelcomeCardWidth(options.width)
+        : getChatCardWidth(options.width);
     const indent = ' '.repeat(getWelcomeIndent(width, options.width));
-    const displayInput = options.input && options.input.length > 0
-        ? composerInputWindow(options.input, options.inputCaret ?? options.input.length, width).text
-        : '\x1b[38;5;242mAsk anything, I am all ears...\x1b[0m';
+    const inputText = options.input ?? '';
+    const inputView = composerView(inputText, options.inputCaret ?? inputText.length, width, options.maxInputRows ?? getComposerInputMaxRows());
+    // The placeholder owns the first row only; a typed prompt is wrapped into as
+    // many rows as it needs, so the box grows instead of scrolling sideways.
+    const inputRows = inputText.length > 0
+        ? inputView.rows.map((row) => row.text)
+        : ['\x1b[38;5;242mAsk anything, I am all ears...\x1b[0m'];
     const promptMarker = '\x1b[1;38;5;75m' + String.fromCodePoint(0x276F) + '\x1b[0;48;5;236m';
-    const textBox = `${promptMarker} ${displayInput}`;
     const surface = '\x1b[48;5;236m';
     const surfaceLine = (content = '') => {
         const preserved = content.replace(/\x1b\[0m/g, '\x1b[0;48;5;236m');
@@ -110,16 +391,26 @@ export function renderWelcomeCard(options) {
         : processUsage;
     const processInfo = options.chatQuestion ? `${processPrefix}${processSuffix}` : details.slice(0, modeSpace);
     const left4 = processInfo ? `\x1b[38;5;244m${processInfo}\x1b[0m` : '';
-    const right4 = options.mode === 'Plan'
-        ? '\x1b[1;38;5;75m[Plan]\x1b[0m / Execute (Tab)'
-        : 'Plan / \x1b[1;38;5;75m[Execute]\x1b[0m (Tab)';
-    const right4Raw = options.mode === 'Plan' ? '[Plan] / Execute (Tab)' : 'Plan / [Execute] (Tab)';
-    const spaces4Count = Math.max(1, width - visibleLen(left4) - right4Raw.length);
-    const line4 = left4 + ' '.repeat(spaces4Count) + right4;
+    const compactChatFooter = options.chatQuestion !== undefined && width < 72;
+    const right4Raw = compactChatFooter
+        ? options.mode === 'Plan' ? '[Plan]' : '[Execute]'
+        : options.mode === 'Plan' ? '[Plan] / Execute (Tab)' : 'Plan / [Execute] (Tab)';
+    const compactMode = right4Raw.length > width ? (options.mode === 'Plan' ? 'P' : 'E') : right4Raw;
+    const right4 = compactChatFooter
+        ? `\x1b[1;38;5;75m${compactMode}\x1b[0m`
+        : options.mode === 'Plan'
+            ? '\x1b[1;38;5;75m[Plan]\x1b[0m / Execute (Tab)'
+            : 'Plan / \x1b[1;38;5;75m[Execute]\x1b[0m (Tab)';
+    const right4Visible = compactChatFooter ? compactMode : right4Raw;
+    const left4Fit = compactChatFooter
+        ? truncateToWidth(processInfo, Math.max(0, width - right4Visible.length - 1))
+        : left4;
+    const spaces4Count = Math.max(0, width - visibleLen(left4Fit) - right4Visible.length);
+    const line4 = left4Fit + ' '.repeat(spaces4Count) + right4;
     // Line 5: Working directory (left) ... provider, model, and Auto-approve (right)
-    const approvalLabelRaw = options.autoApprove
-        ? 'Auto-approve enabled (Shift+Tab)'
-        : 'Auto-approve off (Shift+Tab)';
+    const approvalLabelRaw = compactChatFooter
+        ? width < 20 ? (options.autoApprove ? 'On' : 'Off') : (options.autoApprove ? 'Auto-approve on' : 'Auto-approve off')
+        : options.autoApprove ? 'Auto-approve enabled (Shift+Tab)' : 'Auto-approve off (Shift+Tab)';
     const modelSpace = Math.max(8, width - approvalLabelRaw.length - 10);
     const provider = options.provider?.trim() ?? '';
     const providerSpace = Math.max(1, modelSpace - 6);
@@ -140,7 +431,23 @@ export function renderWelcomeCard(options) {
         : '\x1b[38;5;242mAuto-approve off (Shift+Tab)\x1b[0m';
     const modelLabel = `\x1b[38;5;180m${modelText}\x1b[0m`;
     const spaces5Count = Math.max(1, width - shortWs.length - modelText.length - approvalLabelRaw.length - 1);
-    const line5 = left5 + ' '.repeat(spaces5Count) + modelLabel + ' ' + approvalLabel;
+    const line5 = compactChatFooter
+        ? (() => {
+            const fieldBudget = Math.max(0, width - approvalLabelRaw.length - 2);
+            const workspaceBudget = Math.ceil(fieldBudget / 2);
+            const modelBudget = fieldBudget - workspaceBudget;
+            const workspaceText = sliceTailToWidth(options.workspace, workspaceBudget);
+            const modelField = sliceTailToWidth(modelText, modelBudget);
+            if (fieldBudget === 0)
+                return truncateToWidth(approvalLabel, width);
+            const fields = [
+                workspaceText ? `\x1b[38;5;245m${workspaceText}\x1b[0m` : '',
+                modelField ? `\x1b[38;5;180m${modelField}\x1b[0m` : '',
+                `\x1b[38;5;242m${approvalLabelRaw}\x1b[0m`,
+            ].filter(Boolean);
+            return fields.join(' ');
+        })()
+        : left5 + ' '.repeat(spaces5Count) + modelLabel + ' ' + approvalLabel;
     const cardLines = [];
     const queuedBox = renderQueuedCommandsBox(options.queuedCommands ?? [], width);
     if (queuedBox.length > 0) {
@@ -152,7 +459,10 @@ export function renderWelcomeCard(options) {
         if (matching.length)
             cardLines.push(...renderSuggestionsBox(matching, width, options.commandSelection ?? 0).map(line => indent + line));
     }
-    cardLines.push(indent + surfaceLine(), indent + surfaceLine(textBox), indent + surfaceLine(), indent + line4, indent + line5);
+    cardLines.push(indent + surfaceLine(), 
+    // Continuation rows keep the marker's two cells, so wrapped text lines up
+    // under the first row's text instead of under the ❯.
+    ...inputRows.map((rowText, index) => indent + surfaceLine(`${index === 0 ? promptMarker : '  '} ${rowText}`)), indent + surfaceLine(), indent + line4, indent + line5);
     if (options.mentionFiles && options.mentionFiles.length > 0) {
         cardLines.push(...renderMentionSuggestionsBox(options.mentionFiles, options.mentionSelection ?? 0, width).map((line) => indent + line));
     }
@@ -172,7 +482,8 @@ export const SLASH_COMMANDS = [
     { name: '/budget', desc: 'Set a per-task token limit' },
     { name: '/skills', desc: 'List skills; enable or disable user skills' },
     { name: '/clear', desc: 'Reset conversation memory' },
-    { name: '/help', desc: 'Display commands, shortcuts & version' },
+    { name: '/about', desc: 'Show version and copyright info' },
+    { name: '/help', desc: 'Display commands & shortcuts' },
     { name: '/exit', desc: 'Exit Moderado' },
 ];
 export function getMatchingCommands(input) {
@@ -261,6 +572,12 @@ export function renderModeradoHeader(width) {
         ...centerBlock([COMMAND_HINT], width),
     ].join('\n');
 }
+/** Compact wordmark used after the welcome screen transitions into chat. */
+export function renderChatHeader(width) {
+    const terminalWidth = width ?? (process.stdout.columns || 80);
+    const label = 'MODERADO'.slice(0, Math.max(1, terminalWidth));
+    return ' '.repeat(Math.max(0, terminalWidth - label.length)) + `\x1b[1;38;5;75m${label}\x1b[0m`;
+}
 /** Word-wrap plain text to `maxWidth` visible columns, hard-breaking long words. */
 export function wrapText(text, maxWidth) {
     const out = [];
@@ -318,104 +635,393 @@ export function wrapText(text, maxWidth) {
 export function renderChatScreen(options, height) {
     const terminalWidth = options.width ?? (process.stdout.columns || 80);
     const terminalHeight = height ?? process.stdout.rows ?? 24;
-    const area = getChatAnswerArea(terminalWidth);
+    const question = options.chatQuestion ?? '';
+    // The composer is measured before the layout: a queued-commands box or a
+    // mention box makes the card taller, and the answer area must give up those
+    // rows instead of pushing the card past the bottom of the viewport.
+    const cardOptions = options.maxInputRows === undefined
+        ? { ...options, maxInputRows: getComposerInputMaxRows(terminalHeight) }
+        : options;
+    const composer = renderWelcomeCard(cardOptions).split('\n');
+    const layout = getChatLayout(terminalWidth, terminalHeight, question, composer.length);
+    const area = layout.area;
     const indent = ' '.repeat(area.indent);
     const lines = [];
-    lines.push(...renderModeradoHeader(terminalWidth).split('\n'));
+    lines.push(renderChatHeader(terminalWidth));
     lines.push('');
     // Row 1: the user's question, wrapped onto the same columns as the composer card.
     const questionMarker = '\x1b[1;38;5;75m' + String.fromCodePoint(0x276F) + '\x1b[0;48;5;236m';
-    for (const [index, questionLine] of wrapText(options.chatQuestion ?? '', area.textWidth - 2).entries()) {
-        const questionText = `${index === 0 ? questionMarker : '  '} ${questionLine}`;
+    const questionLines = wrapText(question, Math.max(1, area.textWidth - 2));
+    const visibleQuestion = questionLines.slice(0, layout.questionRows);
+    for (const [index, questionLine] of visibleQuestion.entries()) {
+        const clipped = index === layout.questionRows - 1 && questionLines.length > layout.questionRows
+            ? `${questionLine.slice(0, Math.max(0, area.textWidth - 3))}…`
+            : questionLine;
+        const questionText = `${index === 0 ? questionMarker : '  '} ${clipped}`;
         lines.push(indent + String.fromCharCode(27) + '[48;5;236m' + questionText + ' '.repeat(Math.max(0, area.cardWidth - visibleLen(questionText))) + String.fromCharCode(27) + '[0m');
     }
     const thoughtTime = options.chatThoughtTime ?? 0;
     const thoughtTimeLabel = thoughtTime > 0 && thoughtTime < 1 ? '<1s' : `${Math.round(thoughtTime)}s`;
-    const chatStatus = !options.chatAnswer?.trim()
-        ? ''
-        : options.chatTaskDone
-            ? `✔ Done · Thought for ${thoughtTimeLabel}`
-            : options.tokenUsage
+    const answerText = options.chatAnswer ?? '';
+    const answerOffset = options.chatAnswerOffset ?? 0;
+    // The activity log and the answer are one list, so both the scroll position
+    // and the window are computed over the merged rows.
+    const transcriptWidth = getChatTranscriptWidth(layout);
+    const transcript = buildChatTranscriptRows(options.chatActivity, answerText, transcriptWidth);
+    // While the reader is scrolled up, the status row belongs to the scroll
+    // position: the turn clock is not what they are looking for.
+    const scrollWindow = transcript.rows.length > 0 && layout.answerRows > 0 && answerOffset > 0
+        ? windowChatTranscriptAt(transcript.rows, layout.answerRows, answerOffset)
+        : undefined;
+    const activityElapsed = options.chatActivity
+        ? (options.chatActivity.elapsedLabel ?? formatElapsed(thoughtTime))
+        : '';
+    // An offset that no longer hides anything (the answer shrank, or the viewport
+    // grew) must report the live view, not claim a scroll position that is gone.
+    // Sitting at the very top still counts: rows are hidden *below* the window.
+    const scrolled = scrollWindow !== undefined
+        && (scrollWindow.hiddenAbove > 0 || scrollWindow.hiddenBelow > 0);
+    const chatStatus = scrolled
+        ? `${scrollWindow.hiddenAbove === 0 ? 'Top of the turn' : `↑ ${scrollWindow.hiddenAbove} above`} · ↓ ${scrollWindow.hiddenBelow} below · PgUp/PgDn`
+        : options.chatActivity
+            ? truncateToWidth(`${options.chatActivity.glyph} ${options.chatActivity.label} · ${activityElapsed}`, transcriptWidth)
+            : !answerText.trim()
                 ? ''
-                : `Thought for ${thoughtTimeLabel}`;
-    lines.push(chatStatus ? indent + `\x1b[38;5;244m${chatStatus.slice(0, Math.max(0, area.cardWidth - 1))}\x1b[0m` : '');
-    // Answer section: multi-line model answer
-    if (options.chatAnswer && options.chatAnswer.trim().length > 0) {
+                : options.chatTaskDone
+                    ? `✔ Done · Thought for ${thoughtTimeLabel}`
+                    : options.tokenUsage
+                        ? ''
+                        : `Thought for ${thoughtTimeLabel}`;
+    lines.push(chatStatus
+        ? indent + `\x1b[38;5;244m${chatStatus}\x1b[0m`
+        : '');
+    // Transcript section: the activity log followed by the answer, windowed to the
+    // rows the composer leaves free. The log is never dropped to make room for the
+    // answer — that trade is what produced the one-line view.
+    if (transcript.rows.length > 0 && layout.answerRows > 0) {
         lines.push('');
-        for (const answerLine of wrapText(options.chatAnswer.trim(), area.textWidth)) {
-            const heading = answerLine.match(/^\s*(?:#{1,6}\s+([^#]+?)|\*\*(.+?)\*\*)\s*$/);
-            lines.push(indent + (heading
-                ? `\x1b[1;38;5;25m${(heading[1] ?? heading[2]).trim()}\x1b[0m`
-                : `\x1b[38;5;253m${answerLine}\x1b[0m`));
+        const { lines: transcriptLines, hiddenAbove } = windowChatTranscriptAt(transcript.rows, layout.answerRows, answerOffset);
+        if (hiddenAbove > 0)
+            lines.push(indent + `\x1b[38;5;244m${truncateToWidth(chatAnswerOverflowNote(hiddenAbove), transcriptWidth)}\x1b[0m`);
+        for (const transcriptLine of transcriptLines) {
+            lines.push(indent + renderAnswerLine(transcriptLine, getChatTranscriptWidth(layout)));
         }
     }
-    const composer = renderWelcomeCard(options).split('\n');
-    lines.push(...Array(Math.max(1, terminalHeight - lines.length - composer.length - 1)).fill(''));
+    // Hard guarantee: the composer starts at `composerTop` and the frame ends one
+    // row above the viewport bottom, whatever the content did. This holds for any
+    // composer the viewport can hold (rows >= card height + 2); a terminal too
+    // short to show the card at all cannot be contained by layout arithmetic.
+    while (lines.length < layout.composerTop - 1)
+        lines.push('');
+    if (lines.length > layout.composerTop - 1)
+        lines.length = layout.composerTop - 1;
     lines.push(...composer);
     return lines.join('\n') + '\n';
 }
-/** Place the terminal cursor on the first row of the bottom composer. */
-export function renderChatComposerCursor(options, inputLength) {
-    const width = getWelcomeCardWidth(options.width);
-    const column = getWelcomeIndent(width, options.width) + 2 + Math.min(inputLength, width - 3);
-    return `\x1b[1 q\x1b[?25h\x1b[4A\r\x1b[${column}C`;
+/**
+ * Place the terminal cursor on the caret's row inside the input box. Passing
+ * the layout's `composerTop` addresses the row absolutely, which stays correct
+ * when the card grows (a queued-commands box or a wrapped prompt); the relative
+ * form is the legacy path.
+ */
+export function renderChatComposerCursor(options, input, composerTop) {
+    const width = getChatCardWidth(options.width);
+    const indent = getWelcomeIndent(width, options.width);
+    const view = composerView(input, input.length, width, getComposerInputMaxRows());
+    const caretColumn = indent + 2 + view.caretColumn;
+    if (composerTop !== undefined)
+        return `\x1b[1 q\x1b[?25h\x1b[${composerTop + 1 + view.caretRow};${caretColumn + 1}H`;
+    return `\x1b[1 q\x1b[?25h\x1b[${4 + view.caretRow}A\r\x1b[${caretColumn}C`;
 }
 export function navigateQuestionHistory(history, direction, index, draft) {
     const nextIndex = Math.max(0, Math.min(history.length, index + direction));
     return { input: nextIndex === history.length ? draft : history[nextIndex], index: nextIndex, draft };
 }
+/** Silence before the row admits it is waiting on the model. */
+export const WAIT_NOTICE_AFTER_MS = 10_000;
+/** How often that notice is refreshed while the wait continues. */
+export const WAIT_NOTICE_REPEAT_MS = 20_000;
+/**
+ * What to say while the model has produced nothing.
+ *
+ * Silent for the first ten seconds — that is normal inference. After that the
+ * row says it is waiting, and re-announces every twenty seconds with the length
+ * of the silence, so a long wait never looks like a hung process. The bucket is
+ * quantised so the line changes on that cadence instead of every second.
+ */
+export function describeWait(silentForMs) {
+    if (!Number.isFinite(silentForMs) || silentForMs < WAIT_NOTICE_AFTER_MS)
+        return undefined;
+    const repeats = Math.floor((silentForMs - WAIT_NOTICE_AFTER_MS) / WAIT_NOTICE_REPEAT_MS);
+    if (repeats === 0)
+        return { label: 'Waiting on the model' };
+    const announcedAt = (WAIT_NOTICE_AFTER_MS + repeats * WAIT_NOTICE_REPEAT_MS) / 1000;
+    return { label: 'Waiting on the model', elapsedLabel: `no output for ${announcedAt}s` };
+}
+/**
+ * Elapsed time as a short label: `8s`, `1m 04s`.
+ *
+ * This replaced the step counter. `Step 1/25` was true for minutes at a time
+ * while one inference ran, so it measured the engine's internal loop rather
+ * than anything the person waiting could act on.
+ */
+export function formatElapsed(seconds) {
+    if (!Number.isFinite(seconds) || seconds <= 0)
+        return '0s';
+    if (seconds < 1)
+        return '<1s';
+    const total = Math.round(seconds);
+    if (total < 60)
+        return `${total}s`;
+    const minutes = Math.floor(total / 60);
+    return `${minutes}m ${String(total % 60).padStart(2, '0')}s`;
+}
+/**
+ * Shorten the middle of a label, keeping the head (the verb) and the tail (the
+ * filename, which is the part a person actually reads). Measured in terminal
+ * cells, not code units, so a CJK path cannot overflow the card.
+ */
+export function elideMiddle(text, max) {
+    if (max <= 0)
+        return '';
+    if (displayWidth(text) <= max)
+        return text;
+    if (max <= 3)
+        return truncateToWidth(text, max);
+    const budget = max - 1;
+    const head = Math.ceil(budget / 2);
+    const tail = budget - head;
+    return `${sliceToWidth(text, head)}…${sliceTailToWidth(text, tail)}`;
+}
+/**
+ * Shorten the engine's progress sentence into a phase the user can follow.
+ *
+ * The status row is the only thing moving during a long, silent inference — the
+ * reasoning stream is deliberately not displayed — so it names what the agent is
+ * doing instead of repeating the step counter.
+ */
+export function describeActivity(status) {
+    const text = status
+        .trim()
+        .replace(/^step\s+\d+\s*\/\s*\d+\s*:\s*/i, '')
+        .replace(/\s*\.{3}$/, '')
+        .trim();
+    if (/^inferring\b/i.test(text))
+        return 'Thinking';
+    if (/^discovering and selecting models/i.test(text))
+        return 'Selecting model';
+    if (/^retrying\b/i.test(text))
+        return 'Retrying request';
+    if (/^delegating sub-task/i.test(text))
+        return 'Delegating a sub-task';
+    return text || 'Working';
+}
+const TOOL_VERBS = {
+    read_file: 'Reading',
+    write_file: 'Writing',
+    edit_file: 'Editing',
+    apply_patch: 'Editing',
+    list_files: 'Listing',
+    search_files: 'Searching',
+    run_command: 'Running',
+    run_diagnostics: 'Running',
+};
+/**
+ * Name the work a tool call is about to do, from its parameters.
+ *
+ * `Running read_file` told the person nothing they could not already see; the
+ * path does. This is the part of the status row that keeps moving during a long
+ * coding turn, so it carries the real target.
+ */
+export function describeToolActivity(toolName, parameters = {}) {
+    const text = (key) => {
+        const value = parameters[key];
+        return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+    };
+    if (toolName === 'apply_patch') {
+        const edits = Array.isArray(parameters.edits) ? parameters.edits : [];
+        if (edits.length > 1)
+            return `Editing ${edits.length} files`;
+        const first = edits[0];
+        const path = typeof first?.path === 'string' ? first.path : undefined;
+        return path ? `Editing ${path}` : 'Editing files';
+    }
+    if (toolName === 'run_command') {
+        const command = text('command');
+        if (!command)
+            return 'Running a command';
+        const args = Array.isArray(parameters.args)
+            ? parameters.args.filter((arg) => typeof arg === 'string')
+            : [];
+        return `Running ${[command, ...args].join(' ')}`;
+    }
+    if (toolName === 'search_files') {
+        const query = text('query');
+        return query ? `Searching "${query}"` : 'Searching the workspace';
+    }
+    if (toolName === 'list_files') {
+        const subpath = text('subpath');
+        return subpath && subpath !== '.' ? `Listing ${subpath}` : 'Listing the workspace';
+    }
+    if (toolName === 'run_diagnostics') {
+        const script = text('script');
+        return script ? `Running ${script}` : 'Running diagnostics';
+    }
+    if (toolName === 'web_search')
+        return 'Searching the web';
+    if (toolName === 'git_diff')
+        return 'Checking changes';
+    const verb = TOOL_VERBS[toolName];
+    const path = text('path');
+    if (verb && path)
+        return `${verb} ${path}`;
+    if (verb)
+        return verb;
+    return `Running ${toolName}`;
+}
 /**
  * Update the fixed chat elapsed-time row without repainting the terminal.
  * With an activity, the row is a live "still running" indicator that stays
  * visible after text starts streaming and during silent tool execution.
  */
-export function renderChatThoughtTimeUpdate(thoughtTime, taskStep, width, activity) {
+export function renderChatThoughtTimeUpdate(thoughtTime, width, activity, row = 13) {
     const area = getChatAnswerArea(width);
-    const label = thoughtTime > 0 && thoughtTime < 1 ? '<1s' : `${Math.round(thoughtTime)}s`;
-    const stepText = taskStep && taskStep.maxSteps > 0 && taskStep.step >= 0
-        ? `Step ${taskStep.step}/${taskStep.maxSteps}`
-        : undefined;
-    const status = (activity
-        ? [`${activity.glyph} ${activity.label}`, stepText, label].filter(Boolean).join(' · ')
-        : stepText ? `Processing task… ${stepText} · ${label}` : `Thought for ${label}`).slice(0, area.cardWidth);
-    return `\x1b7\x1b[13;${area.startColumn}H\x1b[K\x1b[38;5;244m${status}\x1b[0m\x1b8`;
+    // A wait phase reports silence, not the turn clock; two timers side by side
+    // would be ambiguous.
+    const elapsed = activity?.elapsedLabel ?? formatElapsed(thoughtTime);
+    const paint = (status) => `\x1b7\x1b[${row};${area.startColumn}H\x1b[K\x1b[38;5;244m${truncateToWidth(status, area.cardWidth)}\x1b[0m\x1b8`;
+    if (!activity)
+        return paint(`Thought for ${elapsed}`);
+    // The timer is reserved before the label gets any room, so a long path can
+    // never push the elapsed time off the row.
+    const timer = ` · ${elapsed}`;
+    const timerCells = displayWidth(timer);
+    const label = elideMiddle(
+    // The engine's sentence often carries its own step prefix; the row no longer
+    // prints a counter, so drop it rather than showing engine internals.
+    `${activity.glyph} ${activity.label.replace(/^step\s+\d+\s*\/\s*\d+\s*:\s*/i, '')}`, Math.max(12, area.cardWidth - timerCells - 2));
+    const reasoning = activity.reasoning?.replace(/\s+/g, ' ').trim() ?? '';
+    // Everything here is measured in cells: a CJK reasoning tail is twice as wide
+    // as its length suggests, and the overflow used to wrap outside the card.
+    const room = area.cardWidth - displayWidth(label) - timerCells - 3;
+    const excerpt = reasoning && room > 8
+        ? (displayWidth(reasoning) > room ? `…${sliceTailToWidth(reasoning, room - 1)}` : reasoning)
+        : '';
+    // Clock first, then the message: the timer belongs to the phase, so the
+    // trailing text can be cut without taking the time with it.
+    return paint(excerpt ? `${label}${timer} · ${excerpt}` : `${label}${timer}`);
 }
 /**
- * Write one streamed fragment into the answer area without repainting the chat
- * frame. Wrapped lines return to `startColumn` so the answer keeps the same
- * columns as the composer card instead of stretching across the terminal.
+ * Invisible prefix marking a rendered row as part of the live activity log.
+ *
+ * A second mark next to `SUMMARY_MARK` lets one renderer style both kinds of
+ * row in the same scrollable list without them knowing about each other.
  */
-export function renderChatAnswerDelta(delta, start, width, startColumn = 1) {
-    let row = start.row;
-    let column = start.column;
-    let writeColumn = start.column;
-    let sequence = '';
-    let line = '';
-    const flush = () => {
-        if (line.length === 0)
-            return;
-        sequence += `\x1b[${row};${writeColumn}H\x1b[38;5;253m${line}\x1b[0m`;
-        line = '';
-    };
-    for (const character of delta) {
-        if (character === '\n') {
-            flush();
-            row++;
-            column = startColumn;
-            writeColumn = startColumn;
-            continue;
-        }
-        line += character;
-        column++;
-        if (column > width) {
-            flush();
-            row++;
-            column = startColumn;
-            writeColumn = startColumn;
-        }
+const LOG_MARK = '\u0002';
+/**
+ * Cells the transcript may use on this layout.
+ *
+ * The card has a 70-column floor, the terminal does not: on a narrow window the
+ * transcript still has to stop at the screen edge, not at the card's. Wrapping
+ * to the card width and painting anyway is what let a long row spill past the
+ * right border of the frame, so the wrap width is the narrower of the two and
+ * every row is clamped to it.
+ */
+export function getChatTranscriptWidth(layout) {
+    const { area } = layout;
+    return Math.min(area.textWidth, Math.min(area.cardWidth, Math.max(8, layout.terminalWidth - area.startColumn + 1)));
+}
+/**
+ * Rows of the live turn transcript: the activity log first, the answer after.
+ *
+ * This is the Cline model. Cline keeps one scrollable list where every action
+ * and every message is a row, the newest pinned to the bottom and the rest
+ * reachable by scrolling. Merging the two here is what fixes "the output
+ * becomes one line again": the activity log used to be a separate block that
+ * handed its rows back the moment the first token streamed, so a long fix
+ * explanation left nothing on screen but a single clipped status row — exactly
+ * when there was most to read.
+ *
+ * The log and the answer now share the window, so the record of what the agent
+ * did and the answer it produced are read in one place and scroll together.
+ */
+export function buildChatTranscriptRows(activity, answer, textWidth) {
+    const rows = [];
+    for (const entry of activity?.history ?? []) {
+        rows.push(LOG_MARK + `${entry.glyph} ${entry.label}`);
     }
-    flush();
-    return { sequence, row, column };
+    const reasoning = activity?.reasoning?.replace(/\s+/g, ' ').trim();
+    if (reasoning) {
+        // Two columns of indent mark the thought as subordinate to the phase, and
+        // wrapping (not truncating) is what turns one clipped line into prose.
+        for (const line of wrapText(reasoning, Math.max(8, textWidth - 2)))
+            rows.push(LOG_MARK + `  ${line}`);
+    }
+    const answerStart = rows.length;
+    if (answer.trim().length > 0)
+        rows.push(...wrapAnswerLines(answer.trimEnd(), textWidth));
+    return { rows, answerStart };
+}
+/**
+ * Window the transcript around an offset, measured in rows scrolled up from the
+ * tail. `offset = 0` is the live view (newest rows). One row is reserved for
+ * the "earlier lines hidden" note whenever anything is above the window.
+ */
+export function windowChatTranscriptAt(rows, maxRows, offsetFromBottom = 0) {
+    if (rows.length <= maxRows)
+        return { lines: [...rows], hiddenAbove: 0, hiddenBelow: 0 };
+    // The note costs a row, so the content capacity is one row smaller — and the
+    // maximum offset follows from that capacity, not from the raw row count.
+    const capacity = Math.max(1, maxRows - 1);
+    const maxOffset = Math.max(0, rows.length - capacity);
+    const offset = Math.max(0, Math.min(Math.round(offsetFromBottom), maxOffset));
+    const end = rows.length - offset;
+    const start = Math.max(0, end - capacity);
+    return { lines: [...rows.slice(start, end)], hiddenAbove: start, hiddenBelow: rows.length - end };
+}
+/** Rows the transcript occupies for a layout; 0 when the viewport is tiny. */
+export function getChatTranscriptRows(layout) {
+    return Math.max(0, layout.answerRows);
+}
+/**
+ * Paint the pinned phase header on the status row.
+ *
+ * One row, always: the phase and its clock. Everything it used to squeeze into
+ * that row now lives in the transcript below it.
+ */
+export function renderChatTranscriptHeader(activity, layout, thoughtTime) {
+    const { area } = layout;
+    const cells = getChatTranscriptWidth(layout);
+    const elapsed = activity.elapsedLabel ?? formatElapsed(thoughtTime);
+    const header = `\x1b[38;5;250m${truncateToWidth(`${activity.glyph} ${activity.label} · ${elapsed}`, cells)}\x1b[0m`;
+    return `\x1b7\x1b[${layout.statusRow};${area.startColumn}H\x1b[2K${header}\x1b8`;
+}
+/**
+ * Repaint the transcript in place: exactly the rows the layout reserves,
+ * between the status row and the composer. The window scrolls (oldest rows
+ * leave first) instead of writing over the composer, so a long turn can never
+ * damage the bottom rows. The cursor is saved and restored, so the caller keeps
+ * its position on the input line.
+ *
+ * Unlike the answer window it replaced, this never gives its rows up: the log
+ * and the answer are one list, so the newest rows stay on screen and the rest
+ * is one PgUp away. Every row is clamped to the card in terminal cells, so a
+ * wide CJK glyph or a long path cannot push a row past the right border.
+ */
+export function renderChatTranscriptWindow(activity, answer, layout, offsetFromBottom = 0) {
+    const { area } = layout;
+    const cells = getChatTranscriptWidth(layout);
+    const { rows } = buildChatTranscriptRows(activity, answer, cells);
+    const { lines, hiddenAbove } = windowChatTranscriptAt(rows, layout.answerRows, offsetFromBottom);
+    const visible = hiddenAbove > 0
+        ? [`\x1b[38;5;244m${truncateToWidth(chatAnswerOverflowNote(hiddenAbove), cells)}\x1b[0m`, ...lines.map((line) => renderAnswerLine(line, cells))]
+        : lines.map((line) => renderAnswerLine(line, cells));
+    let sequence = '\x1b7';
+    for (let index = 0; index < layout.answerRows; index++) {
+        const row = layout.answerTop + index;
+        sequence += `\x1b[${row};${area.startColumn}H\x1b[2K${visible[index] ?? ''}`;
+    }
+    return sequence + '\x1b8';
 }
 export function renderFullWelcomeScreen(options, height) {
     if (options.chatQuestion !== undefined) {
@@ -455,7 +1061,7 @@ export function renderWelcomePopupLayer(options, popupLines, width, height) {
     const lightPopup = popupLines.map((line) => surface + line.replace(/\x1b\[0m/g, `\x1b[0m${surface}`) + '\x1b[0m');
     return background + shadowUnder(lightPopup, cols, rows) + overlayCentered(lightPopup, cols, rows);
 }
-export function renderHelpPopupBox(version, workspace, width) {
+export function renderHelpPopupBox(_version, workspace, width) {
     const terminalWidth = width ?? (process.stdout.columns || 80);
     const targetWidth = 82;
     const boxWidth = Math.max(76, Math.min(terminalWidth, targetWidth));
@@ -473,6 +1079,7 @@ export function renderHelpPopupBox(version, workspace, width) {
         '\x1b[1;38;5;114mKeyboard Shortcuts:\x1b[0m',
         '\x1b[1mTab\x1b[0m          Toggle between [Plan] and [Execute] mode',
         '\x1b[1mShift+Tab\x1b[0m    Toggle Auto-approval on / off for actions',
+        '\x1b[1mShift+Enter\x1b[0m  Insert a line break (Ctrl+J works everywhere)',
         '\x1b[1mCtrl+C\x1b[0m       Cancel active inference or exit session',
         '\x1b[1mEsc\x1b[0m          Stop the active task',
         '\x1b[1mLeft/Right\x1b[0m   Move the caret inside the bottom input line',
@@ -480,7 +1087,6 @@ export function renderHelpPopupBox(version, workspace, width) {
         '\x1b[1mMouse click\x1b[0m  Place the caret on the input line',
         '',
         `\x1b[38;5;245mWorkspace:\x1b[0m  \x1b[38;5;253m${shortWs}\x1b[0m`,
-        `\x1b[38;5;245mVersion:\x1b[0m    \x1b[1;38;5;75m${version}\x1b[0m`,
         '',
         '\x1b[38;5;244mPress \x1b[1;38;5;75m[Esc]\x1b[0;38;5;244m or \x1b[1;38;5;75m[Enter]\x1b[0;38;5;244m to close\x1b[0m',
     ];
@@ -499,6 +1105,31 @@ export function renderHelpPopupBox(version, workspace, width) {
     lines.push('\x1b[38;5;240m╰' + '─'.repeat(boxWidth - 2) + '╯\x1b[0m');
     return lines;
 }
+/** Render a centered "About" popup with version and copyright info. */
+export function renderAboutPopupBox(version) {
+    const boxWidth = 52;
+    const innerW = boxWidth - 4;
+    const titleStr = 'About Moderado';
+    const remainingDashes = Math.max(0, boxWidth - titleStr.length - 5);
+    // Strip the Alfazen build suffix (`+261024h`) so only `v<major.minor.patch>` shows.
+    const semverOnly = version.split('+')[0];
+    const content = [
+        'Moderado CLI',
+        semverOnly,
+        '',
+        '(c) 2026 Moderado AI, an Alfazen Product',
+    ];
+    const lines = [];
+    lines.push('\x1b[38;5;240m╭─ \x1b[1;38;5;75m' + titleStr + '\x1b[0;38;5;240m ' + '─'.repeat(remainingDashes) + '╮\x1b[0m');
+    for (const item of content) {
+        const plain = item.replace(/\x1b\\[[0-9;]*[a-zA-Z]/g, '');
+        const leftPad = Math.max(0, Math.floor((innerW - plain.length) / 2));
+        const rightPad = Math.max(0, innerW - plain.length - leftPad);
+        lines.push('\x1b[38;5;240m│\x1b[0m' + ' '.repeat(leftPad) + item + ' '.repeat(rightPad) + '\x1b[38;5;240m│\x1b[0m');
+    }
+    lines.push('\x1b[38;5;240m╰' + '─'.repeat(boxWidth - 2) + '╯\x1b[0m');
+    return lines;
+}
 export let terminalCleanExitDone = false;
 /** Mark that a clean exit already restored + cleared the terminal (guards the process 'exit' hook). */
 export function notifyCleanExit() {
@@ -526,7 +1157,7 @@ export async function exitCleanly(message) {
     notifyCleanExit();
     const stdout = process.stdout;
     const payload = stdout.isTTY
-        ? MOUSE_REPORT_OFF + '\x1b[?25h\x1b[?1049l\x1b[0 q\x1b[0m\x1b[2J\x1b[3J\x1b[H' + renderExitMessage(message)
+        ? KEY_MODIFIER_REPORT_OFF + MOUSE_REPORT_OFF + '\x1b[?25h\x1b[?1049l\x1b[0 q\x1b[0m\x1b[2J\x1b[3J\x1b[H' + renderExitMessage(message)
         : renderExitMessage(message);
     try {
         fs.writeSync(1, payload);
@@ -546,608 +1177,6 @@ export async function exitCleanly(message) {
     setTimeout(() => process.exit(0), 2000).unref();
     return new Promise(() => { });
 }
-function isMcpCommandInput(value) {
-    const command = value.trim();
-    return command === '/mcp' || command.startsWith('/mcp ');
-}
-/**
- * SGR mouse report, e.g. "\x1b[<0;12;5M" for a primary-button press on column 12
- * of row 5. readline splits that escape into several keypress events ("0", ";",
- * "5", "M"), so the raw data chunk is parsed instead of the derived keystrokes.
- */
-const MOUSE_REPORT_PATTERN = /\x1b\[<(\d+);(\d+);(\d+)([Mm])/g;
-const MOUSE_REPORT_ON = '\x1b[?1000h\x1b[?1006h';
-const MOUSE_REPORT_OFF = '\x1b[?1000l\x1b[?1006l';
-export async function promptInteractiveTurn(options) {
-    const stdin = process.stdin;
-    const stdout = process.stdout;
-    let currentModel = options.model;
-    let currentMode = options.initialMode ?? 'Execute';
-    let currentAutoApprove = options.initialAutoApprove ?? true;
-    let input = '';
-    /** Caret index inside `input` (0 .. input.length) - the composer is editable. */
-    let caret = 0;
-    /** True while keypress events derived from a mouse report are being dropped. */
-    let ignoreComposerKeypress = false;
-    /** Terminal height, with the same fallback the renderer uses. */
-    const getRows = () => stdout.rows || 24;
-    let commandSelection = 0;
-    const questionHistory = options.questionHistory ?? [];
-    let questionHistoryIndex = questionHistory.length;
-    let questionHistoryDraft = '';
-    let cachedFiles = [];
-    if (options.onMentionComplete) {
-        Promise.resolve(options.onMentionComplete('')).then((files) => {
-            cachedFiles = Array.isArray(files) ? files : [];
-            updateMentions();
-        }).catch(() => { cachedFiles = []; });
-    }
-    let mentionFiles = [];
-    let mentionSelection = 0;
-    const updateMentions = () => {
-        const mention = activeMentionToken(input, caret);
-        if (mention && cachedFiles.length > 0) {
-            mentionFiles = filterMentionCandidates(cachedFiles, mention.token, 5);
-            mentionSelection = Math.min(mentionSelection, Math.max(0, mentionFiles.length - 1));
-        }
-        else {
-            mentionFiles = [];
-            mentionSelection = 0;
-        }
-    };
-    /** Replace the composer text, leaving the caret at the end of the new value. */
-    const setInput = (value) => {
-        input = value;
-        caret = value.length;
-    };
-    const getOptions = () => ({
-        model: currentModel,
-        provider: options.getProviderName?.(),
-        tokens: options.tokens,
-        cost: options.cost,
-        usageAvailable: options.usageAvailable,
-        usageEstimated: options.usageEstimated,
-        workspace: options.workspace,
-        mode: currentMode,
-        autoApprove: currentAutoApprove,
-        input,
-        inputCaret: caret,
-        commandSelection,
-        chatQuestion: options.chatQuestion,
-        chatAnswer: options.chatAnswer,
-        chatThoughtTime: options.chatThoughtTime,
-        chatTaskDone: options.chatTaskDone,
-        outputTokenRate: options.outputTokenRate,
-        tokenUsage: options.tokenUsage,
-        queuedCommands: options.queuedCommands,
-        isTurnSettled: true,
-    });
-    // ── Non-TTY fallback ──────────────────────────────────────────────────────
-    if (!stdin.isTTY) {
-        stdout.write('\x1b]0;Moderado\x07');
-        stdout.write(renderFullWelcomeScreen(getOptions()));
-        return new Promise((resolve) => {
-            const rl = readline.createInterface({ input: stdin, output: stdout });
-            rl.question('\x1b[1;38;5;75m❯\x1b[0m ', (answer) => {
-                rl.close();
-                resolve({ text: answer.trim(), mode: currentMode, autoApprove: currentAutoApprove });
-            });
-        });
-    }
-    // ── TTY Interactive Loop ───────────────────────────────────────────────────
-    readline.emitKeypressEvents(stdin);
-    // A previous turn's cleanup() pauses stdin — resume it so keystrokes keep
-    // flowing after an answer (the main app must never appear dead post-answer).
-    stdin.resume();
-    stdin.setRawMode(true);
-    const getExtraLines = () => mentionFiles.length > 0 ? mentionFiles.length + 2 : 0;
-    /** Rows between the painted composer line and the terminal's last row. */
-    const getComposerOffset = () => getWelcomeBottomPadding(getOptions(), getRows()) + 4 + getExtraLines();
-    /** Screen row and 1-based column of the composer's first text cell. */
-    const getComposerAnchor = () => ({
-        row: getRows() - getComposerOffset(),
-        column: getWelcomeIndent(getWelcomeCardWidth()) + 3,
-    });
-    /**
-     * Move cursor to the ❯ input line (Line 2 inside the centered card).
-     * Absolute addressing (`row;column H`) works no matter where the cursor
-     * currently sits — relative "move up N" escapes the input line when
-     * pressed repeatedly, e.g. browsing history with Left/Right.
-     */
-    const positionCursorOnInput = () => {
-        const { row, column } = getComposerAnchor();
-        const { caretColumn } = composerInputWindow(input, caret, getWelcomeCardWidth());
-        stdout.write(`\x1b[1 q\x1b[?25h\x1b[${row};${column + caretColumn}H`);
-    };
-    /** Full-screen redraw: clear everything, repaint welcome TUI, reposition cursor. */
-    const redrawFull = () => {
-        stdout.write('\x1b[H\x1b[J');
-        stdout.write(renderCenteredWelcomeScreen(getOptions(), stdout.rows));
-        positionCursorOnInput();
-    };
-    /** Repaint the welcome view so it remains centered after every edit or resize. */
-    const redrawCard = () => {
-        redrawFull();
-    };
-    const onResize = () => redrawFull();
-    /**
-     * Place the caret where the user clicked on the composer line. Only a primary
-     * press is honoured; releases, drags, wheel and other buttons are ignored.
-     */
-    const onMouseData = (chunk) => {
-        const text = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
-        let reported = false;
-        for (const report of text.matchAll(MOUSE_REPORT_PATTERN)) {
-            reported = true;
-            if (report[4] !== 'M' || Number(report[1]) !== 0)
-                continue;
-            const { row, column } = getComposerAnchor();
-            if (Number(report[3]) !== row)
-                continue;
-            caret = Math.max(0, Math.min(input.length, Number(report[2]) - column));
-            positionCursorOnInput();
-        }
-        if (reported) {
-            // readline turns the same bytes into keypress events ("0", ";", "5", "M").
-            ignoreComposerKeypress = true;
-            setImmediate(() => { ignoreComposerKeypress = false; });
-        }
-    };
-    // Registered before readline's decoder so a report is consumed before it is
-    // mistaken for typed text.
-    stdin.prependListener('data', onMouseData);
-    stdout.on('resize', onResize);
-    // Initial paint
-    if (options.isFirstTurn) {
-        stdout.write('\x1b]0;Moderado\x07');
-        stdout.write('\x1b[2J\x1b[3J\x1b[H');
-    }
-    else {
-        // After an AI response the screen has content below — clear and repaint the full TUI.
-        stdout.write('\x1b[H\x1b[J');
-    }
-    stdout.write(renderCenteredWelcomeScreen(getOptions(), stdout.rows));
-    positionCursorOnInput();
-    return new Promise((resolve) => {
-        const cleanup = () => {
-            unbindComposerInput();
-            stdin.removeListener('data', onMouseData);
-            stdout.removeListener('resize', onResize);
-            stdout.write(`${MOUSE_REPORT_OFF}\x1b[0 q\x1b[?25h`);
-            if (stdin.isTTY) {
-                try {
-                    stdin.setRawMode(false);
-                }
-                catch { /* ignore */ }
-            }
-            try {
-                stdin.pause();
-            }
-            catch { /* ignore */ }
-        };
-        const onAbort = () => {
-            cleanup();
-            resolve({ text: '', mode: currentMode, autoApprove: currentAutoApprove });
-        };
-        if (options.signal) {
-            options.signal.addEventListener('abort', onAbort, { once: true });
-        }
-        // ── Async keypress handler ────────────────────────────────────────────────
-        // Using a void async IIFE so we can await async operations (model selector)
-        // inside a synchronous event listener.  For any async branch we first
-        // remove ourselves from stdin so no duplicate events fire during the await.
-        const onKeypress = (str, key) => {
-            void (async () => {
-                // Keystrokes decoded from a mouse report were already handled above.
-                if (ignoreComposerKeypress)
-                    return;
-                if (options.signal?.aborted) {
-                    cleanup();
-                    resolve({ text: '', mode: currentMode, autoApprove: currentAutoApprove });
-                    return;
-                }
-                // ── Ctrl+C ────────────────────────────────────────────────────────────
-                if (key && key.ctrl && key.name === 'c') {
-                    cleanup();
-                    return await exitCleanly('\x1b[33mSession cancelled.\x1b[0m');
-                }
-                // ── /help overlay popup ───────────────────────────────────────────────
-                // Triggered when Enter is pressed with "/help" already in the input box.
-                // We keep the main TUI as background and layer the help box on top.
-                if (key && (key.name === 'return' || key.name === 'enter') && input.trim() === '/help') {
-                    setInput('');
-                    unbindComposerInput(); // pause main handler
-                    // Paint: full welcome TUI (background) + help box on top
-                    const helpLines = renderHelpPopupBox(options.version ?? 'v0.1', options.workspace);
-                    stdout.write('\x1b[H\x1b[J');
-                    stdout.write(renderWelcomePopupLayer(getOptions(), helpLines, stdout.columns, stdout.rows));
-                    // Wait for Esc / Enter / q to dismiss
-                    await new Promise((dismissResolve) => {
-                        const onDismiss = (s, k) => {
-                            if ((k && (k.name === 'escape' || k.name === 'return' || k.name === 'enter')) ||
-                                s === 'q' || s === 'Q' ||
-                                (k && k.ctrl && k.name === 'c')) {
-                                stdin.removeListener('keypress', onDismiss);
-                                dismissResolve();
-                            }
-                        };
-                        stdin.on('keypress', onDismiss);
-                    });
-                    // Restore: repaint the full welcome TUI, show cursor, position on input line
-                    stdout.write('\x1b[H\x1b[J');
-                    stdout.write(renderCenteredWelcomeScreen(getOptions(), stdout.rows));
-                    positionCursorOnInput();
-                    bindComposerInput(); // re-attach main handler
-                    return;
-                }
-                // ── /model overlay popup ──────────────────────────────────────────────
-                // Triggered when Enter is pressed with "/model" in the input box.
-                // We temporarily detach the main keypress listener and hand the model
-                // selector a drawFrame callback. drawFrame repaints the background TUI
-                // exactly as-is and composites the popup content as a centered floating
-                // layer on top of it (Cline/OpenCode style) — the popup never scrolls
-                // the background because every step redraws the whole frame.
-                // After it returns, we repaint the full welcome TUI and reposition cursor.
-                if (key && (key.name === 'return' || key.name === 'enter') && input.trim() === '/model') {
-                    setInput('');
-                    unbindComposerInput(); // pause main handler
-                    if (options.onModelSelect) {
-                        const drawFrame = (popupLines) => {
-                            stdout.write('\x1b[H\x1b[J');
-                            stdout.write(renderWelcomePopupLayer(getOptions(), popupLines, stdout.columns, stdout.rows));
-                        };
-                        const newId = await options.onModelSelect(drawFrame);
-                        if (newId && newId !== currentModel) {
-                            currentModel = newId;
-                        }
-                        const autoContinuePrompt = options.takeAutoContinuePrompt?.();
-                        if (autoContinuePrompt) {
-                            options.signal?.removeEventListener('abort', onAbort);
-                            cleanup();
-                            resolve({ text: autoContinuePrompt, mode: currentMode, autoApprove: currentAutoApprove });
-                            return;
-                        }
-                    }
-                    // Selection flow left stdin in non-raw mode — restore it for our TUI
-                    readline.emitKeypressEvents(stdin);
-                    stdin.resume();
-                    stdin.setRawMode(true);
-                    stdout.write('\x1b[H\x1b[J');
-                    stdout.write(renderCenteredWelcomeScreen(getOptions(), stdout.rows));
-                    positionCursorOnInput();
-                    bindComposerInput(); // re-attach main handler
-                    return;
-                }
-                if (key && (key.name === 'return' || key.name === 'enter') && input.trim() === '/connect') {
-                    setInput('');
-                    unbindComposerInput();
-                    const drawFrame = (popupLines) => {
-                        stdout.write('\x1b[H\x1b[J');
-                        stdout.write(renderWelcomePopupLayer(getOptions(), popupLines, stdout.columns, stdout.rows));
-                    };
-                    if (options.onConnect) {
-                        const newModel = await options.onConnect(drawFrame);
-                        if (newModel)
-                            currentModel = newModel;
-                    }
-                    readline.emitKeypressEvents(stdin);
-                    stdin.resume();
-                    stdin.setRawMode(true);
-                    stdout.write('\x1b[H\x1b[J');
-                    stdout.write(renderCenteredWelcomeScreen(getOptions(), stdout.rows));
-                    positionCursorOnInput();
-                    bindComposerInput();
-                    return;
-                }
-                if (key && (key.name === 'return' || key.name === 'enter') && input.trim().startsWith('/session')) {
-                    const command = input.trim();
-                    setInput('');
-                    unbindComposerInput();
-                    if (options.onSession) {
-                        await options.onSession(command, (popupLines) => {
-                            stdout.write('\x1b[H\x1b[J');
-                            stdout.write(renderWelcomePopupLayer(getOptions(), popupLines, stdout.columns, stdout.rows));
-                        });
-                    }
-                    const autoContinuePrompt = options.takeAutoContinuePrompt?.();
-                    if (autoContinuePrompt) {
-                        options.signal?.removeEventListener('abort', onAbort);
-                        cleanup();
-                        resolve({ text: autoContinuePrompt, mode: currentMode, autoApprove: currentAutoApprove });
-                        return;
-                    }
-                    readline.emitKeypressEvents(stdin);
-                    stdin.resume();
-                    stdin.setRawMode(true);
-                    stdout.write('\x1b[H\x1b[J');
-                    stdout.write(renderCenteredWelcomeScreen(getOptions(), stdout.rows));
-                    positionCursorOnInput();
-                    bindComposerInput();
-                    return;
-                }
-                if (key && (key.name === 'return' || key.name === 'enter') && input.trim().startsWith('/queue')) {
-                    const command = input.trim();
-                    setInput('');
-                    unbindComposerInput();
-                    if (options.onQueue) {
-                        await options.onQueue(command, async (popupLines) => {
-                            stdout.write('\x1b[H\x1b[J');
-                            stdout.write(renderWelcomePopupLayer(getOptions(), popupLines, stdout.columns, stdout.rows));
-                            await new Promise((dismissResolve) => {
-                                const onDismiss = (s, k) => {
-                                    if ((k && (k.name === 'escape' || k.name === 'return' || k.name === 'enter')) ||
-                                        s === 'q' || s === 'Q' || s === '\x1b') {
-                                        stdin.removeListener('keypress', onDismiss);
-                                        dismissResolve();
-                                    }
-                                };
-                                stdin.on('keypress', onDismiss);
-                            });
-                        });
-                    }
-                    readline.emitKeypressEvents(stdin);
-                    stdin.resume();
-                    stdin.setRawMode(true);
-                    stdout.write('\x1b[H\x1b[J');
-                    stdout.write(renderCenteredWelcomeScreen(getOptions(), stdout.rows));
-                    positionCursorOnInput();
-                    bindComposerInput();
-                    return;
-                }
-                if (key && (key.name === 'return' || key.name === 'enter') && input.trim().startsWith('/btw')) {
-                    const command = input.trim();
-                    setInput('');
-                    unbindComposerInput();
-                    if (options.onBtw) {
-                        const ac = new AbortController();
-                        const onBtwKey = (s, k) => {
-                            if ((k && k.name === 'escape') || s === '\x1b') {
-                                ac.abort();
-                            }
-                        };
-                        stdin.on('keypress', onBtwKey);
-                        try {
-                            await options.onBtw(command, async (popupLines, frameOpts) => {
-                                stdout.write('\x1b[H\x1b[J');
-                                stdout.write(renderWelcomePopupLayer(getOptions(), popupLines, stdout.columns, stdout.rows));
-                                if (frameOpts?.waitDismiss !== false && !ac.signal.aborted) {
-                                    await new Promise((dismissResolve) => {
-                                        const onDismiss = (s, k) => {
-                                            if ((k && (k.name === 'escape' || k.name === 'return' || k.name === 'enter')) ||
-                                                s === 'q' || s === 'Q' || s === '\x1b') {
-                                                stdin.removeListener('keypress', onDismiss);
-                                                dismissResolve();
-                                            }
-                                        };
-                                        stdin.on('keypress', onDismiss);
-                                    });
-                                }
-                            }, ac.signal);
-                        }
-                        finally {
-                            stdin.removeListener('keypress', onBtwKey);
-                        }
-                    }
-                    readline.emitKeypressEvents(stdin);
-                    stdin.resume();
-                    stdin.setRawMode(true);
-                    stdout.write('\x1b[H\x1b[J');
-                    stdout.write(renderCenteredWelcomeScreen(getOptions(), stdout.rows));
-                    positionCursorOnInput();
-                    bindComposerInput();
-                    return;
-                }
-                if (key && (key.name === 'return' || key.name === 'enter') && isMcpCommandInput(input)) {
-                    const command = input.trim();
-                    setInput('');
-                    unbindComposerInput();
-                    if (options.onMcp) {
-                        await options.onMcp(command, (popupLines) => {
-                            stdout.write('\x1b[H\x1b[J');
-                            stdout.write(renderWelcomePopupLayer(getOptions(), popupLines, stdout.columns, stdout.rows));
-                        });
-                    }
-                    if (options.signal?.aborted)
-                        return;
-                    readline.emitKeypressEvents(stdin);
-                    stdin.resume();
-                    stdin.setRawMode(true);
-                    redrawFull();
-                    bindComposerInput();
-                    return;
-                }
-                if (key && (key.name === 'return' || key.name === 'enter') && input.trim() === '/init') {
-                    setInput('');
-                    unbindComposerInput();
-                    if (options.onInit) {
-                        await options.onInit((popupLines) => {
-                            stdout.write('\x1b[H\x1b[J');
-                            stdout.write(renderWelcomePopupLayer(getOptions(), popupLines, stdout.columns, stdout.rows));
-                        });
-                    }
-                    if (options.signal?.aborted)
-                        return;
-                    readline.emitKeypressEvents(stdin);
-                    stdin.resume();
-                    stdin.setRawMode(true);
-                    redrawFull();
-                    bindComposerInput();
-                    return;
-                }
-                if (key && (key.name === 'return' || key.name === 'enter') && input.trim().startsWith('/workflow')) {
-                    const command = input.trim();
-                    setInput('');
-                    unbindComposerInput();
-                    const action = options.onWorkflow ? await options.onWorkflow(command, (popupLines) => { stdout.write('\x1b[H\x1b[J'); stdout.write(renderWelcomePopupLayer(getOptions(), popupLines, stdout.columns, stdout.rows)); }) : undefined;
-                    if (action === 'build') {
-                        cleanup();
-                        resolve({ text: '', mode: 'Execute', autoApprove: currentAutoApprove, workflowAction: 'build' });
-                        return;
-                    }
-                    readline.emitKeypressEvents(stdin);
-                    stdin.resume();
-                    stdin.setRawMode(true);
-                    redrawFull();
-                    bindComposerInput();
-                    return;
-                }
-                // ── /clear ────────────────────────────────────────────────────────────
-                if (key && (key.name === 'return' || key.name === 'enter') && input.trim() === '/clear') {
-                    setInput('');
-                    options.onClear?.();
-                    redrawFull();
-                    return;
-                }
-                // ── /exit ─────────────────────────────────────────────────────────────
-                if (key && (key.name === 'return' || key.name === 'enter') &&
-                    (input.trim() === '/exit' || input.trim() === '/quit')) {
-                    cleanup();
-                    if (options.signal)
-                        options.signal.removeEventListener('abort', onAbort);
-                    return await exitCleanly(options.onExit?.() ?? '\x1b[32mGoodbye! Stay Tuned with Moderado!\x1b[0m');
-                }
-                // ── Normal keys ───────────────────────────────────────────────────────
-                if (!key) {
-                    if (str && str.length === 1 && str.charCodeAt(0) >= 32) {
-                        input = input.slice(0, caret) + str + input.slice(caret);
-                        caret += 1;
-                        updateMentions();
-                        redrawCard();
-                    }
-                    return;
-                }
-                // Shift+Tab — toggle auto-approve
-                if ((key.name === 'tab' && key.shift) || key.sequence === '\x1b[Z') {
-                    currentAutoApprove = !currentAutoApprove;
-                    redrawCard();
-                    return;
-                }
-                // Tab — autocomplete mention, autocomplete slash command or toggle mode
-                if (key.name === 'tab' && !key.shift) {
-                    const mention = activeMentionToken(input, caret);
-                    if (mention && mentionFiles.length > 0) {
-                        const chosen = mentionFiles[Math.min(mentionSelection, mentionFiles.length - 1)];
-                        const before = input.slice(0, mention.start);
-                        const after = input.slice(caret);
-                        const insert = `@${chosen} `;
-                        input = before + insert + after;
-                        caret = before.length + insert.length;
-                        updateMentions();
-                        redrawCard();
-                        return;
-                    }
-                    if (input.startsWith('/')) {
-                        const matching = getMatchingCommands(input);
-                        if (matching.length > 0) {
-                            setInput(matching[Math.min(commandSelection, matching.length - 1)].name);
-                            commandSelection = 0;
-                            redrawCard();
-                            return;
-                        }
-                    }
-                    currentMode = currentMode === 'Plan' ? 'Execute' : 'Plan';
-                    redrawCard();
-                    return;
-                }
-                if (mentionFiles.length > 0 && (key.name === 'up' || key.name === 'down')) {
-                    mentionSelection = ((mentionSelection + (key.name === 'up' ? -1 : 1)) % mentionFiles.length + mentionFiles.length) % mentionFiles.length;
-                    redrawCard();
-                    return;
-                }
-                if (input.startsWith('/') && (key.name === 'up' || key.name === 'down')) {
-                    const matching = getMatchingCommands(input);
-                    if (matching.length > 0) {
-                        commandSelection = ((commandSelection + (key.name === 'up' ? -1 : 1)) % matching.length + matching.length) % matching.length;
-                        redrawCard();
-                        return;
-                    }
-                }
-                if (!input.startsWith('/') && (key.name === 'up' || key.name === 'down') && questionHistory.length > 0) {
-                    if (questionHistoryIndex === questionHistory.length)
-                        questionHistoryDraft = input;
-                    const recalled = navigateQuestionHistory(questionHistory, key.name === 'up' ? -1 : 1, questionHistoryIndex, questionHistoryDraft);
-                    setInput(recalled.input);
-                    questionHistoryIndex = recalled.index;
-                    redrawCard();
-                    return;
-                }
-                // Enter — submit real user message
-                if (key.name === 'return' || key.name === 'enter') {
-                    const matching = getMatchingCommands(input);
-                    if (input.startsWith('/') && matching.length > 0 && !matching.some((command) => command.name === input.trim())) {
-                        setInput(matching[Math.min(commandSelection, matching.length - 1)].name);
-                        commandSelection = 0;
-                        redrawCard();
-                        return;
-                    }
-                    const trimmed = input.trim();
-                    cleanup();
-                    if (options.signal)
-                        options.signal.removeEventListener('abort', onAbort);
-                    const moveDown = 4 + getExtraLines();
-                    stdout.write(`\x1b[${moveDown}B\r\n\x1b[0 q\x1b[?25h`);
-                    resolve({ text: trimmed, mode: currentMode, autoApprove: currentAutoApprove });
-                    return;
-                }
-                // Caret movement (cursor-only hop) and forward delete (repaint: the
-                // line shrank, so the old trailing character must be cleared).
-                if (key.name === 'left' || key.name === 'right' || key.name === 'delete') {
-                    if (key.name === 'left') {
-                        caret = Math.max(0, caret - 1);
-                        updateMentions();
-                        redrawCard();
-                    }
-                    else if (key.name === 'right') {
-                        caret = Math.min(input.length, caret + 1);
-                        updateMentions();
-                        redrawCard();
-                    }
-                    else if (caret < input.length) {
-                        input = input.slice(0, caret) + input.slice(caret + 1);
-                        updateMentions();
-                        redrawCard();
-                    }
-                    return;
-                }
-                // Backspace
-                if (key.name === 'backspace') {
-                    if (caret > 0) {
-                        input = input.slice(0, caret - 1) + input.slice(caret);
-                        caret = Math.max(0, caret - 1);
-                        commandSelection = 0;
-                        updateMentions();
-                        redrawCard();
-                    }
-                    return;
-                }
-                // Printable character
-                if (str && str.length === 1 && str.charCodeAt(0) >= 32 && !key.ctrl && !key.meta) {
-                    input = input.slice(0, caret) + str + input.slice(caret);
-                    caret += 1;
-                    commandSelection = 0;
-                    questionHistoryIndex = questionHistory.length;
-                    updateMentions();
-                    redrawCard();
-                }
-            })();
-        };
-        /**
-         * Mouse reporting is only useful while the composer owns the keyboard: a
-         * click on the composer line places the caret. Popups and sub-prompts take
-         * the keyboard over with mouse reporting off, so they keep the terminal's
-         * normal text selection, and clicks never leak into their filter fields.
-         */
-        const bindComposerInput = () => {
-            stdout.write(MOUSE_REPORT_ON);
-            stdin.on('keypress', onKeypress);
-        };
-        const unbindComposerInput = () => {
-            stdin.removeListener('keypress', onKeypress);
-            stdout.write(MOUSE_REPORT_OFF);
-        };
-        bindComposerInput();
-    });
-}
 /** A cumulative task snapshot; a request ending does not mean the task ended. */
 export function formatTokenUsage(event) {
     const marker = event.estimated ? '~' : '';
@@ -1178,7 +1207,7 @@ export function renderGatewayFallbackUpdate(event, width = process.stdout.column
     const area = getChatAnswerArea(width);
     const destination = event.toProvider ? `${event.toProvider}/${event.toModel}` : event.toModel;
     const reason = event.reason === 'rate_limited_or_unavailable' ? 'after an upstream route was rate limited or unavailable' : 'after a fallback';
-    const text = `Gateway route changed to ${destination} ${reason}`.slice(0, area.cardWidth);
+    const text = truncateToWidth(`Gateway route changed to ${destination} ${reason}`, area.cardWidth);
     const row = renderModeradoHeader().split('\n').length + 3;
     return `\x1b7\x1b[${row};${area.startColumn}H\x1b[K\x1b[38;5;244m${text}\x1b[0m\x1b8`;
 }