@astralyn/pi 0.83.0 → 0.84.0

package/dist/modes/interactive/interactive-mode.js

@@ -6,7 +6,8 @@ import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { CombinedAutocompleteProvider, Container, fuzzyFilter, Markdown, matchesKey, Spacer, setKeybindings, Text, TruncatedText, TUI, visibleWidth, } from "@earendil-works/pi-tui";
+import * as TuiLayouts from "@earendil-works/pi-tui";
+import { CombinedAutocompleteProvider, Container, fuzzyFilter, Markdown, matchesKey, ProcessTerminal, Spacer, setKeybindings, Text, TruncatedText, TuiAltScreen, TuiMainScreen, visibleWidth, } from "@earendil-works/pi-tui";
 import chalk from "chalk";
 import { spawn, spawnSync } from "child_process";
 import { APP_NAME, APP_TITLE, CONFIG_DIR_NAME, getAgentDir, getAuthPath, getDebugLogPath, getDocsPath, getShareViewerUrl, VERSION, } from "../../config.js";
@@ -17,7 +18,8 @@ import { FooterDataProvider } from "../../core/footer-data-provider.js";
 import { configureHttpDispatcher, formatHttpIdleTimeoutMs } from "../../core/http-dispatcher.js";
 import { KeybindingsManager } from "../../core/keybindings.js";
 import { createCompactionSummaryMessage } from "../../core/messages.js";
-import { defaultModelPerProvider, findExactModelReferenceMatch, resolveModelScope, resolveModelScopeWithDiagnostics, } from "../../core/model-resolver.js";
+import { defaultModelPerProvider, findExactModelReferenceMatch, resolveModelScopeFromModels, } from "../../core/model-resolver.js";
+import { CredentialSynchronizationError } from "../../core/model-runtime.js";
 import { DefaultPackageManager } from "../../core/package-manager.js";
 import { formatMissingSessionCwdPrompt, MissingSessionCwdError } from "../../core/session-cwd.js";
 import { SessionManager, sessionEntryToContextMessages } from "../../core/session-manager.js";
@@ -29,6 +31,7 @@ import { copyToClipboard, readClipboardText } from "../../utils/clipboard.js";
 import { extensionForImageMimeType, readClipboardImage } from "../../utils/clipboard-image.js";
 import { CoalescingTerminal } from "../../utils/coalescing-terminal.js";
 import { parseGitUrl } from "../../utils/git.js";
+import { openBrowser } from "../../utils/open-browser.js";
 import { getCwdRelativePath } from "../../utils/paths.js";
 import { killTrackedDetachedChildren } from "../../utils/shell.js";
 import { ensureTool } from "../../utils/tools-manager.js";
@@ -51,6 +54,7 @@ import { ExtensionSelectorComponent } from "./components/extension-selector.js";
 import { FooterComponent, formatTokens } from "./components/footer.js";
 import { formatKeyText, keyDisplayText, keyHint, keyText, rawKeyHint } from "./components/keybinding-hints.js";
 import { LoginDialogComponent } from "./components/login-dialog.js";
+import { createMermaidMarkdownTransformer } from "./components/mermaid.js";
 import { ModelSelectorComponent } from "./components/model-selector.js";
 import { formatAuthSelectorProviderType, OAuthSelectorComponent, } from "./components/oauth-selector.js";
 import { ScopedModelsSelectorComponent } from "./components/scoped-models-selector.js";
@@ -72,8 +76,6 @@ function isExpandable(obj) {
     return typeof obj === "object" && obj !== null && "setExpanded" in obj && typeof obj.setExpanded === "function";
 }
 class ExpandableText extends Text {
-    getCollapsedText;
-    getExpandedText;
     constructor(getCollapsedText, getExpandedText, expanded = false, paddingX = 0, paddingY = 0) {
         super(expanded ? getExpandedText() : getCollapsedText(), paddingX, paddingY);
         this.getCollapsedText = getCollapsedText;
@@ -161,98 +163,39 @@ function formatLoginProviderCompletionDescription(provider) {
     const authTypes = provider.authTypes.map(formatAuthSelectorProviderType).join("/");
     return provider.name === provider.id ? authTypes : `${provider.name} · ${authTypes}`;
 }
+/** Composition root for selecting the interactive terminal renderer. */
+export function createInteractiveTui(options) {
+    const terminal = options.terminal ?? new ProcessTerminal();
+    if (options.tuiMode === "fullscreen") {
+        return new TuiAltScreen(terminal, options.showHardwareCursor, options.logDirectory, { openUrl: openBrowser });
+    }
+    return new TuiMainScreen(terminal, options.showHardwareCursor, options.logDirectory);
+}
+/** Stable reference for components while InteractiveMode replaces the active renderer. */
+export function createInteractiveTuiReference(getTui) {
+    return new Proxy({}, {
+        get: (_target, property) => {
+            const tui = getTui();
+            const value = Reflect.get(tui, property, tui);
+            if (typeof value !== "function")
+                return value;
+            return (...args) => {
+                const tui = getTui();
+                const method = Reflect.get(tui, property, tui);
+                if (typeof method !== "function")
+                    throw new TypeError(`TUI property ${String(property)} is not callable`);
+                return Reflect.apply(method, tui, args);
+            };
+        },
+        set: (_target, property, value) => {
+            const tui = getTui();
+            return Reflect.set(tui, property, value, tui);
+        },
+        has: (_target, property) => Reflect.has(getTui(), property),
+        getPrototypeOf: () => Reflect.getPrototypeOf(getTui()),
+    });
+}
 export class InteractiveMode {
-    runtimeHost;
-    ui;
-    coalescingTerminal;
-    agentRunActive = false;
-    loadedResourcesContainer;
-    chatContainer;
-    pendingMessagesContainer;
-    statusContainer;
-    defaultEditor;
-    editor;
-    editorComponentFactory;
-    autocompleteProvider;
-    autocompleteProviderWrappers = [];
-    fdPath;
-    editorContainer;
-    footer;
-    footerDataProvider;
-    // Stored so the same manager can be injected into custom editors, selectors, and extension UI.
-    keybindings;
-    version;
-    isInitialized = false;
-    onInputCallback;
-    pendingUserInputs = [];
-    activeStatusIndicator = undefined;
-    activeSelector = null;
-    activeSelectorCleanup = null;
-    idleStatus = new IdleStatus();
-    workingMessage = undefined;
-    workingVisible = true;
-    workingIndicatorOptions = undefined;
-    defaultWorkingMessage = "Working...";
-    defaultHiddenThinkingLabel = "Thinking...";
-    hiddenThinkingLabel = this.defaultHiddenThinkingLabel;
-    lastSigintTime = 0;
-    lastEscapeTime = 0;
-    changelogMarkdown = undefined;
-    startupNoticesShown = false;
-    anthropicSubscriptionWarningShown = false;
-    // Status line tracking (for mutating immediately-sequential status updates)
-    lastStatusSpacer = undefined;
-    lastStatusText = undefined;
-    // Streaming message tracking
-    streamingComponent = undefined;
-    streamingMessage = undefined;
-    // Tool execution tracking: toolCallId -> component
-    pendingTools = new Map();
-    // Tool output expansion state
-    toolOutputExpanded = false;
-    // Thinking block visibility state
-    hideThinkingBlock = false;
-    outputPad = 1;
-    // Skill commands: command name -> skill file path
-    skillCommands = new Map();
-    // Agent subscription unsubscribe function
-    unsubscribe;
-    signalCleanupHandlers = [];
-    // Track if editor is in bash mode (text starts with !)
-    isBashMode = false;
-    // Track current bash execution component
-    bashComponent = undefined;
-    // Track pending bash components (shown in pending area, moved to chat on submit)
-    pendingBashComponents = [];
-    // Auto-compaction state
-    autoCompactionEscapeHandler;
-    // Auto-retry state
-    retryEscapeHandler;
-    // Messages queued while compaction is running
-    compactionQueuedMessages = [];
-    // Shutdown state
-    shutdownRequested = false;
-    // Extension UI state
-    extensionSelector = undefined;
-    extensionInput = undefined;
-    extensionEditor = undefined;
-    extensionTerminalInputUnsubscribers = new Set();
-    // Extension widgets (components rendered above/below the editor)
-    extensionWidgetsAbove = new Map();
-    extensionWidgetsBelow = new Map();
-    widgetContainerAbove;
-    widgetContainerBelow;
-    // Custom footer from extension (undefined = use built-in footer)
-    customFooter = undefined;
-    // Header container that holds the built-in or custom header
-    headerContainer;
-    // Built-in header (logo + keybinding hints + changelog)
-    builtInHeader = undefined;
-    // Custom header from extension (undefined = use built-in header)
-    customHeader = undefined;
-    options;
-    autoTrustOnReloadCwd;
-    themeController;
     // Convenience accessors
     get session() {
         return this.runtimeHost.session;
@@ -267,8 +210,85 @@ export class InteractiveMode {
         return this.session.settingsManager;
     }
     constructor(runtimeHost, options = {}) {
+        // Input listeners live on the TUI renderer instance, which switchTuiMode
+        // replaces; this pair tracks the scrollback-preservation listener so it
+        // can be unsubscribed from the outgoing renderer and re-registered on the
+        // incoming one without duplicates.
+        this.scrollbackPreservationInputHandler = () => {
+            if (!this.agentRunActive)
+                this.coalescingTerminal.setScrollbackPreservation(false);
+            return undefined;
+        };
+        this.agentRunActive = false;
+        this.autocompleteProviderWrappers = [];
+        this.isInitialized = false;
+        this.pendingUserInputs = [];
+        this.activeStatusIndicator = undefined;
+        this.idleStatus = new IdleStatus();
+        this.workingMessage = undefined;
+        this.workingVisible = true;
+        this.workingIndicatorOptions = undefined;
+        this.defaultWorkingMessage = "Working...";
+        this.defaultHiddenThinkingLabel = "Thinking...";
+        this.hiddenThinkingLabel = this.defaultHiddenThinkingLabel;
+        this.lastSigintTime = 0;
+        this.lastEscapeTime = 0;
+        this.changelogMarkdown = undefined;
+        this.startupNoticesShown = false;
+        this.anthropicSubscriptionWarningShown = false;
+        // Status line tracking (for mutating immediately-sequential status updates)
+        this.lastStatusSpacer = undefined;
+        this.lastStatusText = undefined;
+        // Streaming message tracking
+        this.streamingComponent = undefined;
+        this.streamingMessage = undefined;
+        // Tool execution tracking: toolCallId -> component
+        this.pendingTools = new Map();
+        // Tool output expansion state
+        this.toolOutputExpanded = false;
+        // Thinking block visibility state
+        this.hideThinkingBlock = false;
+        this.outputPad = 1;
+        this.mermaidMarkdownTransformer = createMermaidMarkdownTransformer({
+            getMode: () => this.settingsManager.getMermaidRenderingMode(),
+            theme,
+        });
+        // Skill commands: command name -> skill file path
+        this.skillCommands = new Map();
+        this.signalCleanupHandlers = [];
+        // Track if editor is in bash mode (text starts with !)
+        this.isBashMode = false;
+        // Track current bash execution component
+        this.bashComponent = undefined;
+        // Track pending bash components (shown in pending area, moved to chat on submit)
+        this.pendingBashComponents = [];
+        // Messages queued while compaction is running
+        this.compactionQueuedMessages = [];
+        // Shutdown state
+        this.shutdownRequested = false;
+        // Extension UI state
+        this.extensionSelector = undefined;
+        this.extensionInput = undefined;
+        this.extensionEditor = undefined;
+        this.extensionTerminalInputSubscriptions = new Set();
+        // Extension widgets (components rendered above/below the editor)
+        this.extensionWidgetsAbove = new Map();
+        this.extensionWidgetsBelow = new Map();
+        // Custom footer from extension (undefined = use built-in footer)
+        this.customFooter = undefined;
+        // Built-in header (logo + keybinding hints + changelog)
+        this.builtInHeader = undefined;
+        // Custom header from extension (undefined = use built-in header)
+        this.customHeader = undefined;
+        /**
+         * Gracefully shutdown the agent.
+         * Stops the TUI before emitting shutdown events so extension UI cleanup cannot
+         * repaint the final frame while the process is exiting.
+         */
+        this.isShuttingDown = false;
         this.runtimeHost = runtimeHost;
-        this.options = options;
+        const tuiMode = options.tuiMode ?? this.settingsManager.getTuiMode();
+        this.options = { ...options, tuiMode };
         this.autoTrustOnReloadCwd = options.autoTrustOnReloadCwd;
         this.runtimeHost.setBeforeSessionInvalidate(() => {
             this.resetExtensionUI();
@@ -279,7 +299,13 @@ export class InteractiveMode {
         this.version = VERSION;
         const terminal = new CoalescingTerminal();
         this.coalescingTerminal = terminal;
-        this.ui = new TUI(terminal, this.settingsManager.getShowHardwareCursor(), getAgentDir());
+        this.renderer = createInteractiveTui({
+            tuiMode,
+            showHardwareCursor: this.settingsManager.getShowHardwareCursor(),
+            logDirectory: getAgentDir(),
+            terminal,
+        });
+        this.ui = createInteractiveTuiReference(() => this.renderer);
         // Lets full-redraw rewrites scroll grown content into scrollback
         // instead of dropping the lines pushed above the screen.
         // previousViewportTop is TS-private but a plain runtime field, and
@@ -291,15 +317,17 @@ export class InteractiveMode {
         // next input after the run settles: post-run reflow frames must not
         // yank a reader who is still scrolled up, but once the user acts they
         // are back at the bottom and upstream's clean wipe-and-replay wins.
-        this.ui.addInputListener(() => {
-            if (!this.agentRunActive)
-                this.coalescingTerminal.setScrollbackPreservation(false);
-            return undefined;
-        });
+        // The listener is registered on the initial renderer and rebound by
+        // switchTuiMode whenever the renderer is replaced.
+        this.scrollbackPreservationInputUnsubscribe = this.ui.addInputListener(this.scrollbackPreservationInputHandler);
         this.ui.setClearOnShrink(this.settingsManager.getClearOnShrink());
         this.headerContainer = new Container();
         this.loadedResourcesContainer = new Container();
         this.chatContainer = new Container();
+        this.documentContainer = new Container();
+        this.documentContainer.addChild(this.headerContainer);
+        this.documentContainer.addChild(this.loadedResourcesContainer);
+        this.documentContainer.addChild(this.chatContainer);
         this.pendingMessagesContainer = new Container();
         this.statusContainer = new Container();
         this.widgetContainerAbove = new Container();
@@ -318,6 +346,8 @@ export class InteractiveMode {
         this.footerDataProvider = new FooterDataProvider(this.sessionManager.getCwd());
         this.footer = new FooterComponent(this.session, this.footerDataProvider);
         this.footer.setAutoCompactEnabled(this.session.autoCompactionEnabled);
+        this.footerContainer = new Container();
+        this.footerContainer.addChild(this.footer);
         // Load hide thinking block setting
         this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
         this.outputPad = this.settingsManager.getOutputPad();
@@ -373,11 +403,10 @@ export class InteractiveMode {
         }));
         const modelCommand = slashCommands.find((command) => command.name === "model");
         if (modelCommand) {
-            modelCommand.getArgumentCompletions = async (prefix) => {
-                // Get available models (scoped or from registry)
+            modelCommand.getArgumentCompletions = (prefix) => {
                 const models = this.session.scopedModels.length > 0
                     ? this.session.scopedModels.map((s) => s.model)
-                    : await this.session.modelRuntime.getAvailable();
+                    : this.session.modelRuntime.getAvailableSnapshot();
                 if (models.length === 0)
                     return null;
                 // Create items with provider/id format
@@ -478,6 +507,75 @@ export class InteractiveMode {
         }
         this.chatContainer.addChild(new DynamicBorder());
     }
+    mountInteractiveTui(tui, components) {
+        for (const component of components)
+            tui.addChild(component);
+        if (TuiLayouts.isViewportTUI(tui)) {
+            if (!this.fullscreenLayoutRoot)
+                throw new Error("Fullscreen layout is not initialized");
+            tui.setLayoutRoot(this.fullscreenLayoutRoot);
+        }
+    }
+    stopInteractiveTui() {
+        if (this.renderer.mode === "fullscreen") {
+            while (this.renderer.hasOverlayEntries)
+                this.renderer.hideOverlay();
+            this.switchTuiMode("regular", false, false);
+            this.renderer.renderNow();
+        }
+        this.ui.stop();
+    }
+    switchTuiMode(mode, restoreProgress = true, startRenderer = true) {
+        const previousUi = this.renderer;
+        if (mode === previousUi.mode)
+            return true;
+        if (previousUi.hasOverlayEntries)
+            return false;
+        const components = [...previousUi.children];
+        const focus = previousUi.getFocusedComponent();
+        const terminal = previousUi.terminal;
+        const showHardwareCursor = previousUi.getShowHardwareCursor();
+        const clearOnShrink = previousUi.getClearOnShrink();
+        const onDebug = previousUi.onDebug;
+        if (previousUi instanceof TuiMainScreen) {
+            this.mainScreenRenderState = previousUi.captureRenderState();
+        }
+        previousUi.stop({ preserveScreen: true });
+        previousUi.setFocus(null);
+        previousUi.clear();
+        if (TuiLayouts.isViewportTUI(previousUi))
+            previousUi.setLayoutRoot(undefined);
+        const nextUi = createInteractiveTui({
+            tuiMode: mode,
+            showHardwareCursor,
+            logDirectory: getAgentDir(),
+            terminal,
+        });
+        nextUi.setClearOnShrink(clearOnShrink);
+        nextUi.onDebug = onDebug;
+        if (nextUi instanceof TuiMainScreen && this.mainScreenRenderState) {
+            nextUi.restoreRenderState(this.mainScreenRenderState);
+        }
+        this.renderer = nextUi;
+        // Renderers own their input-listener sets; move the preservation
+        // listener onto the incoming renderer before anything else touches it.
+        this.rebindScrollbackPreservationInputListener();
+        this.options.tuiMode = mode;
+        this.mountInteractiveTui(nextUi, components);
+        nextUi.invalidate();
+        nextUi.setFocus(focus);
+        if (!startRenderer)
+            return true;
+        nextUi.start();
+        this.themeController.rebindTui();
+        this.rebindExtensionTerminalInputListeners();
+        if (restoreProgress &&
+            this.settingsManager.getShowTerminalProgress() &&
+            (this.session.isStreaming || this.session.isCompacting)) {
+            terminal.setProgress(true);
+        }
+        return true;
+    }
     async init() {
         if (this.isInitialized)
             return;
@@ -501,18 +599,36 @@ export class InteractiveMode {
                 : "";
             console.log(theme.fg("dim", `Model scope: ${modelList}${cycleHint}`));
         }
-        // Add header container as first child. Populate it after applying theme settings.
-        // Keep loaded resources before chat so restored session messages never precede them.
-        this.ui.addChild(this.headerContainer);
-        this.ui.addChild(this.loadedResourcesContainer);
-        this.ui.addChild(this.chatContainer);
-        this.ui.addChild(this.pendingMessagesContainer);
-        this.ui.addChild(this.statusContainer);
+        // Keep one component tree and remount it when changing renderers.
         this.renderWidgets(); // Initialize with default spacer
-        this.ui.addChild(this.widgetContainerAbove);
-        this.ui.addChild(this.editorContainer);
-        this.ui.addChild(this.widgetContainerBelow);
-        this.ui.addChild(this.footer);
+        this.transcriptScrollView = new TuiLayouts.ScrollView(this.documentContainer, {
+            follow: "end",
+            primary: true,
+            overscroll: "chain",
+            scrollbar: this.settingsManager.getFullscreenScrollbar(),
+            scrollbarStyle: (text) => theme.bg("scrollbarThumb", text),
+        });
+        const dock = new TuiLayouts.VStack([
+            { component: this.pendingMessagesContainer, shrink: 1, minSize: 0 },
+            { component: this.statusContainer, shrink: 1, minSize: 0 },
+            { component: this.widgetContainerAbove, shrink: 1, minSize: 0 },
+            { component: this.editorContainer, shrink: 1, minSize: 3 },
+            { component: this.widgetContainerBelow, shrink: 1, minSize: 0 },
+            { component: this.footerContainer, shrink: 1, minSize: 1 },
+        ]);
+        this.fullscreenLayoutRoot = new TuiLayouts.VStack([
+            { component: this.transcriptScrollView, basis: 0, grow: 1, shrink: 1, minSize: 1 },
+            { component: dock, basis: "auto", grow: 0, shrink: 1, minSize: 1 },
+        ]);
+        this.mountInteractiveTui(this.renderer, [
+            this.documentContainer,
+            this.pendingMessagesContainer,
+            this.statusContainer,
+            this.widgetContainerAbove,
+            this.editorContainer,
+            this.widgetContainerBelow,
+            this.footerContainer,
+        ]);
         this.ui.setFocus(this.editor);
         this.setupKeyHandlers();
         this.setupEditorSubmitHandler();
@@ -604,10 +720,13 @@ export class InteractiveMode {
     async run() {
         await this.init();
         if (!process.env.PI_OFFLINE) {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 15_000);
             void this.session.modelRuntime
-                .refresh()
+                .refresh({ signal: controller.signal })
                 .then(() => this.updateAvailableProviderCount())
-                .catch(() => { });
+                .catch(() => { })
+                .finally(() => clearTimeout(timeout));
         }
         // Start version check asynchronously
         checkForNewPiVersion(this.version).then((newRelease) => {
@@ -1259,6 +1378,7 @@ export class InteractiveMode {
                     if (result.cancelled) {
                         return { cancelled: true };
                     }
+                    this.coalescingTerminal.passNextFullRedraw();
                     this.clearChat();
                     this.renderInitialMessages();
                     if (result.editorText && !this.editor.getText().trim()) {
@@ -1292,8 +1412,12 @@ export class InteractiveMode {
         this.showLoadedResources({ force: false, showDiagnosticsWhenQuiet: true });
         this.showStartupNoticesIfNeeded();
     }
+    applyFullscreenScrollbarSetting() {
+        this.transcriptScrollView?.setScrollbar(this.settingsManager.getFullscreenScrollbar());
+    }
     applyRuntimeSettings() {
         configureHttpDispatcher(this.settingsManager.getHttpIdleTimeoutMs());
+        this.applyFullscreenScrollbarSetting();
         this.footer.setSession(this.session);
         this.footer.setAutoCompactEnabled(this.session.autoCompactionEnabled);
         this.footerDataProvider.setCwd(this.sessionManager.getCwd());
@@ -1362,6 +1486,10 @@ export class InteractiveMode {
         this.pendingTools.clear();
     }
     renderCurrentSessionState() {
+        // Resuming, forking, or starting a new session rebuilds the transcript
+        // at the user's request; the rebuild's full redraw keeps the clean
+        // wipe-and-replay even if preservation is still windowed on.
+        this.coalescingTerminal.passNextFullRedraw();
         this.loadedResourcesContainer.clear();
         this.clearChat();
         this.pendingMessagesContainer.clear();
@@ -1405,6 +1533,9 @@ export class InteractiveMode {
         }
         this.chatContainer.addChild(component);
     }
+    getMarkdownTransformers() {
+        return [this.mermaidMarkdownTransformer, ...this.session.extensionRunner.getMarkdownTransformers()];
+    }
     /**
      * Set up keyboard shortcuts registered by extensions.
      */
@@ -1484,7 +1615,7 @@ export class InteractiveMode {
         this.activeStatusIndicator?.dispose();
         this.activeStatusIndicator = undefined;
         this.statusContainer.clear();
-        if (hadActiveStatusIndicator && this.ui.getClearOnShrink()) {
+        if (hadActiveStatusIndicator && this.options.tuiMode === "regular" && this.ui.getClearOnShrink()) {
             this.statusContainer.addChild(this.idleStatus);
         }
     }
@@ -1598,7 +1729,7 @@ export class InteractiveMode {
         this.setHiddenThinkingLabel();
     }
     // Maximum total widget lines to prevent viewport overflow
-    static MAX_WIDGET_LINES = 10;
+    static { this.MAX_WIDGET_LINES = 10; }
     /**
      * Render all extension widgets to the widget container.
      */
@@ -1632,22 +1763,16 @@ export class InteractiveMode {
         if (this.customFooter?.dispose) {
             this.customFooter.dispose();
         }
-        // Remove current footer from UI
-        if (this.customFooter) {
-            this.ui.removeChild(this.customFooter);
-        }
-        else {
-            this.ui.removeChild(this.footer);
-        }
+        this.footerContainer.clear();
         if (factory) {
             // Create and add custom footer, passing the data provider
             this.customFooter = factory(this.ui, theme, this.footerDataProvider);
-            this.ui.addChild(this.customFooter);
+            this.footerContainer.addChild(this.customFooter);
         }
         else {
             // Restore built-in footer
             this.customFooter = undefined;
-            this.ui.addChild(this.footer);
+            this.footerContainer.addChild(this.footer);
         }
         this.ui.requestRender();
     }
@@ -1693,18 +1818,27 @@ export class InteractiveMode {
         this.ui.requestRender();
     }
     addExtensionTerminalInputListener(handler) {
-        const unsubscribe = this.ui.addInputListener(handler);
-        this.extensionTerminalInputUnsubscribers.add(unsubscribe);
+        const subscription = { handler, unsubscribe: this.ui.addInputListener(handler) };
+        this.extensionTerminalInputSubscriptions.add(subscription);
         return () => {
-            unsubscribe();
-            this.extensionTerminalInputUnsubscribers.delete(unsubscribe);
+            subscription.unsubscribe();
+            this.extensionTerminalInputSubscriptions.delete(subscription);
         };
     }
-    clearExtensionTerminalInputListeners() {
-        for (const unsubscribe of this.extensionTerminalInputUnsubscribers) {
-            unsubscribe();
+    rebindScrollbackPreservationInputListener() {
+        this.scrollbackPreservationInputUnsubscribe?.();
+        this.scrollbackPreservationInputUnsubscribe = this.ui.addInputListener(this.scrollbackPreservationInputHandler);
+    }
+    rebindExtensionTerminalInputListeners() {
+        for (const subscription of this.extensionTerminalInputSubscriptions) {
+            subscription.unsubscribe();
+            subscription.unsubscribe = this.ui.addInputListener(subscription.handler);
         }
-        this.extensionTerminalInputUnsubscribers.clear();
+    }
+    clearExtensionTerminalInputListeners() {
+        for (const subscription of this.extensionTerminalInputSubscriptions)
+            subscription.unsubscribe();
+        this.extensionTerminalInputSubscriptions.clear();
     }
     /**
      * Create the ExtensionUIContext for extensions.
@@ -1805,6 +1939,7 @@ export class InteractiveMode {
                 cancelHint: opts?.cancelHint,
                 onToggleToolsExpanded: () => this.toggleToolOutputExpansion(),
             });
+            this.disposeActiveSelector();
             this.editorContainer.clear();
             this.editorContainer.addChild(this.extensionSelector);
             this.ui.setFocus(this.extensionSelector);
@@ -1826,7 +1961,9 @@ export class InteractiveMode {
      * Show a confirmation dialog for extensions.
      */
     async showExtensionConfirm(title, message, opts) {
-        const result = await this.showExtensionSelector(`${title}\n${message}`, ["Yes", "No"], opts);
+        // The message is context, not a heading: render it as the selector's muted
+        // subtitle instead of folding it into the accent-bold title.
+        const result = await this.showExtensionSelector(title, ["Yes", "No"], { ...opts, subtitle: message });
         return result === "Yes";
     }
     async promptForMissingSessionCwd(error) {
@@ -1856,6 +1993,7 @@ export class InteractiveMode {
                 this.hideExtensionInput();
                 resolve(undefined);
             }, { tui: this.ui, timeout: opts?.timeout });
+            this.disposeActiveSelector();
             this.editorContainer.clear();
             this.editorContainer.addChild(this.extensionInput);
             this.ui.setFocus(this.extensionInput);
@@ -1885,6 +2023,7 @@ export class InteractiveMode {
                 this.hideExtensionEditor();
                 resolve(undefined);
             }, undefined, this.settingsManager.getExternalEditorCommand());
+            this.disposeActiveSelector();
             this.editorContainer.clear();
             this.editorContainer.addChild(this.extensionEditor);
             this.ui.setFocus(this.extensionEditor);
@@ -1909,6 +2048,7 @@ export class InteractiveMode {
         this.editorComponentFactory = factory;
         // Save text from current editor before switching
         const currentText = this.editor.getText();
+        this.disposeActiveSelector();
         this.editorContainer.clear();
         if (factory) {
             // Create the custom editor with tui, theme, and keybindings
@@ -1925,6 +2065,9 @@ export class InteractiveMode {
             if (newEditor.setPaddingX !== undefined) {
                 newEditor.setPaddingX(this.defaultEditor.getPaddingX());
             }
+            if (newEditor.setAutocompleteMaxVisible !== undefined) {
+                newEditor.setAutocompleteMaxVisible(this.defaultEditor.getAutocompleteMaxVisible());
+            }
             // Set autocomplete if supported
             if (newEditor.setAutocompleteProvider && this.autocompleteProvider) {
                 newEditor.setAutocompleteProvider(this.autocompleteProvider);
@@ -2029,6 +2172,7 @@ export class InteractiveMode {
                     options?.onHandle?.(handle);
                 }
                 else {
+                    this.disposeActiveSelector();
                     this.editorContainer.clear();
                     this.editorContainer.addChild(component);
                     this.ui.setFocus(component);
@@ -2115,7 +2259,7 @@ export class InteractiveMode {
         this.defaultEditor.onAction("app.tools.expand", () => this.toggleToolOutputExpansion());
         this.defaultEditor.onAction("app.thinking.toggle", () => this.toggleThinkingBlockVisibility());
         this.defaultEditor.onAction("app.editor.external", () => void this.handleOpenExternalEditor());
-        this.defaultEditor.onAction("app.message.copy", () => void this.handleCopyCommand());
+        this.defaultEditor.onAction("app.message.copy", () => void this.handleCopyCommand({ flashConfirmation: true }));
         this.defaultEditor.onAction("app.message.followUp", () => this.handleFollowUp());
         this.defaultEditor.onAction("app.message.dequeue", () => this.handleDequeue());
         this.defaultEditor.onAction("app.session.new", () => this.handleClearCommand());
@@ -2416,17 +2560,17 @@ export class InteractiveMode {
                     this.ui.requestRender();
                 }
                 else if (event.message.role === "assistant") {
-                    this.streamingComponent = new AssistantMessageComponent(undefined, this.hideThinkingBlock, this.getMarkdownThemeWithSettings(), this.hiddenThinkingLabel, this.outputPad);
+                    this.streamingComponent = new AssistantMessageComponent(undefined, this.hideThinkingBlock, this.getMarkdownThemeWithSettings(), this.hiddenThinkingLabel, this.outputPad, this.getMarkdownTransformers());
                     this.streamingMessage = event.message;
                     this.chatContainer.addChild(this.streamingComponent);
-                    this.streamingComponent.updateContent(this.streamingMessage);
+                    this.streamingComponent.updateContent(this.streamingMessage, true);
                     this.ui.requestRender();
                 }
                 break;
             case "message_update":
                 if (this.streamingComponent && event.message.role === "assistant") {
                     this.streamingMessage = event.message;
-                    this.streamingComponent.updateContent(this.streamingMessage);
+                    this.streamingComponent.updateContent(this.streamingMessage, true);
                     for (const content of this.streamingMessage.content) {
                         if (content.type === "toolCall") {
                             if (!this.pendingTools.has(content.id)) {
@@ -2459,7 +2603,7 @@ export class InteractiveMode {
                                 : "Operation aborted";
                         this.streamingMessage.errorMessage = errorMessage;
                     }
-                    this.streamingComponent.updateContent(this.streamingMessage);
+                    this.streamingComponent.updateContent(this.streamingMessage, false);
                     if (this.streamingMessage.stopReason === "aborted" || this.streamingMessage.stopReason === "error") {
                         if (!errorMessage) {
                             errorMessage = this.streamingMessage.errorMessage || "Error";
@@ -2735,12 +2879,12 @@ export class InteractiveMode {
                         // Render user message separately if present
                         if (skillBlock.userMessage) {
                             this.chatContainer.addChild(new Spacer(1));
-                            const userComponent = new UserMessageComponent(skillBlock.userMessage, this.getMarkdownThemeWithSettings(), this.outputPad);
+                            const userComponent = new UserMessageComponent(skillBlock.userMessage, this.getMarkdownThemeWithSettings(), this.outputPad, this.getMarkdownTransformers());
                             this.chatContainer.addChild(userComponent);
                         }
                     }
                     else {
-                        const userComponent = new UserMessageComponent(textContent, this.getMarkdownThemeWithSettings(), this.outputPad);
+                        const userComponent = new UserMessageComponent(textContent, this.getMarkdownThemeWithSettings(), this.outputPad, this.getMarkdownTransformers());
                         this.chatContainer.addChild(userComponent);
                     }
                     if (options?.populateHistory) {
@@ -2750,7 +2894,7 @@ export class InteractiveMode {
                 break;
             }
             case "assistant": {
-                const assistantComponent = new AssistantMessageComponent(message, this.hideThinkingBlock, this.getMarkdownThemeWithSettings(), this.hiddenThinkingLabel, this.outputPad);
+                const assistantComponent = new AssistantMessageComponent(message, this.hideThinkingBlock, this.getMarkdownThemeWithSettings(), this.hiddenThinkingLabel, this.outputPad, this.getMarkdownTransformers());
                 this.chatContainer.addChild(assistantComponent);
                 break;
             }
@@ -2933,12 +3077,6 @@ export class InteractiveMode {
         // Only called when editor is empty (enforced by CustomEditor)
         void this.shutdown();
     }
-    /**
-     * Gracefully shutdown the agent.
-     * Stops the TUI before emitting shutdown events so extension UI cleanup cannot
-     * repaint the final frame while the process is exiting.
-     */
-    isShuttingDown = false;
     async shutdown(options) {
         if (this.isShuttingDown)
             return;
@@ -3180,6 +3318,8 @@ export class InteractiveMode {
         this.setToolsExpanded(!this.toolOutputExpanded);
     }
     setToolsExpanded(expanded) {
+        if (expanded === this.toolOutputExpanded)
+            return;
         this.toolOutputExpanded = expanded;
         // An explicit toggle prefers upstream's clean wipe-and-replay even
         // mid-run: the user just pressed the key, so they are interacting at
@@ -3242,7 +3382,7 @@ export class InteractiveMode {
     }
     showError(errorMessage) {
         this.chatContainer.addChild(new Spacer(1));
-        this.chatContainer.addChild(new Text(theme.fg("error", `Error: ${errorMessage}`), 1, 0));
+        this.chatContainer.addChild(new Text(theme.fg("error", `Error: ${errorMessage}`), this.outputPad, 0));
         this.ui.requestRender();
     }
     showWarning(warningMessage) {
@@ -3448,52 +3588,50 @@ export class InteractiveMode {
     // =========================================================================
     // Selectors
     // =========================================================================
+    disposeActiveSelector() {
+        const dispose = this.activeSelectorDispose;
+        this.activeSelectorToken = undefined;
+        this.activeSelectorDispose = undefined;
+        dispose?.();
+    }
     /**
      * Shows a selector component in place of the editor.
      * @param create Factory that receives a `done` callback and returns the component and focus target
      */
     showSelector(create) {
-        this.activeSelectorCleanup?.();
-        this.activeSelectorCleanup = null;
-        this.activeSelector = null;
-        let selector;
+        const token = {};
+        let dispose;
         let disposed = false;
-        let closed = false;
-        const dispose = () => {
-            if (disposed || !selector)
+        const disposeOnce = () => {
+            if (disposed)
                 return;
             disposed = true;
-            selector.dispose?.();
+            dispose?.();
         };
         const done = () => {
-            if (closed)
+            disposeOnce();
+            if (this.activeSelectorToken !== token)
                 return;
-            closed = true;
-            dispose();
-            if (!selector || this.activeSelector === selector) {
-                this.activeSelector = null;
-                this.activeSelectorCleanup = null;
-                this.editorContainer.clear();
-                this.editorContainer.addChild(this.editor);
-                this.ui.setFocus(this.editor);
-            }
+            this.activeSelectorToken = undefined;
+            this.activeSelectorDispose = undefined;
+            this.editorContainer.clear();
+            this.editorContainer.addChild(this.editor);
+            this.ui.setFocus(this.editor);
         };
         const created = create(done);
-        selector = created.component;
-        if (closed) {
-            dispose();
-            return;
-        }
-        this.activeSelector = selector;
-        this.activeSelectorCleanup = dispose;
+        dispose = created.dispose;
+        this.disposeActiveSelector();
+        this.activeSelectorToken = token;
+        this.activeSelectorDispose = disposeOnce;
         this.editorContainer.clear();
-        this.editorContainer.addChild(selector);
+        this.editorContainer.addChild(created.component);
         this.ui.setFocus(created.focus);
         this.ui.requestRender();
     }
     showSettingsSelector() {
         this.showSelector((done) => {
-            const selector = new SettingsSelectorComponent({
+            let selector;
+            selector = new SettingsSelectorComponent({
                 autoCompact: this.session.autoCompactionEnabled,
                 showImages: this.settingsManager.getShowImages(),
                 imageWidthCells: this.settingsManager.getImageWidthCells(),
@@ -3510,6 +3648,7 @@ export class InteractiveMode {
                 terminalTheme: this.themeController.getTerminalTheme(),
                 availableThemes: getAvailableThemes(),
                 hideThinkingBlock: this.hideThinkingBlock,
+                mermaidRenderingMode: this.settingsManager.getMermaidRenderingMode(),
                 collapseChangelog: this.settingsManager.getCollapseChangelog(),
                 enableInstallTelemetry: this.settingsManager.getEnableInstallTelemetry(),
                 doubleEscapeAction: this.settingsManager.getDoubleEscapeAction(),
@@ -3523,6 +3662,8 @@ export class InteractiveMode {
                 quietStartup: this.settingsManager.getQuietStartup(),
                 clearOnShrink: this.settingsManager.getClearOnShrink(),
                 showTerminalProgress: this.settingsManager.getShowTerminalProgress(),
+                tuiMode: this.ui.mode,
+                fullscreenScrollbar: this.settingsManager.getFullscreenScrollbar(),
                 warnings: this.settingsManager.getWarnings(),
             }, {
                 onAutoCompactChange: (enabled) => {
@@ -3591,6 +3732,11 @@ export class InteractiveMode {
                     this.clearChat();
                     this.rebuildChatFromMessages();
                 },
+                onMermaidRenderingModeChange: (mode) => {
+                    this.settingsManager.setMermaidRenderingMode(mode);
+                    this.chatContainer.invalidate();
+                    this.ui.requestRender();
+                },
                 onShowCacheMissNoticesChange: (shown) => {
                     this.settingsManager.setShowCacheMissNotices(shown);
                     this.rebuildChatFromMessages();
@@ -3660,6 +3806,21 @@ export class InteractiveMode {
                 onShowTerminalProgressChange: (enabled) => {
                     this.settingsManager.setShowTerminalProgress(enabled);
                 },
+                onTuiModeChange: (mode) => {
+                    if (!this.switchTuiMode(mode)) {
+                        selector?.getSettingsList().updateValue("tui-mode", this.ui.mode);
+                        this.showStatus("Close active overlays before changing TUI mode");
+                        return;
+                    }
+                    this.settingsManager.setTuiMode(mode);
+                    if (!this.activeStatusIndicator)
+                        this.statusContainer.clear();
+                    this.showStatus(`TUI mode: ${mode}`);
+                },
+                onFullscreenScrollbarChange: (mode) => {
+                    this.settingsManager.setFullscreenScrollbar(mode);
+                    this.applyFullscreenScrollbarSetting();
+                },
                 onWarningsChange: (warnings) => {
                     this.settingsManager.setWarnings(warnings);
                 },
@@ -3694,20 +3855,37 @@ export class InteractiveMode {
         this.showModelSelector(searchTerm);
     }
     async findExactModelMatch(searchTerm) {
-        const models = await this.getModelCandidates();
-        return findExactModelReferenceMatch(searchTerm, models);
-    }
-    async getModelCandidates() {
-        if (this.session.scopedModels.length > 0) {
-            return this.session.scopedModels.map((scoped) => scoped.model);
-        }
+        const cachedModels = this.session.scopedModels.length > 0
+            ? this.session.scopedModels.map((scoped) => scoped.model)
+            : [...this.session.modelRuntime.getAvailableSnapshot()];
+        const cachedMatch = findExactModelReferenceMatch(searchTerm, cachedModels);
+        if (cachedMatch || this.session.scopedModels.length > 0)
+            return cachedMatch;
+        this.showStatus("Refreshing model catalogs…");
+        const controller = new AbortController();
+        let timedOut = false;
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, 15_000);
         try {
-            await this.session.modelRuntime.refresh();
-            return [...(await this.session.modelRuntime.getAvailable())];
+            const result = await this.session.modelRuntime.refresh({ signal: controller.signal });
+            if (result.aborted && timedOut) {
+                this.showWarning("Model refresh timed out; searching cached models.");
+            }
+            else if (result.errors.size > 0) {
+                this.showWarning(`Could not refresh ${[...result.errors.keys()].join(", ")}; searching cached models.`);
+            }
         }
-        catch {
-            return [];
+        catch (error) {
+            this.showWarning(timedOut
+                ? "Model refresh timed out; searching cached models."
+                : `Could not refresh model catalogs: ${error instanceof Error ? error.message : String(error)}`);
         }
+        finally {
+            clearTimeout(timeout);
+        }
+        return findExactModelReferenceMatch(searchTerm, [...this.session.modelRuntime.getAvailableSnapshot()]);
     }
     /** Update the footer's available provider count from the current snapshot without refreshing catalogs. */
     updateAvailableProviderCount() {
@@ -3809,73 +3987,67 @@ export class InteractiveMode {
                 done();
                 this.ui.requestRender();
             }, initialSearchInput);
-            return { component: selector, focus: selector };
+            return { component: selector, focus: selector, dispose: () => selector.dispose() };
         });
     }
-    async showModelsSelector() {
-        // Get all available models
-        await this.session.modelRuntime.refresh();
-        const allModels = [...(await this.session.modelRuntime.getAvailable())];
-        const allModelIds = new Set(allModels.map((model) => `${model.provider}/${model.id}`));
+    showModelsSelector() {
+        let availableModels = [...this.session.modelRuntime.getAvailableSnapshot()];
+        let availableModelIds = new Set(availableModels.map((model) => `${model.provider}/${model.id}`));
         const configuredPatterns = this.settingsManager.getEnabledModels();
         const sessionScopedModels = this.session.scopedModels;
-        if (allModels.length === 0 && !configuredPatterns?.length && sessionScopedModels.length === 0) {
-            this.showStatus("No models available");
-            return;
-        }
-        const configuredScope = configuredPatterns?.length
-            ? await resolveModelScopeWithDiagnostics(configuredPatterns, this.session.modelRuntime)
-            : undefined;
-        // Check if session has scoped models (from previous session-only changes or CLI --models)
-        const hasSessionScope = sessionScopedModels.length > 0;
-        // Build enabled model IDs from session state or settings
-        let currentEnabledIds = null;
-        if (hasSessionScope) {
-            // Use current session's scoped models
-            currentEnabledIds = sessionScopedModels.map((scoped) => `${scoped.model.provider}/${scoped.model.id}`);
-        }
-        else if (configuredScope) {
-            currentEnabledIds = configuredScope.scopedModels.map((scoped) => `${scoped.model.provider}/${scoped.model.id}`);
-        }
-        for (const diagnostic of configuredScope?.diagnostics ?? []) {
-            if (diagnostic.code !== "no-match")
-                continue;
-            currentEnabledIds ??= [];
-            if (!currentEnabledIds.includes(diagnostic.pattern))
-                currentEnabledIds.push(diagnostic.pattern);
-        }
-        // Helper to update session's scoped models (session-only, no persist)
-        const updateSessionModels = async (enabledIds) => {
+        const configuredEnabledIds = (models) => {
+            if (!configuredPatterns?.length)
+                return null;
+            const resolved = resolveModelScopeFromModels(configuredPatterns, models);
+            const ids = resolved.scopedModels.map((scoped) => `${scoped.model.provider}/${scoped.model.id}`);
+            for (const diagnostic of resolved.diagnostics) {
+                if (diagnostic.code === "no-match" && !ids.includes(diagnostic.pattern))
+                    ids.push(diagnostic.pattern);
+            }
+            return ids;
+        };
+        let currentEnabledIds = sessionScopedModels.length > 0
+            ? sessionScopedModels.map((scoped) => `${scoped.model.provider}/${scoped.model.id}`)
+            : configuredEnabledIds(availableModels);
+        let selectionChanged = false;
+        const updateSessionModels = (enabledIds) => {
             currentEnabledIds = enabledIds === null ? null : [...enabledIds];
-            const hasEnabledAvailableModel = enabledIds?.some((id) => allModelIds.has(id)) ?? false;
-            const allAvailableModelsEnabled = enabledIds !== null && [...allModelIds].every((id) => enabledIds.includes(id));
+            const hasEnabledAvailableModel = enabledIds?.some((id) => availableModelIds.has(id)) ?? false;
+            const allAvailableModelsEnabled = enabledIds !== null && [...availableModelIds].every((id) => enabledIds.includes(id));
             if (enabledIds && hasEnabledAvailableModel && !allAvailableModelsEnabled) {
-                const newScopedModels = await resolveModelScope(enabledIds, this.session.modelRuntime);
-                this.session.setScopedModels(newScopedModels.map((sm) => ({
-                    model: sm.model,
-                    thinkingLevel: sm.thinkingLevel,
+                const newScopedModels = resolveModelScopeFromModels(enabledIds, availableModels).scopedModels;
+                this.session.setScopedModels(newScopedModels.map((scoped) => ({
+                    model: scoped.model,
+                    thinkingLevel: scoped.thinkingLevel,
                 })));
             }
             else {
-                // All enabled or none enabled = no filter
                 this.session.setScopedModels([]);
             }
-            await this.updateAvailableProviderCount();
+            this.updateAvailableProviderCount();
             this.ui.requestRender();
         };
         this.showSelector((done) => {
+            let disposed = false;
+            let timedOut = false;
+            const controller = new AbortController();
+            const timeout = setTimeout(() => {
+                timedOut = true;
+                controller.abort();
+            }, 15_000);
             const selector = new ScopedModelsSelectorComponent({
-                allModels,
+                allModels: availableModels,
                 enabledModelIds: currentEnabledIds,
+                refreshStatus: "Refreshing model catalogs…",
             }, {
-                onChange: async (enabledIds) => {
-                    await updateSessionModels(enabledIds);
+                onChange: (enabledIds) => {
+                    selectionChanged = true;
+                    updateSessionModels(enabledIds);
                 },
                 onPersist: (enabledIds) => {
-                    // Persist to settings
                     const allEnabled = enabledIds !== null &&
-                        enabledIds.length === allModels.length &&
-                        enabledIds.every((id) => allModelIds.has(id));
+                        enabledIds.length === availableModels.length &&
+                        enabledIds.every((id) => availableModelIds.has(id));
                     const newPatterns = enabledIds === null || allEnabled ? undefined : enabledIds;
                     this.settingsManager.setEnabledModels(newPatterns ? [...newPatterns] : undefined);
                     this.showStatus("Model selection saved to settings");
@@ -3885,7 +4057,51 @@ export class InteractiveMode {
                     this.ui.requestRender();
                 },
             });
-            return { component: selector, focus: selector };
+            void this.session.modelRuntime
+                .refresh({ signal: controller.signal })
+                .then((result) => {
+                if (disposed)
+                    return;
+                availableModels = [...this.session.modelRuntime.getAvailableSnapshot()];
+                availableModelIds = new Set(availableModels.map((model) => `${model.provider}/${model.id}`));
+                if (!selectionChanged && sessionScopedModels.length === 0) {
+                    currentEnabledIds = configuredEnabledIds(availableModels);
+                    selector.updateModels(availableModels, currentEnabledIds);
+                }
+                else {
+                    selector.updateModels(availableModels);
+                }
+                if (currentEnabledIds !== null)
+                    updateSessionModels(currentEnabledIds);
+                if (result.aborted && timedOut) {
+                    selector.setRefreshStatus("Model refresh timed out; showing cached models.", "warning");
+                }
+                else if (result.errors.size > 0) {
+                    selector.setRefreshStatus(`Could not refresh ${[...result.errors.keys()].join(", ")}; showing cached models.`, "warning");
+                }
+                else {
+                    selector.setRefreshStatus("Model catalogs refreshed.", "success");
+                }
+                this.ui.requestRender();
+            })
+                .catch((error) => {
+                if (disposed)
+                    return;
+                selector.setRefreshStatus(timedOut
+                    ? "Model refresh timed out; showing cached models."
+                    : `Could not refresh model catalogs: ${error instanceof Error ? error.message : String(error)}`, "warning");
+                this.ui.requestRender();
+            })
+                .finally(() => clearTimeout(timeout));
+            return {
+                component: selector,
+                focus: selector,
+                dispose: () => {
+                    disposed = true;
+                    clearTimeout(timeout);
+                    controller.abort();
+                },
+            };
         });
     }
     showUserMessageSelector() {
@@ -4014,6 +4230,9 @@ export class InteractiveMode {
                         this.showStatus("Navigation cancelled");
                         return;
                     }
+                    // User-committed tree navigation rebuilds the transcript; its
+                    // full redraw bypasses scrollback preservation.
+                    this.coalescingTerminal.passNextFullRedraw();
                     // Update UI
                     this.clearChat();
                     this.renderInitialMessages();
@@ -4147,7 +4366,7 @@ export class InteractiveMode {
         return options.sort((a, b) => a.name.localeCompare(b.name));
     }
     async getLogoutProviderOptions() {
-        return (await this.session.modelRuntime.listCredentials())
+        return (await this.session.modelRuntime.listCredentials({ signal: AbortSignal.timeout(15_000) }))
             .map(({ providerId, type }) => ({
             id: providerId,
             name: this.session.modelRuntime.getProvider(providerId)?.name ?? providerId,
@@ -4165,7 +4384,6 @@ export class InteractiveMode {
             provider.name.toLowerCase() === normalizedProviderRef);
     }
     async handleLoginCommand(providerRef) {
-        await this.session.modelRuntime.getAvailable();
         if (!providerRef) {
             this.showLoginAuthTypeSelector();
             return;
@@ -4279,7 +4497,14 @@ export class InteractiveMode {
             this.showLoginAuthTypeSelector();
             return;
         }
-        const providerOptions = await this.getLogoutProviderOptions();
+        let providerOptions;
+        try {
+            providerOptions = await this.getLogoutProviderOptions();
+        }
+        catch (error) {
+            this.showError(`Could not read stored credentials: ${error instanceof Error ? error.message : String(error)}`);
+            return;
+        }
         if (providerOptions.length === 0) {
             this.showStatus("No stored credentials to remove. /logout only removes credentials saved by /login; environment variables and models.json config are unchanged.");
             return;
@@ -4292,7 +4517,9 @@ export class InteractiveMode {
                     return;
                 }
                 try {
-                    await this.session.modelRuntime.logout(providerOption.id);
+                    await this.session.modelRuntime.logout(providerOption.id, {
+                        signal: AbortSignal.timeout(15_000),
+                    });
                     await this.updateAvailableProviderCount();
                     const message = providerOption.authType === "oauth"
                         ? `Logged out of ${providerOption.name}`
@@ -4300,7 +4527,10 @@ export class InteractiveMode {
                     this.showStatus(message);
                 }
                 catch (error) {
-                    this.showError(`Logout failed: ${error instanceof Error ? error.message : String(error)}`);
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.showError(error instanceof CredentialSynchronizationError
+                        ? `Credentials removed for ${providerOption.name}, but local model state could not be synchronized: ${message}`
+                        : `Logout failed: ${message}`);
                 }
             }, () => {
                 done();
@@ -4310,12 +4540,11 @@ export class InteractiveMode {
         });
     }
     async completeProviderAuthentication(providerId, providerName, authType, previousModel) {
-        await this.session.modelRuntime.getAvailable();
         const actionLabel = authType === "oauth" ? `Logged in to ${providerName}` : `Saved API key for ${providerName}`;
         let selectedModel;
         let selectionError;
         if (isUnknownModel(previousModel)) {
-            const availableModels = await this.session.modelRuntime.getAvailable();
+            const availableModels = this.session.modelRuntime.getAvailableSnapshot();
             const providerModels = availableModels.filter((model) => model.provider === providerId);
             if (!hasDefaultModelProvider(providerId)) {
                 selectionError = `${actionLabel}, but no default model is configured for provider "${providerId}". Use /model to select a model.`;
@@ -4358,6 +4587,25 @@ export class InteractiveMode {
                 void this.maybeWarnAboutAnthropicSubscriptionAuth();
             }
         }
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 15_000);
+        void this.session.modelRuntime
+            .refresh({ providers: [providerId], signal: controller.signal })
+            .then((result) => {
+            if (result.aborted) {
+                this.showWarning(`${actionLabel}, but its model catalog refresh timed out; using cached models.`);
+            }
+            else if (result.errors.size > 0) {
+                this.showWarning(`${actionLabel}, but its model catalog could not be refreshed; using cached models.`);
+            }
+            this.updateAvailableProviderCount();
+            this.footer.invalidate();
+            this.ui.requestRender();
+        })
+            .catch((error) => {
+            this.showWarning(`${actionLabel}, but its model catalog could not be refreshed: ${error instanceof Error ? error.message : String(error)}`);
+        })
+            .finally(() => clearTimeout(timeout));
     }
     showAmbientAuthDialog(providerOption) {
         const restoreEditor = () => {
@@ -4403,7 +4651,10 @@ export class InteractiveMode {
         catch (error) {
             restoreEditor();
             const errorMsg = error instanceof Error ? error.message : String(error);
-            if (errorMsg !== "Login cancelled") {
+            if (error instanceof CredentialSynchronizationError) {
+                this.showError(`Saved API key for ${providerName}, but local model state could not be synchronized: ${errorMsg}`);
+            }
+            else if (errorMsg !== "Login cancelled") {
                 this.showError(`Failed to save API key for ${providerName}: ${errorMsg}`);
             }
         }
@@ -4506,7 +4757,10 @@ export class InteractiveMode {
         catch (error) {
             restoreEditor();
             const errorMsg = error instanceof Error ? error.message : String(error);
-            if (errorMsg !== "Login cancelled") {
+            if (error instanceof CredentialSynchronizationError) {
+                this.showError(`Logged in to ${providerName}, but local model state could not be synchronized: ${errorMsg}`);
+            }
+            else if (errorMsg !== "Login cancelled") {
                 this.showError(`Failed to login to ${providerName}: ${errorMsg}`);
             }
         }
@@ -4551,13 +4805,16 @@ export class InteractiveMode {
             }
             this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
             this.outputPad = this.settingsManager.getOutputPad();
+            // The user asked for this rebuild; its full redraw keeps the
+            // upstream wipe-and-replay even if preservation is still windowed
+            // on from the previous run.
+            this.coalescingTerminal.passNextFullRedraw();
             this.rebuildChatFromMessages();
             chatRestoredBeforeSessionStart = true;
         };
         try {
             await this.session.reload({ beforeSessionStart: restoreChatBeforeSessionStart });
             restoreChatBeforeSessionStart();
-            configureHttpDispatcher(this.settingsManager.getHttpIdleTimeoutMs());
             this.keybindings.reload();
             const activeHeader = this.customHeader ?? this.builtInHeader;
             if (isExpandable(activeHeader)) {
@@ -4565,20 +4822,7 @@ export class InteractiveMode {
             }
             setRegisteredThemes(this.session.resourceLoader.getThemes().themes);
             await this.themeController.applyFromSettings();
-            const editorPaddingX = this.settingsManager.getEditorPaddingX();
-            const autocompleteMaxVisible = this.settingsManager.getAutocompleteMaxVisible();
-            this.defaultEditor.setPaddingX(editorPaddingX);
-            this.defaultEditor.setAutocompleteMaxVisible(autocompleteMaxVisible);
-            if (this.editor !== this.defaultEditor) {
-                this.editor.setPaddingX?.(editorPaddingX);
-                this.editor.setAutocompleteMaxVisible?.(autocompleteMaxVisible);
-            }
-            this.ui.setShowHardwareCursor(this.settingsManager.getShowHardwareCursor());
-            const clearOnShrink = this.settingsManager.getClearOnShrink();
-            this.ui.setClearOnShrink(clearOnShrink);
-            if (!clearOnShrink && !this.activeStatusIndicator) {
-                this.statusContainer.clear();
-            }
+            this.applyRuntimeSettings();
             this.setupAutocompleteProvider();
             const runner = this.session.extensionRunner;
             this.setupExtensionShortcuts(runner);
@@ -4774,7 +5018,7 @@ export class InteractiveMode {
             }
         }
     }
-    async handleCopyCommand() {
+    async handleCopyCommand(options = {}) {
         const text = this.session.getLastAssistantText();
         if (!text) {
             this.showError("No agent messages to copy yet.");
@@ -4782,7 +5026,12 @@ export class InteractiveMode {
         }
         try {
             await copyToClipboard(text);
-            this.showStatus("Copied last agent message to clipboard");
+            if (options.flashConfirmation && this.ui instanceof TuiAltScreen) {
+                this.ui.flash("Copied!");
+            }
+            else {
+                this.showStatus("Copied last agent message to clipboard");
+            }
         }
         catch (error) {
             this.showError(error instanceof Error ? error.message : String(error));
@@ -5145,15 +5394,15 @@ export class InteractiveMode {
         }
     }
     stop() {
-        this.activeSelectorCleanup?.();
-        this.activeSelectorCleanup = null;
-        this.activeSelector = null;
+        this.disposeActiveSelector();
         if (this.settingsManager.getShowTerminalProgress()) {
             this.ui.terminal.setProgress(false);
         }
         this.clearStatusIndicator();
         this.themeController.disableAutoSync();
         this.clearExtensionTerminalInputListeners();
+        this.scrollbackPreservationInputUnsubscribe?.();
+        this.scrollbackPreservationInputUnsubscribe = undefined;
         this.clearPendingTools();
         this.disposeChatToolComponents();
         this.footer.dispose();
@@ -5162,7 +5411,7 @@ export class InteractiveMode {
             this.unsubscribe();
         }
         if (this.isInitialized) {
-            this.ui.stop();
+            this.stopInteractiveTui();
             this.isInitialized = false;
         }
         this.unregisterSignalHandlers();