@thegitai/cli 1.0.0-preview.2 → 1.0.0-preview.20

package/dist/src/ui/repl.js

@@ -1,6 +1,8 @@
 import { createRatatuiBridge } from './tui/bridge.js';
-import { buildTuiFrame, formatJobElapsed, formatTodoProgress, renderTranscriptEntryLines, } from './tui/build-frame.js';
+import { bucketActionLabel, } from '../permissions.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';
 import { agentModeLabel, nextAgentMode, } from '../agent-mode.js';
 import { chat, models } from '../api/index.js';
@@ -9,10 +11,14 @@ import { getJobBufferedOutput, getJobOutputPreview, hasRunningBackgroundJobs, ki
 import { clearTodos, listTodos, setTodoSession } from '../todo-list.js';
 import { setScratchSession } from '../scratch-dir.js';
 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 { clearConversation, } from '../session.js';
-import { applySessionSnapshot, listSessionMetadata, loadSessionSnapshot, saveSessionState, } from '../session-store.js';
+import { startNewConversation, } from '../session.js';
+import { applySessionSnapshot, listSessionMetadata, loadSessionSnapshot, saveSessionState, sessionHasUserMessage, } from '../session-store.js';
 import { truncate } from '../utils.js';
 import { writeClipboardText } from '../core/clipboard.js';
 import { openUrl } from '../core/open-url.js';
@@ -69,23 +75,6 @@ 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',
@@ -112,8 +101,8 @@ export const SLASH_COMMANDS = [
         description: 'Background jobs: pick to view output or kill',
     },
     {
-        command: '/clear',
-        description: 'Clear conversation history',
+        command: '/new',
+        description: 'start a new conversation; this session remains saved',
     },
     {
         command: '/exit',
@@ -780,13 +769,21 @@ function displayUserTextFromHistoryEntry(entry) {
         .slice(contentStart, contentEnd === -1 ? text.length : contentEnd)
         .trim();
 }
-function buildTranscriptFromSessionHistory(history) {
+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;
@@ -796,6 +793,21 @@ 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;
@@ -824,8 +836,23 @@ function buildTranscriptFromSessionHistory(history) {
             }
             continue;
         }
+        if (entry.role === 'user' && entry.kind === 'userInterjection') {
+            const text = String(entry.userInput ?? '').trim();
+            if (text) {
+                entries.push({ body: text, kind: 'user', title: 'You · sent mid-turn' });
+            }
+            continue;
+        }
         const text = textFromHistoryEntry(entry);
         if ((entry.role === 'model' || entry.role === 'assistant') && text) {
+            if (isTurnFailureMarker(text)) {
+                entries.push({
+                    body: 'This request did not complete.',
+                    kind: 'system',
+                    title: 'Previous turn',
+                });
+                continue;
+            }
             entries.push({ body: text, kind: 'assistant', title: 'Response' });
         }
     }
@@ -951,11 +978,14 @@ function createInitialShellState(session, serverModels, debugUi) {
         activeTurnInput: '',
         activeTurnInputPreformatted: false,
         agentMode: session.agentMode,
-        approvalCursor: getDefaultApprovalCursor(),
+        analyzingImages: 0,
+        approvalCursor: 0,
         approvalPrompt: null,
+        approvalScrollOffset: 0,
         autoYes: session.autoYes,
         backgroundJobs: [],
         busy: false,
+        busyPausedAt: null,
         busySince: null,
         clockNow: Date.now(),
         commandCursor: 0,
@@ -983,6 +1013,7 @@ function createInitialShellState(session, serverModels, debugUi) {
         resumePickerSessions: [],
         transcriptScrollOffset: 0,
         queuedMessage: null,
+        turnMessages: [],
         serverModels: serverModels.models,
         sudoPrompt: null,
         status: 'Ready',
@@ -993,6 +1024,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: [],
@@ -1060,6 +1092,24 @@ function splitThinkingLines(text) {
         .map((part) => part.trim())
         .filter(Boolean));
 }
+const LIVE_STATUS_PANEL_MAX_CHARS = 72;
+const TOOL_PROGRESS_STATUS_PATTERN = /^(?:Tool:\s|Running\s\S+(?:\slocally)?\.\.\.$)/i;
+export function isToolProgressStatus(status) {
+    return TOOL_PROGRESS_STATUS_PATTERN.test(String(status ?? '').trim());
+}
+function holdOrPickFallback(currentTitle) {
+    return THINKING_FALLBACK_PHRASES.includes(currentTitle.trim())
+        ? currentTitle
+        : pickThinkingFallbackPhrase();
+}
+function liveStatusPanelTitle(status) {
+    const text = String(status ?? '').trim();
+    if (!text || text.includes('\n'))
+        return '';
+    if (isToolProgressStatus(text))
+        return '';
+    return text.length <= LIVE_STATUS_PANEL_MAX_CHARS ? text : '';
+}
 function thinkingPanelFromStatus(status) {
     const rawText = thinkingNoteFromStatus(status);
     if (!rawText)
@@ -1083,7 +1133,7 @@ function thinkingPanelFromStatus(status) {
     const bodyLines = rawLines.length > 1 && rawLines[0].length <= 72 ? rawLines.slice(1) : rawLines;
     return {
         title,
-        notes: splitThinkingLines(bodyLines.join('\n')).slice(-3),
+        notes: splitThinkingLines(bodyLines.join('\n')).slice(0, 3),
     };
 }
 export const EXIT_CTRL_C_CONFIRM_MESSAGE = 'Press Ctrl+C again to quit.';
@@ -1213,32 +1263,47 @@ export function navigatePromptHistory(state, direction) {
         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 getDefaultApprovalCursor(optionCount) {
+    return Math.max(0, optionCount - 1);
+}
+export function getNextApprovalCursor(currentIndex, direction, optionCount) {
+    if (optionCount <= 0)
+        return 0;
+    return (currentIndex + direction + optionCount) % optionCount;
+}
+export function pauseBusyClock(state, nowMs) {
+    if (state.busySince === null || state.busyPausedAt !== null)
+        return state;
+    return { ...state, busyPausedAt: nowMs };
+}
+export function resumeBusyClock(state, nowMs) {
+    if (state.busyPausedAt === null)
+        return state;
+    return {
+        ...state,
+        busyPausedAt: null,
+        busySince: state.busySince === null
+            ? null
+            : state.busySince + Math.max(0, nowMs - state.busyPausedAt),
+    };
+}
+export function busyElapsedMs(state, nowMs) {
+    if (state.busySince === null)
+        return null;
+    return Math.max(0, (state.busyPausedAt ?? nowMs) - state.busySince);
+}
+export function busyElapsedSeconds(state, nowMs) {
+    return Math.floor((busyElapsedMs(state, nowMs) ?? 0) / 1000);
 }
 export function buildModelPickerOptions(currentModelId, serverModels) {
     return serverModels.map((model) => ({
         id: model.id,
         label: model.label,
-        meta: model.id === currentModelId ? 'current' : '',
+        publicId: model.id,
+        costRating: model.costRating,
+        current: model.id === currentModelId,
+        disabled: false,
+        note: model.description,
     }));
 }
 function getDefaultModelPickerIndex(currentModelId, serverModels) {
@@ -1266,21 +1331,19 @@ function appendCommandLog(state, text) {
     };
 }
 async function saveSessionBoth({ serverSessionClient, session, }) {
+    if (!sessionHasUserMessage(session))
+        return;
     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.');
+    if (process.stdin.isTTY !== true) {
+        throw new Error('stdin is not a terminal');
+    }
+    if (process.stdout.isTTY !== true) {
+        throw new Error('stdout is not a terminal');
     }
+    let fatalError = null;
     await withTuiMode(async () => {
         setBackgroundJobSession(session.sessionId);
         setScratchSession(session.sessionId);
@@ -1290,11 +1353,13 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
         let currentServerModels = serverModels;
         let sessionAutoYes = session.autoYes;
         let resolveDone = null;
-        let resolveApprovalChoice = null;
+        let resolvePermissionDecision = null;
         let resolveSudoPassword = null;
+        let pendingUserInput = null;
         let cleanupSudoPasswordPrompt = null;
         let sudoPasswordBuffer = '';
         const bridge = createRatatuiBridge();
+        captureTerminalWrites();
         const { handleShellKeyEvent } = await import('./tui/shell-input.js');
         let terminalCols = 80;
         let terminalRows = 24;
@@ -1307,6 +1372,10 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
         let latestUsageSummary = null;
         let pendingTurnEntries = [];
         let activeTurnAbort = null;
+        let activeServerTurnId = null;
+        let unacknowledged = new Map();
+        const blockedRows = new WeakMap();
+        let newConversationInFlight = false;
         let todosTouchedThisTurn = false;
         const syncTodosState = () => {
             store.update((current) => ({ ...current, todos: listTodos() }));
@@ -1315,6 +1384,36 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
         let exitCtrlCArmed = false;
         let exitCtrlCTimer = null;
         let transientStatusTimer = null;
+        const THINKING_MIN_DWELL_MS = 3_000;
+        let thinkingAppliedAt = 0;
+        let pendingThinking = null;
+        const applyThinking = (next) => {
+            thinkingAppliedAt = Date.now();
+            pendingThinking = null;
+            store.update((current) => ({
+                ...current,
+                thinkingTitle: next.title || holdOrPickFallback(current.thinkingTitle),
+                thinkingNotes: next.notes,
+            }));
+        };
+        const queueThinkingUpdate = (next) => {
+            if (Date.now() - thinkingAppliedAt >= THINKING_MIN_DWELL_MS) {
+                applyThinking(next);
+                return;
+            }
+            pendingThinking = next;
+        };
+        const flushPendingThinking = () => {
+            if (!pendingThinking)
+                return;
+            if (Date.now() - thinkingAppliedAt < THINKING_MIN_DWELL_MS)
+                return;
+            applyThinking(pendingThinking);
+        };
+        const resetThinkingPacer = () => {
+            thinkingAppliedAt = 0;
+            pendingThinking = null;
+        };
         const done = new Promise((resolve) => {
             resolveDone = resolve;
         });
@@ -1339,7 +1438,9 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 store.update((current) => current.status === status ? { ...current, status: 'Ready' } : current);
             }, 2500);
         };
-        const terminalTitle = createTerminalTitleController();
+        const terminalTitle = createTerminalTitleController({
+            write: (title) => bridge.setTitle(title),
+        });
         const syncTerminalTitle = () => {
             const state = store.getState();
             terminalTitle.sync({
@@ -1352,9 +1453,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 return;
             const state = store.getState();
             syncTerminalTitle();
-            const elapsedSeconds = state.busySince
-                ? Math.max(0, Math.floor((Date.now() - state.busySince) / 1000))
-                : 0;
+            const elapsedSeconds = busyElapsedSeconds(state, Date.now());
             bridge.render(buildTuiFrame(state, terminalCols, terminalRows, spinnerFrame, elapsedSeconds, Date.now()));
         };
         const remountTui = async () => {
@@ -1480,15 +1579,16 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             }
         };
         const dismissPendingApproval = () => {
-            if (!resolveApprovalChoice)
+            if (!resolvePermissionDecision)
                 return;
-            const pendingResolve = resolveApprovalChoice;
-            resolveApprovalChoice = null;
-            pendingResolve('n');
+            const pendingResolve = resolvePermissionDecision;
+            resolvePermissionDecision = null;
+            pendingResolve({ kind: 'deny' });
             store.update((current) => ({
-                ...current,
-                approvalCursor: getDefaultApprovalCursor(),
+                ...resumeBusyClock(current, Date.now()),
+                approvalCursor: 0,
                 approvalPrompt: null,
+                approvalScrollOffset: 0,
             }));
         };
         const dismissPendingSudoPassword = () => {
@@ -1501,17 +1601,34 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             sudoPasswordBuffer = '';
             pendingResolve(null);
             store.update((current) => ({
-                ...current,
+                ...resumeBusyClock(current, Date.now()),
                 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)
+            if (!store.getState().busy || newConversationInFlight)
                 return;
             disarmExitConfirm();
             dismissPendingApproval();
             dismissPendingSudoPassword();
+            dismissPendingUserInput();
             activeTurnGeneration += 1;
+            resetThinkingPacer();
             activeTurnAbort?.abort();
             activeTurnAbort = null;
             cancelActiveCommand();
@@ -1529,6 +1646,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 activeTurnInput: '',
                 activeTurnInputPreformatted: false,
                 busy: false,
+                busyPausedAt: null,
                 busySince: null,
                 commandLog: [],
                 cursor: queued ? queued.body.length : current.cursor,
@@ -1541,8 +1659,9 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 status: 'Ready',
                 thinkingTitle: '',
                 thinkingNotes: [],
+                turnMessages: [],
                 workingTools: [],
-                tokenUsage: formatClientTokenUsage(current.busySince == null ? null : Date.now() - current.busySince, latestUsageSummary),
+                tokenUsage: formatClientTokenUsage(busyElapsedMs(current, Date.now()), latestUsageSummary),
             }));
             appendStaticEntries(cancelledEntries);
             lastTurnStartedAt = null;
@@ -1550,14 +1669,6 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 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,
@@ -1636,6 +1747,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             }
             dismissPendingApproval();
             dismissPendingSudoPassword();
+            dismissPendingUserInput();
             exiting = true;
             killAllBackgroundJobs();
             store.update((current) => ({
@@ -1645,9 +1757,45 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 status: 'Exiting...',
             }));
             void bridge.close().then(() => {
+                releaseTerminalWrites();
                 resolveDone?.();
             });
         };
+        const exitForAuthenticationError = (error) => {
+            if (!isAuthenticationError(error))
+                return false;
+            clearCliAuthConfig(session.env);
+            if (sessionHasUserMessage(session)) {
+                saveSessionState(session);
+            }
+            fatalError = new Error(authenticationErrorMessage(error));
+            requestExit();
+            return true;
+        };
+        const saveActiveSession = async () => {
+            try {
+                await saveSessionBoth({ serverSessionClient, session });
+                return true;
+            }
+            catch (error) {
+                if (exitForAuthenticationError(error))
+                    return false;
+                appendError(`Session save failed: ${error.message}`);
+                return true;
+            }
+        };
+        const saveActiveSessionOrAbort = async () => {
+            try {
+                await saveSessionBoth({ serverSessionClient, session });
+                return true;
+            }
+            catch (error) {
+                if (exitForAuthenticationError(error))
+                    return false;
+                appendError(`Session save failed: ${error.message}`);
+                return false;
+            }
+        };
         const openSudoPasswordPrompt = (command, prompt, signal) => new Promise((resolve) => {
             if (exiting || signal?.aborted) {
                 resolve(null);
@@ -1665,7 +1813,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 cleanupSudoPasswordPrompt = null;
             }
             store.update((current) => ({
-                ...current,
+                ...pauseBusyClock(current, Date.now()),
                 sudoPrompt: {
                     command,
                     passwordLength: 0,
@@ -1685,7 +1833,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 cleanupSudoPasswordPrompt = null;
                 sudoPasswordBuffer = '';
                 store.update((current) => ({
-                    ...current,
+                    ...resumeBusyClock(current, Date.now()),
                     sudoPrompt: null,
                     status: current.sudoPrompt?.returnStatus ?? current.status,
                 }));
@@ -1699,7 +1847,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 cleanupSudoPasswordPrompt = null;
                 sudoPasswordBuffer = '';
                 store.update((current) => ({
-                    ...current,
+                    ...resumeBusyClock(current, Date.now()),
                     sudoPrompt: null,
                     status: current.sudoPrompt?.returnStatus ?? current.status,
                 }));
@@ -1719,38 +1867,88 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                     : null,
             }));
         };
-        const openApprovalPrompt = (title, body, options = {}) => new Promise((resolve) => {
+        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 = (request) => new Promise((resolve) => {
+            const deny = { kind: 'deny' };
             if (exiting) {
-                resolve('n');
+                resolve(deny);
                 return;
             }
-            resolveApprovalChoice = resolve;
+            resolvePermissionDecision = resolve;
             store.update((current) => ({
-                ...current,
-                approvalCursor: getDefaultApprovalCursor(),
+                ...pauseBusyClock(current, Date.now()),
+                approvalCursor: getDefaultApprovalCursor(request.options.length),
+                approvalOpenedAt: Date.now(),
+                approvalScrollOffset: 0,
                 approvalPrompt: {
-                    title,
-                    body,
-                    diffPreview: options.diff && options.filePath
-                        ? parseDiffPreview(options.diff)
+                    title: request.title,
+                    body: request.body,
+                    diffPreview: request.diff && request.filePath
+                        ? parseDiffPreview(request.diff)
                         : undefined,
-                    filePath: options.filePath,
+                    filePath: request.filePath,
+                    options: request.options,
                     returnStatus: current.status,
                 },
-                status: title,
+                status: request.title,
             }));
         });
-        const handleInlineApprovalChoice = async (choice) => {
+        const handleInlineApprovalChoice = async (index) => {
             const current = store.getState();
-            const pendingResolve = resolveApprovalChoice;
-            resolveApprovalChoice = null;
+            const options = current.approvalPrompt?.options ?? [];
+            const chosen = options[index]?.decision ?? { kind: 'deny' };
+            const pendingResolve = resolvePermissionDecision;
+            resolvePermissionDecision = null;
             store.update((next) => ({
-                ...next,
-                approvalCursor: getDefaultApprovalCursor(),
+                ...resumeBusyClock(next, Date.now()),
+                approvalCursor: getDefaultApprovalCursor(options.length),
                 approvalPrompt: null,
+                approvalScrollOffset: 0,
                 status: current.approvalPrompt?.returnStatus ?? next.status,
             }));
-            pendingResolve?.(choice);
+            pendingResolve?.(chosen);
         };
         const refreshServerModels = async () => {
             currentServerModels = await models.fetchServerModels({ config: authConfig });
@@ -1784,7 +1982,8 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 selectedModelId: selected,
                 serverModels: fresh,
             });
-            await saveActiveSession();
+            if (!(await saveActiveSession()))
+                return;
             syncShellStateFromSession();
             appendStaticEntry({
                 body: `Switched to ${formatModelLabel(selected, fresh.models)}. Conversation history preserved.`,
@@ -1903,6 +2102,8 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 await switchToModel(selected.id);
             }
             catch (error) {
+                if (exitForAuthenticationError(error))
+                    return;
                 appendError(error.message);
             }
         };
@@ -1952,6 +2153,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             store.update((next) => ({
                 ...next,
                 busy: true,
+                busyPausedAt: null,
                 busySince: resumeStartedAt,
                 clockNow: resumeStartedAt,
                 status: 'Loading session...',
@@ -1964,11 +2166,11 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 syncBackgroundJobsState();
                 setTodoSession(session.sessionId);
                 syncTodosState();
-                await saveActiveSession();
                 syncShellStateFromSession();
                 store.update((next) => ({
                     ...next,
                     busy: false,
+                    busyPausedAt: null,
                     busySince: null,
                     resumePickerFilter: '',
                     resumePickerIndex: 0,
@@ -1987,9 +2189,12 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 await remountTui();
             }
             catch (error) {
+                if (exitForAuthenticationError(error))
+                    return;
                 store.update((next) => ({
                     ...next,
                     busy: false,
+                    busyPausedAt: null,
                     busySince: null,
                     resumePickerFilter: '',
                     resumePickerIndex: 0,
@@ -2013,6 +2218,129 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             }));
             await handleSubmit(queued.body);
         };
+        let turnMessageCounter = 0;
+        const upsertTurnMessage = (id, patch) => {
+            store.update((current) => ({
+                ...current,
+                turnMessages: current.turnMessages.map((message) => message.id === id ? { ...message, ...patch } : message),
+            }));
+        };
+        const recoverUnacknowledgedMessages = (autoSubmits = true) => {
+            if (unacknowledged.size === 0)
+                return;
+            const stranded = [...unacknowledged.values()];
+            unacknowledged = new Map();
+            for (const { row } of stranded) {
+                upsertTurnMessage(row, {
+                    state: 'queued',
+                    note: autoSubmits
+                        ? 'not read — sending as the next prompt'
+                        : 'not read — left in the composer',
+                });
+            }
+            const existing = store.getState().queuedMessage;
+            const combined = [
+                ...stranded.map((entry) => entry.queued),
+                ...(existing ? [existing] : []),
+            ];
+            const body = combined
+                .map((entry) => entry.body)
+                .filter((entry) => entry.trim())
+                .join('\n\n');
+            if (!body.trim())
+                return;
+            scheduleLiveFrameRemount();
+            store.update((current) => ({
+                ...current,
+                queuedMessage: {
+                    body,
+                    imageAttachments: combined.flatMap((entry) => entry.imageAttachments),
+                    pastedChunks: combined.flatMap((entry) => entry.pastedChunks),
+                },
+            }));
+        };
+        const fireQueuedMessage = async () => {
+            const state = store.getState();
+            const queued = state.queuedMessage;
+            if (!queued || !state.busy || exiting)
+                return;
+            const text = (queued.pastedChunks.length
+                ? expandPastedChunks(queued.body, queued.pastedChunks)
+                : queued.body).trim();
+            if (!text)
+                return;
+            const turnId = activeServerTurnId;
+            const blockedReason = queued.imageAttachments.length > 0
+                ? 'waiting — images go with the next prompt'
+                : !turnId
+                    ? 'waiting for the turn to end'
+                    : null;
+            const existingRow = blockedRows.get(queued);
+            if (existingRow !== undefined) {
+                upsertTurnMessage(existingRow, {
+                    state: 'queued',
+                    ...(blockedReason ? { note: blockedReason } : {}),
+                });
+                if (blockedReason || !turnId)
+                    return;
+            }
+            const id = existingRow ?? ++turnMessageCounter;
+            const messageId = `m${id}_${Date.now().toString(36)}`;
+            if (existingRow === undefined) {
+                scheduleLiveFrameRemount();
+                store.update((current) => ({
+                    ...current,
+                    turnMessages: [
+                        ...current.turnMessages,
+                        {
+                            id,
+                            text,
+                            state: blockedReason ? 'queued' : 'sending',
+                            ...(blockedReason ? { note: blockedReason } : {}),
+                        },
+                    ],
+                }));
+            }
+            if (blockedReason || !turnId) {
+                blockedRows.set(queued, id);
+                return;
+            }
+            blockedRows.delete(queued);
+            unacknowledged.set(messageId, { row: id, queued });
+            scheduleLiveFrameRemount();
+            store.update((current) => current.queuedMessage === queued
+                ? { ...current, queuedMessage: null }
+                : current);
+            queueTurnEntry({
+                body: text,
+                kind: 'user',
+                preformatted: queued.pastedChunks.length > 0,
+                title: 'You · sent mid-turn',
+            });
+            const rollback = (note) => {
+                if (!unacknowledged.delete(messageId))
+                    return;
+                upsertTurnMessage(id, { state: 'queued', note });
+                scheduleLiveFrameRemount();
+                store.update((current) => current.queuedMessage ? current : { ...current, queuedMessage: queued });
+            };
+            let outcome;
+            try {
+                outcome = await chat.postInterjection({
+                    config: authConfig,
+                    turnId,
+                    text,
+                    messageId,
+                });
+            }
+            catch (error) {
+                rollback(`not sent — ${error?.message ?? 'request failed'}`);
+                return;
+            }
+            if (outcome === 'stale') {
+                rollback('turn ended — sending as the next prompt');
+            }
+        };
         const handleSubmit = async (rawInput) => {
             const chunks = store.getState().pastedChunks;
             const expanded = chunks.length
@@ -2139,14 +2467,18 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                     });
                 }
                 catch (error) {
+                    if (exitForAuthenticationError(error))
+                        return;
                     appendError(error.message);
                 }
                 finally {
-                    store.update((current) => ({
-                        ...current,
-                        busy: false,
-                        status: 'Ready',
-                    }));
+                    if (!exiting) {
+                        store.update((current) => ({
+                            ...current,
+                            busy: false,
+                            status: 'Ready',
+                        }));
+                    }
                 }
                 return;
             }
@@ -2160,14 +2492,18 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                     await openResumePicker();
                 }
                 catch (error) {
+                    if (exitForAuthenticationError(error))
+                        return;
                     appendError(error.message);
                 }
                 finally {
-                    store.update((current) => ({
-                        ...current,
-                        busy: false,
-                        status: current.resumePickerOpen ? 'Select a session to resume' : 'Ready',
-                    }));
+                    if (!exiting) {
+                        store.update((current) => ({
+                            ...current,
+                            busy: false,
+                            status: current.resumePickerOpen ? 'Select a session to resume' : 'Ready',
+                        }));
+                    }
                 }
                 return;
             }
@@ -2187,43 +2523,84 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                     }
                 }
                 catch (error) {
+                    if (exitForAuthenticationError(error))
+                        return;
                     appendError(error.message);
                 }
                 finally {
+                    if (!exiting) {
+                        store.update((current) => ({
+                            ...current,
+                            busy: false,
+                            status: current.modelPickerOpen ? 'Select a model' : 'Ready',
+                        }));
+                    }
+                }
+                return;
+            }
+            if (input === '/new') {
+                newConversationInFlight = true;
+                store.update((current) => ({
+                    ...current,
+                    busy: true,
+                    busyPausedAt: null,
+                    busySince: Date.now(),
+                    imageAttachments: [],
+                    queuedMessage: null,
+                    status: 'Starting a new conversation...',
+                }));
+                if (!(await saveActiveSessionOrAbort())) {
+                    newConversationInFlight = false;
                     store.update((current) => ({
                         ...current,
                         busy: false,
-                        status: current.modelPickerOpen ? 'Select a model' : 'Ready',
+                        busyPausedAt: null,
+                        busySince: null,
+                        status: 'Ready',
                     }));
+                    await flushQueuedMessage();
+                    return;
                 }
-                return;
-            }
-            if (input === '/clear') {
-                clearConversation(session);
+                startNewConversation(session);
+                setBackgroundJobSession(session.sessionId);
+                setScratchSession(session.sessionId);
+                setTodoSession(session.sessionId);
                 clearTodos();
+                syncBackgroundJobsState();
                 syncTodosState();
                 latestUsageSummary = null;
-                await saveActiveSession();
                 store.replaceTranscript([
                     {
-                        body: 'Conversation cleared.',
+                        body: 'Started a new conversation. The previous session remains saved.',
                         kind: 'system',
-                        title: 'System',
+                        title: 'Session',
                     },
                 ]);
+                await saveActiveSession();
                 syncShellStateFromSession();
-                store.update((current) => ({ ...current, queuedMessage: null }));
+                newConversationInFlight = false;
+                store.update((current) => ({
+                    ...current,
+                    busy: false,
+                    busyPausedAt: null,
+                    busySince: null,
+                    status: 'Ready',
+                }));
                 await remountTui();
+                await flushQueuedMessage();
                 return;
             }
             latestUsageSummary = null;
             disarmExitConfirm();
+            unacknowledged = new Map();
             const turnStartedAt = Date.now();
             const turnGeneration = ++activeTurnGeneration;
             const turnAbort = new AbortController();
             activeTurnAbort = turnAbort;
             lastTurnStartedAt = turnStartedAt;
             todosTouchedThisTurn = false;
+            clearTodos();
+            syncTodosState();
             const userEntry = {
                 body: input,
                 kind: 'user',
@@ -2232,11 +2609,14 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             };
             pendingTurnEntries = [];
             queueTurnEntry(userEntry);
+            resetThinkingPacer();
             store.update((current) => ({
                 ...current,
                 activeTurnInput: input,
                 activeTurnInputPreformatted: preformatted,
+                analyzingImages: 0,
                 busy: true,
+                busyPausedAt: null,
                 busySince: turnStartedAt,
                 clockNow: turnStartedAt,
                 status: 'Running turn...',
@@ -2245,6 +2625,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 transcriptScrollOffset: 0,
                 tokenUsage: formatClientTokenUsage(0, latestUsageSummary),
                 turnCounter: current.turnCounter + 1,
+                turnMessages: [],
                 workingTools: [],
             }));
             try {
@@ -2255,12 +2636,32 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                     input,
                     imageAttachments,
                     signal: turnAbort.signal,
+                    onTurnStart: (serverTurnId) => {
+                        if (turnGeneration !== activeTurnGeneration)
+                            return;
+                        activeServerTurnId = serverTurnId;
+                    },
+                    onInterjectionDelivered: (event) => {
+                        if (turnGeneration !== activeTurnGeneration)
+                            return;
+                        for (const messageId of event.messageIds ?? []) {
+                            const pending = unacknowledged.get(messageId);
+                            if (!pending)
+                                continue;
+                            unacknowledged.delete(messageId);
+                            upsertTurnMessage(pending.row, {
+                                state: 'delivered',
+                                note: undefined,
+                            });
+                        }
+                    },
                 });
                 if (turnGeneration !== activeTurnGeneration)
                     return;
                 latestUsageSummary = result.usageSummary ?? null;
                 const turnEntries = takePendingTurnEntries();
-                await saveActiveSession();
+                if (!(await saveActiveSession()))
+                    return;
                 syncShellStateFromSession();
                 store.update((current) => ({
                     ...current,
@@ -2297,10 +2698,12 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 store.update((current) => ({
                     ...current,
                     busy: false,
+                    busyPausedAt: null,
                     busySince: null,
                     status: result.waitingForApproval ? 'Awaiting approval' : 'Ready',
                     tokenUsage: formatClientTokenUsage(Date.now() - turnStartedAt, latestUsageSummary),
                 }));
+                recoverUnacknowledgedMessages();
                 await flushQueuedMessage();
             }
             catch (error) {
@@ -2311,11 +2714,14 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                     return;
                 }
                 const cancelled = isTurnCancelledError(error);
+                if (exitForAuthenticationError(error))
+                    return;
                 store.update((current) => ({
                     ...current,
                     activeTurnInput: '',
                     activeTurnInputPreformatted: false,
                     busy: false,
+                    busyPausedAt: null,
                     busySince: null,
                     commandLog: [],
                     imageAttachments: [],
@@ -2335,13 +2741,15 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                             title: 'System',
                         },
                     ]);
-                    await saveActiveSession();
+                    if (!(await saveActiveSession()))
+                        return;
                 }
                 else {
                     appendStaticEntries(turnEntries);
                     appendError(error.message);
                 }
                 await remountTui();
+                recoverUnacknowledgedMessages(!cancelled);
                 if (!cancelled && turnGeneration === activeTurnGeneration) {
                     await flushQueuedMessage();
                 }
@@ -2352,24 +2760,34 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 }
                 if (turnGeneration === activeTurnGeneration) {
                     lastTurnStartedAt = null;
+                    activeServerTurnId = null;
                 }
+                recoverUnacknowledgedMessages();
             }
         };
+        session.onImageAnalysis = (activeImageCount) => {
+            store.update((current) => ({
+                ...current,
+                analyzingImages: Math.max(0, activeImageCount),
+            }));
+        };
         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),
+                tokenUsage: formatClientTokenUsage(busyElapsedMs(current, Date.now()), latestUsageSummary),
             }));
+            queueThinkingUpdate({
+                title: panel ? panel.title : liveStatusPanelTitle(message),
+                notes: panel ? panel.notes : [],
+            });
         };
         session.onContextLog = (message) => {
             store.update((current) => ({
                 ...current,
                 contextStatus: message,
-                tokenUsage: formatClientTokenUsage(current.busySince == null ? null : Date.now() - current.busySince, latestUsageSummary),
+                tokenUsage: formatClientTokenUsage(busyElapsedMs(current, Date.now()), latestUsageSummary),
             }));
         };
         session.onToolEvent = (event) => {
@@ -2438,51 +2856,45 @@ 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.confirmCommand = async (command) => {
+        session.requestUserInput = async (request, signal) => openUserInputPrompt(request.questions, signal);
+        session.requestPermission = async (request) => {
+            const deny = { kind: 'deny' };
             if (exiting)
-                return false;
+                return deny;
             if (sessionAutoYes)
-                return true;
-            const choice = await openApprovalPrompt('Approve command?', command);
-            if (choice === 'a') {
-                setAgentMode('auto-accept');
-                syncShellStateFromSession();
+                return { kind: 'once' };
+            const decision = await openApprovalPrompt(request);
+            if (decision.kind === 'always-bucket') {
                 appendTurnAwareEntry({
-                    body: 'Auto-approve enabled for the rest of this session.',
+                    body: `Allowed for the rest of this session: ${bucketActionLabel(request.bucket)}.`,
                     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();
+            else if (decision.kind === 'always-prefix') {
                 appendTurnAwareEntry({
-                    body: 'Auto-approve enabled for the rest of this session.',
+                    body: `Allowed for the rest of this session: commands starting with \`${decision.prefix}\`.`,
                     kind: 'system',
                     title: 'Approvals',
                 });
-                return true;
             }
-            return choice === 'y';
+            return decision;
         };
         const shellInputHandlers = {
+            getApprovalScrollLimit: () => {
+                const contentWidth = Math.max(20, Math.floor(terminalCols * 0.95) - 2);
+                return approvalScrollLimit(store.getState().approvalPrompt, contentWidth, terminalRows);
+            },
             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);
             },
+            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,
@@ -2491,6 +2903,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             onLiveFrameShapeChange: scheduleLiveFrameRemount,
             onRequestExit: requestExit,
             onResolveApproval: handleInlineApprovalChoice,
+            onResolveUserInput: handleInlineUserInput,
             onResumeSession: handleInlineResumeSelection,
             onSelectionCopy: handleAppSelectionCopy,
             onSelectModel: handleInlineModelSelection,
@@ -2498,6 +2911,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             onJobsPickerKill: handleJobsPickerKill,
             onSudoPasswordInput: handleSudoPasswordInput,
             onSubmit: handleSubmit,
+            onFireQueuedMessage: fireQueuedMessage,
         };
         const unsubscribe = store.subscribe(() => {
             renderCurrentFrame();
@@ -2505,6 +2919,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
         const spinnerTimer = setInterval(() => {
             spinnerFrame = (spinnerFrame + 1) % 6;
             if (store.getState().busy) {
+                flushPendingThinking();
                 renderCurrentFrame();
             }
         }, 120);
@@ -2563,7 +2978,10 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             setTodoSession(null);
             setBackgroundJobUpdateHook(null);
             await bridge.close();
+            releaseTerminalWrites();
             setCommandOutputHook(null);
         }
     });
+    if (fatalError)
+        throw fatalError;
 }