@thegitai/cli 1.0.0-preview.13 → 1.0.0-preview.15

package/README.md

@@ -38,6 +38,22 @@ CLI login tokens use a rolling 24-hour inactivity timeout. If one expires during
 any server request, the CLI saves the local session, removes the expired
 credential, and asks you to run `ai login` before resuming.
 
+## Structured questions
+
+The agent can pause its current turn to ask up to four related questions in one
+form. Use **↑ / ↓**, the displayed option number, or **Enter** to choose, and
+**← / →** to move between questions. **Something else / add details** is the
+numbered final option; focus it and type, paste, or press **Enter** to add a
+single-line note. On single-select questions it is mutually exclusive with the
+listed choices, and **↑ / ↓** leaves its editor when the note is empty.
+Multi-select questions toggle choices. The last question has an explicit
+**Submit answers** row. **Esc** closes an open note first and otherwise cancels
+the form; **Ctrl+C** cancels the whole turn.
+
+Answers return to the same turn, and completed question/answer records remain
+readable when the session is resumed. Default, Auto-Accept, and Plan modes all
+support the form; Auto-Accept does not choose answers for you.
+
 ## Visible to-do list
 
 For larger multi-step tasks, the agent keeps a compact to-do list on screen so

package/dist/src/api/chat.js

@@ -2,6 +2,7 @@ import { drainBackgroundJobNotifications } from '../background-jobs.js';
 import { createPromptCheckpoint, sanitizeSessionSafetyForServer, } from '../session-safety.js';
 import { applySessionSnapshot, saveSessionState, snapshotFromSession, } from '../session-store.js';
 import { executeLocalToolCall } from '../tool-executor.js';
+import { isUserInputQuestionArray } from './contracts.js';
 import { createTraceContext, normalizeServerUrl, readErrorResponse, } from './http.js';
 import { collectClientEnvironment } from '../client-environment.js';
 import { collectProjectOrientation } from '../project-orientation.js';
@@ -168,6 +169,8 @@ function publicStatusMessage(data) {
         return `Running ${toolName}...`;
     if (event.phase === 'waiting_for_tool')
         return `Running ${toolName} locally...`;
+    if (event.phase === 'waiting_for_user_input')
+        return 'Waiting for your input...';
     return null;
 }
 function normalizeShellJobToolCall(call) {
@@ -223,6 +226,28 @@ async function postToolResult({ config, turnId, event, result, session, fetchImp
         throw await readErrorResponse(response, trace.traceId);
     }
 }
+async function postUserInputResult({ config, turnId, requestId, result, fetchImpl, traceId, }) {
+    const payload = {
+        requestId,
+        result,
+    };
+    const trace = createTraceContext(traceId);
+    const response = await fetchImpl(`${normalizeServerUrl(config.serverUrl)}/v1/chat/turn/${encodeURIComponent(turnId)}/user-input-result`, {
+        method: 'POST',
+        headers: {
+            authorization: `Bearer ${config.token}`,
+            'content-type': 'application/json',
+            ...trace.headers,
+        },
+        body: JSON.stringify(payload),
+    });
+    if (response.status === 410) {
+        return;
+    }
+    if (!response.ok) {
+        throw await readErrorResponse(response, trace.traceId);
+    }
+}
 const turnIdOverrides = new WeakMap();
 function enterServerTurnId(session, serverSessionTurnId) {
     const active = turnIdOverrides.get(session);
@@ -371,6 +396,33 @@ async function consumeTurnStream({ response, config, projectIndex, session, inpu
             }
             return;
         }
+        if (event.event === 'user-input-request') {
+            await drainParallelTools();
+            const data = event.data;
+            const turnId = String(data?.turnId ?? '').trim();
+            const requestId = String(data?.requestId ?? '').trim();
+            if (!turnId ||
+                !requestId ||
+                !isUserInputQuestionArray(data?.questions)) {
+                throw new Error('Server emitted an invalid user-input request.');
+            }
+            if (!session.requestUserInput) {
+                throw new Error('Interactive user input is unavailable in this client.');
+            }
+            const result = await session.requestUserInput({ questions: data.questions }, signal);
+            if (signal?.aborted) {
+                throw new TurnCancelledError();
+            }
+            await postUserInputResult({
+                config,
+                turnId,
+                requestId,
+                result,
+                fetchImpl,
+                traceId,
+            });
+            return;
+        }
         if (event.event === 'result') {
             await drainParallelTools();
             finalResult.current = event.data;

package/dist/src/api/contracts.js

@@ -1 +1,55 @@
-export {};
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+const USER_INPUT_ID_PATTERN = /^[a-z][a-z0-9_]*$/;
+export function isUserInputQuestionArray(value) {
+    if (!Array.isArray(value) || value.length < 1 || value.length > 4) {
+        return false;
+    }
+    const questionIds = new Set();
+    return value.every((question) => {
+        if (!question || typeof question !== 'object' || Array.isArray(question)) {
+            return false;
+        }
+        const candidate = question;
+        if (!nonEmptyString(candidate.id) ||
+            !USER_INPUT_ID_PATTERN.test(candidate.id) ||
+            questionIds.has(candidate.id) ||
+            !nonEmptyString(candidate.header) ||
+            Array.from(candidate.header).length > 12 ||
+            !nonEmptyString(candidate.question) ||
+            typeof candidate.multiSelect !== 'boolean' ||
+            !Array.isArray(candidate.options) ||
+            candidate.options.length < 2 ||
+            candidate.options.length > 4) {
+            return false;
+        }
+        questionIds.add(candidate.id);
+        const optionIds = new Set();
+        const optionsValid = candidate.options.every((option) => {
+            if (!option || typeof option !== 'object' || Array.isArray(option)) {
+                return false;
+            }
+            const item = option;
+            if (!nonEmptyString(item.id) ||
+                !USER_INPUT_ID_PATTERN.test(item.id) ||
+                optionIds.has(item.id) ||
+                !nonEmptyString(item.label) ||
+                !nonEmptyString(item.description)) {
+                return false;
+            }
+            optionIds.add(item.id);
+            return true;
+        });
+        if (!optionsValid) {
+            return false;
+        }
+        if (candidate.recommendedOptionId !== undefined &&
+            (!nonEmptyString(candidate.recommendedOptionId) ||
+                candidate.recommendedOptionId !==
+                    candidate.options[0].id)) {
+            return false;
+        }
+        return true;
+    });
+}

package/dist/src/session.js

@@ -31,7 +31,7 @@ function preserveProviderSelection(serverState) {
         : null;
     return providerSelection ? { providerSelection } : {};
 }
-export function createSession({ rootDir, autoYes = false, agentMode, modelId, maxToolSteps = DEFAULT_MAX_TOOL_STEPS, confirmCommand = null, confirmPatch = null, requestSudoPassword = null, onStatus = null, onContextLog = null, onToolEvent = null, env = process.env, sessionId = createSessionId(), sessionName = null, history = [], serverState = null, editJournal = [], stickyFilePaths = [], editCounter = 0, safety = createSessionSafetyState(), }) {
+export function createSession({ rootDir, autoYes = false, agentMode, modelId, maxToolSteps = DEFAULT_MAX_TOOL_STEPS, confirmCommand = null, confirmPatch = null, requestSudoPassword = null, requestUserInput = null, onStatus = null, onContextLog = null, onToolEvent = null, env = process.env, sessionId = createSessionId(), sessionName = null, history = [], serverState = null, editJournal = [], stickyFilePaths = [], editCounter = 0, safety = createSessionSafetyState(), }) {
     const createdAt = new Date().toISOString();
     const initialAgentMode = normalizeAgentMode(agentMode ?? (autoYes ? 'auto-accept' : 'default'));
     return {
@@ -46,6 +46,7 @@ export function createSession({ rootDir, autoYes = false, agentMode, modelId, ma
         confirmCommand,
         confirmPatch,
         requestSudoPassword,
+        requestUserInput,
         history: JSON.parse(JSON.stringify(history)),
         initialized: true,
         sessionId,

package/dist/src/ui/repl.js

@@ -1,5 +1,5 @@
 import { createRatatuiBridge } from './tui/bridge.js';
-import { approvalScrollLimit, buildTuiFrame, formatJobElapsed, formatTodoProgress, pickThinkingFallbackPhrase, renderTranscriptEntryLines, THINKING_FALLBACK_PHRASES, } from './tui/build-frame.js';
+import { approvalScrollLimit, buildTuiFrame, formatJobElapsed, formatTodoProgress, pickThinkingFallbackPhrase, renderTranscriptEntryLines, THINKING_FALLBACK_PHRASES, userInputViewportForFrame, } from './tui/build-frame.js';
 import { createTerminalTitleController } from './tui/terminal-title.js';
 import { captureTerminalWrites, releaseTerminalWrites, } from './tui/terminal-writes.js';
 export { getSlashCommandSuggestions } from './tui/build-frame.js';
@@ -13,6 +13,7 @@ import { cancelActiveCommand } from '../executor.js';
 import { isTurnFailureMarker } from '../turn-failure-marker.js';
 import { clearCliAuthConfig } from '../api/auth.js';
 import { authenticationErrorMessage, isAuthenticationError, } from '../api/http.js';
+import { createUserInputPromptState, formatUserInputTranscript, } from './tui/user-input.js';
 import { setCommandOutputHook, withTuiMode } from '../runtime-mode.js';
 import { collectBackgroundJobUiKillMutations, collectBackgroundJobUiOutputMutations, } from '../tool-executor.js';
 import { startNewConversation, } from '../session.js';
@@ -787,10 +788,18 @@ function displayUserTextFromHistoryEntry(entry) {
 export function buildTranscriptFromSessionHistory(history) {
     const entries = [];
     const pendingCalls = new Map();
+    const pendingUserInputRequests = new Map();
     for (const entry of history) {
         if (!entry?.parts?.length)
             continue;
         for (const part of entry.parts) {
+            const userInputRequest = part?.userInputRequest;
+            if (userInputRequest && typeof userInputRequest === 'object') {
+                const requestId = String(userInputRequest.requestId ?? '').trim();
+                if (requestId && Array.isArray(userInputRequest.questions)) {
+                    pendingUserInputRequests.set(requestId, userInputRequest.questions);
+                }
+            }
             const call = part?.functionCall;
             if (!call || typeof call !== 'object')
                 continue;
@@ -800,6 +809,21 @@ export function buildTranscriptFromSessionHistory(history) {
             pendingCalls.set(callId, call);
         }
         for (const part of entry.parts) {
+            const userInputResult = part?.userInputResult;
+            if (userInputResult && typeof userInputResult === 'object') {
+                const requestId = String(userInputResult.requestId ?? '').trim();
+                const questions = pendingUserInputRequests.get(requestId);
+                const result = userInputResult.result;
+                if (questions &&
+                    (result?.status === 'submitted' || result?.status === 'cancelled')) {
+                    pendingUserInputRequests.delete(requestId);
+                    entries.push({
+                        body: formatUserInputTranscript(questions, result),
+                        kind: result.status === 'submitted' ? 'user' : 'system',
+                        title: result.status === 'submitted' ? 'Your answers' : 'Question',
+                    });
+                }
+            }
             const functionResponse = part?.functionResponse;
             if (!functionResponse || typeof functionResponse !== 'object')
                 continue;
@@ -1008,6 +1032,7 @@ function createInitialShellState(session, serverModels, debugUi) {
         tokenUsage: formatClientTokenUsage(null),
         transcript: [],
         turnCounter: Math.max(0, session.history.filter((entry) => entry.role === 'user').length),
+        userInputPrompt: null,
         pastedChunks: [],
         imageAttachments: [],
         workingTools: [],
@@ -1351,6 +1376,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
         let resolveDone = null;
         let resolveApprovalChoice = null;
         let resolveSudoPassword = null;
+        let pendingUserInput = null;
         let cleanupSudoPasswordPrompt = null;
         let sudoPasswordBuffer = '';
         const bridge = createRatatuiBridge();
@@ -1597,12 +1623,28 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 sudoPrompt: null,
             }));
         };
+        const dismissPendingUserInput = () => {
+            const pending = pendingUserInput;
+            if (!pending)
+                return;
+            pendingUserInput = null;
+            pending.signal?.removeEventListener('abort', pending.onAbort);
+            const error = new Error('Turn cancelled.');
+            error.name = 'AbortError';
+            pending.reject(error);
+            store.update((current) => ({
+                ...resumeBusyClock(current, Date.now()),
+                status: current.userInputPrompt?.returnStatus ?? current.status,
+                userInputPrompt: null,
+            }));
+        };
         const cancelActiveTurn = () => {
             if (!store.getState().busy || newConversationInFlight)
                 return;
             disarmExitConfirm();
             dismissPendingApproval();
             dismissPendingSudoPassword();
+            dismissPendingUserInput();
             activeTurnGeneration += 1;
             resetThinkingPacer();
             activeTurnAbort?.abort();
@@ -1722,6 +1764,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             }
             dismissPendingApproval();
             dismissPendingSudoPassword();
+            dismissPendingUserInput();
             exiting = true;
             killAllBackgroundJobs();
             store.update((current) => ({
@@ -1841,6 +1884,49 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                     : null,
             }));
         };
+        const openUserInputPrompt = (questions, signal) => new Promise((resolve, reject) => {
+            if (exiting || signal?.aborted) {
+                const error = new Error('Turn cancelled.');
+                error.name = 'AbortError';
+                reject(error);
+                return;
+            }
+            const onAbort = () => dismissPendingUserInput();
+            pendingUserInput = {
+                questions,
+                resolve,
+                reject,
+                signal,
+                onAbort,
+            };
+            signal?.addEventListener('abort', onAbort, { once: true });
+            store.update((current) => ({
+                ...pauseBusyClock(current, Date.now()),
+                status: 'Waiting for your input',
+                userInputPrompt: createUserInputPromptState(questions, current.status),
+            }));
+            scheduleLiveFrameRemount();
+        });
+        const handleInlineUserInput = async (result) => {
+            const pending = pendingUserInput;
+            const prompt = store.getState().userInputPrompt;
+            if (!pending || !prompt)
+                return;
+            pendingUserInput = null;
+            pending.signal?.removeEventListener('abort', pending.onAbort);
+            store.update((current) => ({
+                ...resumeBusyClock(current, Date.now()),
+                status: prompt.returnStatus,
+                userInputPrompt: null,
+            }));
+            appendTurnAwareEntry({
+                body: formatUserInputTranscript(pending.questions, result),
+                kind: result.status === 'submitted' ? 'user' : 'system',
+                title: result.status === 'submitted' ? 'Your answers' : 'Question',
+            });
+            pending.resolve(result);
+            scheduleLiveFrameRemount();
+        };
         const openApprovalPrompt = (title, body, options = {}) => new Promise((resolve) => {
             if (exiting) {
                 resolve('n');
@@ -2634,6 +2720,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
         projectIndex.onStatus = session.onStatus;
         projectIndex.onContextLog = session.onContextLog;
         session.requestSudoPassword = async ({ command, prompt, signal }) => openSudoPasswordPrompt(command, prompt, signal);
+        session.requestUserInput = async (request, signal) => openUserInputPrompt(request.questions, signal);
         session.confirmCommand = async (command) => {
             if (exiting)
                 return false;
@@ -2683,6 +2770,11 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 const blocks = store.getState().transcript.map((entry) => renderTranscriptEntryLines(entry, contentWidth));
                 return blocks.reduce((total, block, index) => total + block.length + (index > 0 ? 1 : 0), 0);
             },
+            getUserInputViewport: () => {
+                const nowMs = Date.now();
+                const state = store.getState();
+                return userInputViewportForFrame(state, terminalCols, terminalRows, spinnerFrame, busyElapsedSeconds(state, nowMs), nowMs);
+            },
             onCancelTurn: cancelActiveTurn,
             onCycleAgentMode: cycleAgentMode,
             onCtrlC: handleCtrlC,
@@ -2691,6 +2783,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             onLiveFrameShapeChange: scheduleLiveFrameRemount,
             onRequestExit: requestExit,
             onResolveApproval: handleInlineApprovalChoice,
+            onResolveUserInput: handleInlineUserInput,
             onResumeSession: handleInlineResumeSelection,
             onSelectionCopy: handleAppSelectionCopy,
             onSelectModel: handleInlineModelSelection,

package/dist/src/ui/tui/bridge.js

@@ -61,6 +61,13 @@ function normalizeChildMessage(raw) {
             deltaLines: Number(raw.deltaLines ?? raw.delta_lines ?? 0),
         };
     }
+    if (raw.kind === 'transcriptScrollTo') {
+        return {
+            op: 'event',
+            kind: 'transcriptScrollTo',
+            offset: Number(raw.offset ?? 0),
+        };
+    }
     if (raw.kind !== 'key') {
         return null;
     }

package/dist/src/ui/tui/build-frame.js

@@ -3,6 +3,7 @@ import { singleLinePreview, truncate } from '../../utils.js';
 import { formatClientTokenUsage } from '../repl.js';
 import { renderFormattedBodyLines, renderPreformattedBodyLines, } from './markdown-render.js';
 import { displayWidth, line, plainLine, sliceToWidth, span, wrapText, } from './text.js';
+import { buildUserInputOverlayLines, } from './user-input.js';
 const WORKING_CLOCK_ICON = '◷';
 const BRAILLE_SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴'];
 const TODO_PANEL_MAX_ROWS = 12;
@@ -30,6 +31,7 @@ const OVERLAY_PANEL_MAX_WIDTH = 86;
 const OVERLAY_PANEL_MARGIN_LINES = 2;
 const OVERLAY_PANEL_MARGIN_MIN_ROWS = 30;
 const OVERLAY_BORDER_COLOR = 'yellow';
+const USER_INPUT_BORDER_COLOR = 'cyan';
 const OVERLAY_WARNING_COLOR = 'ansi256(208)';
 const MODEL_PICKER_PANEL_MAX_WIDTH = 144;
 const MODEL_PICKER_PANEL_MARGIN_LINES = 2;
@@ -339,6 +341,26 @@ export function renderTranscriptEntryLines(entry, width) {
     }
     return lines;
 }
+const transcriptEntryLineCache = new WeakMap();
+const MAX_CACHED_TRANSCRIPT_WIDTHS = 2;
+function cachedTranscriptEntryLines(entry, width) {
+    let byWidth = transcriptEntryLineCache.get(entry);
+    if (!byWidth) {
+        byWidth = new Map();
+        transcriptEntryLineCache.set(entry, byWidth);
+    }
+    const cached = byWidth.get(width);
+    if (cached)
+        return cached;
+    const lines = renderTranscriptEntryLines(entry, width);
+    if (byWidth.size >= MAX_CACHED_TRANSCRIPT_WIDTHS) {
+        const oldest = byWidth.keys().next().value;
+        if (oldest !== undefined)
+            byWidth.delete(oldest);
+    }
+    byWidth.set(width, lines);
+    return lines;
+}
 function renderDiffPreviewLines(preview, width, maxDiffLines = TRANSCRIPT_DIFF_PREVIEW_LINES) {
     return [
         plainLine(`  Added ${preview.added} line${preview.added === 1 ? '' : 's'}, removed ${preview.removed} line${preview.removed === 1 ? '' : 's'}`, { color: 'gray' }),
@@ -454,13 +476,15 @@ function composerFooterLines(state) {
         : state.input
             ? 'Enter queues • Esc cancels turn • Ctrl+C clears draft'
             : 'Enter queues • Esc / Ctrl+C cancel turn';
-    const helperText = state.busy
-        ? busyHelperText
-        : process.platform === 'win32'
-            ? 'Enter sends • Shift+Tab mode • Alt+V image • Esc cancel turn • Ctrl+C clears / quits'
-            : process.platform === 'darwin'
-                ? 'Enter sends • Shift+Tab mode • Ctrl+V image • Esc cancel turn • Ctrl+C clears / quits'
-                : 'Enter sends • Shift+Tab mode • Ctrl+V image • Esc cancel turn • Ctrl+C clears / quits';
+    const helperText = state.userInputPrompt
+        ? 'Answering agent questions • Ctrl+C cancels turn'
+        : state.busy
+            ? busyHelperText
+            : process.platform === 'win32'
+                ? 'Enter sends • Shift+Tab mode • Alt+V image • Esc cancel turn • Ctrl+C clears / quits'
+                : process.platform === 'darwin'
+                    ? 'Enter sends • Shift+Tab mode • Ctrl+V image • Esc cancel turn • Ctrl+C clears / quits'
+                    : 'Enter sends • Shift+Tab mode • Ctrl+V image • Esc cancel turn • Ctrl+C clears / quits';
     const agentLabel = agentModeLabel(state.agentMode).padEnd(AGENT_MODE_LABEL_WIDTH);
     const tokenUsageText = state.tokenUsage || formatClientTokenUsage(null);
     const footerSpans = [
@@ -661,11 +685,23 @@ function overlayPanelLine(row, width, color) {
     const padding = Math.max(0, width - lineCharCount(row));
     return line(span('│ ', { color }), ...row.spans, span(' '.repeat(padding)), span(' │', { color }));
 }
+function overlayPanelMarginLineCount(height) {
+    return height < OVERLAY_PANEL_MARGIN_MIN_ROWS
+        ? 0
+        : OVERLAY_PANEL_MARGIN_LINES;
+}
+function overlayPanelContentBudget(height) {
+    if (!Number.isFinite(height)) {
+        return Number.POSITIVE_INFINITY;
+    }
+    const margins = overlayPanelMarginLineCount(height) * 2;
+    return Math.max(1, Math.floor(height) - margins - 2);
+}
 function buildOverlayPanel(rows, width, color, height = Number.POSITIVE_INFINITY) {
     const panelWidth = Math.max(24, Math.min(width, OVERLAY_PANEL_MAX_WIDTH));
     const innerWidth = Math.max(1, panelWidth - 4);
     const margin = Array.from({
-        length: height < OVERLAY_PANEL_MARGIN_MIN_ROWS ? 0 : OVERLAY_PANEL_MARGIN_LINES,
+        length: overlayPanelMarginLineCount(height),
     }, () => plainLine(''));
     return [
         ...margin,
@@ -990,6 +1026,12 @@ function buildOverlayLines(state, width, height, nowMs) {
         lines.push(plainLine('Press Enter to submit, Escape to cancel', { color: 'gray' }));
         return buildOverlayPanel(lines, width, OVERLAY_BORDER_COLOR, height);
     }
+    if (state.userInputPrompt) {
+        if (height < 3) {
+            return [];
+        }
+        return buildOverlayPanel(buildUserInputOverlayLines(state.userInputPrompt, innerWidth, overlayPanelContentBudget(height)), width, USER_INPUT_BORDER_COLOR, height);
+    }
     if (state.approvalPrompt) {
         const prompt = state.approvalPrompt;
         const padded = approvalPaddingEnabled(height);
@@ -1111,6 +1153,15 @@ function buildOverlayLines(state, width, height, nowMs) {
 function countSectionLines(sections) {
     return sections.reduce((sum, section) => sum + section.lines.length, 0);
 }
+export function userInputViewportForFrame(state, cols, rows, spinnerFrame, elapsedSeconds, nowMs = 0) {
+    const contentWidth = Math.max(20, Math.floor(cols * 0.95) - 2);
+    const liveRows = buildLiveLines(state, contentWidth, spinnerFrame, elapsedSeconds, nowMs).length;
+    const overlayHeight = Math.max(0, rows - liveRows - composerFooterLines(state).length);
+    return {
+        width: approvalPanelInnerWidth(contentWidth),
+        maxRows: overlayPanelContentBudget(overlayHeight),
+    };
+}
 function sliceTranscriptLines(lines, maxLines, scrollOffset) {
     if (maxLines <= 0 || lines.length <= maxLines) {
         return lines;
@@ -1123,20 +1174,24 @@ function sliceTranscriptLines(lines, maxLines, scrollOffset) {
 export function buildTuiFrame(state, cols, rows, spinnerFrame, elapsedSeconds, nowMs = 0) {
     const contentWidth = Math.max(20, Math.floor(cols * 0.95) - 2);
     const gutter = Math.max(Math.floor((cols - contentWidth) / 2), 0);
-    const transcriptBlocks = state.transcript.map((entry) => renderTranscriptEntryLines(entry, contentWidth));
-    const transcriptLines = [];
-    transcriptBlocks.forEach((block, index) => {
-        if (index > 0) {
-            transcriptLines.push(plainLine(''));
-        }
-        transcriptLines.push(...block);
-    });
+    const buildTranscriptLines = (wrapWidth) => {
+        const blocks = state.transcript.map((entry) => cachedTranscriptEntryLines(entry, wrapWidth));
+        const lines = [];
+        blocks.forEach((block, index) => {
+            if (index > 0) {
+                lines.push(plainLine(''));
+            }
+            lines.push(...block);
+        });
+        return lines;
+    };
+    let transcriptLines = buildTranscriptLines(contentWidth);
     const sections = [];
     const liveLines = buildLiveLines(state, contentWidth, spinnerFrame, elapsedSeconds, nowMs);
     if (liveLines.length > 0) {
         sections.push({ kind: 'live', lines: liveLines });
     }
-    const overlayActive = Boolean(state.approvalPrompt || state.sudoPrompt);
+    const overlayActive = Boolean(state.approvalPrompt || state.sudoPrompt || state.userInputPrompt);
     if (!state.resumePickerOpen && !state.modelPickerOpen && !state.jobsPickerOpen && !overlayActive) {
         const composerLines = [];
         if (state.busy && state.status === 'Starting a new conversation...') {
@@ -1161,14 +1216,32 @@ export function buildTuiFrame(state, cols, rows, spinnerFrame, elapsedSeconds, n
             lines: [...composerLines, plainLine(''), ...composerFooterLines(state)],
         });
     }
-    const overlayLines = buildOverlayLines(state, contentWidth, rows, nowMs);
+    if (state.userInputPrompt) {
+        sections.push({
+            kind: 'busyFooter',
+            lines: composerFooterLines(state),
+        });
+    }
+    const overlayHeight = state.userInputPrompt
+        ? Math.max(0, rows - countSectionLines(sections))
+        : rows;
+    const overlayLines = buildOverlayLines(state, contentWidth, overlayHeight, nowMs);
     if (overlayLines.length > 0) {
         sections.push({ kind: 'overlay', lines: overlayLines });
     }
     const reservedLines = countSectionLines(sections.filter((section) => section.kind !== 'transcript'));
-    const composerReserve = state.resumePickerOpen || state.approvalPrompt || state.sudoPrompt ? 0 : 4;
+    const composerReserve = state.resumePickerOpen ||
+        state.approvalPrompt ||
+        state.sudoPrompt ||
+        state.userInputPrompt
+        ? 0
+        : 4;
     const transcriptBudget = Math.max(1, rows - reservedLines - composerReserve - 1);
-    const transcriptScrollLimit = Math.max(0, transcriptLines.length - transcriptBudget);
+    let transcriptScrollLimit = Math.max(0, transcriptLines.length - transcriptBudget);
+    if (transcriptScrollLimit > 0 && contentWidth > 2) {
+        transcriptLines = buildTranscriptLines(contentWidth - 2);
+        transcriptScrollLimit = Math.max(0, transcriptLines.length - transcriptBudget);
+    }
     const transcriptScrollOffset = Math.min(Math.max(state.transcriptScrollOffset, 0), transcriptScrollLimit);
     sections.unshift({
         kind: 'transcript',

package/dist/src/ui/tui/markdown-render.js

@@ -275,9 +275,9 @@ function wrapInlineToLines(text, width, bodyColor, prefix = '') {
     };
     const appendSpan = (part) => {
         let current = rows[rows.length - 1];
-        const limit = safeWidth - (rows.length === 1 && indent ? displayWidth(prefix) : 0);
         let remaining = part.text;
         while (remaining.length > 0) {
+            const limit = safeWidth - (rows.length === 1 && indent ? displayWidth(prefix) : 0);
             const room = limit - rowWidth;
             if (room <= 0) {
                 startRow();
@@ -291,8 +291,17 @@ function wrapInlineToLines(text, width, bodyColor, prefix = '') {
                 remaining = '';
                 break;
             }
+            if (rowWidth > 0) {
+                if (/^\s+$/.test(remaining)) {
+                    remaining = '';
+                    break;
+                }
+                startRow();
+                current = rows[rows.length - 1];
+                continue;
+            }
             const head = sliceToWidth(remaining, room);
-            if (displayWidth(head) > room && current.length > 0) {
+            if (!head || (displayWidth(head) > room && current.length > 0)) {
                 startRow();
                 current = rows[rows.length - 1];
                 continue;

package/dist/src/ui/tui/shell-input.js

@@ -1,6 +1,7 @@
 import { readClipboardImage, readClipboardText } from '../../core/clipboard.js';
 import { applySlashCommandSuggestion, buildModelPickerOptions, deleteAtCursor, deleteBeforeCursor, getApprovalChoiceForCursor, getInputCommandToken, getNextApprovalCursor, getNextModelPickerIndex, getSlashCommandSuggestions, insertAtCursor, isExactSlashCommandToken, navigatePromptHistory, resolveApprovalChoiceFromInput, shouldRemountLiveFrameForComposerInputChange, } from '../repl.js';
 import { buildPastePlaceholder, shouldCollapsePaste, } from '../paste-collapse.js';
+import { handleUserInputPromptEvent, } from './user-input.js';
 const APPROVAL_PREVIEW_PAGE_ROWS = 3;
 function isClipboardImagePasteKey(key) {
     if (process.platform === 'win32') {
@@ -10,6 +11,20 @@ function isClipboardImagePasteKey(key) {
     }
     return key.ctrl && key.input === 'v' && !key.shift && !key.meta;
 }
+function applyUserInputPromptEvent(store, handlers, event) {
+    const current = store.getState();
+    if (!current.userInputPrompt)
+        return false;
+    const outcome = handleUserInputPromptEvent(current.userInputPrompt, event, handlers.getUserInputViewport?.());
+    store.update((state) => ({
+        ...state,
+        userInputPrompt: outcome.state,
+    }));
+    if (outcome.result) {
+        void handlers.onResolveUserInput?.(outcome.result);
+    }
+    return true;
+}
 function composerIsEmpty(state) {
     return (!state.input &&
         state.cursor === 0 &&
@@ -99,6 +114,16 @@ function scrollTranscript(store, handlers, delta) {
         };
     });
 }
+function scrollTranscriptTo(store, handlers, offset) {
+    store.update((current) => {
+        const limit = handlers.getTranscriptScrollLimit?.() ??
+            current.transcript.reduce((total, entry) => total + 2 + (entry.body ? entry.body.split('\n').length : 0), 0);
+        return {
+            ...current,
+            transcriptScrollOffset: Math.max(0, Math.min(Math.trunc(offset), limit)),
+        };
+    });
+}
 function scrollApprovalPreview(store, handlers, delta) {
     if (delta === 0)
         return;
@@ -125,6 +150,12 @@ function filterResumeSessionsLocal(sessions, filter, serverModels) {
 }
 export function handleShellKeyEvent(store, handlers, event) {
     if (event.kind === 'paste') {
+        if (applyUserInputPromptEvent(store, handlers, {
+            kind: 'paste',
+            text: event.text,
+        })) {
+            return;
+        }
         insertPastedText(store, handlers, event.text);
         return;
     }
@@ -147,6 +178,13 @@ export function handleShellKeyEvent(store, handlers, event) {
         return;
     }
     if (event.kind === 'contextMenu') {
+        if (store.getState().userInputPrompt) {
+            const text = (handlers.readClipboardText ?? readClipboardText)();
+            if (text) {
+                applyUserInputPromptEvent(store, handlers, { kind: 'paste', text });
+            }
+            return;
+        }
         pasteTextFromClipboard(store, handlers);
         return;
     }
@@ -154,6 +192,10 @@ export function handleShellKeyEvent(store, handlers, event) {
         scrollTranscript(store, handlers, Math.trunc(event.deltaLines));
         return;
     }
+    if (event.kind === 'transcriptScrollTo') {
+        scrollTranscriptTo(store, handlers, Number(event.offset ?? 0));
+        return;
+    }
     if (event.kind !== 'key')
         return;
     const key = event;
@@ -168,6 +210,10 @@ export function handleShellKeyEvent(store, handlers, event) {
         }
     };
     if (key.ctrl && key.input === 'c') {
+        if (state.userInputPrompt) {
+            handlers.onCtrlC?.();
+            return;
+        }
         if (state.sudoPrompt) {
             handlers.onSudoPasswordInput({ kind: 'cancel' });
             return;
@@ -200,6 +246,10 @@ export function handleShellKeyEvent(store, handlers, event) {
         handlers.onRequestExit();
         return;
     }
+    if (state.userInputPrompt &&
+        applyUserInputPromptEvent(store, handlers, key)) {
+        return;
+    }
     if (state.sudoPrompt) {
         if (key.escape) {
             handlers.onSudoPasswordInput({ kind: 'cancel' });

package/dist/src/ui/tui/user-input.js

@@ -0,0 +1,568 @@
+import { displayWidth, line, plainLine, sliceToWidth, span, wrapText, } from './text.js';
+const OTHER_CURSOR = '$other';
+const SUBMIT_CURSOR = '$submit';
+const ACCENT_COLOR = 'cyan';
+const SCROLL_PAGE_ROWS = 4;
+function currentQuestion(state) {
+    return (state.questions.find((question) => question.id === state.questionId) ??
+        state.questions[0]);
+}
+function questionIndex(state) {
+    return Math.max(0, state.questions.findIndex((question) => question.id === state.questionId));
+}
+function defaultCursor(question) {
+    return question.options[0]?.id ?? OTHER_CURSOR;
+}
+function cursorForQuestion(state, question) {
+    return state.cursorByQuestionId[question.id] ?? defaultCursor(question);
+}
+function cursorRows(state, question) {
+    const rows = [...question.options.map((option) => option.id), OTHER_CURSOR];
+    if (questionIndex(state) === state.questions.length - 1) {
+        rows.push(SUBMIT_CURSOR);
+    }
+    return rows;
+}
+function setQuestion(state, index) {
+    const question = state.questions[index];
+    if (!question)
+        return state;
+    return {
+        ...state,
+        questionId: question.id,
+        contentScrollAnchor: null,
+        contentScrollOffset: 0,
+        noteOpen: false,
+        noteCursor: (state.customText[question.id] ?? '').length,
+        validationMessage: '',
+    };
+}
+function setCursor(state, question, cursor) {
+    return {
+        ...state,
+        contentScrollAnchor: cursor,
+        cursorByQuestionId: {
+            ...state.cursorByQuestionId,
+            [question.id]: cursor,
+        },
+        validationMessage: '',
+    };
+}
+function moveCursor(state, delta) {
+    const question = currentQuestion(state);
+    const rows = cursorRows(state, question);
+    const current = cursorForQuestion(state, question);
+    const index = Math.max(0, rows.indexOf(current));
+    const next = Math.max(0, Math.min(index + delta, rows.length - 1));
+    return setCursor(state, question, rows[next]);
+}
+function selectedIds(state, question) {
+    return state.selectedOptionIds[question.id] ?? [];
+}
+function selectOption(state, optionId) {
+    const question = currentQuestion(state);
+    const current = selectedIds(state, question);
+    const nextSelected = question.multiSelect
+        ? current.includes(optionId)
+            ? current.filter((id) => id !== optionId)
+            : question.options
+                .map((option) => option.id)
+                .filter((id) => id === optionId || current.includes(id))
+        : [optionId];
+    let next = {
+        ...setCursor(state, question, optionId),
+        selectedOptionIds: {
+            ...state.selectedOptionIds,
+            [question.id]: nextSelected,
+        },
+        customText: question.multiSelect
+            ? state.customText
+            : {
+                ...state.customText,
+                [question.id]: '',
+            },
+    };
+    if (!question.multiSelect) {
+        const index = questionIndex(state);
+        next =
+            index < state.questions.length - 1
+                ? setQuestion(next, index + 1)
+                : setCursor(next, question, SUBMIT_CURSOR);
+    }
+    return next;
+}
+function normalizeNoteText(value) {
+    return value.replace(/[\r\n\t]+/g, ' ').replace(/ {2,}/g, ' ');
+}
+function previousCharacterBoundary(value, cursor) {
+    const previous = Array.from(value.slice(0, cursor)).at(-1);
+    return previous ? cursor - previous.length : 0;
+}
+function nextCharacterBoundary(value, cursor) {
+    const next = Array.from(value.slice(cursor))[0];
+    return next ? cursor + next.length : value.length;
+}
+function openCustomTextEditor(state) {
+    const question = currentQuestion(state);
+    return {
+        ...setCursor(state, question, OTHER_CURSOR),
+        selectedOptionIds: question.multiSelect
+            ? state.selectedOptionIds
+            : {
+                ...state.selectedOptionIds,
+                [question.id]: [],
+            },
+        noteOpen: true,
+        noteCursor: (state.customText[question.id] ?? '').length,
+    };
+}
+function insertNote(state, insertedText) {
+    const nextState = openCustomTextEditor(state);
+    const question = currentQuestion(nextState);
+    const current = nextState.customText[question.id] ?? '';
+    const inserted = normalizeNoteText(insertedText);
+    if (!inserted) {
+        return nextState;
+    }
+    const noteCursor = Math.max(0, Math.min(nextState.noteCursor, current.length));
+    const nextText = `${current.slice(0, noteCursor)}${inserted}${current.slice(noteCursor)}`;
+    return {
+        ...nextState,
+        customText: {
+            ...nextState.customText,
+            [question.id]: nextText,
+        },
+        noteCursor: noteCursor + inserted.length,
+    };
+}
+function editOpenNote(state, event) {
+    const question = currentQuestion(state);
+    const current = state.customText[question.id] ?? '';
+    const cursor = Math.max(0, Math.min(state.noteCursor, current.length));
+    if (event.escape || event.returnKey) {
+        return { ...state, noteOpen: false };
+    }
+    if (event.tab)
+        return state;
+    if ((event.upArrow || event.downArrow) && !current.trim()) {
+        return moveCursor({
+            ...state,
+            customText: {
+                ...state.customText,
+                [question.id]: '',
+            },
+            noteOpen: false,
+            noteCursor: 0,
+        }, event.upArrow ? -1 : 1);
+    }
+    if (event.leftArrow) {
+        return {
+            ...state,
+            noteCursor: previousCharacterBoundary(current, cursor),
+        };
+    }
+    if (event.rightArrow) {
+        return {
+            ...state,
+            noteCursor: nextCharacterBoundary(current, cursor),
+        };
+    }
+    if (event.home) {
+        return { ...state, noteCursor: 0 };
+    }
+    if (event.end) {
+        return { ...state, noteCursor: current.length };
+    }
+    if (event.backspace && cursor > 0) {
+        const previous = previousCharacterBoundary(current, cursor);
+        return {
+            ...state,
+            customText: {
+                ...state.customText,
+                [question.id]: `${current.slice(0, previous)}${current.slice(cursor)}`,
+            },
+            noteCursor: previous,
+        };
+    }
+    if (event.delete && cursor < current.length) {
+        const next = nextCharacterBoundary(current, cursor);
+        return {
+            ...state,
+            customText: {
+                ...state.customText,
+                [question.id]: `${current.slice(0, cursor)}${current.slice(next)}`,
+            },
+        };
+    }
+    if (!event.ctrl && !event.meta && event.input) {
+        return insertNote(state, event.input);
+    }
+    return state;
+}
+function questionAnswered(state, question) {
+    return (selectedIds(state, question).length > 0 ||
+        Boolean((state.customText[question.id] ?? '').trim()));
+}
+function submitResult(state) {
+    const missing = state.questions.find((question) => !questionAnswered(state, question));
+    if (missing) {
+        const next = setQuestion(state, state.questions.indexOf(missing));
+        return {
+            state: {
+                ...next,
+                validationMessage: 'Choose an option or add details before submitting.',
+            },
+        };
+    }
+    return {
+        state,
+        result: {
+            status: 'submitted',
+            answers: Object.fromEntries(state.questions.map((question) => {
+                const customText = (state.customText[question.id] ?? '').trim();
+                return [
+                    question.id,
+                    {
+                        selectedOptionIds: selectedIds(state, question),
+                        ...(customText ? { customText } : {}),
+                    },
+                ];
+            })),
+        },
+    };
+}
+export function createUserInputPromptState(questions, returnStatus) {
+    const first = questions[0];
+    return {
+        questions,
+        questionId: first.id,
+        cursorByQuestionId: Object.fromEntries(questions.map((question) => [question.id, defaultCursor(question)])),
+        selectedOptionIds: Object.fromEntries(questions.map((question) => [question.id, []])),
+        customText: Object.fromEntries(questions.map((question) => [question.id, ''])),
+        contentScrollAnchor: null,
+        contentScrollOffset: 0,
+        noteOpen: false,
+        noteCursor: 0,
+        returnStatus,
+        validationMessage: '',
+    };
+}
+export function handleUserInputPromptEvent(state, event, viewport) {
+    const visibleState = viewport
+        ? normalizeUserInputScrollState(state, viewport)
+        : state;
+    if (event.kind === 'paste') {
+        return {
+            state: visibleState.noteOpen ||
+                cursorForQuestion(visibleState, currentQuestion(visibleState)) ===
+                    OTHER_CURSOR
+                ? insertNote(visibleState, event.text)
+                : visibleState,
+        };
+    }
+    if (event.pageUp || event.pageDown) {
+        if (!viewport) {
+            return {
+                state: {
+                    ...visibleState,
+                    contentScrollAnchor: null,
+                    contentScrollOffset: visibleState.contentScrollOffset +
+                        (event.pageUp ? -SCROLL_PAGE_ROWS : SCROLL_PAGE_ROWS),
+                },
+            };
+        }
+        const window = buildUserInputWindow(visibleState, viewport.width, viewport.maxRows);
+        return {
+            state: {
+                ...visibleState,
+                contentScrollAnchor: null,
+                contentScrollOffset: Math.max(0, Math.min(window.offset +
+                    (event.pageUp ? -SCROLL_PAGE_ROWS : SCROLL_PAGE_ROWS), window.maxOffset)),
+            },
+        };
+    }
+    if (visibleState.noteOpen) {
+        return { state: editOpenNote(visibleState, event) };
+    }
+    if (event.escape) {
+        return { state: visibleState, result: { status: 'cancelled' } };
+    }
+    if (event.upArrow || event.downArrow) {
+        return {
+            state: moveCursor(visibleState, event.upArrow ? -1 : 1),
+        };
+    }
+    if (event.leftArrow) {
+        return {
+            state: setQuestion(visibleState, questionIndex(visibleState) - 1),
+        };
+    }
+    if (event.rightArrow) {
+        const index = questionIndex(visibleState);
+        if (index < visibleState.questions.length - 1) {
+            return { state: setQuestion(visibleState, index + 1) };
+        }
+        return {
+            state: setCursor(visibleState, currentQuestion(visibleState), SUBMIT_CURSOR),
+        };
+    }
+    const question = currentQuestion(visibleState);
+    const numberedRow = /^[1-5]$/.test(event.input)
+        ? Number(event.input)
+        : 0;
+    if (numberedRow && !event.ctrl && !event.meta) {
+        if (numberedRow === question.options.length + 1) {
+            return {
+                state: openCustomTextEditor(visibleState),
+            };
+        }
+        const numberedOption = question.options[numberedRow - 1];
+        if (numberedOption) {
+            return { state: selectOption(visibleState, numberedOption.id) };
+        }
+    }
+    if (event.returnKey) {
+        const cursor = cursorForQuestion(visibleState, question);
+        if (cursor === OTHER_CURSOR) {
+            return {
+                state: openCustomTextEditor(visibleState),
+            };
+        }
+        if (cursor === SUBMIT_CURSOR) {
+            return submitResult(visibleState);
+        }
+        return { state: selectOption(visibleState, cursor) };
+    }
+    if (!event.ctrl &&
+        !event.meta &&
+        event.input &&
+        event.input >= ' ' &&
+        cursorForQuestion(visibleState, currentQuestion(visibleState)) ===
+            OTHER_CURSOR) {
+        return { state: insertNote(visibleState, event.input) };
+    }
+    return { state: visibleState };
+}
+function noteInputLine(state, width) {
+    const question = currentQuestion(state);
+    const text = state.customText[question.id] ?? '';
+    const cursor = Math.max(0, Math.min(state.noteCursor, text.length));
+    const characters = Array.from(text);
+    const characterCursor = Array.from(text.slice(0, cursor)).length;
+    const available = Math.max(8, width - 8);
+    const windowStart = Math.max(0, characterCursor - available + 1);
+    const visible = characters.slice(windowStart, windowStart + available);
+    const visibleCursor = characterCursor - windowStart;
+    return line(span('    › ', { color: ACCENT_COLOR }), span(visible.slice(0, visibleCursor).join('')), span(visible[visibleCursor] ?? ' ', { inverse: true }), span(visible.slice(visibleCursor + 1).join('')));
+}
+function sliceWithinWidth(text, width) {
+    if (width <= 0)
+        return '';
+    let result = sliceToWidth(text, width);
+    while (result && displayWidth(result) > width) {
+        result = Array.from(result).slice(0, -1).join('');
+    }
+    return result;
+}
+function fitText(text, width) {
+    if (width <= 0)
+        return '';
+    if (displayWidth(text) <= width)
+        return text;
+    if (width === 1)
+        return '…';
+    return `${sliceWithinWidth(text, width - 1).trimEnd()}…`;
+}
+function clipLineToWidth(row, width) {
+    let remaining = Math.max(0, width);
+    const spans = [];
+    for (const item of row.spans) {
+        if (remaining <= 0)
+            break;
+        const text = sliceWithinWidth(item.text, remaining);
+        if (text)
+            spans.push({ ...item, text });
+        remaining -= displayWidth(text);
+    }
+    return { spans };
+}
+function buildUserInputContent(state, width) {
+    const question = currentQuestion(state);
+    const index = questionIndex(state);
+    const cursor = cursorForQuestion(state, question);
+    const selected = new Set(selectedIds(state, question));
+    let anchorRange = null;
+    const progress = `Question ${index + 1} of ${state.questions.length}`;
+    const headerPrefix = ' · ';
+    const headerBudget = Math.max(0, width - displayWidth(progress) - displayWidth(headerPrefix));
+    const lines = [
+        line(span(progress, {
+            color: ACCENT_COLOR,
+            bold: true,
+        }), ...(headerBudget > 0
+            ? [
+                span(`${headerPrefix}${fitText(question.header, headerBudget)}`, { color: 'gray' }),
+            ]
+            : [])),
+        plainLine(''),
+        ...wrapText(question.question, width).map((text) => plainLine(text, { bold: true })),
+        plainLine(''),
+    ];
+    question.options.forEach((option, optionIndex) => {
+        const focused = cursor === option.id;
+        const checked = selected.has(option.id);
+        const marker = question.multiSelect
+            ? checked
+                ? '[x]'
+                : '[ ]'
+            : checked
+                ? '●'
+                : '○';
+        const blockStart = lines.length;
+        const optionPrefix = `${optionIndex + 1}. ${marker} `;
+        const recommendation = option.id === question.recommendedOptionId ? '  Recommended' : '';
+        const labelBudget = Math.max(1, width -
+            displayWidth('› ') -
+            displayWidth(optionPrefix) -
+            displayWidth(recommendation));
+        lines.push(line(span(focused ? '› ' : '  ', {
+            color: focused ? ACCENT_COLOR : 'gray',
+        }), span(`${optionPrefix}${fitText(option.label, labelBudget)}`, {
+            color: focused ? ACCENT_COLOR : undefined,
+            bold: focused,
+        }), ...(recommendation
+            ? [span(recommendation, { color: 'green' })]
+            : [])));
+        for (const description of wrapText(option.description, Math.max(8, width - 5))) {
+            lines.push(plainLine(`     ${description}`, { color: 'gray' }));
+        }
+        if (state.contentScrollAnchor === option.id) {
+            anchorRange = { start: blockStart, end: lines.length - 1 };
+        }
+    });
+    const customText = (state.customText[question.id] ?? '').trim();
+    const otherFocused = cursor === OTHER_CURSOR;
+    const otherAnswered = Boolean(customText);
+    const otherMarker = question.multiSelect
+        ? otherAnswered
+            ? '[x]'
+            : '[ ]'
+        : otherAnswered
+            ? '●'
+            : '○';
+    const otherNumber = question.options.length + 1;
+    const otherStart = lines.length;
+    lines.push(plainLine(''));
+    lines.push(line(span(otherFocused ? '› ' : '  ', {
+        color: otherFocused ? ACCENT_COLOR : 'gray',
+    }), span(`${otherNumber}. ${otherMarker} Something else / add details`, {
+        color: otherFocused ? ACCENT_COLOR : undefined,
+        bold: otherFocused,
+    }), ...(customText && !state.noteOpen
+        ? [
+            span(` · ${Array.from(customText)
+                .slice(0, Math.max(8, width - 28))
+                .join('')}`, { color: 'gray' }),
+        ]
+        : otherFocused && !state.noteOpen
+            ? [span(' · Type details…', { color: 'gray', dim: true })]
+            : [])));
+    if (state.noteOpen) {
+        lines.push(noteInputLine(state, width));
+    }
+    lines.push(plainLine(''));
+    if (state.contentScrollAnchor === OTHER_CURSOR) {
+        anchorRange = { start: otherStart, end: lines.length - 1 };
+    }
+    if (index === state.questions.length - 1) {
+        const submitStart = lines.length - 1;
+        lines.push(line(span(cursor === SUBMIT_CURSOR ? '› ' : '  ', {
+            color: cursor === SUBMIT_CURSOR ? ACCENT_COLOR : 'gray',
+        }), span('Submit answers', {
+            color: cursor === SUBMIT_CURSOR ? ACCENT_COLOR : undefined,
+            bold: cursor === SUBMIT_CURSOR,
+        })));
+        lines.push(plainLine(''));
+        if (state.contentScrollAnchor === SUBMIT_CURSOR) {
+            anchorRange = { start: submitStart, end: lines.length - 1 };
+        }
+    }
+    if (state.validationMessage) {
+        lines.push(plainLine(state.validationMessage, { color: 'yellow' }));
+    }
+    lines.push(plainLine(state.noteOpen
+        ? 'Type a single-line note • ↑/↓ moves when empty • Enter saves • Esc closes • PgUp/PgDn scroll'
+        : question.multiSelect
+            ? `↑/↓ move • 1–${otherNumber} choose • Enter toggles/edits • ←/→ questions • PgUp/PgDn scroll • Esc cancels`
+            : `↑/↓ move • 1–${otherNumber} choose • Enter selects/edits • ←/→ questions • PgUp/PgDn scroll • Esc cancels`, { color: 'gray' }));
+    return {
+        anchorRange,
+        lines: lines.map((row) => clipLineToWidth(row, width)),
+    };
+}
+function buildUserInputWindow(state, width, maxRows) {
+    const content = buildUserInputContent(state, width);
+    if (!Number.isFinite(maxRows) || content.lines.length <= maxRows) {
+        return { lines: content.lines, maxOffset: 0, offset: 0 };
+    }
+    const rowBudget = Math.max(1, Math.floor(maxRows));
+    const visibleRowBudget = rowBudget === 1 ? 1 : rowBudget - 1;
+    const maxOffset = Math.max(0, content.lines.length - visibleRowBudget);
+    let offset = Math.max(0, Math.min(state.contentScrollOffset, maxOffset));
+    const range = content.anchorRange;
+    if (range) {
+        const blockRows = range.end - range.start + 1;
+        if (blockRows <= visibleRowBudget) {
+            if (range.start < offset) {
+                offset = range.start;
+            }
+            else if (range.end >= offset + visibleRowBudget) {
+                offset = range.end - visibleRowBudget + 1;
+            }
+        }
+        else if (range.start < offset ||
+            range.start >= offset + visibleRowBudget) {
+            offset = range.start;
+        }
+        offset = Math.max(0, Math.min(offset, maxOffset));
+    }
+    const visible = content.lines.slice(offset, offset + visibleRowBudget);
+    if (rowBudget === 1) {
+        return { lines: visible, maxOffset, offset };
+    }
+    return {
+        lines: [
+            ...visible,
+            plainLine(fitText(`Rows ${offset + 1}–${offset + visible.length} of ${content.lines.length} · PgUp/PgDn scroll`, width), { color: 'gray' }),
+        ],
+        maxOffset,
+        offset,
+    };
+}
+export function normalizeUserInputScrollState(state, viewport) {
+    const window = buildUserInputWindow(state, viewport.width, viewport.maxRows);
+    return window.offset === state.contentScrollOffset
+        ? state
+        : { ...state, contentScrollOffset: window.offset };
+}
+export function buildUserInputOverlayLines(state, width, maxRows = Number.POSITIVE_INFINITY) {
+    return buildUserInputWindow(state, width, maxRows).lines;
+}
+export function formatUserInputTranscript(questions, result) {
+    if (result.status === 'cancelled') {
+        return 'Cancelled without answers.';
+    }
+    return questions
+        .map((question) => {
+        const answer = result.answers[question.id];
+        const selected = question.options
+            .filter((option) => answer?.selectedOptionIds.includes(option.id))
+            .map((option) => option.label);
+        const values = [
+            ...selected,
+            ...(answer?.customText ? [answer.customText] : []),
+        ];
+        return `${question.header} · ${question.question}\n  ${values.join(', ')}`;
+    })
+        .join('\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thegitai/cli",
-  "version": "1.0.0-preview.13",
+  "version": "1.0.0-preview.15",
   "description": "TheGitAI is an AI coding agent for your terminal. It indexes your repository, writes and edits files, runs commands, and builds features with you.",
   "keywords": [
     "ai",
@@ -37,10 +37,10 @@
     "@lydell/node-pty-linux-x64": "1.1.0",
     "@lydell/node-pty-win32-arm64": "1.1.0",
     "@lydell/node-pty-win32-x64": "1.1.0",
-    "@thegitai/tui-darwin-arm64": "1.0.0-preview.13",
-    "@thegitai/tui-darwin-x64": "1.0.0-preview.13",
-    "@thegitai/tui-linux-x64": "1.0.0-preview.13",
-    "@thegitai/tui-win32-x64": "1.0.0-preview.13",
+    "@thegitai/tui-darwin-arm64": "1.0.0-preview.15",
+    "@thegitai/tui-darwin-x64": "1.0.0-preview.15",
+    "@thegitai/tui-linux-x64": "1.0.0-preview.15",
+    "@thegitai/tui-win32-x64": "1.0.0-preview.15",
     "@vscode/ripgrep": "1.18.0"
   },
   "publishConfig": {