@thegitai/cli 1.0.0-beta.1

package/dist/src/ui/repl.js

@@ -0,0 +1,2238 @@
+import { createRatatuiBridge } from './tui/bridge.js';
+import { buildTuiFrame, renderTranscriptEntryLines } from './tui/build-frame.js';
+export { getSlashCommandSuggestions } from './tui/build-frame.js';
+import { agentModeLabel, nextAgentMode, } from '../agent-mode.js';
+import { chat, models } from '../api/index.js';
+import { isTurnCancelledError } from '../api/chat.js';
+import { cancelActiveCommand } from '../executor.js';
+import { setCommandOutputHook, withTuiMode } from '../runtime-mode.js';
+import { clearConversation, } from '../session.js';
+import { applySessionSnapshot, listSessionMetadata, loadSessionSnapshot, saveSessionState, } from '../session-store.js';
+import { truncate } from '../utils.js';
+import { writeClipboardText } from '../core/clipboard.js';
+import { openUrl } from '../core/open-url.js';
+import { formatInteractiveHelpText } from '../help-text.js';
+import { expandPastedChunks, } from './paste-collapse.js';
+import { loadPromptHistory, MAX_PROMPT_HISTORY_ENTRIES, } from './prompt-history-store.js';
+const RESPONSE_STREAM_CHUNK_SIZE = 4;
+const RESPONSE_STREAM_DELAY_MS = 8;
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+export function* buildResponseStreamBodies(responseText) {
+    let body = '';
+    let emitted = '';
+    let count = 0;
+    for (const char of responseText) {
+        body += char;
+        count += 1;
+        if (count % RESPONSE_STREAM_CHUNK_SIZE === 0) {
+            emitted = body;
+            yield body;
+        }
+    }
+    if (body && emitted !== body) {
+        yield responseText;
+    }
+}
+function sameTranscriptDraft(a, b) {
+    return Boolean(a &&
+        a.kind === b.kind &&
+        a.title === b.title &&
+        a.body === b.body &&
+        a.filePath === b.filePath &&
+        a.preformatted === b.preformatted);
+}
+export function buildSettledTurnTranscriptEntries(turnEntries, responseText) {
+    const responseBody = String(responseText ?? '').trim();
+    const responseEntry = responseBody
+        ? {
+            body: responseBody,
+            kind: 'assistant',
+            title: 'Response',
+        }
+        : null;
+    return [
+        ...turnEntries,
+        ...(responseEntry !== null && !sameTranscriptDraft(turnEntries.at(-1), responseEntry)
+            ? [responseEntry]
+            : []),
+    ];
+}
+const TUI_WIDTH_RATIO = 0.95;
+const COMMAND_PREVIEW_LINES = 10;
+const TRANSCRIPT_DIFF_PREVIEW_LINES = 24;
+const WORKING_TOOL_PREVIEW_ITEMS = 4;
+const THINKING_NOTE_PREVIEW_ROWS = 3;
+const WORKING_TOOL_PREVIEW_ROWS = 3;
+const AGENT_MODE_LABEL_WIDTH = 16;
+const APPROVAL_OPTIONS = [
+    {
+        value: 'y',
+        label: 'Approve once',
+        description: 'Run this action only this time',
+    },
+    {
+        value: 'a',
+        label: 'Approve all remaining actions',
+        description: 'Turn on auto-approve for the rest of the session',
+    },
+    {
+        value: 'n',
+        label: 'Deny',
+        description: 'Reject this action',
+    },
+];
+export const SLASH_COMMANDS = [
+    {
+        command: '/help',
+        description: 'Show available chat commands',
+    },
+    {
+        command: '/usage',
+        description: 'Show account usage percentage and reset times',
+    },
+    {
+        command: '/model',
+        description: 'Switch the active model',
+    },
+    {
+        command: '/resume',
+        description: 'Open the session picker',
+    },
+    {
+        command: '/clear',
+        description: 'Clear conversation history',
+    },
+    {
+        command: '/exit',
+        description: 'Quit the current session',
+    },
+];
+function getShellWidth(columns) {
+    const safeColumns = Math.max(columns, 20);
+    const targetWidth = Math.floor(safeColumns * TUI_WIDTH_RATIO);
+    return Math.max(20, Math.min(safeColumns - 2, targetWidth));
+}
+function formatModelLabel(modelId, serverModels) {
+    return serverModels.find((model) => model.id === modelId)?.label ?? 'Unknown model';
+}
+function formatRelativeTime(isoDate) {
+    const diff = Date.now() - new Date(isoDate).getTime();
+    const minutes = Math.floor(diff / 60000);
+    if (minutes < 1)
+        return 'just now';
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+function filterResumeSessions(sessions, filter, serverModels) {
+    const q = filter.trim().toLowerCase();
+    if (!q)
+        return sessions;
+    return sessions.filter((session) => {
+        const branch = (session.branch ?? '').toLowerCase();
+        const model = formatModelLabel(session.modelId, serverModels).toLowerCase();
+        const conversation = session.lastUserMessage.toLowerCase();
+        return branch.includes(q) || model.includes(q) || conversation.includes(q);
+    });
+}
+function getEntryColor(kind) {
+    switch (kind) {
+        case 'assistant':
+        case 'diff':
+            return 'green';
+        case 'error':
+            return 'red';
+        case 'system':
+            return 'yellow';
+        case 'tool':
+            return 'blue';
+        case 'user':
+            return 'cyan';
+    }
+}
+function parseInlineSegments(text) {
+    const source = String(text ?? '');
+    const segments = [];
+    let cursor = 0;
+    while (cursor < source.length) {
+        if (source.startsWith('**', cursor)) {
+            const end = source.indexOf('**', cursor + 2);
+            if (end > cursor + 2) {
+                segments.push({ kind: 'bold', text: source.slice(cursor + 2, end) });
+                cursor = end + 2;
+                continue;
+            }
+        }
+        if (source[cursor] === '`') {
+            const end = source.indexOf('`', cursor + 1);
+            if (end > cursor + 1) {
+                segments.push({ kind: 'code', text: source.slice(cursor + 1, end) });
+                cursor = end + 1;
+                continue;
+            }
+        }
+        let nextCursor = source.length;
+        const nextBold = source.indexOf('**', cursor);
+        const nextCode = source.indexOf('`', cursor);
+        if (nextBold !== -1)
+            nextCursor = Math.min(nextCursor, nextBold);
+        if (nextCode !== -1)
+            nextCursor = Math.min(nextCursor, nextCode);
+        if (nextCursor === cursor)
+            nextCursor += 1;
+        segments.push({ kind: 'text', text: source.slice(cursor, nextCursor) });
+        cursor = nextCursor;
+    }
+    return segments.filter((segment) => segment.text.length > 0);
+}
+function isEscapedMarkdownPipe(source, pipeIndex) {
+    let slashCount = 0;
+    for (let index = pipeIndex - 1; index >= 0 && source[index] === '\\'; index--) {
+        slashCount++;
+    }
+    return slashCount % 2 === 1;
+}
+function splitMarkdownTableRow(line) {
+    const trimmed = String(line ?? '').trim();
+    const withoutLeadingPipe = trimmed.startsWith('|') ? trimmed.slice(1) : trimmed;
+    const trailingPipeIndex = withoutLeadingPipe.length - 1;
+    const hasTrailingBoundaryPipe = trailingPipeIndex >= 0 &&
+        withoutLeadingPipe[trailingPipeIndex] === '|' &&
+        !isEscapedMarkdownPipe(withoutLeadingPipe, trailingPipeIndex);
+    const withoutBoundaryPipes = hasTrailingBoundaryPipe
+        ? withoutLeadingPipe.slice(0, -1)
+        : withoutLeadingPipe;
+    const cells = [];
+    let cell = '';
+    for (let index = 0; index < withoutBoundaryPipes.length; index++) {
+        const char = withoutBoundaryPipes[index] ?? '';
+        if (char === '|' && !isEscapedMarkdownPipe(withoutBoundaryPipes, index)) {
+            cells.push(cell.trim().replace(/\\\|/g, '|'));
+            cell = '';
+            continue;
+        }
+        cell += char;
+    }
+    cells.push(cell.trim().replace(/\\\|/g, '|'));
+    return cells;
+}
+function isMarkdownTableRow(line) {
+    const cells = splitMarkdownTableRow(line);
+    return cells.length >= 2 && String(line ?? '').includes('|');
+}
+function isMarkdownTableSeparator(line) {
+    const cells = splitMarkdownTableRow(line);
+    return cells.length >= 2 && cells.every((cell) => /^:?-{3,}:?$/.test(cell));
+}
+function stripInlineFormattingForWidth(text) {
+    return String(text ?? '')
+        .replace(/`([^`]*)`/g, '$1')
+        .replace(/\*\*([^*]+)\*\*/g, '$1');
+}
+const TRANSCRIPT_BAR_WIDTH = 3;
+const TABLE_BORDER_WIDTH = 2;
+const TABLE_CELL_OVERHEAD_WIDTH = 3;
+function fitTableColumnWidths(columnWidths, maxWidth) {
+    const widths = columnWidths.map((width) => Math.max(3, Math.floor(width)));
+    if (widths.length === 0)
+        return widths;
+    const overhead = TABLE_BORDER_WIDTH + widths.length * TABLE_CELL_OVERHEAD_WIDTH;
+    const budget = Math.max(widths.length * 3, maxWidth - overhead);
+    const total = widths.reduce((sum, width) => sum + width, 0);
+    if (total <= budget)
+        return widths;
+    let remaining = budget;
+    const scaled = widths.map((width) => {
+        const next = Math.max(3, Math.floor((width / total) * budget));
+        remaining -= next;
+        return next;
+    });
+    while (remaining > 0) {
+        let targetIndex = 0;
+        for (let index = 1; index < widths.length; index++) {
+            if (widths[index] - scaled[index] > widths[targetIndex] - scaled[targetIndex]) {
+                targetIndex = index;
+            }
+        }
+        scaled[targetIndex]++;
+        remaining--;
+    }
+    while (remaining < 0) {
+        let targetIndex = -1;
+        for (let index = 0; index < scaled.length; index++) {
+            if (scaled[index] <= 3)
+                continue;
+            if (targetIndex === -1 || scaled[index] > scaled[targetIndex]) {
+                targetIndex = index;
+            }
+        }
+        if (targetIndex === -1)
+            break;
+        scaled[targetIndex]--;
+        remaining++;
+    }
+    return scaled;
+}
+function normalizeMarkdownTableCells(cells, columnCount) {
+    return Array.from({ length: columnCount }, (_, index) => cells[index] ?? '');
+}
+function parseMarkdownTableBlock(lines, startIndex) {
+    const headerLine = lines[startIndex] ?? '';
+    const separatorLine = lines[startIndex + 1] ?? '';
+    if (!isMarkdownTableRow(headerLine) || !isMarkdownTableSeparator(separatorLine)) {
+        return null;
+    }
+    const headers = splitMarkdownTableRow(headerLine);
+    const separators = splitMarkdownTableRow(separatorLine);
+    if (headers.length !== separators.length) {
+        return null;
+    }
+    const columnCount = Math.max(headers.length, separators.length);
+    const rows = [];
+    let nextIndex = startIndex + 2;
+    while (nextIndex < lines.length && isMarkdownTableRow(lines[nextIndex] ?? '')) {
+        const cells = splitMarkdownTableRow(lines[nextIndex] ?? '');
+        if (cells.length !== columnCount)
+            break;
+        rows.push(normalizeMarkdownTableCells(cells, columnCount));
+        nextIndex++;
+    }
+    const normalizedHeaders = normalizeMarkdownTableCells(headers, columnCount);
+    const columnWidths = normalizedHeaders.map((header, columnIndex) => {
+        const values = [header, ...rows.map((row) => row[columnIndex] ?? '')];
+        return Math.max(3, ...values.map((value) => stripInlineFormattingForWidth(value).length));
+    });
+    return {
+        nextIndex,
+        table: {
+            columnWidths,
+            headers: normalizedHeaders,
+            rows,
+        },
+    };
+}
+function splitFormattedLines(body) {
+    const lines = String(body ?? '').split('\n');
+    const formatted = [];
+    let inCodeBlock = false;
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index] ?? '';
+        const trimmed = line.trim();
+        if (trimmed.startsWith('```')) {
+            inCodeBlock = !inCodeBlock;
+            continue;
+        }
+        if (inCodeBlock) {
+            formatted.push({ kind: 'code', text: line });
+            continue;
+        }
+        if (!trimmed) {
+            formatted.push({ kind: 'blank', text: '' });
+            continue;
+        }
+        if (/^<{3,}/.test(trimmed)) {
+            formatted.push({ kind: 'conflict-start', text: trimmed });
+            continue;
+        }
+        if (/^={3,}$/.test(trimmed)) {
+            formatted.push({ kind: 'conflict-sep', text: trimmed });
+            continue;
+        }
+        if (/^>{3,}/.test(trimmed)) {
+            formatted.push({ kind: 'conflict-end', text: trimmed });
+            continue;
+        }
+        const tableBlock = parseMarkdownTableBlock(lines, index);
+        if (tableBlock) {
+            formatted.push({ kind: 'table', table: tableBlock.table, text: '' });
+            index = tableBlock.nextIndex - 1;
+            continue;
+        }
+        const headingMatch = trimmed.match(/^(#{1,4})\s+(.*)$/);
+        if (headingMatch) {
+            formatted.push({ kind: 'heading', text: headingMatch[2] ?? '' });
+            continue;
+        }
+        const numberedMatch = trimmed.match(/^(\d+)\.\s+(.*)$/);
+        if (numberedMatch) {
+            formatted.push({
+                kind: 'numbered',
+                marker: numberedMatch[1],
+                text: numberedMatch[2] ?? '',
+            });
+            continue;
+        }
+        const bulletMatch = trimmed.match(/^[-*]\s+(.*)$/);
+        if (bulletMatch) {
+            formatted.push({ kind: 'bullet', text: bulletMatch[1] ?? '' });
+            continue;
+        }
+        const quoteMatch = trimmed.match(/^>\s+(.*)$/);
+        if (quoteMatch) {
+            formatted.push({ kind: 'quote', text: quoteMatch[1] ?? '' });
+            continue;
+        }
+        formatted.push({ kind: 'paragraph', text: line });
+    }
+    return formatted;
+}
+function parseDiffPreview(patchText) {
+    const lines = String(patchText ?? '').split('\n');
+    const previewLines = [];
+    let added = 0;
+    let removed = 0;
+    let oldLine = null;
+    let newLine = null;
+    for (const rawLine of lines) {
+        const hunk = rawLine.match(/^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+        if (hunk) {
+            oldLine = Number(hunk[1]);
+            newLine = Number(hunk[2]);
+            previewLines.push({ kind: 'hunk', lineNumber: null, content: rawLine });
+            continue;
+        }
+        if (rawLine.startsWith('@@')) {
+            previewLines.push({ kind: 'hunk', lineNumber: null, content: rawLine });
+            continue;
+        }
+        if (rawLine.startsWith('--- ') || rawLine.startsWith('+++ ')) {
+            continue;
+        }
+        if (rawLine === '\') {
+            continue;
+        }
+        if (rawLine.startsWith('+')) {
+            added++;
+            previewLines.push({ kind: 'add', lineNumber: newLine, content: rawLine.slice(1) });
+            if (newLine !== null)
+                newLine++;
+            continue;
+        }
+        if (rawLine.startsWith('-')) {
+            removed++;
+            previewLines.push({ kind: 'remove', lineNumber: oldLine, content: rawLine.slice(1) });
+            if (oldLine !== null)
+                oldLine++;
+            continue;
+        }
+        const content = rawLine.startsWith(' ') ? rawLine.slice(1) : rawLine;
+        previewLines.push({ kind: 'context', lineNumber: newLine ?? oldLine, content });
+        if (oldLine !== null)
+            oldLine++;
+        if (newLine !== null)
+            newLine++;
+    }
+    return { added, lines: previewLines, removed };
+}
+function diffLineColor(kind) {
+    switch (kind) {
+        case 'add':
+            return 'green';
+        case 'remove':
+            return 'red';
+        case 'hunk':
+            return 'cyan';
+        case 'context':
+            return 'gray';
+    }
+}
+function diffLinePrefix(kind) {
+    switch (kind) {
+        case 'add':
+            return '+';
+        case 'remove':
+            return '-';
+        case 'hunk':
+        case 'context':
+            return ' ';
+    }
+}
+function splitDiffLines(text) {
+    if (text === '')
+        return [];
+    const lines = text.split('\n');
+    return text.endsWith('\n') && lines[lines.length - 1] === ''
+        ? lines.slice(0, -1)
+        : lines;
+}
+function buildStrReplaceDiff(oldString, newString) {
+    const oldLines = splitDiffLines(String(oldString ?? ''));
+    const newLines = splitDiffLines(String(newString ?? ''));
+    const lines = [`@@ -1,${oldLines.length} +1,${newLines.length} @@`];
+    if (oldLines.length > 0)
+        lines.push(oldLines.map((line) => `-${line}`).join('\n'));
+    if (newLines.length > 0)
+        lines.push(newLines.map((line) => `+${line}`).join('\n'));
+    return lines.join('\n');
+}
+function buildWriteFileDiff(content) {
+    const lines = splitDiffLines(String(content ?? ''));
+    if (lines.length === 0)
+        return '';
+    return `@@ -0,0 +1,${lines.length} @@\n${lines.map((line) => `+${line}`).join('\n')}`;
+}
+function buildDeleteFileDiff(content) {
+    const lines = splitDiffLines(String(content ?? ''));
+    if (lines.length === 0)
+        return '';
+    return `@@ -1,${lines.length} +0,0 @@\n${lines.map((line) => `-${line}`).join('\n')}`;
+}
+function isFileChangeTool(name) {
+    return (name === 'patch_file' ||
+        name === 'str_replace' ||
+        name === 'write_file' ||
+        name === 'delete_file' ||
+        name === 'undo_edit');
+}
+function getToolFilePath(call, result) {
+    return String(call.args?.filePath ??
+        call.args?.file_path ??
+        result?.filePath ??
+        '').trim();
+}
+function formatToolResultState(result) {
+    if (result?.skipped)
+        return 'Skipped';
+    if (result?.blocked)
+        return 'Blocked';
+    if (result?.ok === true)
+        return 'OK';
+    return 'Failed';
+}
+function formatRunCommandResultState(result) {
+    if (result?.timedOut)
+        return 'Timed out';
+    if (result?.exitCode != null)
+        return `Exit code ${result.exitCode}`;
+    return formatToolResultState(result);
+}
+function formatToolArgs(call, result) {
+    const filePath = getToolFilePath(call, result);
+    if (filePath)
+        return filePath;
+    if (call.name === 'search_code' || call.name === 'grep_code') {
+        return truncate(String(call.args?.query ?? call.args?.pattern ?? ''), 120);
+    }
+    if (call.name === 'thegitai_web_fetch') {
+        return truncate(String(call.args?.url ?? ''), 120);
+    }
+    if (call.name === 'thegitai_web_search') {
+        return truncate(String(call.args?.query ?? ''), 120);
+    }
+    return '';
+}
+function buildFileChangeEntry(event) {
+    const { call, result } = event;
+    const filePath = getToolFilePath(call, result) || '(unknown file)';
+    const ok = result?.ok === true;
+    const skipped = result?.skipped === true;
+    const error = typeof result?.error === 'string' && result.error.trim()
+        ? truncate(result.error.trim(), 180)
+        : '';
+    if (!ok) {
+        const verb = call.name === 'delete_file'
+            ? 'Delete'
+            : call.name === 'undo_edit'
+                ? 'Undo'
+                : 'Edit';
+        return {
+            body: error || `${call.name} ${filePath}`,
+            filePath,
+            kind: skipped ? 'system' : 'error',
+            title: skipped ? `${verb} skipped: ${filePath}` : `${verb} failed: ${filePath}`,
+        };
+    }
+    if (call.name === 'undo_edit') {
+        const dryRun = result?.dryRun === true ||
+            result?.dry_run === true ||
+            call.args?.dryRun === true ||
+            call.args?.dry_run === true;
+        const records = dryRun && Array.isArray(result?.previewed)
+            ? result.previewed
+            : Array.isArray(result?.reverted)
+                ? result.reverted
+                : [];
+        const files = records
+            .map((record) => String(record?.filePath ?? '').trim())
+            .filter((file) => Boolean(file));
+        const uniqueFiles = Array.from(new Set(files));
+        const titleFile = uniqueFiles.length === 1 ? uniqueFiles[0] : `${uniqueFiles.length} files`;
+        return {
+            body: '',
+            filePath: uniqueFiles[0] ?? filePath,
+            kind: 'tool',
+            title: dryRun
+                ? `Undo preview: ${titleFile}`
+                : `Undid assistant edit: ${titleFile}`,
+        };
+    }
+    if (call.name === 'delete_file') {
+        if (result?.deleted !== true) {
+            return {
+                body: '',
+                filePath,
+                kind: skipped ? 'system' : 'tool',
+                title: `Delete skipped: ${filePath}`,
+            };
+        }
+        const content = typeof result?.content === 'string' ? result.content : '';
+        const diffText = buildDeleteFileDiff(content);
+        const preview = diffText ? parseDiffPreview(diffText) : undefined;
+        const summary = preview ? ` (+0 -${preview.removed})` : '';
+        return {
+            body: '',
+            diffPreview: preview,
+            filePath,
+            kind: 'diff',
+            title: `Deleted ${filePath}${summary}`,
+        };
+    }
+    if (call.name === 'write_file') {
+        const content = typeof call.args?.content === 'string' ? call.args.content : '';
+        const diffText = buildWriteFileDiff(content);
+        const preview = diffText ? parseDiffPreview(diffText) : undefined;
+        const verb = result?.created === true ? 'Created' : 'Wrote';
+        const summary = preview ? ` (+${preview.added} -0)` : '';
+        return {
+            body: '',
+            diffPreview: preview,
+            filePath,
+            kind: 'diff',
+            title: `${verb} ${filePath}${summary}`,
+        };
+    }
+    let diffText = '';
+    if (call.name === 'patch_file') {
+        diffText = typeof call.args?.patch === 'string' ? call.args.patch : '';
+    }
+    else if (call.name === 'str_replace') {
+        const oldString = typeof call.args?.old_string === 'string'
+            ? call.args.old_string
+            : typeof call.args?.oldString === 'string'
+                ? call.args.oldString
+                : '';
+        const newString = typeof call.args?.new_string === 'string'
+            ? call.args.new_string
+            : typeof call.args?.newString === 'string'
+                ? call.args.newString
+                : '';
+        diffText = buildStrReplaceDiff(oldString, newString);
+    }
+    const preview = diffText ? parseDiffPreview(diffText) : undefined;
+    const summary = preview ? ` (+${preview.added} -${preview.removed})` : '';
+    return {
+        body: '',
+        diffPreview: preview,
+        filePath,
+        kind: 'diff',
+        title: `Edited ${filePath}${summary}`,
+    };
+}
+function buildWorkingToolEntry(event) {
+    const { call, result } = event;
+    const error = typeof result?.error === 'string' && result.error.trim()
+        ? `\n${truncate(result.error.trim(), 180)}`
+        : '';
+    if (call.name === 'run_command') {
+        const command = String(call.args?.command ?? result?.command ?? '').trim();
+        return {
+            body: `$ ${truncate(command, 180)}\n${formatRunCommandResultState(result)}${error}`,
+            kind: result?.ok === true ? 'tool' : 'error',
+            title: 'Shell',
+        };
+    }
+    if (call.name === 'run_node_script') {
+        return {
+            body: `node --input-type=module <script via stdin>\n${formatRunCommandResultState(result)}${error}`,
+            kind: result?.ok === true ? 'tool' : 'error',
+            title: 'Node',
+        };
+    }
+    if (isFileChangeTool(call.name)) {
+        return buildFileChangeEntry(event);
+    }
+    const args = formatToolArgs(call, result);
+    return {
+        body: `${call.name}${args ? ` ${args}` : ''} -> ${formatToolResultState(result)}${error}`,
+        kind: result?.ok === true ? 'tool' : 'error',
+        title: 'Tool',
+    };
+}
+function findPendingToolCallByName(pendingCalls, name) {
+    for (const [id, call] of pendingCalls) {
+        if (call.name !== name)
+            continue;
+        pendingCalls.delete(id);
+        return call;
+    }
+    return null;
+}
+function textFromHistoryEntry(entry) {
+    return (entry.parts ?? [])
+        .filter((part) => typeof part?.text === 'string' && part.text.trim())
+        .map((part) => part.text.trim())
+        .join('\n\n');
+}
+function displayUserTextFromHistoryEntry(entry) {
+    const text = textFromHistoryEntry(entry);
+    const markers = [
+        'Current user request:\n',
+        'Current user message:\n',
+        'User request:\n',
+        'User message:\n',
+    ];
+    const marker = markers.find((candidate) => text.includes(candidate)) ?? '';
+    if (!marker)
+        return text;
+    const start = text.indexOf(marker);
+    const contentStart = start + marker.length;
+    const contentEnd = text.indexOf('\n\n', contentStart);
+    return text
+        .slice(contentStart, contentEnd === -1 ? text.length : contentEnd)
+        .trim();
+}
+function buildTranscriptFromSessionHistory(history) {
+    const entries = [];
+    const pendingCalls = new Map();
+    for (const entry of history) {
+        if (!entry?.parts?.length)
+            continue;
+        for (const part of entry.parts) {
+            const call = part?.functionCall;
+            if (!call || typeof call !== 'object')
+                continue;
+            const callId = String(call.id ?? '').trim();
+            if (!callId || !call.name)
+                continue;
+            pendingCalls.set(callId, call);
+        }
+        for (const part of entry.parts) {
+            const functionResponse = part?.functionResponse;
+            if (!functionResponse || typeof functionResponse !== 'object')
+                continue;
+            const responseName = String(functionResponse.name ?? '').trim();
+            const responseId = String(functionResponse.id ?? functionResponse.toolCallId ?? '').trim();
+            let call = null;
+            if (responseId) {
+                call = pendingCalls.get(responseId) ?? null;
+                if (call)
+                    pendingCalls.delete(responseId);
+            }
+            if (!call && responseName) {
+                call = findPendingToolCallByName(pendingCalls, responseName);
+            }
+            if (!call || !isFileChangeTool(call.name))
+                continue;
+            entries.push(buildFileChangeEntry({
+                call,
+                result: functionResponse.response ?? {},
+            }));
+        }
+        if (entry.role === 'user' && entry.kind === 'turnStart') {
+            const text = displayUserTextFromHistoryEntry(entry);
+            if (text) {
+                entries.push({ body: text, kind: 'user', title: 'You' });
+            }
+            continue;
+        }
+        const text = textFromHistoryEntry(entry);
+        if ((entry.role === 'model' || entry.role === 'assistant') && text) {
+            entries.push({ body: text, kind: 'assistant', title: 'Response' });
+        }
+    }
+    return entries;
+}
+function createInitialTranscript() {
+    return [
+        {
+            body: 'Interactive mode ready. Type /help for commands.',
+            kind: 'system',
+            title: 'System',
+        },
+    ];
+}
+function createSessionTranscript(session) {
+    const transcript = buildTranscriptFromSessionHistory(session.history);
+    return transcript.length ? transcript : createInitialTranscript();
+}
+function createShellStore(initialState) {
+    let state = initialState;
+    let nextEntryId = 1;
+    const listeners = new Set();
+    const notify = () => {
+        for (const listener of listeners)
+            listener();
+    };
+    return {
+        getState: () => state,
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        setState: (nextState) => {
+            state = nextState;
+            notify();
+        },
+        update: (updater) => {
+            state = updater(state);
+            notify();
+        },
+        appendEntry: (entry) => {
+            const id = nextEntryId++;
+            state = {
+                ...state,
+                transcript: [...state.transcript, { ...entry, id }],
+                transcriptScrollOffset: 0,
+            };
+            notify();
+            return id;
+        },
+        appendEntries: (entries) => {
+            if (entries.length === 0)
+                return [];
+            const appended = entries.map((entry) => ({
+                ...entry,
+                id: nextEntryId++,
+            }));
+            state = {
+                ...state,
+                transcript: [...state.transcript, ...appended],
+                transcriptScrollOffset: 0,
+            };
+            notify();
+            return appended.map((entry) => entry.id);
+        },
+        appendWorkingTool: (entry) => {
+            const lastEntry = state.workingTools.at(-1);
+            if (sameTranscriptDraft(lastEntry, entry))
+                return;
+            state = {
+                ...state,
+                workingTools: [...state.workingTools, entry].slice(-WORKING_TOOL_PREVIEW_ITEMS),
+            };
+            notify();
+        },
+        replaceTranscript: (entries) => {
+            state = {
+                ...state,
+                transcript: entries.map((entry) => ({ ...entry, id: nextEntryId++ })),
+                transcriptScrollOffset: 0,
+                workingTools: [],
+            };
+            notify();
+        },
+        updateEntry: (id, changes) => {
+            const index = state.transcript.findIndex((entry) => entry.id === id);
+            if (index === -1)
+                return;
+            const current = state.transcript[index];
+            const next = { ...current, ...changes };
+            if (current.body === next.body &&
+                current.kind === next.kind &&
+                current.title === next.title) {
+                return;
+            }
+            const nextTranscript = [...state.transcript];
+            nextTranscript[index] = next;
+            state = { ...state, transcript: nextTranscript };
+            notify();
+        },
+    };
+}
+function shallowArrayEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a.length !== b.length)
+        return false;
+    for (let index = 0; index < a.length; index++) {
+        if (!Object.is(a[index], b[index]))
+            return false;
+    }
+    return true;
+}
+function createInitialShellState(session, serverModels, debugUi) {
+    return {
+        activeTurnInput: '',
+        activeTurnInputPreformatted: false,
+        agentMode: session.agentMode,
+        approvalCursor: getDefaultApprovalCursor(),
+        approvalPrompt: null,
+        autoYes: session.autoYes,
+        busy: false,
+        busySince: null,
+        clockNow: Date.now(),
+        commandCursor: 0,
+        commandLog: [],
+        contextStatus: 'Idle',
+        currentModelId: session.modelId,
+        cursor: 0,
+        exiting: false,
+        input: '',
+        maxToolSteps: session.maxToolSteps,
+        modelPickerIndex: getDefaultModelPickerIndex(session.modelId, serverModels.models),
+        modelPickerOpen: false,
+        projectRoot: session.rootDir,
+        sessionId: session.sessionId,
+        showSessionId: debugUi.showSessionId,
+        promptHistory: loadPromptHistory(session.env),
+        promptHistoryCursor: null,
+        promptHistoryDraft: '',
+        resumePickerFilter: '',
+        resumePickerIndex: 0,
+        resumePickerOpen: false,
+        resumePickerSessions: [],
+        transcriptScrollOffset: 0,
+        queuedMessage: null,
+        serverModels: serverModels.models,
+        sudoPrompt: null,
+        status: 'Ready',
+        exitConfirmUntil: null,
+        thinkingTitle: '',
+        thinkingNotes: [],
+        tokenUsage: formatClientTokenUsage(null),
+        transcript: [],
+        turnCounter: Math.max(0, session.history.filter((entry) => entry.role === 'user').length),
+        pastedChunks: [],
+        imageAttachments: [],
+        workingTools: [],
+    };
+}
+function formatTokenCount(value) {
+    return Math.max(0, Math.round(value)).toLocaleString();
+}
+export function formatClientTokenUsage(_responseTimeMs, usageSummary = null) {
+    if (!usageSummary)
+        return '';
+    const inputTokens = usageSummary?.inputTokens ?? 0;
+    const outputTokens = usageSummary?.outputTokens ?? 0;
+    const reasoningTokens = usageSummary?.reasoningTokens ?? 0;
+    const cacheTokens = usageSummary?.cacheTokens ?? 0;
+    const cacheWriteTokens = usageSummary?.cacheWriteTokens ?? 0;
+    const indexTokens = usageSummary?.indexTokens ?? 0;
+    return [
+        'Session tokens',
+        `in ${formatTokenCount(inputTokens)}`,
+        `out ${formatTokenCount(outputTokens)}`,
+        ...(reasoningTokens > 0 ? [`think ${formatTokenCount(reasoningTokens)}`] : []),
+        `cache ${formatTokenCount(cacheTokens)}`,
+        `write ${formatTokenCount(cacheWriteTokens)}`,
+        `index ${formatTokenCount(indexTokens)}`,
+    ].join(' • ');
+}
+export function formatPromptDirectoryLabel(projectRoot, homeDir = process.env.HOME ?? '') {
+    const trimmed = String(projectRoot ?? '').trim();
+    if (!trimmed)
+        return '.';
+    const normalizedHome = String(homeDir ?? '').trim().replace(/\/+$/, '');
+    if (normalizedHome && trimmed === normalizedHome)
+        return '~';
+    if (normalizedHome && trimmed.startsWith(`${normalizedHome}/`)) {
+        return `~/${trimmed.slice(normalizedHome.length + 1)}`;
+    }
+    return trimmed;
+}
+export function formatPromptSessionIdLabel(showSessionId, sessionId) {
+    return showSessionId ? String(sessionId ?? '').trim() : '';
+}
+function thinkingNoteFromStatus(status) {
+    const text = String(status ?? '').trim();
+    if (!text.startsWith('Thinking:'))
+        return null;
+    const note = text.slice('Thinking:'.length).trim();
+    return note ? note : null;
+}
+function splitThinkingLines(text) {
+    return text
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && line !== 'Thinking')
+        .flatMap((line) => line
+        .split(/(?<=[.!?])\s+(?=[A-Z0-9"'`])/)
+        .map((part) => part.trim())
+        .filter(Boolean))
+        .map((line) => truncate(line, 120));
+}
+function thinkingPanelFromStatus(status) {
+    const text = thinkingNoteFromStatus(status);
+    if (!text)
+        return null;
+    const rawLines = text
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean);
+    if (rawLines.length === 0)
+        return null;
+    if (rawLines.length === 1 && rawLines[0].length <= 72) {
+        return {
+            title: truncate(rawLines[0], 72),
+            notes: [],
+        };
+    }
+    const title = rawLines.length > 1 && rawLines[0].length <= 72
+        ? truncate(rawLines[0], 72)
+        : 'Thinking';
+    const bodyLines = rawLines.length > 1 && rawLines[0].length <= 72 ? rawLines.slice(1) : rawLines;
+    return {
+        title,
+        notes: splitThinkingLines(bodyLines.join('\n')).slice(-3),
+    };
+}
+export const EXIT_CTRL_C_CONFIRM_MESSAGE = 'Press Ctrl+C again to quit.';
+export const EXIT_CTRL_C_CONFIRM_MS = 3000;
+export function isExitConfirmActive(exitConfirmUntil, now = Date.now()) {
+    return exitConfirmUntil != null && now < exitConfirmUntil;
+}
+export function getInputCommandToken(input) {
+    const trimmed = String(input ?? '').trim();
+    if (!trimmed.startsWith('/'))
+        return '';
+    const firstSpaceIndex = trimmed.indexOf(' ');
+    return firstSpaceIndex === -1 ? trimmed : trimmed.slice(0, firstSpaceIndex);
+}
+function shouldShowCommandPalette(state) {
+    const trimmed = String(state.input ?? '').trim();
+    return (!state.busy &&
+        !state.exiting &&
+        !state.modelPickerOpen &&
+        !state.resumePickerOpen &&
+        trimmed.startsWith('/') &&
+        !trimmed.includes(' '));
+}
+export function shouldRemountLiveFrameForComposerInputChange(current, nextInput) {
+    const currentShowsCommands = shouldShowCommandPalette(current);
+    const nextShowsCommands = shouldShowCommandPalette({
+        ...current,
+        input: nextInput,
+    });
+    return currentShowsCommands !== nextShowsCommands;
+}
+export function applySlashCommandSuggestion(currentInput, suggestion) {
+    const token = getInputCommandToken(currentInput);
+    if (!token) {
+        return { cursor: suggestion.command.length, input: suggestion.command };
+    }
+    const tokenStart = currentInput.indexOf(token);
+    const before = currentInput.slice(0, tokenStart);
+    const after = currentInput.slice(tokenStart + token.length);
+    return {
+        cursor: before.length + suggestion.command.length,
+        input: `${before}${suggestion.command}${after}`,
+    };
+}
+export function isExactSlashCommandToken(token) {
+    return SLASH_COMMANDS.some((command) => command.command === token);
+}
+export function insertAtCursor(state, text) {
+    const before = state.input.slice(0, state.cursor);
+    const after = state.input.slice(state.cursor);
+    return {
+        cursor: state.cursor + text.length,
+        input: `${before}${text}${after}`,
+    };
+}
+export function deleteBeforeCursor(state) {
+    if (state.cursor <= 0)
+        return null;
+    return {
+        cursor: state.cursor - 1,
+        input: `${state.input.slice(0, state.cursor - 1)}${state.input.slice(state.cursor)}`,
+    };
+}
+export function deleteAtCursor(state) {
+    if (state.cursor >= state.input.length)
+        return null;
+    return {
+        cursor: state.cursor,
+        input: `${state.input.slice(0, state.cursor)}${state.input.slice(state.cursor + 1)}`,
+    };
+}
+function appendPromptToHistory(history, prompt) {
+    const trimmed = prompt.trim();
+    if (!trimmed || trimmed.startsWith('/'))
+        return history;
+    const last = history[history.length - 1];
+    if (last === trimmed)
+        return history;
+    const next = [...history.filter((entry) => entry !== trimmed), trimmed];
+    if (next.length > MAX_PROMPT_HISTORY_ENTRIES) {
+        next.splice(0, next.length - MAX_PROMPT_HISTORY_ENTRIES);
+    }
+    return next;
+}
+export function navigatePromptHistory(state, direction) {
+    if (state.promptHistory.length === 0)
+        return state;
+    if (direction === 'previous') {
+        const nextCursor = state.promptHistoryCursor === null
+            ? state.promptHistory.length - 1
+            : Math.max(state.promptHistoryCursor - 1, 0);
+        const draft = state.promptHistoryCursor === null ? state.input : state.promptHistoryDraft;
+        const nextInput = state.promptHistory[nextCursor] ?? '';
+        return {
+            ...state,
+            commandCursor: 0,
+            cursor: nextInput.length,
+            input: nextInput,
+            promptHistoryCursor: nextCursor,
+            promptHistoryDraft: draft,
+        };
+    }
+    if (state.promptHistoryCursor === null)
+        return state;
+    const nextCursor = state.promptHistoryCursor + 1;
+    if (nextCursor >= state.promptHistory.length) {
+        const restored = state.promptHistoryDraft;
+        return {
+            ...state,
+            commandCursor: 0,
+            cursor: restored.length,
+            input: restored,
+            promptHistoryCursor: null,
+            promptHistoryDraft: '',
+        };
+    }
+    const nextInput = state.promptHistory[nextCursor] ?? '';
+    return {
+        ...state,
+        commandCursor: 0,
+        cursor: nextInput.length,
+        input: nextInput,
+        promptHistoryCursor: nextCursor,
+    };
+}
+function getDefaultApprovalCursor() {
+    const denyIndex = APPROVAL_OPTIONS.findIndex((option) => option.value === 'n');
+    return denyIndex === -1 ? 0 : denyIndex;
+}
+export function getNextApprovalCursor(currentIndex, direction) {
+    return (currentIndex + direction + APPROVAL_OPTIONS.length) % APPROVAL_OPTIONS.length;
+}
+export function getApprovalChoiceForCursor(cursor) {
+    return (APPROVAL_OPTIONS[Math.min(Math.max(cursor, 0), APPROVAL_OPTIONS.length - 1)]
+        ?.value ?? 'n');
+}
+export function resolveApprovalChoiceFromInput(input) {
+    const normalizedInput = String(input ?? '').trim().toLowerCase();
+    if (normalizedInput === 'y')
+        return 'y';
+    if (normalizedInput === 'a')
+        return 'a';
+    if (normalizedInput === 'n')
+        return 'n';
+    return null;
+}
+export function buildModelPickerOptions(currentModelId, serverModels) {
+    return serverModels.map((model) => ({
+        id: model.id,
+        label: model.label,
+        meta: model.id === currentModelId ? 'current' : '',
+    }));
+}
+function getDefaultModelPickerIndex(currentModelId, serverModels) {
+    const options = buildModelPickerOptions(currentModelId, serverModels);
+    const currentIndex = options.findIndex((option) => option.id === currentModelId);
+    return currentIndex === -1 ? 0 : currentIndex;
+}
+export function getNextModelPickerIndex(options, currentIndex, direction) {
+    if (!options.length)
+        return 0;
+    return (currentIndex + direction + options.length) % options.length;
+}
+export const TranscriptEntryCard = {
+    render: renderTranscriptEntryLines,
+    memoized: true,
+};
+function appendCommandLog(state, text) {
+    const parts = text.replace(/\r\n?/g, '\n').split('\n');
+    const complete = parts.filter((line) => line.trim().length > 0);
+    if (complete.length === 0)
+        return state;
+    return {
+        ...state,
+        commandLog: [...state.commandLog, ...complete].slice(-COMMAND_PREVIEW_LINES),
+    };
+}
+async function saveSessionBoth({ serverSessionClient, session, }) {
+    saveSessionState(session);
+    await serverSessionClient.save(session);
+}
+function shouldUseRatatuiShell() {
+    if (process.env.THEGITAI_PLAIN === '1')
+        return false;
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+export function shouldUseClientRatatuiShell() {
+    return shouldUseRatatuiShell();
+}
+export async function runClientInteractive({ appendPromptHistory, authConfig, debugUi, projectIndex, serverModels, serverSessionClient, session, usageText, initialPrompt, }) {
+    if (!shouldUseRatatuiShell()) {
+        throw new Error('Client TUI requires an interactive terminal.');
+    }
+    await withTuiMode(async () => {
+        const store = createShellStore(createInitialShellState(session, serverModels, debugUi));
+        store.replaceTranscript(createSessionTranscript(session));
+        let currentServerModels = serverModels;
+        let sessionAutoYes = session.autoYes;
+        let resolveDone = null;
+        let resolveApprovalChoice = null;
+        let resolveSudoPassword = null;
+        let cleanupSudoPasswordPrompt = null;
+        let sudoPasswordBuffer = '';
+        const bridge = createRatatuiBridge();
+        const { handleShellKeyEvent } = await import('./tui/shell-input.js');
+        let terminalCols = 80;
+        let terminalRows = 24;
+        let exiting = false;
+        let remountPromise = null;
+        let liveFrameRemountTimer = null;
+        let spinnerFrame = 0;
+        let tuiReady = false;
+        let lastTurnStartedAt = null;
+        let latestUsageSummary = null;
+        let pendingTurnEntries = [];
+        let activeTurnAbort = null;
+        let activeTurnGeneration = 0;
+        let exitCtrlCArmed = false;
+        let exitCtrlCTimer = null;
+        let transientStatusTimer = null;
+        const done = new Promise((resolve) => {
+            resolveDone = resolve;
+        });
+        const scheduleLiveFrameRemount = () => {
+            if (exiting || liveFrameRemountTimer)
+                return;
+            liveFrameRemountTimer = setTimeout(() => {
+                liveFrameRemountTimer = null;
+                if (exiting)
+                    return;
+                void remountTui();
+            }, 0);
+        };
+        const showTransientStatus = (status) => {
+            if (transientStatusTimer) {
+                clearTimeout(transientStatusTimer);
+                transientStatusTimer = null;
+            }
+            store.update((current) => ({ ...current, status }));
+            transientStatusTimer = setTimeout(() => {
+                transientStatusTimer = null;
+                store.update((current) => current.status === status ? { ...current, status: 'Ready' } : current);
+            }, 2500);
+        };
+        const renderCurrentFrame = () => {
+            if (!tuiReady)
+                return;
+            const state = store.getState();
+            const elapsedSeconds = state.busySince
+                ? Math.max(0, Math.floor((Date.now() - state.busySince) / 1000))
+                : 0;
+            bridge.render(buildTuiFrame(state, terminalCols, terminalRows, spinnerFrame, elapsedSeconds));
+        };
+        const remountTui = async () => {
+            if (remountPromise) {
+                await remountPromise;
+                return;
+            }
+            remountPromise = (async () => {
+                if (exiting)
+                    return;
+                bridge.clear();
+                renderCurrentFrame();
+            })();
+            try {
+                await remountPromise;
+            }
+            finally {
+                remountPromise = null;
+            }
+        };
+        const appendStaticEntries = (entries) => store.appendEntries(entries);
+        const appendStaticEntry = (entry) => {
+            const ids = appendStaticEntries([entry]);
+            return ids[0] ?? -1;
+        };
+        const queueTurnEntry = (entry) => {
+            if (sameTranscriptDraft(pendingTurnEntries.at(-1), entry))
+                return;
+            pendingTurnEntries = [...pendingTurnEntries, entry];
+        };
+        const appendTurnAwareEntry = (entry) => {
+            if (store.getState().busy) {
+                queueTurnEntry(entry);
+                return;
+            }
+            appendStaticEntry(entry);
+        };
+        const appendSettledTurnEntries = async (turnEntries, responseText, shouldContinue = () => true) => {
+            const entries = buildSettledTurnTranscriptEntries(turnEntries, responseText);
+            const responseEntry = entries.at(-1);
+            if (!responseEntry ||
+                responseEntry.kind !== 'assistant' ||
+                responseEntry.title !== 'Response' ||
+                !responseEntry.body) {
+                appendStaticEntries(entries);
+                await remountTui();
+                return;
+            }
+            appendStaticEntries(entries.slice(0, -1));
+            const responseId = appendStaticEntry({
+                ...responseEntry,
+                body: '',
+            });
+            await remountTui();
+            let first = true;
+            for (const body of buildResponseStreamBodies(responseEntry.body)) {
+                if (!first) {
+                    await wait(RESPONSE_STREAM_DELAY_MS);
+                }
+                if (exiting)
+                    return;
+                if (!shouldContinue()) {
+                    store.updateEntry(responseId, { body: responseEntry.body });
+                    return;
+                }
+                store.updateEntry(responseId, { body });
+                first = false;
+            }
+        };
+        const takePendingTurnEntries = () => {
+            const entries = pendingTurnEntries;
+            pendingTurnEntries = [];
+            return entries;
+        };
+        const appendError = (message) => {
+            appendStaticEntry({
+                body: message,
+                kind: 'error',
+                title: 'Error',
+            });
+        };
+        const handleAppSelectionCopy = (text) => {
+            try {
+                writeClipboardText(text);
+                showTransientStatus('Copied selection');
+            }
+            catch (error) {
+                appendError(`Selection copy failed: ${error.message}`);
+            }
+        };
+        const handleLinkCopy = (url) => {
+            try {
+                writeClipboardText(url);
+                showTransientStatus('Copied link');
+            }
+            catch (error) {
+                appendError(`Link copy failed: ${error.message}`);
+            }
+        };
+        const handleLinkOpen = async (url) => {
+            try {
+                const opened = await openUrl(url);
+                showTransientStatus(opened ? 'Opened link' : 'Could not open link');
+            }
+            catch (error) {
+                appendError(`Link open failed: ${error.message}`);
+            }
+        };
+        const disarmExitConfirm = () => {
+            exitCtrlCArmed = false;
+            if (exitCtrlCTimer) {
+                clearTimeout(exitCtrlCTimer);
+                exitCtrlCTimer = null;
+            }
+            if (store.getState().exitConfirmUntil != null) {
+                store.update((current) => ({
+                    ...current,
+                    exitConfirmUntil: null,
+                    status: current.status === EXIT_CTRL_C_CONFIRM_MESSAGE
+                        ? 'Ready'
+                        : current.status,
+                }));
+            }
+        };
+        const dismissPendingApproval = () => {
+            if (!resolveApprovalChoice)
+                return;
+            const pendingResolve = resolveApprovalChoice;
+            resolveApprovalChoice = null;
+            pendingResolve('n');
+            store.update((current) => ({
+                ...current,
+                approvalCursor: getDefaultApprovalCursor(),
+                approvalPrompt: null,
+            }));
+        };
+        const dismissPendingSudoPassword = () => {
+            if (!resolveSudoPassword)
+                return;
+            const pendingResolve = resolveSudoPassword;
+            resolveSudoPassword = null;
+            cleanupSudoPasswordPrompt?.();
+            cleanupSudoPasswordPrompt = null;
+            sudoPasswordBuffer = '';
+            pendingResolve(null);
+            store.update((current) => ({
+                ...current,
+                sudoPrompt: null,
+            }));
+        };
+        const cancelActiveTurn = () => {
+            if (!store.getState().busy)
+                return;
+            disarmExitConfirm();
+            dismissPendingApproval();
+            dismissPendingSudoPassword();
+            activeTurnGeneration += 1;
+            activeTurnAbort?.abort();
+            activeTurnAbort = null;
+            cancelActiveCommand();
+            // Ctrl+C with a queued message: recall it into the composer for editing
+            // rather than auto-submitting it against the cancelled turn. (Esc with a
+            // queued message clears the slot in shell-input without cancelling.)
+            const queued = store.getState().queuedMessage;
+            const cancelledEntries = [
+                ...takePendingTurnEntries(),
+                {
+                    body: 'Turn cancelled.',
+                    kind: 'error',
+                    title: 'Cancelled',
+                },
+            ];
+            store.update((current) => ({
+                ...current,
+                activeTurnInput: '',
+                activeTurnInputPreformatted: false,
+                busy: false,
+                busySince: null,
+                commandLog: [],
+                cursor: queued ? queued.body.length : current.cursor,
+                imageAttachments: queued ? queued.imageAttachments : [],
+                input: queued ? queued.body : current.input,
+                pastedChunks: queued ? queued.pastedChunks : current.pastedChunks,
+                promptHistoryCursor: queued ? null : current.promptHistoryCursor,
+                promptHistoryDraft: queued ? '' : current.promptHistoryDraft,
+                queuedMessage: null,
+                status: 'Ready',
+                thinkingTitle: '',
+                thinkingNotes: [],
+                workingTools: [],
+                tokenUsage: formatClientTokenUsage(current.busySince == null ? null : Date.now() - current.busySince, latestUsageSummary),
+            }));
+            appendStaticEntries(cancelledEntries);
+            lastTurnStartedAt = null;
+            if (queued)
+                scheduleLiveFrameRemount();
+            void remountTui();
+        };
+        const saveActiveSession = async () => {
+            try {
+                await saveSessionBoth({ serverSessionClient, session });
+            }
+            catch (error) {
+                appendError(`Session save failed: ${error.message}`);
+            }
+        };
+        const syncShellStateFromSession = () => {
+            store.update((current) => ({
+                ...current,
+                agentMode: session.agentMode,
+                autoYes: sessionAutoYes,
+                commandCursor: 0,
+                currentModelId: session.modelId,
+                sessionId: session.sessionId,
+                modelPickerIndex: current.modelPickerOpen
+                    ? getDefaultModelPickerIndex(session.modelId, current.serverModels)
+                    : current.modelPickerIndex,
+                tokenUsage: formatClientTokenUsage(lastTurnStartedAt == null ? null : Date.now() - lastTurnStartedAt, latestUsageSummary),
+                turnCounter: Math.max(current.turnCounter, session.history.filter((entry) => entry.role === 'user').length),
+            }));
+        };
+        const setAgentMode = (mode, status = `Mode: ${agentModeLabel(mode)}`) => {
+            session.agentMode = mode;
+            session.autoYes = mode === 'auto-accept';
+            sessionAutoYes = session.autoYes;
+            store.update((current) => ({
+                ...current,
+                agentMode: mode,
+                autoYes: sessionAutoYes,
+                status,
+            }));
+        };
+        const cycleAgentMode = () => {
+            setAgentMode(nextAgentMode(session.agentMode));
+            scheduleLiveFrameRemount();
+        };
+        const clearLiveFrameRemountTimer = () => {
+            if (!liveFrameRemountTimer)
+                return;
+            clearTimeout(liveFrameRemountTimer);
+            liveFrameRemountTimer = null;
+        };
+        const handleCtrlC = () => {
+            if (exiting)
+                return;
+            if (store.getState().busy) {
+                cancelActiveTurn();
+                return;
+            }
+            if (exitCtrlCArmed) {
+                disarmExitConfirm();
+                requestExit();
+                return;
+            }
+            exitCtrlCArmed = true;
+            const exitConfirmUntil = Date.now() + EXIT_CTRL_C_CONFIRM_MS;
+            store.update((current) => ({
+                ...current,
+                exitConfirmUntil,
+                status: EXIT_CTRL_C_CONFIRM_MESSAGE,
+            }));
+            exitCtrlCTimer = setTimeout(() => {
+                exitCtrlCTimer = null;
+                exitCtrlCArmed = false;
+                store.update((current) => ({
+                    ...current,
+                    exitConfirmUntil: null,
+                    status: current.status === EXIT_CTRL_C_CONFIRM_MESSAGE
+                        ? 'Ready'
+                        : current.status,
+                }));
+            }, EXIT_CTRL_C_CONFIRM_MS);
+            exitCtrlCTimer.unref?.();
+        };
+        const requestExit = () => {
+            if (exiting)
+                return;
+            disarmExitConfirm();
+            if (transientStatusTimer) {
+                clearTimeout(transientStatusTimer);
+                transientStatusTimer = null;
+            }
+            dismissPendingApproval();
+            dismissPendingSudoPassword();
+            exiting = true;
+            store.update((current) => ({
+                ...current,
+                exiting: true,
+                queuedMessage: null,
+                status: 'Exiting...',
+            }));
+            void bridge.close().then(() => {
+                resolveDone?.();
+            });
+        };
+        const openSudoPasswordPrompt = (command, prompt, signal) => new Promise((resolve) => {
+            if (exiting || signal?.aborted) {
+                resolve(null);
+                return;
+            }
+            dismissPendingSudoPassword();
+            const abortPrompt = () => dismissPendingSudoPassword();
+            sudoPasswordBuffer = '';
+            resolveSudoPassword = resolve;
+            if (signal) {
+                signal.addEventListener('abort', abortPrompt, { once: true });
+                cleanupSudoPasswordPrompt = () => signal.removeEventListener('abort', abortPrompt);
+            }
+            else {
+                cleanupSudoPasswordPrompt = null;
+            }
+            store.update((current) => ({
+                ...current,
+                sudoPrompt: {
+                    command,
+                    passwordLength: 0,
+                    prompt,
+                    returnStatus: current.status,
+                },
+                status: 'Sudo authentication required',
+            }));
+        });
+        const handleSudoPasswordInput = (event) => {
+            const pendingResolve = resolveSudoPassword;
+            if (!pendingResolve)
+                return;
+            if (event.kind === 'cancel') {
+                resolveSudoPassword = null;
+                cleanupSudoPasswordPrompt?.();
+                cleanupSudoPasswordPrompt = null;
+                sudoPasswordBuffer = '';
+                store.update((current) => ({
+                    ...current,
+                    sudoPrompt: null,
+                    status: current.sudoPrompt?.returnStatus ?? current.status,
+                }));
+                pendingResolve(null);
+                return;
+            }
+            if (event.kind === 'submit') {
+                const password = sudoPasswordBuffer;
+                resolveSudoPassword = null;
+                cleanupSudoPasswordPrompt?.();
+                cleanupSudoPasswordPrompt = null;
+                sudoPasswordBuffer = '';
+                store.update((current) => ({
+                    ...current,
+                    sudoPrompt: null,
+                    status: current.sudoPrompt?.returnStatus ?? current.status,
+                }));
+                pendingResolve(password);
+                return;
+            }
+            if (event.kind === 'backspace') {
+                sudoPasswordBuffer = sudoPasswordBuffer.slice(0, -1);
+            }
+            else {
+                sudoPasswordBuffer += event.char;
+            }
+            store.update((current) => ({
+                ...current,
+                sudoPrompt: current.sudoPrompt
+                    ? { ...current.sudoPrompt, passwordLength: sudoPasswordBuffer.length }
+                    : null,
+            }));
+        };
+        const openApprovalPrompt = (title, body, options = {}) => new Promise((resolve) => {
+            if (exiting) {
+                resolve('n');
+                return;
+            }
+            resolveApprovalChoice = resolve;
+            store.update((current) => ({
+                ...current,
+                approvalCursor: getDefaultApprovalCursor(),
+                approvalPrompt: {
+                    title,
+                    body,
+                    diffPreview: options.diff && options.filePath
+                        ? parseDiffPreview(options.diff)
+                        : undefined,
+                    filePath: options.filePath,
+                    returnStatus: current.status,
+                },
+                status: title,
+            }));
+        });
+        const handleInlineApprovalChoice = async (choice) => {
+            const current = store.getState();
+            const pendingResolve = resolveApprovalChoice;
+            resolveApprovalChoice = null;
+            store.update((next) => ({
+                ...next,
+                approvalCursor: getDefaultApprovalCursor(),
+                approvalPrompt: null,
+                status: current.approvalPrompt?.returnStatus ?? next.status,
+            }));
+            pendingResolve?.(choice);
+        };
+        const refreshServerModels = async () => {
+            currentServerModels = await models.fetchServerModels({ config: authConfig });
+            store.update((current) => ({
+                ...current,
+                serverModels: currentServerModels.models,
+            }));
+            return currentServerModels;
+        };
+        const openModelPicker = async () => {
+            const fresh = await refreshServerModels();
+            store.update((current) => ({
+                ...current,
+                commandCursor: 0,
+                cursor: 0,
+                input: '',
+                modelPickerIndex: getDefaultModelPickerIndex(current.currentModelId, fresh.models),
+                modelPickerOpen: true,
+                status: 'Select a model',
+            }));
+        };
+        const switchToModel = async (modelId) => {
+            const requested = Number(modelId);
+            const fresh = currentServerModels.models.some((model) => model.id === requested)
+                ? currentServerModels
+                : await refreshServerModels();
+            const selected = models.validateServerModel(modelId, fresh);
+            session.modelId = selected;
+            models.updateSelectedModelCache({
+                config: authConfig,
+                selectedModelId: selected,
+                serverModels: fresh,
+            });
+            await saveActiveSession();
+            syncShellStateFromSession();
+            appendStaticEntry({
+                body: `Switched to ${formatModelLabel(selected, fresh.models)}. Conversation history preserved.`,
+                kind: 'system',
+                title: 'Model',
+            });
+        };
+        const handleInlineModelSelection = async () => {
+            const current = store.getState();
+            const options = buildModelPickerOptions(current.currentModelId, current.serverModels);
+            const selectedIndex = Math.min(current.modelPickerIndex, Math.max(options.length - 1, 0));
+            const selected = options[selectedIndex];
+            store.update((next) => ({
+                ...next,
+                modelPickerOpen: false,
+                status: 'Ready',
+            }));
+            if (!selected) {
+                appendStaticEntry({
+                    body: 'Model selection cancelled.',
+                    kind: 'system',
+                    title: 'Model',
+                });
+                return;
+            }
+            if (selected.id === current.currentModelId) {
+                appendStaticEntry({
+                    body: `Already using ${formatModelLabel(selected.id, current.serverModels)}.`,
+                    kind: 'system',
+                    title: 'Model',
+                });
+                return;
+            }
+            try {
+                await switchToModel(selected.id);
+            }
+            catch (error) {
+                appendError(error.message);
+            }
+        };
+        const loadInteractiveSessionList = async () => {
+            const local = listSessionMetadata(session.rootDir, session.env);
+            if (local.length > 0)
+                return local;
+            return serverSessionClient.list(session.rootDir);
+        };
+        const loadInteractiveSession = async (identifier) => {
+            const local = loadSessionSnapshot(session.rootDir, identifier, session.env);
+            if (local)
+                return local;
+            return serverSessionClient.load(session.rootDir, identifier);
+        };
+        const openResumePicker = async () => {
+            const sessionList = await loadInteractiveSessionList();
+            store.update((current) => ({
+                ...current,
+                commandCursor: 0,
+                cursor: 0,
+                input: '',
+                resumePickerFilter: '',
+                resumePickerIndex: 0,
+                resumePickerOpen: true,
+                resumePickerSessions: sessionList,
+                status: 'Select a session to resume',
+            }));
+        };
+        const handleInlineResumeSelection = async () => {
+            const current = store.getState();
+            const filtered = filterResumeSessions(current.resumePickerSessions, current.resumePickerFilter, current.serverModels);
+            const selectedIndex = Math.min(current.resumePickerIndex, Math.max(filtered.length - 1, 0));
+            const selected = filtered[selectedIndex];
+            if (!selected) {
+                store.update((next) => ({
+                    ...next,
+                    resumePickerFilter: '',
+                    resumePickerIndex: 0,
+                    resumePickerOpen: false,
+                    resumePickerSessions: [],
+                    status: 'Ready',
+                }));
+                return;
+            }
+            const resumeStartedAt = Date.now();
+            store.update((next) => ({
+                ...next,
+                busy: true,
+                busySince: resumeStartedAt,
+                clockNow: resumeStartedAt,
+                status: 'Loading session...',
+            }));
+            try {
+                const snapshot = await loadInteractiveSession(selected.id);
+                applySessionSnapshot(session, snapshot);
+                await saveActiveSession();
+                syncShellStateFromSession();
+                store.update((next) => ({
+                    ...next,
+                    busy: false,
+                    busySince: null,
+                    resumePickerFilter: '',
+                    resumePickerIndex: 0,
+                    resumePickerOpen: false,
+                    resumePickerSessions: [],
+                    status: 'Ready',
+                }));
+                store.replaceTranscript([
+                    {
+                        body: `Resumed session${session.sessionName ? ` "${session.sessionName}"` : ''} (${session.sessionId})`,
+                        kind: 'system',
+                        title: 'Session',
+                    },
+                    ...buildTranscriptFromSessionHistory(session.history),
+                ]);
+                await remountTui();
+            }
+            catch (error) {
+                store.update((next) => ({
+                    ...next,
+                    busy: false,
+                    busySince: null,
+                    resumePickerFilter: '',
+                    resumePickerIndex: 0,
+                    resumePickerOpen: false,
+                    resumePickerSessions: [],
+                    status: 'Ready',
+                }));
+                appendError(`Failed to resume session: ${error.message}`);
+            }
+        };
+        const flushQueuedMessage = async () => {
+            const queued = store.getState().queuedMessage;
+            if (!queued || store.getState().busy || exiting) {
+                return;
+            }
+            // Rehydrate attachments/chunks before submit: handleSubmit expands
+            // pastedChunks from the store and the turn picks up imageAttachments.
+            store.update((current) => ({
+                ...current,
+                imageAttachments: queued.imageAttachments,
+                pastedChunks: queued.pastedChunks,
+                queuedMessage: null,
+            }));
+            await handleSubmit(queued.body);
+        };
+        const handleSubmit = async (rawInput) => {
+            const chunks = store.getState().pastedChunks;
+            const expanded = chunks.length
+                ? expandPastedChunks(String(rawInput ?? ''), chunks)
+                : String(rawInput ?? '');
+            const input = expanded.trim();
+            const preformatted = chunks.length > 0;
+            if (store.getState().busy) {
+                if (!input || exiting)
+                    return;
+                if (input.startsWith('/')) {
+                    appendTurnAwareEntry({
+                        body: "Slash commands can't be queued while a turn is running.",
+                        kind: 'system',
+                        title: 'Queued',
+                    });
+                    return;
+                }
+                // Snapshot the raw (placeholder) body plus chunks/images so recall and
+                // flush round-trip the collapsed paste + attachments. Hold at most one;
+                // a second enqueue replaces the slot.
+                const pending = store.getState();
+                const snapshot = {
+                    body: String(rawInput ?? ''),
+                    imageAttachments: pending.imageAttachments,
+                    pastedChunks: pending.pastedChunks,
+                };
+                scheduleLiveFrameRemount();
+                store.update((current) => ({
+                    ...current,
+                    cursor: 0,
+                    imageAttachments: [],
+                    input: '',
+                    pastedChunks: [],
+                    queuedMessage: snapshot,
+                    transcriptScrollOffset: 0,
+                }));
+                return;
+            }
+            const imageAttachments = store.getState().imageAttachments;
+            scheduleLiveFrameRemount();
+            store.update((current) => ({
+                ...current,
+                cursor: 0,
+                input: '',
+                pastedChunks: [],
+                promptHistory: appendPromptToHistory(current.promptHistory, input),
+                promptHistoryCursor: null,
+                promptHistoryDraft: '',
+            }));
+            appendPromptHistory(input);
+            if (!input || exiting) {
+                store.update((current) => ({ ...current, imageAttachments: [] }));
+                return;
+            }
+            if (input === '/exit' || input === '/quit') {
+                requestExit();
+                return;
+            }
+            if (input === '/help') {
+                appendStaticEntry({
+                    body: formatInteractiveHelpText(),
+                    kind: 'system',
+                    title: 'Help',
+                });
+                return;
+            }
+            if (input === '/usage') {
+                store.update((current) => ({
+                    ...current,
+                    busy: true,
+                    status: 'Loading usage...',
+                }));
+                try {
+                    appendStaticEntry({
+                        body: await usageText(),
+                        kind: 'system',
+                        title: 'Usage',
+                    });
+                }
+                catch (error) {
+                    appendError(error.message);
+                }
+                finally {
+                    store.update((current) => ({
+                        ...current,
+                        busy: false,
+                        status: 'Ready',
+                    }));
+                }
+                return;
+            }
+            if (input === '/resume') {
+                store.update((current) => ({
+                    ...current,
+                    busy: true,
+                    status: 'Loading sessions...',
+                }));
+                try {
+                    await openResumePicker();
+                }
+                catch (error) {
+                    appendError(error.message);
+                }
+                finally {
+                    store.update((current) => ({
+                        ...current,
+                        busy: false,
+                        status: current.resumePickerOpen ? 'Select a session to resume' : 'Ready',
+                    }));
+                }
+                return;
+            }
+            if (input === '/model' || input.startsWith('/model ')) {
+                const inlineSelection = input.slice('/model'.length).trim();
+                store.update((current) => ({
+                    ...current,
+                    busy: true,
+                    status: inlineSelection ? 'Switching model...' : 'Loading models...',
+                }));
+                try {
+                    if (!inlineSelection || inlineSelection === 'list') {
+                        await openModelPicker();
+                    }
+                    else {
+                        await switchToModel(inlineSelection);
+                    }
+                }
+                catch (error) {
+                    appendError(error.message);
+                }
+                finally {
+                    store.update((current) => ({
+                        ...current,
+                        busy: false,
+                        status: current.modelPickerOpen ? 'Select a model' : 'Ready',
+                    }));
+                }
+                return;
+            }
+            if (input === '/clear') {
+                clearConversation(session);
+                latestUsageSummary = null;
+                await saveActiveSession();
+                store.replaceTranscript([
+                    {
+                        body: 'Conversation cleared.',
+                        kind: 'system',
+                        title: 'System',
+                    },
+                ]);
+                syncShellStateFromSession();
+                store.update((current) => ({ ...current, queuedMessage: null }));
+                await remountTui();
+                return;
+            }
+            latestUsageSummary = null;
+            disarmExitConfirm();
+            const turnStartedAt = Date.now();
+            const turnGeneration = ++activeTurnGeneration;
+            const turnAbort = new AbortController();
+            activeTurnAbort = turnAbort;
+            lastTurnStartedAt = turnStartedAt;
+            const userEntry = {
+                body: input,
+                kind: 'user',
+                preformatted,
+                title: 'You',
+            };
+            pendingTurnEntries = [];
+            queueTurnEntry(userEntry);
+            store.update((current) => ({
+                ...current,
+                activeTurnInput: input,
+                activeTurnInputPreformatted: preformatted,
+                busy: true,
+                busySince: turnStartedAt,
+                clockNow: turnStartedAt,
+                status: 'Running turn...',
+                thinkingTitle: '',
+                thinkingNotes: [],
+                transcriptScrollOffset: 0,
+                tokenUsage: formatClientTokenUsage(0, latestUsageSummary),
+                turnCounter: current.turnCounter + 1,
+                workingTools: [],
+            }));
+            try {
+                const result = await chat.sendServerUserMessage({
+                    config: authConfig,
+                    projectIndex,
+                    session,
+                    input,
+                    imageAttachments,
+                    signal: turnAbort.signal,
+                });
+                if (turnGeneration !== activeTurnGeneration)
+                    return;
+                latestUsageSummary = result.usageSummary ?? null;
+                const turnEntries = takePendingTurnEntries();
+                await saveActiveSession();
+                syncShellStateFromSession();
+                store.update((current) => ({
+                    ...current,
+                    activeTurnInput: '',
+                    activeTurnInputPreformatted: false,
+                    busy: true,
+                    commandLog: [],
+                    imageAttachments: [],
+                    status: result.waitingForApproval ? 'Awaiting approval' : 'Finishing response...',
+                    thinkingTitle: '',
+                    thinkingNotes: [],
+                    tokenUsage: formatClientTokenUsage(Date.now() - turnStartedAt, latestUsageSummary),
+                    workingTools: [],
+                }));
+                await appendSettledTurnEntries(turnEntries, result.text ?? '', () => turnGeneration === activeTurnGeneration && !turnAbort.signal.aborted);
+                if (turnGeneration !== activeTurnGeneration)
+                    return;
+                store.update((current) => ({
+                    ...current,
+                    busy: false,
+                    busySince: null,
+                    status: result.waitingForApproval ? 'Awaiting approval' : 'Ready',
+                    tokenUsage: formatClientTokenUsage(Date.now() - turnStartedAt, latestUsageSummary),
+                }));
+                await flushQueuedMessage();
+            }
+            catch (error) {
+                if (turnGeneration !== activeTurnGeneration) {
+                    if (isTurnCancelledError(error)) {
+                        await saveActiveSession();
+                    }
+                    return;
+                }
+                const cancelled = isTurnCancelledError(error);
+                store.update((current) => ({
+                    ...current,
+                    activeTurnInput: '',
+                    activeTurnInputPreformatted: false,
+                    busy: false,
+                    busySince: null,
+                    commandLog: [],
+                    imageAttachments: [],
+                    status: cancelled ? 'Ready' : 'Turn failed',
+                    thinkingTitle: '',
+                    thinkingNotes: [],
+                    tokenUsage: formatClientTokenUsage(Date.now() - turnStartedAt, latestUsageSummary),
+                    workingTools: [],
+                }));
+                const turnEntries = takePendingTurnEntries();
+                if (cancelled) {
+                    appendStaticEntries([
+                        ...turnEntries,
+                        {
+                            body: 'Turn cancelled.',
+                            kind: 'system',
+                            title: 'System',
+                        },
+                    ]);
+                    await saveActiveSession();
+                }
+                else {
+                    appendStaticEntries(turnEntries);
+                    appendError(error.message);
+                }
+                await remountTui();
+                // A cancelled turn never auto-submits the queue (Ctrl+C recalls it via
+                // cancelActiveTurn); only a genuine error flushes a pending message.
+                if (!cancelled && turnGeneration === activeTurnGeneration) {
+                    await flushQueuedMessage();
+                }
+            }
+            finally {
+                if (activeTurnAbort === turnAbort) {
+                    activeTurnAbort = null;
+                }
+                if (turnGeneration === activeTurnGeneration) {
+                    lastTurnStartedAt = null;
+                }
+            }
+        };
+        session.onStatus = (message) => {
+            const panel = thinkingPanelFromStatus(message);
+            store.update((current) => ({
+                ...current,
+                status: message,
+                thinkingTitle: panel?.title ?? current.thinkingTitle,
+                thinkingNotes: panel?.notes ?? current.thinkingNotes,
+                tokenUsage: formatClientTokenUsage(current.busySince == null ? null : Date.now() - current.busySince, latestUsageSummary),
+            }));
+        };
+        session.onContextLog = (message) => {
+            store.update((current) => ({
+                ...current,
+                contextStatus: message,
+                tokenUsage: formatClientTokenUsage(current.busySince == null ? null : Date.now() - current.busySince, latestUsageSummary),
+            }));
+        };
+        session.onToolEvent = (event) => {
+            syncShellStateFromSession();
+            if (isFileChangeTool(event.call.name)) {
+                const entry = buildFileChangeEntry(event);
+                store.appendWorkingTool(entry);
+                appendTurnAwareEntry(entry);
+                return;
+            }
+            store.appendWorkingTool(buildWorkingToolEntry(event));
+        };
+        projectIndex.onStatus = session.onStatus;
+        projectIndex.onContextLog = session.onContextLog;
+        session.requestSudoPassword = async ({ command, prompt, signal }) => openSudoPasswordPrompt(command, prompt, signal);
+        session.confirmCommand = async (command) => {
+            if (exiting)
+                return false;
+            if (sessionAutoYes)
+                return true;
+            const choice = await openApprovalPrompt('Approve command?', command);
+            if (choice === 'a') {
+                setAgentMode('auto-accept');
+                syncShellStateFromSession();
+                appendTurnAwareEntry({
+                    body: 'Auto-approve enabled for the rest of this session.',
+                    kind: 'system',
+                    title: 'Approvals',
+                });
+                return true;
+            }
+            return choice === 'y';
+        };
+        session.confirmPatch = async (filePath, patch) => {
+            if (exiting)
+                return false;
+            if (sessionAutoYes)
+                return true;
+            const choice = await openApprovalPrompt('Approve patch?', 'Review changes before applying.', {
+                diff: patch,
+                filePath,
+            });
+            if (choice === 'a') {
+                setAgentMode('auto-accept');
+                syncShellStateFromSession();
+                appendTurnAwareEntry({
+                    body: 'Auto-approve enabled for the rest of this session.',
+                    kind: 'system',
+                    title: 'Approvals',
+                });
+                return true;
+            }
+            return choice === 'y';
+        };
+        const shellInputHandlers = {
+            getTranscriptScrollLimit: () => {
+                const contentWidth = Math.max(20, Math.floor(terminalCols * 0.95) - 2);
+                const blocks = store.getState().transcript.map((entry) => renderTranscriptEntryLines(entry, contentWidth));
+                return blocks.reduce((total, block, index) => total + block.length + (index > 0 ? 1 : 0), 0);
+            },
+            onCancelTurn: cancelActiveTurn,
+            onCycleAgentMode: cycleAgentMode,
+            onCtrlC: handleCtrlC,
+            onLinkCopy: handleLinkCopy,
+            onLinkOpen: handleLinkOpen,
+            onLiveFrameShapeChange: scheduleLiveFrameRemount,
+            onRequestExit: requestExit,
+            onResolveApproval: handleInlineApprovalChoice,
+            onResumeSession: handleInlineResumeSelection,
+            onSelectionCopy: handleAppSelectionCopy,
+            onSelectModel: handleInlineModelSelection,
+            onSudoPasswordInput: handleSudoPasswordInput,
+            onSubmit: handleSubmit,
+        };
+        const unsubscribe = store.subscribe(() => {
+            renderCurrentFrame();
+        });
+        const spinnerTimer = setInterval(() => {
+            spinnerFrame = (spinnerFrame + 1) % 6;
+            if (store.getState().busy) {
+                renderCurrentFrame();
+            }
+        }, 120);
+        const clockTimer = setInterval(() => {
+            if (store.getState().busy) {
+                renderCurrentFrame();
+            }
+        }, 1000);
+        let initialPromptDelivered = false;
+        bridge.onEvent((message) => {
+            if (message.op === 'ready') {
+                tuiReady = true;
+                terminalCols = message.cols;
+                terminalRows = message.rows;
+                bridge.clear();
+                renderCurrentFrame();
+                if (!initialPromptDelivered && initialPrompt) {
+                    initialPromptDelivered = true;
+                    void handleSubmit(initialPrompt);
+                }
+                return;
+            }
+            if (message.op === 'closed') {
+                resolveDone?.();
+                return;
+            }
+            if (message.op === 'event') {
+                if (message.kind === 'resize') {
+                    terminalCols = message.cols;
+                    terminalRows = message.rows;
+                    void remountTui();
+                    return;
+                }
+                handleShellKeyEvent(store, shellInputHandlers, message);
+                renderCurrentFrame();
+            }
+        });
+        setCommandOutputHook((text) => {
+            store.update((current) => appendCommandLog(current, text));
+        });
+        try {
+            await done;
+        }
+        finally {
+            clearInterval(spinnerTimer);
+            clearInterval(clockTimer);
+            unsubscribe();
+            clearLiveFrameRemountTimer();
+            await bridge.close();
+            setCommandOutputHook(null);
+        }
+    });
+}