@thegitai/cli 1.0.0-preview.4 → 1.0.0-preview.40

package/dist/src/ui/repl.js

@@ -1,19 +1,26 @@
 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 { 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 { 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 { 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,23 +77,35 @@ 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 REPORT_ISSUE_URL = 'https://github.com/thegitai/thegitai-cli/issues/new';
+export function buildReportTranscriptEntries(openedUrl) {
+    return openedUrl
+        ? [
+            {
+                body: `Opening the public GitHub issue form in your browser. If nothing opened, visit:\n\n${REPORT_ISSUE_URL}\n\nThe tracker is public — do not paste secrets or code you may not share.`,
+                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 const SLASH_COMMANDS = [
     {
         command: '/help',
@@ -96,6 +115,10 @@ export const SLASH_COMMANDS = [
         command: '/about',
         description: 'Show version and platform info',
     },
+    {
+        command: '/report',
+        description: 'Report a bug: opens the public GitHub issue form',
+    },
     {
         command: '/usage',
         description: 'Show account usage percentage and reset times',
@@ -113,14 +136,29 @@ 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: '/logout',
+        description: 'Sign out and quit',
     },
     {
         command: '/exit',
         description: 'Quit the current session',
     },
 ];
+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);
@@ -489,11 +527,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' ||
@@ -515,6 +585,8 @@ function formatToolResultState(result) {
         return 'Blocked';
     if (result?.ok === true)
         return 'OK';
+    if (Number.isInteger(result?.httpStatus))
+        return String(result.httpStatus);
     return 'Failed';
 }
 function formatRunCommandResultState(result) {
@@ -619,9 +691,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,
@@ -671,7 +745,7 @@ 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()
         ? `\n${truncate(result.error.trim(), 180)}`
@@ -784,10 +858,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;
@@ -797,6 +879,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;
@@ -825,6 +922,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)) {
@@ -853,6 +957,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;
@@ -960,11 +1081,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,
@@ -992,6 +1117,7 @@ function createInitialShellState(session, serverModels, debugUi) {
         resumePickerSessions: [],
         transcriptScrollOffset: 0,
         queuedMessage: null,
+        turnMessages: [],
         serverModels: serverModels.models,
         sudoPrompt: null,
         status: 'Ready',
@@ -1002,6 +1128,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: [],
@@ -1018,7 +1145,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)}`,
@@ -1026,7 +1152,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 ?? '') {
@@ -1069,6 +1194,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)
@@ -1092,7 +1235,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.';
@@ -1222,26 +1365,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) => ({
@@ -1279,30 +1433,37 @@ 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();
+        captureTerminalWrites();
         const { handleShellKeyEvent } = await import('./tui/shell-input.js');
         let terminalCols = 80;
         let terminalRows = 24;
@@ -1315,6 +1476,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() }));
@@ -1323,6 +1489,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;
         });
@@ -1347,7 +1543,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({
@@ -1360,9 +1558,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 () => {
@@ -1488,15 +1684,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 = () => {
@@ -1509,21 +1706,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(),
                 {
@@ -1537,10 +1753,11 @@ 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,
@@ -1549,8 +1766,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;
@@ -1558,14 +1776,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,
@@ -1644,6 +1854,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             }
             dismissPendingApproval();
             dismissPendingSudoPassword();
+            dismissPendingUserInput();
             exiting = true;
             killAllBackgroundJobs();
             store.update((current) => ({
@@ -1653,9 +1864,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);
@@ -1673,7 +1920,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 cleanupSudoPasswordPrompt = null;
             }
             store.update((current) => ({
-                ...current,
+                ...pauseBusyClock(current, Date.now()),
                 sudoPrompt: {
                     command,
                     passwordLength: 0,
@@ -1693,7 +1940,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,
                 }));
@@ -1707,7 +1954,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,
                 }));
@@ -1727,38 +1974,90 @@ 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()),
+                ...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) => 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()),
+                ...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 });
@@ -1792,7 +2091,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.`,
@@ -1801,23 +2101,24 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             });
         };
         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);
@@ -1843,32 +2144,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.');
@@ -1911,6 +2231,8 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 await switchToModel(selected.id);
             }
             catch (error) {
+                if (exitForAuthenticationError(error))
+                    return;
                 appendError(error.message);
             }
         };
@@ -1960,15 +2282,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();
@@ -1976,6 +2307,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 store.update((next) => ({
                     ...next,
                     busy: false,
+                    busyPausedAt: null,
                     busySince: null,
                     resumePickerFilter: '',
                     resumePickerIndex: 0,
@@ -1989,14 +2321,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,
@@ -2020,6 +2364,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
@@ -2031,17 +2496,28 @@ 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;
+                    }
                     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.",
                         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();
@@ -2056,11 +2532,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),
@@ -2076,6 +2555,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(),
@@ -2092,6 +2587,11 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 });
                 return;
             }
+            if (input === '/report') {
+                const opened = await openUrl(REPORT_ISSUE_URL);
+                appendStaticEntries(buildReportTranscriptEntries(opened));
+                return;
+            }
             if (input === '/jobs' || input.startsWith('/jobs ')) {
                 const jobsArgs = input.slice('/jobs'.length).trim();
                 if (!jobsArgs) {
@@ -2104,7 +2604,6 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                     const killed = await killBackgroundJob(jobId);
                     await collectBackgroundJobUiKillMutations({
                         session,
-                        projectIndex,
                         jobId,
                         result: killed,
                     });
@@ -2146,14 +2645,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;
             }
@@ -2167,14 +2670,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;
             }
@@ -2194,43 +2701,85 @@ 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();
             activeTurnAbort = turnAbort;
             lastTurnStartedAt = turnStartedAt;
             todosTouchedThisTurn = false;
+            clearTodos();
+            syncTodosState();
             const userEntry = {
                 body: input,
                 kind: 'user',
@@ -2239,11 +2788,16 @@ 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,
                 status: 'Running turn...',
@@ -2252,23 +2806,44 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 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: '',
@@ -2304,10 +2879,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) {
@@ -2318,14 +2895,19 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                     return;
                 }
                 const cancelled = isTurnCancelledError(error);
+                if (exitForAuthenticationError(error))
+                    return;
+                const failedTurnAttachments = activeTurnImageAttachments;
+                activeTurnImageAttachments = [];
                 store.update((current) => ({
                     ...current,
                     activeTurnInput: '',
                     activeTurnInputPreformatted: false,
                     busy: false,
+                    busyPausedAt: null,
                     busySince: null,
                     commandLog: [],
-                    imageAttachments: [],
+                    imageAttachments: failedTurnAttachments,
                     status: cancelled ? 'Ready' : 'Turn failed',
                     thinkingTitle: '',
                     thinkingNotes: [],
@@ -2342,13 +2924,16 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                             title: 'System',
                         },
                     ]);
-                    await saveActiveSession();
+                    if (!(await saveActiveSession()))
+                        return;
                 }
                 else {
                     appendStaticEntries(turnEntries);
                     appendError(error.message);
+                    appendStaticEntries(buildTurnFailureHintEntries(cancelled));
                 }
                 await remountTui();
+                recoverUnacknowledgedMessages(!cancelled);
                 if (!cancelled && turnGeneration === activeTurnGeneration) {
                     await flushQueuedMessage();
                 }
@@ -2359,24 +2944,43 @@ 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.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) => {
@@ -2396,26 +3000,20 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             }
             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,
@@ -2424,8 +3022,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) => ({
@@ -2442,54 +3040,54 @@ 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);
+            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';
+            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 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,
             onCtrlC: handleCtrlC,
@@ -2498,13 +3096,16 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             onLiveFrameShapeChange: scheduleLiveFrameRemount,
             onRequestExit: requestExit,
             onResolveApproval: handleInlineApprovalChoice,
+            onResolveUserInput: handleInlineUserInput,
             onResumeSession: handleInlineResumeSelection,
             onSelectionCopy: handleAppSelectionCopy,
             onSelectModel: handleInlineModelSelection,
+            onOpenJobsPicker: openJobsPicker,
             onJobsPickerOutput: handleJobsPickerOutput,
             onJobsPickerKill: handleJobsPickerKill,
             onSudoPasswordInput: handleSudoPasswordInput,
             onSubmit: handleSubmit,
+            onFireQueuedMessage: fireQueuedMessage,
         };
         const unsubscribe = store.subscribe(() => {
             renderCurrentFrame();
@@ -2512,6 +3113,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
         const spinnerTimer = setInterval(() => {
             spinnerFrame = (spinnerFrame + 1) % 6;
             if (store.getState().busy) {
+                flushPendingThinking();
                 renderCurrentFrame();
             }
         }, 120);
@@ -2567,10 +3169,15 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             killAllBackgroundJobs();
             setBackgroundJobSession(null);
             setScratchSession(null);
+            setImageStoreSession(null);
             setTodoSession(null);
             setBackgroundJobUpdateHook(null);
             await bridge.close();
+            releaseTerminalWrites();
             setCommandOutputHook(null);
         }
     });
+    if (fatalError)
+        throw fatalError;
+    return { signedOut };
 }