@thegitai/cli 1.0.0-preview.5 → 1.0.0-preview.51

package/dist/src/ui/repl.js

@@ -1,20 +1,33 @@
+import { basename } from 'node:path';
 import { createRatatuiBridge } from './tui/bridge.js';
-import { buildTuiFrame, formatJobElapsed, formatTodoProgress, renderTranscriptEntryLines, } from './tui/build-frame.js';
+import { bucketActionLabel, } from '../permissions.js';
+import { AGENT_MODE_LOCKED_STATUS, approvalScrollLimit, buildTuiFrame, formatJobElapsed, formatTodoProgress, pickThinkingFallbackPhrase, renderTranscriptEntryLines, THINKING_FALLBACK_PHRASES, userInputViewportForFrame, } from './tui/build-frame.js';
+import { createAttentionController, INITIAL_TERMINAL_FOCUS, } from './tui/attention.js';
+import { backendFor, createNotificationQueue, } from './tui/desktop-notification.js';
+import { readPreferences, writePreferences } from '../preferences.js';
 import { createTerminalTitleController } from './tui/terminal-title.js';
 import { captureTerminalWrites, releaseTerminalWrites, } from './tui/terminal-writes.js';
-export { getSlashCommandSuggestions } from './tui/build-frame.js';
+import { getInputCommandToken, getSlashCommandSuggestions, SLASH_COMMANDS, slashCommandMatchesToken, } from './slash-commands.js';
+export { getInputCommandToken, getSlashCommandSuggestions, SLASH_COMMANDS, slashCommandMatchesToken, };
+import { composerInputWidth, frameContentWidth } from './tui/composer-layout.js';
 import { agentModeLabel, nextAgentMode, } from '../agent-mode.js';
 import { chat, models } from '../api/index.js';
-import { isTurnCancelledError } from '../api/chat.js';
+import { isTurnCancelledError, isTurnOutcomeKnown } from '../api/chat.js';
+import { formatTurnRecoveryStatus } from '../api/turn-recovery.js';
 import { getJobBufferedOutput, getJobOutputPreview, hasRunningBackgroundJobs, killAllBackgroundJobs, killBackgroundJob, listBackgroundJobs, setBackgroundJobSession, setBackgroundJobUpdateHook, } from '../background-jobs.js';
 import { clearTodos, listTodos, setTodoSession } from '../todo-list.js';
 import { setScratchSession } from '../scratch-dir.js';
+import { setImageStoreSession } from '../core/session-image-store.js';
 import { cancelActiveCommand } from '../executor.js';
 import { isTurnFailureMarker } from '../turn-failure-marker.js';
+import { clearCliAuthConfig, logoutFromServer, } from '../api/auth.js';
+import { authenticationErrorMessage, isAuthenticationError, } from '../api/http.js';
+import { buildQuotaNotice } from '../quota-notice.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';
@@ -70,58 +83,46 @@ const TRANSCRIPT_DIFF_PREVIEW_LINES = 24;
 const WORKING_TOOL_PREVIEW_ITEMS = 4;
 const THINKING_NOTE_PREVIEW_ROWS = 3;
 const WORKING_TOOL_PREVIEW_ROWS = 3;
-const AGENT_MODE_LABEL_WIDTH = 16;
-const APPROVAL_OPTIONS = [
-    {
-        value: 'y',
-        label: 'Approve once',
-        description: 'Run this action only this time',
-    },
-    {
-        value: 'a',
-        label: 'Approve all remaining actions',
-        description: 'Turn on auto-approve for the rest of the session',
-    },
-    {
-        value: 'n',
-        label: 'Deny',
-        description: 'Reject this action',
-    },
-];
-export const SLASH_COMMANDS = [
-    {
-        command: '/help',
-        description: 'Show available chat commands',
-    },
-    {
-        command: '/about',
-        description: 'Show version and platform info',
-    },
-    {
-        command: '/usage',
-        description: 'Show account usage percentage and reset times',
-    },
-    {
-        command: '/model',
-        description: 'Switch the active model',
-    },
-    {
-        command: '/resume',
-        description: 'Open the session picker',
-    },
-    {
-        command: '/jobs',
-        description: 'Background jobs: pick to view output or kill',
-    },
-    {
-        command: '/clear',
-        description: 'Clear conversation history',
-    },
-    {
-        command: '/exit',
-        description: 'Quit the current session',
-    },
-];
+export const REPORT_ISSUE_URL = 'https://thegit.ai/report';
+export function buildReportTranscriptEntries(openedUrl) {
+    return openedUrl
+        ? [
+            {
+                body: `Opening the private bug report form in your browser. If nothing opened, visit:\n\n${REPORT_ISSUE_URL}\n`,
+                kind: 'system',
+                title: 'Report',
+            },
+        ]
+        : [
+            {
+                body: `Could not open a browser. Report the bug manually at:\n\n${REPORT_ISSUE_URL}\n`,
+                kind: 'error',
+                title: 'Report',
+            },
+        ];
+}
+export function buildTurnFailureHintEntries(cancelled) {
+    if (cancelled)
+        return [];
+    return [
+        {
+            body: 'Something went wrong? Use /report to submit the issue.',
+            kind: 'error',
+            title: 'Report',
+        },
+    ];
+}
+export function composerAttachmentsAfterCancel(queuedAttachments, inFlightAttachments) {
+    const seen = new Set();
+    const kept = [];
+    for (const attachment of [...queuedAttachments, ...inFlightAttachments]) {
+        if (seen.has(attachment.index))
+            continue;
+        seen.add(attachment.index);
+        kept.push(attachment);
+    }
+    return kept;
+}
 function getShellWidth(columns) {
     const safeColumns = Math.max(columns, 20);
     const targetWidth = Math.floor(safeColumns * TUI_WIDTH_RATIO);
@@ -490,11 +491,43 @@ function buildWriteFileDiff(content) {
         return '';
     return `@@ -0,0 +1,${lines.length} @@\n${lines.map((line) => `+${line}`).join('\n')}`;
 }
+const MAX_DELETE_PREVIEW_LINES = 400;
 function buildDeleteFileDiff(content) {
     const lines = splitDiffLines(String(content ?? ''));
-    if (lines.length === 0)
+    if (lines.length === 0) {
+        return { removed: 0, text: '' };
+    }
+    const shown = lines.slice(0, MAX_DELETE_PREVIEW_LINES);
+    const rows = [
+        `@@ -1,${lines.length} +0,0 @@`,
+        ...shown.map((line) => `-${line}`),
+    ];
+    const omitted = lines.length - shown.length;
+    if (omitted > 0) {
+        rows.push(`@@ ${omitted} more removed line(s) not shown @@`);
+    }
+    return { removed: lines.length, text: rows.join('\n') };
+}
+function deletedFileSummary(result) {
+    const bytes = typeof result?.bytes === 'number' ? result.bytes : null;
+    if (bytes === null) {
         return '';
-    return `@@ -1,${lines.length} +0,0 @@\n${lines.map((line) => `-${line}`).join('\n')}`;
+    }
+    const reason = result?.contentOmitted === 'binary' ? ', binary' : '';
+    return ` (${formatFileSize(bytes)}${reason})`;
+}
+function formatFileSize(bytes) {
+    if (bytes < 1024) {
+        return `${bytes} B`;
+    }
+    const units = ['KiB', 'MiB', 'GiB', 'TiB'];
+    let value = bytes / 1024;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit += 1;
+    }
+    return `${value >= 10 ? Math.round(value) : value.toFixed(1)} ${units[unit]}`;
 }
 function isFileChangeTool(name) {
     return (name === 'patch_file' ||
@@ -510,13 +543,7 @@ function getToolFilePath(call, result) {
         '').trim();
 }
 function formatToolResultState(result) {
-    if (result?.skipped)
-        return 'Skipped';
-    if (result?.blocked)
-        return 'Blocked';
-    if (result?.ok === true)
-        return 'OK';
-    return 'Failed';
+    return result?.skipped ? 'Skipped' : 'OK';
 }
 function formatRunCommandResultState(result) {
     if (result?.timedOut)
@@ -554,12 +581,15 @@ function buildFileChangeEntry(event) {
             : call.name === 'undo_edit'
                 ? 'Undo'
                 : 'Edit';
-        return {
-            body: error || `${call.name} ${filePath}`,
-            filePath,
-            kind: skipped ? 'system' : 'error',
-            title: skipped ? `${verb} skipped: ${filePath}` : `${verb} failed: ${filePath}`,
-        };
+        if (skipped) {
+            return {
+                body: error || `${call.name} ${filePath}`,
+                filePath,
+                kind: 'system',
+                title: `${verb} skipped: ${filePath}`,
+            };
+        }
+        return { body: '', filePath, kind: 'system', title: `${verb}: ${filePath}` };
     }
     if (result?.scratch === true) {
         const scratchName = truncate(filePath.split(/[\\/]/).filter(Boolean).at(-1) ?? filePath, 72);
@@ -620,9 +650,11 @@ function buildFileChangeEntry(event) {
             };
         }
         const content = typeof result?.content === 'string' ? result.content : '';
-        const diffText = buildDeleteFileDiff(content);
-        const preview = diffText ? parseDiffPreview(diffText) : undefined;
-        const summary = preview ? ` (+0 -${preview.removed})` : '';
+        const diff = buildDeleteFileDiff(content);
+        const preview = diff.text ? parseDiffPreview(diff.text) : undefined;
+        const summary = preview
+            ? ` (+0 -${diff.removed})`
+            : deletedFileSummary(result);
         return {
             body: '',
             diffPreview: preview,
@@ -672,24 +704,27 @@ function buildFileChangeEntry(event) {
         title: `Edited ${filePath}${summary}`,
     };
 }
-function buildWorkingToolEntry(event) {
+export function buildWorkingToolEntry(event) {
     const { call, result } = event;
-    const error = typeof result?.error === 'string' && result.error.trim()
+    const failed = result?.ok !== true && result?.skipped !== true;
+    const kind = result?.ok === true ? 'tool' : 'system';
+    const state = (text) => (failed ? '' : text);
+    const error = !failed && typeof result?.error === 'string' && result.error.trim()
         ? `\n${truncate(result.error.trim(), 180)}`
         : '';
     if (call.name === 'run_command') {
         const command = String(call.args?.command ?? result?.command ?? '').trim();
         if (result?.backgrounded === true && result?.jobId) {
             return {
-                body: `$ ${truncate(command, 180)}\nBackground job ${String(result.jobId)} started.${error}`,
-                kind: result?.ok === true ? 'tool' : 'error',
+                body: `$ ${truncate(command, 180)}${state(`\nBackground job ${String(result.jobId)} started.`)}${error}`,
+                kind,
                 preformatted: true,
                 title: 'Shell',
             };
         }
         return {
-            body: `$ ${truncate(command, 180)}\n${formatRunCommandResultState(result)}${error}`,
-            kind: result?.ok === true ? 'tool' : 'error',
+            body: `$ ${truncate(command, 180)}${state(`\n${formatRunCommandResultState(result)}`)}${error}`,
+            kind,
             title: 'Shell',
         };
     }
@@ -701,15 +736,15 @@ function buildWorkingToolEntry(event) {
             ? `${status}${exitCode != null ? ` (code ${exitCode})` : ''}`
             : formatToolResultState(result);
         return {
-            body: `${jobId || '(unknown job)'} · ${stateText}${error}`,
-            kind: result?.ok === true ? 'tool' : 'error',
+            body: `${jobId || '(unknown job)'}${state(` · ${stateText}`)}${error}`,
+            kind,
             title: call.name === 'shell_job_kill' ? 'Kill job' : 'Job output',
         };
     }
     if (call.name === 'run_node_script') {
         return {
-            body: `node --input-type=module <script via stdin>\n${formatRunCommandResultState(result)}${error}`,
-            kind: result?.ok === true ? 'tool' : 'error',
+            body: `node --input-type=module <script via stdin>${state(`\n${formatRunCommandResultState(result)}`)}${error}`,
+            kind,
             title: 'Node',
         };
     }
@@ -718,8 +753,8 @@ function buildWorkingToolEntry(event) {
     }
     const args = formatToolArgs(call, result);
     return {
-        body: `${call.name}${args ? ` ${args}` : ''} -> ${formatToolResultState(result)}${error}`,
-        kind: result?.ok === true ? 'tool' : 'error',
+        body: `${call.name}${args ? ` ${args}` : ''}${state(` -> ${formatToolResultState(result)}`)}${error}`,
+        kind,
         title: 'Tool',
     };
 }
@@ -785,10 +820,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;
@@ -798,6 +841,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;
@@ -814,10 +872,10 @@ export function buildTranscriptFromSessionHistory(history) {
             }
             if (!call || !isFileChangeTool(call.name))
                 continue;
-            entries.push(buildFileChangeEntry({
-                call,
-                result: functionResponse.response ?? {},
-            }));
+            const result = (functionResponse.response ?? {});
+            if (result.ok !== true && result.skipped !== true)
+                continue;
+            entries.push(buildFileChangeEntry({ call, result }));
         }
         if (entry.role === 'user' && entry.kind === 'turnStart') {
             const text = displayUserTextFromHistoryEntry(entry);
@@ -826,6 +884,13 @@ export 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)) {
@@ -854,6 +919,23 @@ function createSessionTranscript(session) {
     const transcript = buildTranscriptFromSessionHistory(session.history);
     return transcript.length ? transcript : createInitialTranscript();
 }
+export function isJobsPickerCommand(input) {
+    return String(input ?? '').trim() === '/jobs';
+}
+export function statusBehindJobsPicker(state) {
+    return state.jobsPickerOpen
+        ? (state.jobsPickerReturnStatus ?? 'Ready')
+        : state.status;
+}
+export function closedJobsPickerFields(state) {
+    if (!state.jobsPickerOpen)
+        return {};
+    return {
+        jobsPickerExpandedId: null,
+        jobsPickerOpen: false,
+        jobsPickerReturnStatus: null,
+    };
+}
 function createShellStore(initialState) {
     let state = initialState;
     let nextEntryId = 1;
@@ -961,11 +1043,15 @@ function createInitialShellState(session, serverModels, debugUi) {
         activeTurnInput: '',
         activeTurnInputPreformatted: false,
         agentMode: session.agentMode,
-        approvalCursor: getDefaultApprovalCursor(),
+        analyzingImages: 0,
+        generatingImage: false,
+        approvalCursor: 0,
         approvalPrompt: null,
+        approvalScrollOffset: 0,
         autoYes: session.autoYes,
         backgroundJobs: [],
         busy: false,
+        busyPausedAt: null,
         busySince: null,
         clockNow: Date.now(),
         commandCursor: 0,
@@ -976,11 +1062,15 @@ function createInitialShellState(session, serverModels, debugUi) {
         exiting: false,
         input: '',
         maxToolSteps: session.maxToolSteps,
+        notificationsEnabled: readPreferences(session.env).notifications,
+        terminalFocused: INITIAL_TERMINAL_FOCUS,
         jobsPickerExpandedId: null,
         jobsPickerIndex: 0,
         jobsPickerOpen: false,
         modelPickerIndex: getDefaultModelPickerIndex(session.modelId, serverModels.models),
         modelPickerOpen: false,
+        shortcutsOpen: false,
+        transientStatus: null,
         projectRoot: session.rootDir,
         sessionId: session.sessionId,
         showSessionId: debugUi.showSessionId,
@@ -993,6 +1083,7 @@ function createInitialShellState(session, serverModels, debugUi) {
         resumePickerSessions: [],
         transcriptScrollOffset: 0,
         queuedMessage: null,
+        turnMessages: [],
         serverModels: serverModels.models,
         sudoPrompt: null,
         status: 'Ready',
@@ -1003,6 +1094,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: [],
@@ -1019,7 +1111,6 @@ export function formatClientTokenUsage(_responseTimeMs, usageSummary = null) {
     const reasoningTokens = usageSummary?.reasoningTokens ?? 0;
     const cacheTokens = usageSummary?.cacheTokens ?? 0;
     const cacheWriteTokens = usageSummary?.cacheWriteTokens ?? 0;
-    const indexTokens = usageSummary?.indexTokens ?? 0;
     return [
         'Session tokens',
         `in ${formatTokenCount(inputTokens)}`,
@@ -1027,7 +1118,6 @@ export function formatClientTokenUsage(_responseTimeMs, usageSummary = null) {
         ...(reasoningTokens > 0 ? [`think ${formatTokenCount(reasoningTokens)}`] : []),
         `cache ${formatTokenCount(cacheTokens)}`,
         `write ${formatTokenCount(cacheWriteTokens)}`,
-        `index ${formatTokenCount(indexTokens)}`,
     ].join(' • ');
 }
 export function formatPromptDirectoryLabel(projectRoot, homeDir = process.env.HOME ?? '') {
@@ -1070,6 +1160,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)
@@ -1093,7 +1201,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.';
@@ -1101,16 +1209,6 @@ export const EXIT_CTRL_C_CONFIRM_MS = 3000;
 export function isExitConfirmActive(exitConfirmUntil, now = Date.now()) {
     return exitConfirmUntil != null && now < exitConfirmUntil;
 }
-export function getInputCommandToken(input) {
-    const trimmed = String(input ?? '').trim();
-    if (!trimmed.startsWith('/'))
-        return '';
-    const firstSpaceIndex = trimmed.indexOf(' ');
-    const token = firstSpaceIndex === -1 ? trimmed : trimmed.slice(0, firstSpaceIndex);
-    if (token.indexOf('/', 1) !== -1)
-        return '';
-    return token;
-}
 function shouldShowCommandPalette(state) {
     const trimmed = String(state.input ?? '').trim();
     return (!state.busy &&
@@ -1118,8 +1216,9 @@ function shouldShowCommandPalette(state) {
         !state.modelPickerOpen &&
         !state.resumePickerOpen &&
         trimmed.startsWith('/') &&
-        !trimmed.includes(' ') &&
-        getInputCommandToken(trimmed) !== '');
+        !String(state.input ?? '').includes(' ') &&
+        getInputCommandToken(trimmed) !== '' &&
+        getSlashCommandSuggestions(trimmed).length > 0);
 }
 export function shouldRemountLiveFrameForComposerInputChange(current, nextInput) {
     const currentShowsCommands = shouldShowCommandPalette(current);
@@ -1142,9 +1241,6 @@ export function applySlashCommandSuggestion(currentInput, suggestion) {
         input: `${before}${suggestion.command}${after}`,
     };
 }
-export function isExactSlashCommandToken(token) {
-    return SLASH_COMMANDS.some((command) => command.command === token);
-}
 export function insertAtCursor(state, text) {
     const before = state.input.slice(0, state.cursor);
     const after = state.input.slice(state.cursor);
@@ -1223,26 +1319,37 @@ 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) => ({
@@ -1280,27 +1387,33 @@ function appendCommandLog(state, text) {
     };
 }
 async function saveSessionBoth({ serverSessionClient, session, }) {
+    if (!sessionHasUserMessage(session))
+        return;
     saveSessionState(session);
     await serverSessionClient.save(session);
 }
-export async function runClientInteractive({ appendPromptHistory, authConfig, debugUi, projectIndex, serverModels, serverSessionClient, session, usageText, initialPrompt, }) {
+export async function runClientInteractive({ appendPromptHistory, authConfig, debugUi, serverModels, serverSessionClient, session, usageText, initialPrompt, }) {
     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;
+    let signedOut = false;
     await withTuiMode(async () => {
         setBackgroundJobSession(session.sessionId);
         setScratchSession(session.sessionId);
+        setImageStoreSession(session.sessionId);
         setTodoSession(session.sessionId);
         const store = createShellStore(createInitialShellState(session, serverModels, debugUi));
         store.replaceTranscript(createSessionTranscript(session));
         let currentServerModels = serverModels;
         let sessionAutoYes = session.autoYes;
         let resolveDone = null;
-        let resolveApprovalChoice = null;
+        let resolvePermissionDecision = null;
         let resolveSudoPassword = null;
+        let pendingUserInput = null;
         let cleanupSudoPasswordPrompt = null;
         let sudoPasswordBuffer = '';
         const bridge = createRatatuiBridge();
@@ -1317,6 +1430,11 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
         let latestUsageSummary = null;
         let pendingTurnEntries = [];
         let activeTurnAbort = null;
+        let activeTurnImageAttachments = [];
+        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() }));
@@ -1325,6 +1443,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;
         });
@@ -1338,15 +1486,17 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 void remountTui();
             }, 0);
         };
-        const showTransientStatus = (status) => {
+        const showTransientStatus = (transientStatus) => {
             if (transientStatusTimer) {
                 clearTimeout(transientStatusTimer);
                 transientStatusTimer = null;
             }
-            store.update((current) => ({ ...current, status }));
+            store.update((current) => ({ ...current, transientStatus }));
             transientStatusTimer = setTimeout(() => {
                 transientStatusTimer = null;
-                store.update((current) => current.status === status ? { ...current, status: 'Ready' } : current);
+                store.update((current) => current.transientStatus === transientStatus
+                    ? { ...current, transientStatus: null }
+                    : current);
             }, 2500);
         };
         const terminalTitle = createTerminalTitleController({
@@ -1359,14 +1509,43 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 busy: state.busy,
             });
         };
+        const notifier = backendFor();
+        let notificationHandle = null;
+        const projectLabel = basename(session.rootDir) || 'TheGitAI';
+        const notifications = createNotificationQueue();
+        const attention = createAttentionController({
+            notify: (kind) => {
+                notifications.run(async () => {
+                    notificationHandle = await notifier.post({
+                        title: projectLabel,
+                        body: kind === 'blocked'
+                            ? 'Waiting for your answer'
+                            : 'Finished \u2014 your turn',
+                    }, notificationHandle);
+                });
+            },
+            withdraw: () => {
+                notifications.run(async () => {
+                    notifier.withdraw(notificationHandle);
+                    notificationHandle = null;
+                });
+            },
+        });
+        const syncAttention = () => {
+            const state = store.getState();
+            attention.sync({
+                awaitingAnswer: Boolean(state.approvalPrompt || state.sudoPrompt || state.userInputPrompt),
+                busy: state.busy,
+                focused: state.terminalFocused,
+            }, state.notificationsEnabled);
+        };
         const renderCurrentFrame = () => {
             if (!tuiReady)
                 return;
             const state = store.getState();
             syncTerminalTitle();
-            const elapsedSeconds = state.busySince
-                ? Math.max(0, Math.floor((Date.now() - state.busySince) / 1000))
-                : 0;
+            syncAttention();
+            const elapsedSeconds = busyElapsedSeconds(state, Date.now());
             bridge.render(buildTuiFrame(state, terminalCols, terminalRows, spinnerFrame, elapsedSeconds, Date.now()));
         };
         const remountTui = async () => {
@@ -1492,15 +1671,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 = () => {
@@ -1513,21 +1693,40 @@ 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();
             const queued = store.getState().queuedMessage;
+            const restoredAttachments = composerAttachmentsAfterCancel(queued ? queued.imageAttachments : [], activeTurnImageAttachments);
+            activeTurnImageAttachments = [];
             const cancelledEntries = [
                 ...takePendingTurnEntries(),
                 {
@@ -1541,20 +1740,23 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 activeTurnInput: '',
                 activeTurnInputPreformatted: false,
                 busy: false,
+                busyPausedAt: null,
                 busySince: null,
                 commandLog: [],
                 cursor: queued ? queued.body.length : current.cursor,
-                imageAttachments: queued ? queued.imageAttachments : [],
+                imageAttachments: restoredAttachments,
                 input: queued ? queued.body : current.input,
                 pastedChunks: queued ? queued.pastedChunks : current.pastedChunks,
                 promptHistoryCursor: queued ? null : current.promptHistoryCursor,
                 promptHistoryDraft: queued ? '' : current.promptHistoryDraft,
                 queuedMessage: null,
+                recoveryStatus: '',
                 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;
@@ -1562,14 +1764,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,
@@ -1600,6 +1794,9 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             setAgentMode(nextAgentMode(session.agentMode));
             scheduleLiveFrameRemount();
         };
+        const reportAgentModeLocked = () => {
+            showTransientStatus(AGENT_MODE_LOCKED_STATUS);
+        };
         const clearLiveFrameRemountTimer = () => {
             if (!liveFrameRemountTimer)
                 return;
@@ -1648,6 +1845,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             }
             dismissPendingApproval();
             dismissPendingSudoPassword();
+            dismissPendingUserInput();
             exiting = true;
             killAllBackgroundJobs();
             store.update((current) => ({
@@ -1661,6 +1859,41 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 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);
@@ -1678,7 +1911,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 cleanupSudoPasswordPrompt = null;
             }
             store.update((current) => ({
-                ...current,
+                ...pauseBusyClock(current, Date.now()),
                 sudoPrompt: {
                     command,
                     passwordLength: 0,
@@ -1698,7 +1931,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,
                 }));
@@ -1712,7 +1945,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,
                 }));
@@ -1732,38 +1965,95 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                     : null,
             }));
         };
-        const openApprovalPrompt = (title, body, options = {}) => new Promise((resolve) => {
-            if (exiting) {
-                resolve('n');
+        const openUserInputPrompt = (questions, signal) => new Promise((resolve, reject) => {
+            if (exiting || signal?.aborted) {
+                const error = new Error('Turn cancelled.');
+                error.name = 'AbortError';
+                reject(error);
                 return;
             }
-            resolveApprovalChoice = resolve;
+            const onAbort = () => dismissPendingUserInput();
+            pendingUserInput = {
+                questions,
+                resolve,
+                reject,
+                signal,
+                onAbort,
+            };
+            signal?.addEventListener('abort', onAbort, { once: true });
             store.update((current) => ({
-                ...current,
-                approvalCursor: getDefaultApprovalCursor(),
+                ...pauseBusyClock(current, Date.now()),
+                ...closedJobsPickerFields(current),
+                status: 'Waiting for your input',
+                userInputPrompt: createUserInputPromptState(questions, statusBehindJobsPicker(current)),
+            }));
+            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, signal) => new Promise((resolve) => {
+            const deny = { kind: 'deny' };
+            if (exiting || signal?.aborted) {
+                resolve(deny);
+                return;
+            }
+            const onAbort = () => dismissPendingApproval();
+            signal?.addEventListener('abort', onAbort, { once: true });
+            resolvePermissionDecision = (decision) => {
+                signal?.removeEventListener('abort', onAbort);
+                resolve(decision);
+            };
+            store.update((current) => ({
+                ...pauseBusyClock(current, Date.now()),
+                ...closedJobsPickerFields(current),
+                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,
-                    returnStatus: current.status,
+                    filePath: request.filePath,
+                    options: request.options,
+                    returnStatus: statusBehindJobsPicker(current),
                 },
-                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 });
@@ -1797,7 +2087,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.`,
@@ -1805,24 +2096,35 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 title: 'Model',
             });
         };
+        const toggleNotifications = () => {
+            const enabled = !store.getState().notificationsEnabled;
+            store.update((current) => ({ ...current, notificationsEnabled: enabled }));
+            try {
+                writePreferences({ ...readPreferences(session.env), notifications: enabled }, session.env);
+            }
+            catch {
+            }
+            showTransientStatus(enabled ? 'Notifications on' : 'Notifications off');
+        };
         const openJobsPicker = () => {
+            if (store.getState().jobsPickerOpen)
+                return;
             syncBackgroundJobsState();
             store.update((current) => ({
                 ...current,
                 commandCursor: 0,
-                cursor: 0,
-                input: '',
                 jobsPickerExpandedId: null,
                 jobsPickerIndex: 0,
                 jobsPickerOpen: true,
+                jobsPickerReturnStatus: current.status,
                 status: 'Background jobs',
             }));
+            scheduleLiveFrameRemount();
         };
         const appendJobOutputEntry = async (jobId) => {
             const id = jobId.trim();
             await collectBackgroundJobUiOutputMutations({
                 session,
-                projectIndex,
                 jobId: id,
             });
             const job = listBackgroundJobs().find((candidate) => candidate.id === id);
@@ -1848,32 +2150,51 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             const index = Math.min(Math.max(current.jobsPickerIndex, 0), current.backgroundJobs.length - 1);
             return current.backgroundJobs[index]?.id ?? null;
         };
+        const deferredJobMutationIds = new Set();
+        const drainDeferredJobMutations = async () => {
+            if (deferredJobMutationIds.size === 0)
+                return;
+            const pending = [...deferredJobMutationIds];
+            deferredJobMutationIds.clear();
+            for (const jobId of pending) {
+                await collectBackgroundJobUiOutputMutations({ session, jobId });
+            }
+            syncBackgroundJobsState();
+        };
         const handleJobsPickerOutput = async () => {
             const jobId = selectedJobsPickerId();
             if (!jobId)
                 return;
-            await collectBackgroundJobUiOutputMutations({
-                session,
-                projectIndex,
-                jobId,
-            });
-            syncBackgroundJobsState();
+            if (store.getState().busy) {
+                deferredJobMutationIds.add(jobId);
+            }
+            else {
+                await collectBackgroundJobUiOutputMutations({
+                    session,
+                    jobId,
+                });
+            }
             store.update((current) => ({
                 ...current,
                 jobsPickerExpandedId: current.jobsPickerExpandedId === jobId ? null : jobId,
             }));
+            syncBackgroundJobsState();
         };
         const handleJobsPickerKill = async () => {
             const jobId = selectedJobsPickerId();
             if (!jobId)
                 return;
             const killed = await killBackgroundJob(jobId);
-            await collectBackgroundJobUiKillMutations({
-                session,
-                projectIndex,
-                jobId,
-                result: killed,
-            });
+            if (store.getState().busy) {
+                deferredJobMutationIds.add(jobId);
+            }
+            else {
+                await collectBackgroundJobUiKillMutations({
+                    session,
+                    jobId,
+                    result: killed,
+                });
+            }
             syncBackgroundJobsState();
             if (!killed.ok) {
                 appendError(killed.error ?? 'Background job kill failed.');
@@ -1916,6 +2237,8 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 await switchToModel(selected.id);
             }
             catch (error) {
+                if (exitForAuthenticationError(error))
+                    return;
                 appendError(error.message);
             }
         };
@@ -1965,15 +2288,24 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             store.update((next) => ({
                 ...next,
                 busy: true,
+                busyPausedAt: null,
                 busySince: resumeStartedAt,
                 clockNow: resumeStartedAt,
                 status: 'Loading session...',
             }));
             try {
                 const snapshot = await loadInteractiveSession(selected.id);
-                applySessionSnapshot(session, snapshot);
+                const requestedModelId = Number(snapshot.modelId);
+                const knownModels = currentServerModels.models.some((model) => model.id === requestedModelId)
+                    ? currentServerModels
+                    : await refreshServerModels();
+                const { modelId: resolvedModelId, fellBack } = models.resolveResumedSessionModel(requestedModelId, knownModels);
+                applySessionSnapshot(session, snapshot, {
+                    modelOverride: fellBack ? resolvedModelId : undefined,
+                });
                 setBackgroundJobSession(session.sessionId);
                 setScratchSession(session.sessionId);
+                setImageStoreSession(session.sessionId);
                 syncBackgroundJobsState();
                 setTodoSession(session.sessionId);
                 syncTodosState();
@@ -1981,6 +2313,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 store.update((next) => ({
                     ...next,
                     busy: false,
+                    busyPausedAt: null,
                     busySince: null,
                     resumePickerFilter: '',
                     resumePickerIndex: 0,
@@ -1994,14 +2327,26 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                         kind: 'system',
                         title: 'Session',
                     },
+                    ...(fellBack
+                        ? [
+                            {
+                                body: `This session's model is no longer available — switched to ${formatModelLabel(resolvedModelId, knownModels.models)}. Conversation history preserved.`,
+                                kind: 'system',
+                                title: 'Model',
+                            },
+                        ]
+                        : []),
                     ...buildTranscriptFromSessionHistory(session.history),
                 ]);
                 await remountTui();
             }
             catch (error) {
+                if (exitForAuthenticationError(error))
+                    return;
                 store.update((next) => ({
                     ...next,
                     busy: false,
+                    busyPausedAt: null,
                     busySince: null,
                     resumePickerFilter: '',
                     resumePickerIndex: 0,
@@ -2025,6 +2370,127 @@ 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();
+            const images = queued.imageAttachments.filter((attachment) => queued.body.includes(`[Image #${attachment.index}]`));
+            if (!text && images.length === 0)
+                return;
+            const turnId = activeServerTurnId;
+            const blockedReason = !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,
+                    imageAttachments: images,
+                });
+            }
+            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
@@ -2036,17 +2502,39 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 if (!input || exiting)
                     return;
                 if (input.startsWith('/')) {
+                    if (isJobsPickerCommand(input)) {
+                        store.update((current) => ({
+                            ...current,
+                            cursor: 0,
+                            input: '',
+                            pastedChunks: [],
+                        }));
+                        openJobsPicker();
+                        return;
+                    }
+                    if (input === '/notify') {
+                        store.update((current) => ({
+                            ...current,
+                            cursor: 0,
+                            input: '',
+                            pastedChunks: [],
+                        }));
+                        toggleNotifications();
+                        return;
+                    }
                     appendTurnAwareEntry({
-                        body: "Slash commands can't be queued while a turn is running.",
+                        body: "Slash commands can't be queued while a turn is running. " +
+                            'Ctrl+B opens background jobs, Ctrl+G toggles notifications.',
                         kind: 'system',
                         title: 'Queued',
                     });
                     return;
                 }
                 const pending = store.getState();
+                const body = String(rawInput ?? '');
                 const snapshot = {
-                    body: String(rawInput ?? ''),
-                    imageAttachments: pending.imageAttachments,
+                    body,
+                    imageAttachments: pending.imageAttachments.filter((attachment) => body.includes(`[Image #${attachment.index}]`)),
                     pastedChunks: pending.pastedChunks,
                 };
                 scheduleLiveFrameRemount();
@@ -2061,11 +2549,14 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 }));
                 return;
             }
-            const imageAttachments = store.getState().imageAttachments;
+            const imageAttachments = store
+                .getState()
+                .imageAttachments.filter((attachment) => input.includes(`[Image #${attachment.index}]`));
             scheduleLiveFrameRemount();
             store.update((current) => ({
                 ...current,
                 cursor: 0,
+                imageAttachments: [],
                 input: '',
                 pastedChunks: [],
                 promptHistory: appendPromptToHistory(current.promptHistory, input),
@@ -2081,6 +2572,22 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 requestExit();
                 return;
             }
+            if (input === '/logout') {
+                store.update((current) => ({
+                    ...current,
+                    busy: true,
+                    status: 'Signing out...',
+                }));
+                try {
+                    await logoutFromServer({ config: authConfig });
+                }
+                catch {
+                }
+                clearCliAuthConfig(session.env);
+                signedOut = true;
+                requestExit();
+                return;
+            }
             if (input === '/help') {
                 appendStaticEntry({
                     body: formatInteractiveHelpText(),
@@ -2097,6 +2604,15 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 });
                 return;
             }
+            if (input === '/report') {
+                const opened = await openUrl(REPORT_ISSUE_URL);
+                appendStaticEntries(buildReportTranscriptEntries(opened));
+                return;
+            }
+            if (input === '/notify') {
+                toggleNotifications();
+                return;
+            }
             if (input === '/jobs' || input.startsWith('/jobs ')) {
                 const jobsArgs = input.slice('/jobs'.length).trim();
                 if (!jobsArgs) {
@@ -2109,7 +2625,6 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                     const killed = await killBackgroundJob(jobId);
                     await collectBackgroundJobUiKillMutations({
                         session,
-                        projectIndex,
                         jobId,
                         result: killed,
                     });
@@ -2151,14 +2666,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;
             }
@@ -2172,14 +2691,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;
             }
@@ -2199,37 +2722,77 @@ 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);
+                setImageStoreSession(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();
@@ -2246,36 +2809,63 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             };
             pendingTurnEntries = [];
             queueTurnEntry(userEntry);
+            resetThinkingPacer();
+            activeTurnImageAttachments = imageAttachments;
             store.update((current) => ({
                 ...current,
                 activeTurnInput: input,
                 activeTurnInputPreformatted: preformatted,
+                analyzingImages: 0,
+                generatingImage: false,
                 busy: true,
+                busyPausedAt: null,
                 busySince: turnStartedAt,
                 clockNow: turnStartedAt,
+                recoveryStatus: '',
                 status: 'Running turn...',
                 thinkingTitle: '',
                 thinkingNotes: [],
                 transcriptScrollOffset: 0,
                 tokenUsage: formatClientTokenUsage(0, latestUsageSummary),
                 turnCounter: current.turnCounter + 1,
+                turnMessages: [],
                 workingTools: [],
             }));
             try {
                 const result = await chat.sendServerUserMessage({
                     config: authConfig,
-                    projectIndex,
                     session,
                     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();
+                activeTurnImageAttachments = [];
                 store.update((current) => ({
                     ...current,
                     activeTurnInput: '',
@@ -2311,10 +2901,13 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 store.update((current) => ({
                     ...current,
                     busy: false,
+                    busyPausedAt: null,
                     busySince: null,
+                    recoveryStatus: '',
                     status: result.waitingForApproval ? 'Awaiting approval' : 'Ready',
                     tokenUsage: formatClientTokenUsage(Date.now() - turnStartedAt, latestUsageSummary),
                 }));
+                recoverUnacknowledgedMessages();
                 await flushQueuedMessage();
             }
             catch (error) {
@@ -2325,15 +2918,29 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                     return;
                 }
                 const cancelled = isTurnCancelledError(error);
+                if (exitForAuthenticationError(error))
+                    return;
+                dismissPendingApproval();
+                dismissPendingSudoPassword();
+                dismissPendingUserInput();
+                const failedTurnAttachments = activeTurnImageAttachments;
+                activeTurnImageAttachments = [];
+                const quotaNotice = cancelled ? null : buildQuotaNotice(error);
                 store.update((current) => ({
                     ...current,
                     activeTurnInput: '',
                     activeTurnInputPreformatted: false,
                     busy: false,
+                    busyPausedAt: null,
                     busySince: null,
                     commandLog: [],
-                    imageAttachments: [],
-                    status: cancelled ? 'Ready' : 'Turn failed',
+                    imageAttachments: failedTurnAttachments,
+                    recoveryStatus: '',
+                    status: cancelled
+                        ? 'Ready'
+                        : quotaNotice
+                            ? quotaNotice.title
+                            : 'Turn failed',
                     thinkingTitle: '',
                     thinkingNotes: [],
                     tokenUsage: formatClientTokenUsage(Date.now() - turnStartedAt, latestUsageSummary),
@@ -2349,14 +2956,28 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                             title: 'System',
                         },
                     ]);
-                    await saveActiveSession();
+                    if (!(await saveActiveSession()))
+                        return;
+                }
+                else if (quotaNotice) {
+                    appendStaticEntries([
+                        ...turnEntries,
+                        {
+                            body: quotaNotice.body,
+                            kind: 'system',
+                            title: quotaNotice.title,
+                        },
+                    ]);
                 }
                 else {
                     appendStaticEntries(turnEntries);
                     appendError(error.message);
+                    appendStaticEntries(buildTurnFailureHintEntries(cancelled));
                 }
                 await remountTui();
-                if (!cancelled && turnGeneration === activeTurnGeneration) {
+                const autoSubmits = !cancelled && isTurnOutcomeKnown(error);
+                recoverUnacknowledgedMessages(autoSubmits);
+                if (autoSubmits && turnGeneration === activeTurnGeneration) {
                     await flushQueuedMessage();
                 }
             }
@@ -2366,24 +2987,60 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 }
                 if (turnGeneration === activeTurnGeneration) {
                     lastTurnStartedAt = null;
+                    activeServerTurnId = null;
                 }
+                recoverUnacknowledgedMessages();
+                await drainDeferredJobMutations();
+            }
+        };
+        session.onImageAnalysis = (activeImageCount) => {
+            store.update((current) => ({
+                ...current,
+                analyzingImages: Math.max(0, activeImageCount),
+                generatingImage: activeImageCount > 0 ? false : current.generatingImage,
+            }));
+        };
+        session.onRecovery = (status) => {
+            if (status.phase === 'restored' || status.phase === 'continued') {
+                store.update((current) => ({ ...current, recoveryStatus: '' }));
+                appendTurnAwareEntry(status.phase === 'restored'
+                    ? { body: 'Continued the same turn.', kind: 'system', title: 'Connection restored' }
+                    : {
+                        body: 'Continued from the steps that had finished.',
+                        kind: 'system',
+                        title: 'Server restarted',
+                    });
+                return;
             }
+            store.update((current) => ({
+                ...current,
+                recoveryStatus: status.phase === 'reconnected' ? '' : formatTurnRecoveryStatus(status),
+            }));
+        };
+        session.onImageGeneration = (active) => {
+            store.update((current) => ({
+                ...current,
+                generatingImage: Boolean(active),
+                analyzingImages: active ? 0 : current.analyzingImages,
+            }));
         };
         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) => {
@@ -2398,31 +3055,27 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             if (isFileChangeTool(event.call.name)) {
                 const entry = buildFileChangeEntry(event);
                 store.appendWorkingTool(entry);
-                appendTurnAwareEntry(entry);
+                const result = event.result;
+                if (result?.ok === true || result?.skipped === true)
+                    appendTurnAwareEntry(entry);
                 return;
             }
             store.appendWorkingTool(buildWorkingToolEntry(event));
         };
-        const jobDetailLines = (jobId) => {
-            const buffered = getJobBufferedOutput(jobId);
-            if (!buffered)
-                return [];
-            const lines = buffered.output
-                .replace(/\r\n/g, '\n')
-                .replace(/\r/g, '\n')
-                .split('\n')
-                .filter((line) => line.trim().length > 0);
-            const visible = lines.slice(-20);
-            return buffered.droppedChars > 0
-                ? [
-                    `... (${buffered.droppedChars} chars of older output dropped) ...`,
-                    ...visible,
-                ]
-                : visible;
-        };
         const syncBackgroundJobsState = () => {
+            const expandedId = store.getState().jobsPickerExpandedId;
             const jobsForDisplay = listBackgroundJobs().map((job) => {
-                const preview = getJobOutputPreview(job.id, 3);
+                const expanded = job.id === expandedId;
+                const preview = getJobOutputPreview(job.id, expanded ? 20 : 3);
+                const dropped = preview?.droppedChars ?? 0;
+                const detailLines = !expanded
+                    ? []
+                    : dropped > 0
+                        ? [
+                            `... (${dropped} chars of older output dropped) ...`,
+                            ...(preview?.tailLines ?? []),
+                        ]
+                        : (preview?.tailLines ?? []);
                 return {
                     id: job.id,
                     command: job.command,
@@ -2431,8 +3084,8 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                     startedAt: job.startedAt,
                     endedAt: job.endedAt,
                     firstOutputLine: preview?.firstLine ?? '',
-                    tailLines: preview?.tailLines ?? [],
-                    detailLines: jobDetailLines(job.id),
+                    tailLines: (preview?.tailLines ?? []).slice(-3),
+                    detailLines,
                 };
             });
             store.update((current) => ({
@@ -2449,69 +3102,74 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 appendTurnAwareEntry(buildBackgroundJobNoticeEntry(snapshot));
             }
         });
-        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, session.turnAbortSignal);
+            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',
+                });
+            }
+            else if (decision.kind === 'always-origin') {
+                appendTurnAwareEntry({
+                    body: `Allowed for the rest of this session: browser actions on ${decision.origin}.`,
                     kind: 'system',
                     title: 'Approvals',
                 });
-                return true;
             }
-            return choice === 'y';
+            return decision;
         };
         const shellInputHandlers = {
+            getApprovalScrollLimit: () => {
+                const contentWidth = frameContentWidth(terminalCols);
+                return approvalScrollLimit(store.getState().approvalPrompt, contentWidth, terminalRows);
+            },
+            getComposerInputWidth: () => composerInputWidth(terminalCols, store.getState()),
             getTranscriptScrollLimit: () => {
-                const contentWidth = Math.max(20, Math.floor(terminalCols * 0.95) - 2);
+                const contentWidth = frameContentWidth(terminalCols);
                 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,
+            onAgentModeChangeBlocked: reportAgentModeLocked,
             onCtrlC: handleCtrlC,
             onLinkCopy: handleLinkCopy,
             onLinkOpen: handleLinkOpen,
             onLiveFrameShapeChange: scheduleLiveFrameRemount,
             onRequestExit: requestExit,
             onResolveApproval: handleInlineApprovalChoice,
+            onResolveUserInput: handleInlineUserInput,
             onResumeSession: handleInlineResumeSelection,
             onSelectionCopy: handleAppSelectionCopy,
             onSelectModel: handleInlineModelSelection,
+            onOpenJobsPicker: openJobsPicker,
+            onToggleNotifications: toggleNotifications,
             onJobsPickerOutput: handleJobsPickerOutput,
             onJobsPickerKill: handleJobsPickerKill,
             onSudoPasswordInput: handleSudoPasswordInput,
             onSubmit: handleSubmit,
+            onFireQueuedMessage: fireQueuedMessage,
         };
         const unsubscribe = store.subscribe(() => {
             renderCurrentFrame();
@@ -2519,6 +3177,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
         const spinnerTimer = setInterval(() => {
             spinnerFrame = (spinnerFrame + 1) % 6;
             if (store.getState().busy) {
+                flushPendingThinking();
                 renderCurrentFrame();
             }
         }, 120);
@@ -2549,6 +3208,13 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 return;
             }
             if (message.op === 'event') {
+                if (message.kind === 'focus') {
+                    store.update((current) => current.terminalFocused === message.focused
+                        ? current
+                        : { ...current, terminalFocused: message.focused });
+                    renderCurrentFrame();
+                    return;
+                }
                 if (message.kind === 'resize') {
                     terminalCols = message.cols;
                     terminalRows = message.rows;
@@ -2574,6 +3240,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             killAllBackgroundJobs();
             setBackgroundJobSession(null);
             setScratchSession(null);
+            setImageStoreSession(null);
             setTodoSession(null);
             setBackgroundJobUpdateHook(null);
             await bridge.close();
@@ -2581,4 +3248,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             setCommandOutputHook(null);
         }
     });
+    if (fatalError)
+        throw fatalError;
+    return { signedOut };
 }