@thegitai/cli 1.0.0-preview.47 → 1.0.0-preview.49

package/dist/src/api/startup-handshake.js

@@ -0,0 +1,36 @@
+import { fetchWhoamiResponse } from './auth.js';
+import { STARTUP_RETRY_BUDGET, isTransientNetworkError, } from './http.js';
+import { fetchServerModels } from './models.js';
+import { abortableDelay, createTurnRecovery, isRetryableTurnFailure, isTurnRecoveryExhausted, } from './turn-recovery.js';
+export async function loadStartupHandshake({ config, canStartOffline, fetchImpl, budget = STARTUP_RETRY_BUDGET, sleep = abortableDelay, onStatus = () => { }, }) {
+    let lastFailure;
+    const recovery = createTurnRecovery({
+        signal: new AbortController().signal,
+        sleep,
+        onStatus: (status) => onStatus(status, lastFailure),
+    });
+    const attempt = async () => {
+        const [models, whoami] = await Promise.allSettled([
+            fetchServerModels({ config, fetchImpl, budget }),
+            fetchWhoamiResponse({ config, fetchImpl, budget }),
+        ]);
+        const unreachable = models.status === 'rejected' &&
+            isRetryableTurnFailure(models.reason) &&
+            !(canStartOffline && isTransientNetworkError(models.reason));
+        if (unreachable) {
+            lastFailure = models.reason;
+            throw models.reason;
+        }
+        return { models, whoami };
+    };
+    try {
+        return await recovery.run('loading your models', attempt);
+    }
+    catch (error) {
+        const reason = isTurnRecoveryExhausted(error) ? error.cause : error;
+        return {
+            models: { status: 'rejected', reason },
+            whoami: { status: 'rejected', reason },
+        };
+    }
+}

package/dist/src/api/turn-recovery.js

@@ -0,0 +1,189 @@
+import { isTransientNetworkError, ServerApiError, transportFailureDetail, } from './http.js';
+export const TURN_RECOVERY_DELAY_MS = 10_000;
+export const TURN_RECOVERY_RETRIES = 3;
+export const TURN_REQUEST_TIMEOUT_MS = 30_000;
+export const TURN_STREAM_IDLE_TIMEOUT_MS = 60_000;
+const RETRYABLE_TURN_STATUSES = new Set([408, 500, 502, 503, 504, 520, 521, 522, 523, 524]);
+export function isRetryableTurnStatus(status) {
+    return RETRYABLE_TURN_STATUSES.has(status);
+}
+export function isRetryableTurnFailure(error) {
+    if (error instanceof ServerApiError)
+        return isRetryableTurnStatus(error.status);
+    return isTransientNetworkError(error);
+}
+export function interruptedStream(message = 'The turn stream ended before the turn finished.') {
+    return Object.assign(new Error(message), { code: 'ECONNRESET' });
+}
+export function formatTurnRecoveryStatus(status) {
+    if (status.phase === 'waiting') {
+        return `Connection interrupted · retrying in ${TURN_RECOVERY_DELAY_MS / 1000}s · retry ${status.retry}/${TURN_RECOVERY_RETRIES}`;
+    }
+    if (status.phase === 'reconnecting') {
+        return `Reconnecting · retry ${status.retry}/${TURN_RECOVERY_RETRIES}`;
+    }
+    if (status.phase === 'reconnected')
+        return 'Reconnected';
+    if (status.phase === 'continuing')
+        return 'Server restarted · continuing from the finished steps';
+    if (status.phase === 'continued')
+        return 'Server restarted · continued from the finished steps';
+    return 'Connection restored · continued the same turn';
+}
+export const TURN_RECOVERY_EXHAUSTED = 'TURN_RECOVERY_EXHAUSTED';
+export function isTurnRecoveryExhausted(error) {
+    return error?.code === TURN_RECOVERY_EXHAUSTED;
+}
+function recoveryExhausted(operation, cause) {
+    const detail = transportFailureDetail(cause);
+    const reason = detail ?? (cause instanceof ServerApiError ? `HTTP ${cause.status}` : 'no response');
+    return Object.assign(new Error(`Connection lost while ${operation} (${reason}). Reconnecting failed after ${TURN_RECOVERY_RETRIES} retries. Some actions in this turn may already have completed.`, { cause }), { code: TURN_RECOVERY_EXHAUSTED });
+}
+export function abortableDelay(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal.aborted) {
+            reject(signal.reason);
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(signal.reason);
+        };
+        const timer = setTimeout(() => {
+            signal.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+}
+function untilAborted(promise, signal) {
+    if (signal.aborted)
+        return Promise.reject(signal.reason);
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(signal.reason);
+        signal.addEventListener('abort', onAbort, { once: true });
+        promise
+            .then(resolve, reject)
+            .finally(() => signal.removeEventListener('abort', onAbort));
+    });
+}
+export function createTurnRecovery({ signal, onStatus = () => { }, sleep = abortableDelay, }) {
+    const affected = new Set();
+    let retry = 0;
+    let gate = null;
+    let exhausted = null;
+    async function retryAfter(token, operation, error, caller = signal) {
+        signal.throwIfAborted();
+        withdrawIfAborted(token, caller);
+        if (exhausted)
+            throw exhausted;
+        if (!isRetryableTurnFailure(error))
+            throw error;
+        affected.add(token);
+        if (!gate) {
+            if (retry === TURN_RECOVERY_RETRIES) {
+                exhausted = recoveryExhausted(operation, error);
+                throw exhausted;
+            }
+            retry += 1;
+            const current = retry;
+            onStatus({ phase: 'waiting', retry: current });
+            gate = sleep(TURN_RECOVERY_DELAY_MS, signal)
+                .then(() => {
+                signal.throwIfAborted();
+                onStatus({ phase: 'reconnecting', retry: current });
+            })
+                .finally(() => {
+                gate = null;
+            });
+        }
+        if (caller === signal) {
+            await gate;
+            return;
+        }
+        await untilAborted(gate, caller).catch((reason) => {
+            withdrawIfAborted(token, caller);
+            throw reason;
+        });
+    }
+    function withdrawIfAborted(token, caller) {
+        if (!caller.aborted)
+            return;
+        affected.delete(token);
+        throw caller.reason;
+    }
+    function reconnected(token) {
+        if (!affected.has(token) || gate || exhausted)
+            return;
+        onStatus({ phase: 'reconnected' });
+    }
+    function restored(token) {
+        if (!affected.delete(token))
+            return;
+        if (affected.size > 0 || gate || exhausted)
+            return;
+        retry = 0;
+        onStatus({ phase: 'restored' });
+    }
+    async function run(operation, attempt, caller = signal) {
+        const token = {};
+        for (;;) {
+            signal.throwIfAborted();
+            withdrawIfAborted(token, caller);
+            if (exhausted)
+                throw exhausted;
+            try {
+                const value = await attempt();
+                restored(token);
+                return value;
+            }
+            catch (error) {
+                await retryAfter(token, operation, error, caller);
+            }
+        }
+    }
+    return { run, retryAfter, reconnected, restored };
+}
+export async function fetchTurnAttempt(fetchImpl, url, init, signal, { readBody = false } = {}) {
+    const controller = new AbortController();
+    const onAbort = () => controller.abort(signal.reason);
+    signal.addEventListener('abort', onAbort, { once: true });
+    if (signal.aborted)
+        onAbort();
+    const timer = setTimeout(() => controller.abort(new DOMException('The request did not get a response in time.', 'TimeoutError')), TURN_REQUEST_TIMEOUT_MS);
+    try {
+        const response = await fetchImpl(url, { ...init, signal: controller.signal });
+        if (!readBody && response.ok)
+            return response;
+        return new Response(await response.arrayBuffer(), {
+            status: response.status,
+            headers: response.headers,
+        });
+    }
+    finally {
+        clearTimeout(timer);
+        signal.removeEventListener('abort', onAbort);
+    }
+}
+export async function readTurnChunk(reader, signal) {
+    let timer;
+    let onAbort;
+    try {
+        return await Promise.race([
+            reader.read(),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(interruptedStream(`The turn stream sent nothing for ${TURN_STREAM_IDLE_TIMEOUT_MS / 1000} seconds.`)), TURN_STREAM_IDLE_TIMEOUT_MS);
+                onAbort = () => reject(signal.reason);
+                signal.addEventListener('abort', onAbort, { once: true });
+                if (signal.aborted)
+                    onAbort();
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        if (onAbort)
+            signal.removeEventListener('abort', onAbort);
+    }
+}

package/dist/src/browser/session-bridge.js

@@ -91,13 +91,12 @@ export function browserAvailability(options) {
             selected: status.selected,
         };
     }
-    const hint = status.registrationErrors.length
-        ? `TheGitAI could not register its browser bridge with Chrome: ${status.registrationErrors[0]}`
-        : status.everConnected
-            ? 'The browser was connected to this session and dropped. Nothing needs reinstalling — it reconnects on its own, usually within a second or two. If it does not, open the TheGitAI icon in Chrome.'
-            : chromiumProcessRunning()
-                ? 'Chrome is running but the TheGitAI extension has not connected. Install or enable the extension, then reload it from chrome://extensions.'
-                : 'Chrome does not appear to be running. Open Chrome with the TheGitAI extension installed.';
+    const hint = connectionHint({
+        registrationError: status.registrationErrors[0] ?? null,
+        everConnected: status.everConnected,
+        chromeRunning: () => chromiumProcessRunning(),
+        extensionSeen: () => browserExtensionSeen(options.env),
+    });
     return {
         connected: false,
         everConnected: status.everConnected,
@@ -106,6 +105,21 @@ export function browserAvailability(options) {
         hint,
     };
 }
+export function connectionHint(state) {
+    if (state.registrationError) {
+        return `TheGitAI could not register its browser bridge with Chrome: ${state.registrationError}`;
+    }
+    if (state.everConnected) {
+        return 'The browser was connected to this session but is disconnected now. Check Chrome and the connection status shown by the TheGitAI extension.';
+    }
+    if (!state.chromeRunning()) {
+        return 'Chrome does not appear to be running. Open Chrome with the TheGitAI extension enabled and check its connection status.';
+    }
+    if (state.extensionSeen()) {
+        return 'The TheGitAI extension has connected on this machine before, but has not connected to this session yet. Check the connection status shown by the extension.';
+    }
+    return 'Chrome is running, but no browser connection reached this session. Check that the TheGitAI extension is installed and enabled, and inspect its connection status.';
+}
 export function resyncBrowserBridge(options) {
     try {
         return ensureBrowserBridge(options).resync();

package/dist/src/help-text.js

@@ -194,6 +194,13 @@ const HELP_MARKDOWN = [
     '  computer" on that page, and paste the code back into the terminal.',
     '- A local session was used with a different sign-in → sign in with the',
     '  account you used for that session or start a new session.',
+    '- The connection drops mid-turn → nothing to do: the CLI reconnects to the',
+    '  same turn up to three times, ten seconds apart, without running anything',
+    '  twice. Esc stops it. If it cannot reconnect it says so; some actions may',
+    '  already have completed, and a queued message waits in the composer.',
+    '  If the service restarted mid-turn, the turn continues from the steps that',
+    '  had finished. Starting `ai` while the service is briefly unavailable waits',
+    '  the same way.',
     '- For anything else, re-run the command and file the printed error',
     '  message with `/report` — there is no client-side debug mode by design.',
 ].join('\n');

package/dist/src/tool-executor.js

@@ -213,6 +213,7 @@ function recordAssistantEdit(session, call, result, before) {
     clearEditFailure(session.clientState.safety, filePath);
 }
 export async function executeLocalToolCall(session, call) {
+    session.turnAbortSignal?.throwIfAborted();
     session.onStatus(formatToolCallForStatus(call));
     try {
         const agentModeBlocked = buildAgentModeToolBlockedResult(session.agentMode, call);

package/dist/src/tools/browser.js

@@ -8,8 +8,7 @@ import { ensurePermission, originForUrl } from '../permissions.js';
 const READ_TIMEOUT_MS = 20000;
 const NAVIGATE_TIMEOUT_MS = 45000;
 const MAX_UPLOAD_BYTES = 10 * 1024 * 1024;
-const RECONNECT_GRACE_MS = 2500;
-const SCAN_GRACE_MS = 1200;
+const DISCOVERY_TIMEOUT_MS = 2500;
 export const READ_ONLY_BROWSER_TOOLS = new Set([
     'browser',
     'browser_tabs',
@@ -35,38 +34,31 @@ function missing(argument, tool) {
 }
 async function waitForBrowser(options, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
-    let availability = browserAvailability(options);
-    while (!availability.connected && Date.now() < deadline) {
+    const bridge = ensureBrowserBridge(options);
+    while (!bridge.status().connected && Date.now() < deadline) {
         await new Promise((resolve) => setTimeout(resolve, 100));
-        availability = browserAvailability(options);
     }
-    return availability;
+    return browserAvailability(options);
 }
 async function notConnected(context) {
     const options = { cwd: context.rootDir, env: context.env };
-    let availability = browserAvailability(options);
+    const status = ensureBrowserBridge(options).status();
+    if (status.connected)
+        return { ok: true };
+    if (status.everConnected)
+        resyncBrowserBridge(options);
+    const availability = await waitForBrowser(options, DISCOVERY_TIMEOUT_MS);
     if (availability.connected)
         return { ok: true };
-    if (availability.everConnected) {
-        const grace = resyncBrowserBridge(options) ? RECONNECT_GRACE_MS : SCAN_GRACE_MS;
-        availability = await waitForBrowser(options, grace);
-        if (availability.connected)
-            return { ok: true };
-    }
     return {
         ok: false,
+        connected: false,
+        browserErrorCode: 'not_connected',
         error: `TheGitAI is not connected to a browser. ${availability.hint ?? ''}`.trim(),
         failureCategory: 'external_service',
-        failureDetails: {
-            category: 'external_service',
-            tool: 'browser',
-            action: availability.everConnected
-                ? 'The link to a browser that was working dropped and did not come back. Nothing is missing and nothing needs installing, so do not send the user to reinstall anything. Say what happened, and that reopening the TheGitAI icon in Chrome restores it. Do not retry in a loop.'
-                : 'Report the connection instructions. The extension is a separate installation. Do not retry in a loop or invent a download URL.',
-        },
     };
 }
-function bridgeFailure(error, tool) {
+function bridgeFailure(error) {
     const code = error instanceof BrowserBridgeError ? error.code : 'browser_error';
     const message = String(error?.message ?? error);
     return {
@@ -74,15 +66,6 @@ function bridgeFailure(error, tool) {
         error: message,
         failureCategory: code === 'not_connected' ? 'external_service' : 'tool_exception',
         browserErrorCode: code,
-        failureDetails: {
-            category: code === 'not_connected' ? 'external_service' : 'tool_exception',
-            tool,
-            action: code === 'timeout' || code === 'disconnected'
-                ? 'The outcome is unknown. Read the page before repeating anything that submits, sends, buys, or deletes.'
-                : code === 'stale_refs' || code === 'unknown_ref'
-                    ? 'Re-read the page and use the references from that read.'
-                    : 'Report what failed. Do not retry the same call more than once.',
-        },
     };
 }
 async function call(context, op, args = {}, timeoutMs = READ_TIMEOUT_MS) {
@@ -152,7 +135,7 @@ export async function browserTabs(context, args) {
         return attachEvents({ ok: true, ...result });
     }
     catch (error) {
-        return bridgeFailure(error, 'browser_tabs');
+        return bridgeFailure(error);
     }
 }
 export async function browserTabNew(context) {
@@ -164,7 +147,7 @@ export async function browserTabNew(context) {
         return attachEvents({ ok: true, ...result });
     }
     catch (error) {
-        return bridgeFailure(error, 'browser_tab_new');
+        return bridgeFailure(error);
     }
 }
 export async function browserTabClose(context, args) {
@@ -179,7 +162,7 @@ export async function browserTabClose(context, args) {
         return attachEvents({ ok: true, ...result });
     }
     catch (error) {
-        return bridgeFailure(error, 'browser_tab_close');
+        return bridgeFailure(error);
     }
 }
 export async function browserNavigate(context, args) {
@@ -212,7 +195,7 @@ export async function browserNavigate(context, args) {
         return attachEvents({ ok: true, ...result });
     }
     catch (error) {
-        return bridgeFailure(error, 'browser_navigate');
+        return bridgeFailure(error);
     }
 }
 async function gatedTabCall(context, { tool, op, args, summary, timeoutMs = READ_TIMEOUT_MS, }) {
@@ -249,7 +232,7 @@ async function gatedTabCall(context, { tool, op, args, summary, timeoutMs = READ
         return attachEvents({ ok: true, tabId, url: tab.url, ...result });
     }
     catch (error) {
-        return bridgeFailure(error, tool);
+        return bridgeFailure(error);
     }
 }
 export function browserReadPage(context, args) {
@@ -557,7 +540,7 @@ export async function browserFileUpload(context, args) {
         return attachEvents({ ok: true, ...result, files: files.map((file) => file.name) });
     }
     catch (error) {
-        return bridgeFailure(error, 'browser_file_upload');
+        return bridgeFailure(error);
     }
 }
 function guessMimeType(file) {

package/dist/src/ui/repl.js

@@ -12,7 +12,8 @@ export { getInputCommandToken, getSlashCommandSuggestions, SLASH_COMMANDS, slash
 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';
@@ -542,15 +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';
-    if (Number.isInteger(result?.httpStatus))
-        return String(result.httpStatus);
-    return 'Failed';
+    return result?.skipped ? 'Skipped' : 'OK';
 }
 function formatRunCommandResultState(result) {
     if (result?.timedOut)
@@ -588,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);
@@ -710,22 +706,25 @@ function buildFileChangeEntry(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',
         };
     }
@@ -737,15 +736,15 @@ export 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',
         };
     }
@@ -754,8 +753,8 @@ export 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',
     };
 }
@@ -873,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);
@@ -1751,6 +1750,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 promptHistoryCursor: queued ? null : current.promptHistoryCursor,
                 promptHistoryDraft: queued ? '' : current.promptHistoryDraft,
                 queuedMessage: null,
+                recoveryStatus: '',
                 status: 'Ready',
                 thinkingTitle: '',
                 thinkingNotes: [],
@@ -2009,13 +2009,18 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             pending.resolve(result);
             scheduleLiveFrameRemount();
         };
-        const openApprovalPrompt = (request) => new Promise((resolve) => {
+        const openApprovalPrompt = (request, signal) => new Promise((resolve) => {
             const deny = { kind: 'deny' };
-            if (exiting) {
+            if (exiting || signal?.aborted) {
                 resolve(deny);
                 return;
             }
-            resolvePermissionDecision = resolve;
+            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),
@@ -2816,6 +2821,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 busyPausedAt: null,
                 busySince: turnStartedAt,
                 clockNow: turnStartedAt,
+                recoveryStatus: '',
                 status: 'Running turn...',
                 thinkingTitle: '',
                 thinkingNotes: [],
@@ -2897,6 +2903,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                     busy: false,
                     busyPausedAt: null,
                     busySince: null,
+                    recoveryStatus: '',
                     status: result.waitingForApproval ? 'Awaiting approval' : 'Ready',
                     tokenUsage: formatClientTokenUsage(Date.now() - turnStartedAt, latestUsageSummary),
                 }));
@@ -2913,6 +2920,9 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 const cancelled = isTurnCancelledError(error);
                 if (exitForAuthenticationError(error))
                     return;
+                dismissPendingApproval();
+                dismissPendingSudoPassword();
+                dismissPendingUserInput();
                 const failedTurnAttachments = activeTurnImageAttachments;
                 activeTurnImageAttachments = [];
                 const quotaNotice = cancelled ? null : buildQuotaNotice(error);
@@ -2925,6 +2935,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                     busySince: null,
                     commandLog: [],
                     imageAttachments: failedTurnAttachments,
+                    recoveryStatus: '',
                     status: cancelled
                         ? 'Ready'
                         : quotaNotice
@@ -2964,8 +2975,9 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                     appendStaticEntries(buildTurnFailureHintEntries(cancelled));
                 }
                 await remountTui();
-                recoverUnacknowledgedMessages(!cancelled);
-                if (!cancelled && turnGeneration === activeTurnGeneration) {
+                const autoSubmits = !cancelled && isTurnOutcomeKnown(error);
+                recoverUnacknowledgedMessages(autoSubmits);
+                if (autoSubmits && turnGeneration === activeTurnGeneration) {
                     await flushQueuedMessage();
                 }
             }
@@ -2988,6 +3000,23 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 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,
@@ -3026,7 +3055,9 @@ 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));
@@ -3079,7 +3110,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 return deny;
             if (sessionAutoYes)
                 return { kind: 'once' };
-            const decision = await openApprovalPrompt(request);
+            const decision = await openApprovalPrompt(request, session.turnAbortSignal);
             if (decision.kind === 'always-bucket') {
                 appendTurnAwareEntry({
                     body: `Allowed for the rest of this session: ${bucketActionLabel(request.bucket)}.`,