@daniel156161/prism 0.2.76 → 0.2.81

package/node_modules/@earendil-works/pi-coding-agent/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, getCapabilities, hyperlink, Markdown, matchesKey, ProcessTerminal, Spacer, setKeybindings, Text, TruncatedText, TUI, visibleWidth, } from "@earendil-works/pi-tui";
+import * as TuiLayouts from "@earendil-works/pi-tui";
+import { CombinedAutocompleteProvider, Container, fuzzyFilter, getCapabilities, hyperlink, 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 { getChangelogPath, getNewEntries, normalizeChangelogLinks, parseChangelo
 import { copyToClipboard, readClipboardText } from "../../utils/clipboard.js";
 import { extensionForImageMimeType, readClipboardImage } from "../../utils/clipboard-image.js";
 import { parseGitUrl } from "../../utils/git.js";
+import { openBrowser } from "../../utils/open-browser.js";
 import { getCwdRelativePath } from "../../utils/paths.js";
 import { getPiUserAgent } from "../../utils/pi-user-agent.js";
 import { killTrackedDetachedChildren } from "../../utils/shell.js";
@@ -52,6 +55,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";
@@ -161,11 +165,58 @@ 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,
+            onRightClickPaste: options.onRightClickPaste,
+        });
+    }
+    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;
+            let methodTui = tui;
+            let method = value;
+            return (...args) => {
+                const currentTui = getTui();
+                if (currentTui !== methodTui) {
+                    const currentMethod = Reflect.get(currentTui, property, currentTui);
+                    if (typeof currentMethod !== "function") {
+                        throw new TypeError(`TUI property ${String(property)} is not callable`);
+                    }
+                    methodTui = currentTui;
+                    method = currentMethod;
+                }
+                return Reflect.apply(method, methodTui, 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;
+    renderer;
     ui;
+    mainScreenRenderState;
     loadedResourcesContainer;
     chatContainer;
+    documentContainer;
+    transcriptScrollView;
+    fullscreenLayoutRoot;
     pendingMessagesContainer;
     statusContainer;
     defaultEditor;
@@ -175,7 +226,10 @@ export class InteractiveMode {
     autocompleteProviderWrappers = [];
     fdPath;
     editorContainer;
+    activeSelectorToken;
+    activeSelectorDispose;
     footer;
+    footerContainer;
     footerDataProvider;
     // Stored so the same manager can be injected into custom editors, selectors, and extension UI.
     keybindings;
@@ -209,6 +263,10 @@ export class InteractiveMode {
     // Thinking block visibility state
     hideThinkingBlock = false;
     outputPad = 1;
+    mermaidMarkdownTransformer = createMermaidMarkdownTransformer({
+        getMode: () => this.settingsManager.getMermaidRenderingMode(),
+        theme,
+    });
     // Skill commands: command name -> skill file path
     skillCommands = new Map();
     // Agent subscription unsubscribe function
@@ -232,7 +290,7 @@ export class InteractiveMode {
     extensionSelector = undefined;
     extensionInput = undefined;
     extensionEditor = undefined;
-    extensionTerminalInputUnsubscribers = new Set();
+    extensionTerminalInputSubscriptions = new Set();
     // Extension widgets (components rendered above/below the editor)
     extensionWidgetsAbove = new Map();
     extensionWidgetsBelow = new Map();
@@ -247,6 +305,9 @@ export class InteractiveMode {
     // Custom header from extension (undefined = use built-in header)
     customHeader = undefined;
     options;
+    onRightClickPaste = () => {
+        void this.handleRightClickPaste();
+    };
     autoTrustOnReloadCwd;
     themeController;
     // Convenience accessors
@@ -264,7 +325,8 @@ export class InteractiveMode {
     }
     constructor(runtimeHost, options = {}) {
         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();
@@ -273,11 +335,21 @@ export class InteractiveMode {
             await this.rebindCurrentSession({ renderBeforeBind: true });
         });
         this.version = VERSION;
-        this.ui = new TUI(new ProcessTerminal(), this.settingsManager.getShowHardwareCursor(), getAgentDir());
+        this.renderer = createInteractiveTui({
+            tuiMode,
+            showHardwareCursor: this.settingsManager.getShowHardwareCursor(),
+            logDirectory: getAgentDir(),
+            onRightClickPaste: this.onRightClickPaste,
+        });
+        this.ui = createInteractiveTuiReference(() => this.renderer);
         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();
@@ -296,6 +368,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();
@@ -351,11 +425,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
@@ -459,6 +532,73 @@ 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,
+            onRightClickPaste: this.onRightClickPaste,
+        });
+        nextUi.setClearOnShrink(clearOnShrink);
+        nextUi.onDebug = onDebug;
+        if (nextUi instanceof TuiMainScreen && this.mainScreenRenderState) {
+            nextUi.restoreRenderState(this.mainScreenRenderState);
+        }
+        this.renderer = nextUi;
+        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;
@@ -482,18 +622,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();
@@ -503,7 +661,7 @@ export class InteractiveMode {
         await this.themeController.applyFromSettings();
         // Add header with keybindings from config (unless silenced)
         if (this.options.verbose || !this.settingsManager.getQuietStartup()) {
-            const logo = "▲ \u001b[38;5;196mp\u001b[38;5;202mr\u001b[38;5;226mi\u001b[38;5;46ms\u001b[38;5;51mm\u001b[0m v0.2.75";
+            const logo = "▲ \u001b[38;5;196mp\u001b[38;5;202mr\u001b[38;5;226mi\u001b[38;5;46ms\u001b[38;5;51mm\u001b[0m v0.2.81";
             // Build startup instructions using keybinding hint helpers
             const hint = (keybinding, description) => keyHint(keybinding, description);
             const expandedInstructions = [
@@ -585,10 +743,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) => {
@@ -636,6 +797,7 @@ export class InteractiveMode {
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+                errorMessage = this.humanizeUsageLimitError(errorMessage);
                 this.showError(errorMessage);
             }
         }
@@ -646,7 +808,8 @@ export class InteractiveMode {
                 }
                 catch (error) {
                     const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
-                    this.showError(errorMessage);
+                    errorMessage = this.humanizeUsageLimitError(errorMessage);
+                this.showError(errorMessage);
                 }
             }
         }
@@ -658,6 +821,7 @@ export class InteractiveMode {
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+                errorMessage = this.humanizeUsageLimitError(errorMessage);
                 this.showError(errorMessage);
             }
         }
@@ -734,19 +898,19 @@ export class InteractiveMode {
         const entries = parseChangelog(changelogPath);
         if (!lastVersion) {
             // Fresh install - record the version, send telemetry, don't show changelog
-            this.settingsManager.setLastChangelogVersion("0.83.0");
-            this.reportInstallTelemetry("0.83.0");
+            this.settingsManager.setLastChangelogVersion("0.84.1");
+            this.reportInstallTelemetry("0.84.1");
             return undefined;
         }
         const newEntries = getNewEntries(entries, lastVersion);
         if (entries.length > 0 && newEntries.length === entries.length) {
-            this.settingsManager.setLastChangelogVersion("0.83.0");
-            this.reportInstallTelemetry("0.83.0");
+            this.settingsManager.setLastChangelogVersion("0.84.1");
+            this.reportInstallTelemetry("0.84.1");
             return normalizeChangelogLinks(entries[0].content, entries[0]);
         }
         if (newEntries.length > 0) {
-            this.settingsManager.setLastChangelogVersion("0.83.0");
-            this.reportInstallTelemetry("0.83.0");
+            this.settingsManager.setLastChangelogVersion("0.84.1");
+            this.reportInstallTelemetry("0.84.1");
             return newEntries.map((e) => normalizeChangelogLinks(e.content, e)).join("\n\n");
         }
         return undefined;
@@ -1300,8 +1464,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());
@@ -1365,6 +1533,9 @@ export class InteractiveMode {
     getRegisteredToolDefinition(toolName) {
         return this.session.getToolDefinition(toolName);
     }
+    getMarkdownTransformers() {
+        return [this.mermaidMarkdownTransformer, ...this.session.extensionRunner.getMarkdownTransformers()];
+    }
     /**
      * Set up keyboard shortcuts registered by extensions.
      */
@@ -1444,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);
         }
     }
@@ -1592,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();
     }
@@ -1653,18 +1818,23 @@ 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();
+    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.
@@ -1759,6 +1929,7 @@ export class InteractiveMode {
                 this.hideExtensionSelector();
                 resolve(undefined);
             }, { tui: this.ui, timeout: opts?.timeout, onToggleToolsExpanded: () => this.toggleToolOutputExpansion() });
+            this.disposeActiveSelector();
             this.editorContainer.clear();
             this.editorContainer.addChild(this.extensionSelector);
             this.ui.setFocus(this.extensionSelector);
@@ -1810,6 +1981,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);
@@ -1839,6 +2011,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);
@@ -1863,6 +2036,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
@@ -1879,6 +2053,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);
@@ -1983,6 +2160,7 @@ export class InteractiveMode {
                     options?.onHandle?.(handle);
                 }
                 else {
+                    this.disposeActiveSelector();
                     this.editorContainer.clear();
                     this.editorContainer.addChild(component);
                     this.ui.setFocus(component);
@@ -2069,7 +2247,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());
@@ -2089,6 +2267,22 @@ export class InteractiveMode {
             void this.handleClipboardPaste();
         };
     }
+    async handleRightClickPaste() {
+        const target = this.renderer.getFocusedComponent();
+        const handleInput = target?.handleInput;
+        if (!target || !handleInput)
+            return;
+        try {
+            const text = await readClipboardText();
+            if (!text || this.renderer.getFocusedComponent() !== target)
+                return;
+            handleInput.call(target, `\x1b[200~${text}\x1b[201~`);
+            this.ui.requestRender();
+        }
+        catch {
+            // Silently ignore clipboard errors (may not have permission, etc.)
+        }
+    }
     async handleClipboardPaste() {
         try {
             const image = await readClipboardImage();
@@ -2378,17 +2572,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)) {
@@ -2425,7 +2619,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";
@@ -2501,6 +2695,8 @@ export class InteractiveMode {
                 break;
             case "agent_settled":
                 await this.checkShutdownRequested();
+                void this.maybeShowUsageLimitRecoveryMenu(event);
+                void this.maybeShowPrismPlanApprovalMenu(event);
                 break;
             case "compaction_start": {
                 if (this.settingsManager.getShowTerminalProgress()) {
@@ -2599,6 +2795,189 @@ export class InteractiveMode {
             }
         }
     }
+    formatUsageLimitDuration(ms) {
+        const totalMinutes = Math.ceil(ms / 60000);
+        const hours = Math.floor(totalMinutes / 60);
+        const minutes = totalMinutes % 60;
+        const parts = [];
+        if (hours > 0) parts.push(hours + "h");
+        if (minutes > 0 || parts.length === 0) parts.push(minutes + "min");
+        return parts.join(" ");
+    }
+    humanizeUsageLimitError(errorMessage) {
+        return String(errorMessage || "").replace(/(~|about\s*)?(\d+)\s*min\b/gi, (_match, prefix, minutes) => {
+            return (prefix || "") + this.formatUsageLimitDuration(Number(minutes) * 60 * 1000);
+        });
+    }
+    extractUsageLimitWaitMs(errorMessage) {
+        const text = String(errorMessage || "");
+        const parsedSeconds = text.match(/"(?:resets_in_seconds|X-Codex-Primary-Reset-After-Seconds|Retry-After)"\s*:?\s*"?(\d+)"?/i)?.[1];
+        if (parsedSeconds) return Number(parsedSeconds) * 1000;
+        const resetAt = text.match(/"(?:resets_at|X-Codex-Primary-Reset-At)"\s*:?\s*"?(\d+)"?/i)?.[1];
+        if (resetAt) {
+            const resetMs = Number(resetAt) * 1000 - Date.now();
+            if (Number.isFinite(resetMs) && resetMs > 0) return resetMs;
+        }
+        const hours = text.match(/(?:~|about\s*)?(\d+)\s*h(?:our)?/i)?.[1];
+        if (hours) return Number(hours) * 60 * 60 * 1000;
+        const minutes = text.match(/(?:~|about\s*)?(\d+)\s*min/i)?.[1];
+        if (minutes) return Number(minutes) * 60 * 1000;
+        const seconds = text.match(/(?:~|about\s*)?(\d+)\s*s(?:ec|econd)?/i)?.[1];
+        if (seconds) return Number(seconds) * 1000;
+        return 5 * 60 * 1000;
+    }
+    getUsageLimitError(event) {
+        const last = event?.messages?.[event.messages.length - 1];
+        let errorMessage = last?.errorMessage || last?.content?.find?.((block) => block?.type === "text")?.text || "";
+        if (last?.role !== "assistant" || last?.stopReason !== "error") return undefined;
+        errorMessage = this.humanizeUsageLimitError(errorMessage);
+        return /usage limit|try again in/i.test(errorMessage) ? String(errorMessage) : undefined;
+    }
+    removeLastAssistantErrorFromState() {
+        const messages = this.agent.state.messages;
+        const last = messages[messages.length - 1];
+        if (last?.role === "assistant" && last?.stopReason === "error") this.agent.state.messages = messages.slice(0, -1);
+    }
+    async continueAfterUsageLimitRecovery() {
+        try {
+            await this.agent.continue();
+        } catch (error) {
+            this.showError(error instanceof Error ? error.message : String(error));
+        }
+    }
+    maybeShowUsageLimitRecoveryMenu(event) {
+        const errorMessage = this.getUsageLimitError(event);
+        if (!errorMessage) return;
+        const delayMs = this.extractUsageLimitWaitMs(errorMessage);
+        const waitLabel = "Wait " + this.formatUsageLimitDuration(delayMs) + " then retry";
+        this.showSelector((done) => {
+            const selector = new ExtensionSelectorComponent("Usage limit hit", [waitLabel, "Change model and retry", "Cancel"], async (selected) => {
+                done();
+                if (selected === "Cancel") return;
+                this.removeLastAssistantErrorFromState();
+                if (selected === waitLabel) {
+                    const endTime = Date.now() + delayMs;
+                    const updateCountdown = () => {
+                        const remaining = Math.max(0, endTime - Date.now());
+                        this.showStatus("Waiting " + this.formatUsageLimitDuration(remaining) + " for usage limit, then retrying...");
+                        this.ui.requestRender();
+                    };
+                    updateCountdown();
+                    const countdownInterval = setInterval(updateCountdown, 60000);
+                    setTimeout(() => { clearInterval(countdownInterval); void this.continueAfterUsageLimitRecovery(); }, delayMs);
+                    return;
+                }
+                this.showUsageLimitModelSelector();
+            }, () => {
+                done();
+                this.ui.requestRender();
+            }, { tui: this.ui });
+            return { component: selector, focus: selector };
+        });
+    }
+    showUsageLimitModelSelector(initialSearchInput) {
+        this.showSelector((done) => {
+            const selector = new ModelSelectorComponent(this.ui, this.session.model, this.settingsManager, this.session.modelRegistry, this.session.scopedModels, async (model) => {
+                try {
+                    await this.session.setModel(model);
+                    this.footer.invalidate();
+                    this.updateEditorBorderColor();
+                    done();
+                    this.showStatus("Model: " + model.id + "; retrying...");
+                    void this.maybeWarnAboutAnthropicSubscriptionAuth(model);
+                    this.checkDaxnutsEasterEgg(model);
+                    void this.continueAfterUsageLimitRecovery();
+                } catch (error) {
+                    done();
+                    this.showError(error instanceof Error ? error.message : String(error));
+                }
+            }, () => {
+                done();
+                this.ui.requestRender();
+            }, initialSearchInput);
+            return { component: selector, focus: selector };
+        });
+    }
+    getPrismReadOnlyToolNames() {
+        const readOnly = new Set(["read", "grep", "find", "ls", "obsidian_memory_read", "obsidian_memory_search", "obsidian_memory_list", "web_search", "web_fetch"]);
+        return this.session.getActiveToolNames().filter((name) => readOnly.has(name));
+    }
+    setPrismPlanStatus(enabled) {
+        this.prismPlanMode = enabled;
+        this.setExtensionStatus("prism-mode", enabled ? "[Plan]" : undefined);
+        this.footer.invalidate();
+    }
+    async startPrismPlanMode(task) {
+        if (!this.prismPlanPreviousTools) this.prismPlanPreviousTools = this.session.getActiveToolNames();
+        if (this.prismPlanLeafId === undefined) this.prismPlanLeafId = this.session.sessionManager.getLeafId();
+        this.session.setActiveToolsByName(this.getPrismReadOnlyToolNames());
+        this.setPrismPlanStatus(true);
+        globalThis.__PRISM_MANIFEST_TIER_OVERRIDE__ = "plan";
+        const prompt = "PLAN MODE ACTIVE. You must only inspect and plan. Do not modify files or run mutating commands. Ask concise clarification questions if needed. When ready, write the full implementation plan, then end with exactly: /plan:ready\n\nTask: " + (task || "Create an implementation plan for the user's next change.");
+        await this.session.prompt(prompt);
+    }
+    getPrismLastAssistantText(event) {
+        const last = event?.messages?.[event.messages.length - 1];
+        if (last?.role !== "assistant") return "";
+        return (last.content || []).map((block) => block?.type === "text" ? block.text || "" : "").join("\n");
+    }
+    maybeShowPrismPlanApprovalMenu(event) {
+        if (!this.prismPlanMode) return;
+        const text = this.getPrismLastAssistantText(event);
+        if (!text.includes("/plan:ready")) return;
+        this.prismPlanText = text.replace("/plan:ready", "").trim();
+        this.showSelector((done) => {
+            const selector = new ExtensionSelectorComponent("Plan ready", ["Approve -> make changes", "Reject -> add more context", "Cancel plan"], async (selected) => {
+                done();
+                if (selected.startsWith("Approve")) return void this.approvePrismPlan();
+                if (selected.startsWith("Reject")) return this.rejectPrismPlan();
+                this.cancelPrismPlan();
+            }, () => {
+                done();
+                this.ui.requestRender();
+            }, { tui: this.ui });
+            return { component: selector, focus: selector };
+        });
+    }
+    restorePrismPlanTools() {
+        if (this.prismPlanPreviousTools) this.session.setActiveToolsByName(this.prismPlanPreviousTools);
+        this.prismPlanPreviousTools = undefined;
+        if (globalThis.__PRISM_MANIFEST_TIER_OVERRIDE__ === "plan") globalThis.__PRISM_MANIFEST_TIER_OVERRIDE__ = undefined;
+        this.setPrismPlanStatus(false);
+    }
+    restorePrismPlanBranch() {
+        if (this.prismPlanLeafId === undefined) return;
+        if (this.prismPlanLeafId === null) {
+            this.session.sessionManager.resetLeaf();
+        } else {
+            this.session.sessionManager.branch(this.prismPlanLeafId);
+        }
+        this.agent.state.messages = this.session.sessionManager.buildSessionContext().messages;
+        this.prismPlanLeafId = undefined;
+    }
+    async approvePrismPlan() {
+        if (!this.prismPlanMode) return this.showWarning("No active plan to approve.");
+        const planText = this.prismPlanText || "";
+        this.prismPlanText = undefined;
+        this.restorePrismPlanBranch();
+        this.restorePrismPlanTools();
+        await this.session.prompt("Implement this plan:\n\n" + planText);
+    }
+    rejectPrismPlan() {
+        if (!this.prismPlanMode) return this.showWarning("No active plan to reject.");
+        this.prismPlanText = undefined;
+        this.editor.setText("/plan ");
+        this.showStatus("Add more context after /plan and submit.");
+        this.ui.requestRender();
+    }
+    cancelPrismPlan() {
+        if (!this.prismPlanMode) return this.showWarning("No active plan to cancel.");
+        this.restorePrismPlanBranch();
+        this.prismPlanText = undefined;
+        this.restorePrismPlanTools();
+        this.showStatus("Plan cancelled");
+        this.ui.requestRender();
+    }
     /** Extract text content from a user message */
     getUserMessageText(message) {
         if (message.role !== "user")
@@ -2699,12 +3078,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) {
@@ -2714,7 +3093,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;
             }
@@ -2863,2425 +3242,4 @@ export class InteractiveMode {
         if (this.settingsManager.isProjectTrusted() || !hasTrustRequiringProjectResources(this.sessionManager.getCwd())) {
             return;
         }
-        if (this.chatContainer.children.length > 0) {
-            this.chatContainer.addChild(new Spacer(1));
-        }
-        this.chatContainer.addChild(new Text(theme.fg("warning", `This project is not trusted. Project ${CONFIG_DIR_NAME} resources and packages are ignored. Use /trust to save a trust decision, then restart pi.`), 1, 0));
-    }
-    async getUserInput() {
-        const queuedInput = this.pendingUserInputs.shift();
-        if (queuedInput !== undefined) {
-            return queuedInput;
-        }
-        return new Promise((resolve) => {
-            this.onInputCallback = (text) => {
-                this.onInputCallback = undefined;
-                resolve(text);
-            };
-        });
-    }
-    rebuildChatFromMessages() {
-        this.chatContainer.clear();
-        this.renderSessionEntries(this.sessionManager.buildContextEntries());
-    }
-    // =========================================================================
-    // Key handlers
-    // =========================================================================
-    handleCtrlC() {
-        const now = Date.now();
-        if (now - this.lastSigintTime < 500) {
-            void this.shutdown();
-        }
-        else {
-            this.clearEditor();
-            this.lastSigintTime = now;
-        }
-    }
-    handleCtrlD() {
-        // 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;
-        this.isShuttingDown = true;
-        // Keep signal handlers registered until terminal cleanup has completed.
-        // `signal-exit` checks the listener list during the same SIGTERM/SIGHUP
-        // dispatch and re-sends the signal if only its own listeners remain.
-        if (options?.fromSignal) {
-            // Signal-triggered shutdown (SIGTERM/SIGHUP). Emit extension cleanup
-            // (session_shutdown) BEFORE touching the terminal. Extension teardown
-            // such as removing sockets does not write to the tty, so it must not be
-            // skipped if a later terminal-restore write fails on a dead or stalled
-            // terminal. If the terminal is gone, the restore writes below emit EIO,
-            // which the stdout/stderr error handler turns into emergencyTerminalExit;
-            // the render loop is already idle, so this cannot hot-spin (see #4144).
-            await this.runtimeHost.dispose();
-            this.themeController.disableAutoSync();
-            await this.ui.terminal.drainInput(1000);
-            this.stop();
-            process.exit(0);
-        }
-        // Interactive quit (Ctrl+D, Ctrl+C, /quit, extension shutdown()). Stop the
-        // TUI before emitting shutdown events so extension UI cleanup cannot repaint
-        // the final frame while the process is exiting.
-        // Drain any in-flight Kitty key release events before stopping.
-        // This prevents escape sequences from leaking to the parent shell over slow SSH.
-        this.themeController.disableAutoSync();
-        await this.ui.terminal.drainInput(1000);
-        this.stop();
-        await this.runtimeHost.dispose();
-        const resumeCommand = formatResumeCommand(this.sessionManager);
-        if (resumeCommand) {
-            process.stdout.write(`${chalk.dim("To resume this session:")} ${resumeCommand}\n`);
-        }
-        process.exit(0);
-    }
-    emergencyTerminalExit() {
-        this.isShuttingDown = true;
-        this.unregisterSignalHandlers();
-        killTrackedDetachedChildren();
-        // The terminal is gone. Do not run normal shutdown because TUI and
-        // extension cleanup can write restore sequences and re-trigger EIO.
-        process.exit(129);
-    }
-    /**
-     * Last-resort handler for uncaught exceptions. The TUI puts stdin into raw
-     * mode and hides the cursor; without this handler, an uncaught throw from
-     * anywhere (e.g. an extension's async `ChildProcess.on("exit")` callback)
-     * tears down the process while leaving the terminal in raw mode with no
-     * cursor, requiring `stty sane && reset` to recover.
-     *
-     * Unlike emergencyTerminalExit, the terminal is still alive here, so we
-     * call ui.stop() to restore cooked mode, the cursor, and disable bracketed
-     * paste / Kitty / modifyOtherKeys sequences.
-     */
-    uncaughtCrash(error) {
-        if (this.isShuttingDown) {
-            process.exit(1);
-        }
-        this.isShuttingDown = true;
-        try {
-            this.unregisterSignalHandlers();
-        }
-        catch { }
-        try {
-            killTrackedDetachedChildren();
-        }
-        catch { }
-        try {
-            this.ui.stop();
-        }
-        catch { }
-        console.error("pi exiting due to uncaughtException:");
-        console.error(error);
-        process.exit(1);
-    }
-    /**
-     * Check if shutdown was requested and perform shutdown if so.
-     */
-    async checkShutdownRequested() {
-        if (!this.shutdownRequested)
-            return;
-        await this.shutdown();
-    }
-    registerSignalHandlers() {
-        this.unregisterSignalHandlers();
-        const signals = ["SIGTERM"];
-        if (process.platform !== "win32") {
-            signals.push("SIGHUP");
-        }
-        for (const signal of signals) {
-            const handler = () => {
-                // SIGHUP no longer hard-exits: graceful shutdown emits session_shutdown
-                // first, then attempts terminal restore. A genuinely dead terminal
-                // surfaces as an EIO on the restore writes, which the stdout/stderr
-                // error handler converts into emergencyTerminalExit (see #4144, #5080).
-                killTrackedDetachedChildren();
-                void this.shutdown({ fromSignal: true });
-            };
-            process.prependListener(signal, handler);
-            this.signalCleanupHandlers.push(() => process.off(signal, handler));
-        }
-        const terminalErrorHandler = (error) => {
-            if (isDeadTerminalError(error)) {
-                this.emergencyTerminalExit();
-            }
-            throw error;
-        };
-        process.stdout.on("error", terminalErrorHandler);
-        process.stderr.on("error", terminalErrorHandler);
-        this.signalCleanupHandlers.push(() => process.stdout.off("error", terminalErrorHandler));
-        this.signalCleanupHandlers.push(() => process.stderr.off("error", terminalErrorHandler));
-        // Restore the terminal before the process dies on any uncaught throw.
-        // Without this, an unhandled exception from extension code (or anywhere
-        // in pi) leaves the terminal in raw mode with no cursor.
-        const uncaughtExceptionHandler = (error) => this.uncaughtCrash(error);
-        process.prependListener("uncaughtException", uncaughtExceptionHandler);
-        this.signalCleanupHandlers.push(() => process.off("uncaughtException", uncaughtExceptionHandler));
-    }
-    unregisterSignalHandlers() {
-        for (const cleanup of this.signalCleanupHandlers) {
-            cleanup();
-        }
-        this.signalCleanupHandlers = [];
-    }
-    handleCtrlZ() {
-        if (process.platform === "win32") {
-            this.showStatus("Suspend to background is not supported on Windows");
-            return;
-        }
-        // Keep the event loop alive while suspended. Without this, stopping the TUI
-        // can leave Node with no ref'ed handles, causing the process to exit on fg
-        // before the SIGCONT handler gets a chance to restore the terminal.
-        const suspendKeepAlive = setInterval(() => { }, 2 ** 30);
-        // Ignore SIGINT while suspended so Ctrl+C in the terminal does not
-        // kill the backgrounded process. The handler is removed on resume.
-        const ignoreSigint = () => { };
-        process.on("SIGINT", ignoreSigint);
-        // Set up handler to restore TUI when resumed
-        process.once("SIGCONT", () => {
-            clearInterval(suspendKeepAlive);
-            process.removeListener("SIGINT", ignoreSigint);
-            this.ui.start();
-            this.ui.requestRender(true);
-        });
-        try {
-            // Stop the TUI (restore terminal to normal mode)
-            this.ui.stop();
-            // Send SIGTSTP to process group (pid=0 means all processes in group)
-            process.kill(0, "SIGTSTP");
-        }
-        catch (error) {
-            clearInterval(suspendKeepAlive);
-            process.removeListener("SIGINT", ignoreSigint);
-            throw error;
-        }
-    }
-    async handleFollowUp() {
-        const text = (this.editor.getExpandedText?.() ?? this.editor.getText()).trim();
-        if (!text)
-            return;
-        // Queue input during compaction (extension commands execute immediately)
-        if (this.session.isCompacting) {
-            if (this.isExtensionCommand(text)) {
-                this.editor.addToHistory?.(text);
-                this.editor.setText("");
-                await this.session.prompt(text);
-            }
-            else {
-                this.queueCompactionMessage(text, "followUp");
-            }
-            return;
-        }
-        // Alt+Enter queues a follow-up message (waits until agent finishes)
-        // This handles extension commands (execute immediately), prompt template expansion, and queueing
-        if (this.session.isStreaming) {
-            this.editor.addToHistory?.(text);
-            this.editor.setText("");
-            await this.session.prompt(text, { streamingBehavior: "followUp" });
-            this.updatePendingMessagesDisplay();
-            this.ui.requestRender();
-        }
-        // If not streaming, Alt+Enter acts like regular Enter (trigger onSubmit)
-        else if (this.editor.onSubmit) {
-            this.editor.setText("");
-            this.editor.onSubmit(text);
-        }
-    }
-    handleDequeue() {
-        const restored = this.restoreQueuedMessagesToEditor();
-        if (restored === 0) {
-            this.showStatus("No queued messages to restore");
-        }
-        else {
-            this.showStatus(`Restored ${restored} queued message${restored > 1 ? "s" : ""} to editor`);
-        }
-    }
-    updateEditorBorderColor() {
-        if (this.isBashMode) {
-            this.editor.borderColor = theme.getBashModeBorderColor();
-        }
-        else {
-            const level = this.session.thinkingLevel || "off";
-            this.editor.borderColor = theme.getThinkingBorderColor(level);
-        }
-        this.ui.requestRender();
-    }
-    cycleThinkingLevel() {
-        const newLevel = this.session.cycleThinkingLevel();
-        if (newLevel === undefined) {
-            this.showStatus("Current model does not support thinking");
-        }
-        else {
-            this.footer.invalidate();
-            this.updateEditorBorderColor();
-            this.showStatus(`Thinking level: ${newLevel}`);
-        }
-    }
-    async cycleModel(direction) {
-        try {
-            const result = await this.session.cycleModel(direction);
-            if (result === undefined) {
-                const msg = this.session.scopedModels.length > 0 ? "Only one model in scope" : "Only one model available";
-                this.showStatus(msg);
-            }
-            else {
-                this.footer.invalidate();
-                this.updateEditorBorderColor();
-                const thinkingStr = result.model.reasoning && result.thinkingLevel !== "off" ? ` (thinking: ${result.thinkingLevel})` : "";
-                this.showStatus(`Switched to ${result.model.name || result.model.id}${thinkingStr}`);
-                void this.maybeWarnAboutAnthropicSubscriptionAuth(result.model);
-            }
-        }
-        catch (error) {
-            this.showError(error instanceof Error ? error.message : String(error));
-        }
-    }
-    toggleToolOutputExpansion() {
-        this.setToolsExpanded(!this.toolOutputExpanded);
-    }
-    setToolsExpanded(expanded) {
-        this.toolOutputExpanded = expanded;
-        const activeHeader = this.customHeader ?? this.builtInHeader;
-        if (isExpandable(activeHeader)) {
-            activeHeader.setExpanded(expanded);
-        }
-        for (const container of [this.loadedResourcesContainer, this.chatContainer]) {
-            for (const child of container.children) {
-                if (isExpandable(child)) {
-                    child.setExpanded(expanded);
-                }
-            }
-        }
-        this.showStatus(`Tool output: ${expanded ? "expanded" : "collapsed"}`);
-    }
-    toggleThinkingBlockVisibility() {
-        this.hideThinkingBlock = !this.hideThinkingBlock;
-        this.settingsManager.setHideThinkingBlock(this.hideThinkingBlock);
-        // Rebuild chat from session messages
-        this.chatContainer.clear();
-        this.rebuildChatFromMessages();
-        // If streaming, re-add the streaming component with updated visibility and re-render
-        if (this.streamingComponent && this.streamingMessage) {
-            this.streamingComponent.setHideThinkingBlock(this.hideThinkingBlock);
-            this.streamingComponent.updateContent(this.streamingMessage);
-            this.chatContainer.addChild(this.streamingComponent);
-        }
-        this.showStatus(`Thinking blocks: ${this.hideThinkingBlock ? "hidden" : "visible"}`);
-    }
-    async handleOpenExternalEditor() {
-        const editorCmd = this.settingsManager.getExternalEditorCommand();
-        const content = this.editor.getExpandedText?.() ?? this.editor.getText();
-        this.ui.stop();
-        try {
-            const result = await editInExternalEditor({
-                command: editorCmd,
-                content,
-            });
-            if (result.status === "complete") {
-                this.editor.setText(result.content);
-            }
-        }
-        finally {
-            this.ui.start();
-            this.ui.requestRender(true);
-        }
-    }
-    // =========================================================================
-    // UI helpers
-    // =========================================================================
-    clearEditor() {
-        this.editor.setText("");
-        this.ui.requestRender();
-    }
-    showError(errorMessage) {
-        errorMessage = this.humanizeUsageLimitError(errorMessage);
-        this.chatContainer.addChild(new Spacer(1));
-        this.chatContainer.addChild(new Text(theme.fg("error", `Error: ${errorMessage}`), 1, 0));
-        this.ui.requestRender();
-    }
-    showWarning(warningMessage) {
-        this.chatContainer.addChild(new Spacer(1));
-        this.chatContainer.addChild(new Text(theme.fg("warning", `Warning: ${warningMessage}`), 1, 0));
-        this.ui.requestRender();
-    }
-    showNewVersionNotification(release) {
-        const action = theme.fg("accent", `${APP_NAME} update`);
-        const updateInstruction = theme.fg("muted", `New version ${release.version} is available. Run `) + action;
-        const changelogUrl = "https://pi.dev/changelog";
-        const changelogLink = getCapabilities().hyperlinks
-            ? hyperlink(theme.fg("accent", changelogUrl), changelogUrl)
-            : theme.fg("accent", changelogUrl);
-        const changelogLine = theme.fg("muted", "Changelog: ") + changelogLink;
-        const note = release.note?.trim();
-        this.chatContainer.addChild(new Spacer(1));
-        this.chatContainer.addChild(new DynamicBorder((text) => theme.fg("warning", text)));
-        this.chatContainer.addChild(new Text(`${theme.bold(theme.fg("warning", "Update Available"))}\n${updateInstruction}`, 1, 0));
-        if (note) {
-            this.chatContainer.addChild(new Spacer(1));
-            this.chatContainer.addChild(new Markdown(note, 1, 0, this.getMarkdownThemeWithSettings(), {
-                color: (text) => theme.fg("muted", text),
-            }));
-            this.chatContainer.addChild(new Spacer(1));
-        }
-        this.chatContainer.addChild(new Text(changelogLine, 1, 0));
-        this.chatContainer.addChild(new DynamicBorder((text) => theme.fg("warning", text)));
-        this.ui.requestRender();
-    }
-    showPackageUpdateNotification(packages) {
-        const action = theme.fg("accent", `${APP_NAME} update --extensions`);
-        const updateInstruction = theme.fg("muted", "Package updates are available. Run ") + action;
-        const packageLines = packages.map((pkg) => `- ${pkg}`).join("\n");
-        this.chatContainer.addChild(new Spacer(1));
-        this.chatContainer.addChild(new DynamicBorder((text) => theme.fg("warning", text)));
-        this.chatContainer.addChild(new Text(`${theme.bold(theme.fg("warning", "Package Updates Available"))}\n${updateInstruction}\n${theme.fg("muted", "Packages:")}\n${packageLines}`, 1, 0));
-        this.chatContainer.addChild(new DynamicBorder((text) => theme.fg("warning", text)));
-        this.ui.requestRender();
-    }
-    /**
-     * Get all queued messages (read-only).
-     * Combines session queue and compaction queue.
-     */
-    getAllQueuedMessages() {
-        return {
-            steering: [
-                ...this.session.getSteeringMessages(),
-                ...this.compactionQueuedMessages.filter((msg) => msg.mode === "steer").map((msg) => msg.text),
-            ],
-            followUp: [
-                ...this.session.getFollowUpMessages(),
-                ...this.compactionQueuedMessages.filter((msg) => msg.mode === "followUp").map((msg) => msg.text),
-            ],
-        };
-    }
-    /**
-     * Clear all queued messages and return their contents.
-     * Clears both session queue and compaction queue.
-     */
-    clearAllQueues() {
-        const { steering, followUp } = this.session.clearQueue();
-        const compactionSteering = this.compactionQueuedMessages
-            .filter((msg) => msg.mode === "steer")
-            .map((msg) => msg.text);
-        const compactionFollowUp = this.compactionQueuedMessages
-            .filter((msg) => msg.mode === "followUp")
-            .map((msg) => msg.text);
-        this.compactionQueuedMessages = [];
-        return {
-            steering: [...steering, ...compactionSteering],
-            followUp: [...followUp, ...compactionFollowUp],
-        };
-    }
-    updatePendingMessagesDisplay() {
-        this.pendingMessagesContainer.clear();
-        const { steering: steeringMessages, followUp: followUpMessages } = this.getAllQueuedMessages();
-        if (steeringMessages.length > 0 || followUpMessages.length > 0) {
-            this.pendingMessagesContainer.addChild(new Spacer(1));
-            for (const message of steeringMessages) {
-                const text = theme.fg("dim", `Steering: ${message}`);
-                this.pendingMessagesContainer.addChild(new TruncatedText(text, 1, 0));
-            }
-            for (const message of followUpMessages) {
-                const text = theme.fg("dim", `Follow-up: ${message}`);
-                this.pendingMessagesContainer.addChild(new TruncatedText(text, 1, 0));
-            }
-            const dequeueHint = this.getAppKeyDisplay("app.message.dequeue");
-            const hintText = theme.fg("dim", `↳ ${dequeueHint} to edit all queued messages`);
-            this.pendingMessagesContainer.addChild(new TruncatedText(hintText, 1, 0));
-        }
-    }
-    restoreQueuedMessagesToEditor(options) {
-        const { steering, followUp } = this.clearAllQueues();
-        const allQueued = [...steering, ...followUp];
-        if (allQueued.length === 0) {
-            this.updatePendingMessagesDisplay();
-            if (options?.abort) {
-                this.agent.abort();
-            }
-            return 0;
-        }
-        const queuedText = allQueued.join("\n\n");
-        const currentText = options?.currentText ?? this.editor.getText();
-        const combinedText = [queuedText, currentText].filter((t) => t.trim()).join("\n\n");
-        this.editor.setText(combinedText);
-        this.updatePendingMessagesDisplay();
-        if (options?.abort) {
-            this.agent.abort();
-        }
-        return allQueued.length;
-    }
-    queueCompactionMessage(text, mode) {
-        this.compactionQueuedMessages.push({ text, mode });
-        this.editor.addToHistory?.(text);
-        this.editor.setText("");
-        this.updatePendingMessagesDisplay();
-        this.showStatus("Queued message for after compaction");
-    }
-    isExtensionCommand(text) {
-        if (!text.startsWith("/"))
-            return false;
-        const extensionRunner = this.session.extensionRunner;
-        const spaceIndex = text.indexOf(" ");
-        const commandName = spaceIndex === -1 ? text.slice(1) : text.slice(1, spaceIndex);
-        return !!extensionRunner.getCommand(commandName);
-    }
-    async flushCompactionQueue(options) {
-        if (this.compactionQueuedMessages.length === 0) {
-            return;
-        }
-        const queuedMessages = [...this.compactionQueuedMessages];
-        this.compactionQueuedMessages = [];
-        this.updatePendingMessagesDisplay();
-        const restoreQueue = (error) => {
-            this.session.clearQueue();
-            this.compactionQueuedMessages = queuedMessages;
-            this.updatePendingMessagesDisplay();
-            this.showError(`Failed to send queued message${queuedMessages.length > 1 ? "s" : ""}: ${error instanceof Error ? error.message : String(error)}`);
-        };
-        try {
-            if (options?.willRetry) {
-                // When retry is pending, queue messages for the retry turn
-                for (const message of queuedMessages) {
-                    if (this.isExtensionCommand(message.text)) {
-                        await this.session.prompt(message.text);
-                    }
-                    else if (message.mode === "followUp") {
-                        await this.session.followUp(message.text);
-                    }
-                    else {
-                        await this.session.steer(message.text);
-                    }
-                }
-                this.updatePendingMessagesDisplay();
-                return;
-            }
-            // Find first non-extension-command message to use as prompt
-            const firstPromptIndex = queuedMessages.findIndex((message) => !this.isExtensionCommand(message.text));
-            if (firstPromptIndex === -1) {
-                // All extension commands - execute them all
-                for (const message of queuedMessages) {
-                    await this.session.prompt(message.text);
-                }
-                return;
-            }
-            // Execute any extension commands before the first prompt
-            const preCommands = queuedMessages.slice(0, firstPromptIndex);
-            const firstPrompt = queuedMessages[firstPromptIndex];
-            const rest = queuedMessages.slice(firstPromptIndex + 1);
-            for (const message of preCommands) {
-                await this.session.prompt(message.text);
-            }
-            // Start a prompt when idle, or queue it into a run still finishing compaction.
-            const promptPromise = this.session
-                .prompt(firstPrompt.text, { streamingBehavior: firstPrompt.mode })
-                .catch((error) => {
-                restoreQueue(error);
-            });
-            // Queue remaining messages
-            for (const message of rest) {
-                if (this.isExtensionCommand(message.text)) {
-                    await this.session.prompt(message.text);
-                }
-                else if (message.mode === "followUp") {
-                    await this.session.followUp(message.text);
-                }
-                else {
-                    await this.session.steer(message.text);
-                }
-            }
-            this.updatePendingMessagesDisplay();
-            void promptPromise;
-        }
-        catch (error) {
-            restoreQueue(error);
-        }
-    }
-    /** Move pending bash components from pending area to chat */
-    flushPendingBashComponents() {
-        for (const component of this.pendingBashComponents) {
-            this.pendingMessagesContainer.removeChild(component);
-            this.chatContainer.addChild(component);
-        }
-        this.pendingBashComponents = [];
-    }
-    // =========================================================================
-    // Selectors
-    // =========================================================================
-    /**
-     * 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) {
-        const done = () => {
-            this.editorContainer.clear();
-            this.editorContainer.addChild(this.editor);
-            this.ui.setFocus(this.editor);
-        };
-        const { component, focus } = create(done);
-        this.editorContainer.clear();
-        this.editorContainer.addChild(component);
-        this.ui.setFocus(focus);
-        this.ui.requestRender();
-    }
-    showSettingsSelector() {
-        this.showSelector((done) => {
-            const selector = new SettingsSelectorComponent({
-                autoCompact: this.session.autoCompactionEnabled,
-                showImages: this.settingsManager.getShowImages(),
-                imageWidthCells: this.settingsManager.getImageWidthCells(),
-                autoResizeImages: this.settingsManager.getImageAutoResize(),
-                blockImages: this.settingsManager.getBlockImages(),
-                enableSkillCommands: this.settingsManager.getEnableSkillCommands(),
-                steeringMode: this.session.steeringMode,
-                followUpMode: this.session.followUpMode,
-                transport: this.settingsManager.getTransport(),
-                httpIdleTimeoutMs: this.settingsManager.getHttpIdleTimeoutMs(),
-                thinkingLevel: this.session.thinkingLevel,
-                availableThinkingLevels: this.session.getAvailableThinkingLevels(),
-                currentTheme: this.settingsManager.getThemeSetting() || "dark",
-                terminalTheme: this.themeController.getTerminalTheme(),
-                availableThemes: getAvailableThemes(),
-                hideThinkingBlock: this.hideThinkingBlock,
-                collapseChangelog: this.settingsManager.getCollapseChangelog(),
-                enableInstallTelemetry: this.settingsManager.getEnableInstallTelemetry(),
-                doubleEscapeAction: this.settingsManager.getDoubleEscapeAction(),
-                treeFilterMode: this.settingsManager.getTreeFilterMode(),
-                showHardwareCursor: this.settingsManager.getShowHardwareCursor(),
-                showCacheMissNotices: this.settingsManager.getShowCacheMissNotices(),
-                defaultProjectTrust: this.settingsManager.getDefaultProjectTrust(),
-                editorPaddingX: this.settingsManager.getEditorPaddingX(),
-                outputPad: this.settingsManager.getOutputPad(),
-                autocompleteMaxVisible: this.settingsManager.getAutocompleteMaxVisible(),
-                quietStartup: this.settingsManager.getQuietStartup(),
-                clearOnShrink: this.settingsManager.getClearOnShrink(),
-                showTerminalProgress: this.settingsManager.getShowTerminalProgress(),
-                warnings: this.settingsManager.getWarnings(),
-            }, {
-                onAutoCompactChange: (enabled) => {
-                    this.session.setAutoCompactionEnabled(enabled);
-                    this.footer.setAutoCompactEnabled(enabled);
-                },
-                onShowImagesChange: (enabled) => {
-                    this.settingsManager.setShowImages(enabled);
-                    for (const child of this.chatContainer.children) {
-                        if (child instanceof ToolExecutionComponent) {
-                            child.setShowImages(enabled);
-                        }
-                    }
-                },
-                onImageWidthCellsChange: (width) => {
-                    this.settingsManager.setImageWidthCells(width);
-                    for (const child of this.chatContainer.children) {
-                        if (child instanceof ToolExecutionComponent) {
-                            child.setImageWidthCells(width);
-                        }
-                    }
-                },
-                onAutoResizeImagesChange: (enabled) => {
-                    this.settingsManager.setImageAutoResize(enabled);
-                },
-                onBlockImagesChange: (blocked) => {
-                    this.settingsManager.setBlockImages(blocked);
-                },
-                onEnableSkillCommandsChange: (enabled) => {
-                    this.settingsManager.setEnableSkillCommands(enabled);
-                    this.setupAutocompleteProvider();
-                },
-                onSteeringModeChange: (mode) => {
-                    this.session.setSteeringMode(mode);
-                },
-                onFollowUpModeChange: (mode) => {
-                    this.session.setFollowUpMode(mode);
-                },
-                onTransportChange: (transport) => {
-                    this.settingsManager.setTransport(transport);
-                    this.session.agent.transport = transport;
-                },
-                onHttpIdleTimeoutMsChange: (timeoutMs) => {
-                    this.settingsManager.setHttpIdleTimeoutMs(timeoutMs);
-                    configureHttpDispatcher(timeoutMs);
-                    this.showStatus(`HTTP idle timeout: ${formatHttpIdleTimeoutMs(timeoutMs)}`);
-                },
-                onThinkingLevelChange: (level) => {
-                    this.session.setThinkingLevel(level);
-                    this.footer.invalidate();
-                    this.updateEditorBorderColor();
-                },
-                onThemeChange: (themeSetting) => {
-                    this.settingsManager.setTheme(themeSetting);
-                    void this.themeController.applyFromSettings();
-                },
-                onThemePreview: (themeName) => this.themeController.preview(themeName),
-                onHideThinkingBlockChange: (hidden) => {
-                    this.hideThinkingBlock = hidden;
-                    this.settingsManager.setHideThinkingBlock(hidden);
-                    for (const child of this.chatContainer.children) {
-                        if (child instanceof AssistantMessageComponent) {
-                            child.setHideThinkingBlock(hidden);
-                        }
-                    }
-                    this.chatContainer.clear();
-                    this.rebuildChatFromMessages();
-                },
-                onShowCacheMissNoticesChange: (shown) => {
-                    this.settingsManager.setShowCacheMissNotices(shown);
-                    this.rebuildChatFromMessages();
-                },
-                onCollapseChangelogChange: (collapsed) => {
-                    this.settingsManager.setCollapseChangelog(collapsed);
-                },
-                onEnableInstallTelemetryChange: (enabled) => {
-                    this.settingsManager.setEnableInstallTelemetry(enabled);
-                },
-                onQuietStartupChange: (enabled) => {
-                    this.settingsManager.setQuietStartup(enabled);
-                },
-                onDefaultProjectTrustChange: (defaultProjectTrust) => {
-                    this.settingsManager.setDefaultProjectTrust(defaultProjectTrust);
-                },
-                onDoubleEscapeActionChange: (action) => {
-                    this.settingsManager.setDoubleEscapeAction(action);
-                },
-                onTreeFilterModeChange: (mode) => {
-                    this.settingsManager.setTreeFilterMode(mode);
-                },
-                onShowHardwareCursorChange: (enabled) => {
-                    this.settingsManager.setShowHardwareCursor(enabled);
-                    this.ui.setShowHardwareCursor(enabled);
-                },
-                onEditorPaddingXChange: (padding) => {
-                    this.settingsManager.setEditorPaddingX(padding);
-                    this.defaultEditor.setPaddingX(padding);
-                    if (this.editor !== this.defaultEditor && this.editor.setPaddingX !== undefined) {
-                        this.editor.setPaddingX(padding);
-                    }
-                },
-                onOutputPadChange: (padding) => {
-                    this.settingsManager.setOutputPad(padding);
-                    this.outputPad = padding;
-                    if (this.streamingComponent || this.session.isStreaming) {
-                        for (const child of this.chatContainer.children) {
-                            if (child instanceof AssistantMessageComponent ||
-                                child instanceof CustomMessageComponent ||
-                                child instanceof UserMessageComponent) {
-                                child.setOutputPad(padding);
-                            }
-                        }
-                        if (this.streamingComponent) {
-                            this.streamingComponent.setOutputPad(padding);
-                        }
-                        this.ui.requestRender();
-                        return;
-                    }
-                    this.rebuildChatFromMessages();
-                },
-                onAutocompleteMaxVisibleChange: (maxVisible) => {
-                    this.settingsManager.setAutocompleteMaxVisible(maxVisible);
-                    this.defaultEditor.setAutocompleteMaxVisible(maxVisible);
-                    if (this.editor !== this.defaultEditor && this.editor.setAutocompleteMaxVisible !== undefined) {
-                        this.editor.setAutocompleteMaxVisible(maxVisible);
-                    }
-                },
-                onClearOnShrinkChange: (enabled) => {
-                    this.settingsManager.setClearOnShrink(enabled);
-                    this.ui.setClearOnShrink(enabled);
-                    if (!enabled && !this.activeStatusIndicator) {
-                        this.statusContainer.clear();
-                    }
-                },
-                onShowTerminalProgressChange: (enabled) => {
-                    this.settingsManager.setShowTerminalProgress(enabled);
-                },
-                onWarningsChange: (warnings) => {
-                    this.settingsManager.setWarnings(warnings);
-                },
-                onCancel: () => {
-                    done();
-                    this.ui.requestRender();
-                },
-            });
-            return { component: selector, focus: selector.getSettingsList() };
-        });
-    }
-    async handleModelCommand(searchTerm) {
-        if (!searchTerm) {
-            this.showModelSelector();
-            return;
-        }
-        const model = await this.findExactModelMatch(searchTerm);
-        if (model) {
-            try {
-                await this.session.setModel(model);
-                this.footer.invalidate();
-                this.updateEditorBorderColor();
-                this.showStatus(`Model: ${model.id}`);
-                void this.maybeWarnAboutAnthropicSubscriptionAuth(model);
-                this.checkDaxnutsEasterEgg(model);
-            }
-            catch (error) {
-                this.showError(error instanceof Error ? error.message : String(error));
-            }
-            return;
-        }
-        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);
-        }
-        try {
-            await this.session.modelRuntime.refresh();
-            return [...(await this.session.modelRuntime.getAvailable())];
-        }
-        catch {
-            return [];
-        }
-    }
-    /** Update the footer's available provider count from the current snapshot without refreshing catalogs. */
-    updateAvailableProviderCount() {
-        const models = this.session.scopedModels.length > 0
-            ? this.session.scopedModels.map((scoped) => scoped.model)
-            : this.session.modelRuntime.getAvailableSnapshot();
-        const uniqueProviders = new Set(models.map((model) => model.provider));
-        this.footerDataProvider.setAvailableProviderCount(uniqueProviders.size);
-    }
-    async maybeWarnAboutAnthropicSubscriptionAuth(model = this.session.model) {
-        if (this.settingsManager.getWarnings().anthropicExtraUsage === false) {
-            return;
-        }
-        if (this.anthropicSubscriptionWarningShown) {
-            return;
-        }
-        if (!model || model.provider !== "anthropic") {
-            return;
-        }
-        try {
-            if ((await this.session.modelRuntime.checkAuth("anthropic"))?.type === "oauth") {
-                this.anthropicSubscriptionWarningShown = true;
-                this.showWarning(ANTHROPIC_SUBSCRIPTION_AUTH_WARNING);
-                return;
-            }
-            const apiKey = (await this.session.modelRuntime.getAuth(model.provider))?.auth.apiKey;
-            if (!isAnthropicSubscriptionAuthKey(apiKey)) {
-                return;
-            }
-            this.anthropicSubscriptionWarningShown = true;
-            this.showWarning(ANTHROPIC_SUBSCRIPTION_AUTH_WARNING);
-        }
-        catch {
-            // Ignore auth lookup failures for warning-only checks.
-        }
-    }
-    maybeSaveImplicitProjectTrustAfterReload() {
-        const cwd = this.sessionManager.getCwd();
-        if (this.autoTrustOnReloadCwd !== cwd) {
-            return false;
-        }
-        if (!this.settingsManager.isProjectTrusted() || !hasTrustRequiringProjectResources(cwd)) {
-            return false;
-        }
-        const trustStore = new ProjectTrustStore(this.runtimeHost.services.agentDir);
-        try {
-            if (trustStore.get(cwd) !== null) {
-                this.autoTrustOnReloadCwd = undefined;
-                return false;
-            }
-            trustStore.set(cwd, true);
-            this.autoTrustOnReloadCwd = undefined;
-            return true;
-        }
-        catch (error) {
-            this.showWarning(`Could not save project trust after reload: ${error instanceof Error ? error.message : String(error)}`);
-            return false;
-        }
-    }
-    showTrustSelector() {
-        const cwd = this.sessionManager.getCwd();
-        const trustStore = new ProjectTrustStore(this.runtimeHost.services.agentDir);
-        const savedDecision = trustStore.getEntry(cwd);
-        this.showSelector((done) => {
-            const selector = new TrustSelectorComponent({
-                cwd,
-                savedDecision,
-                projectTrusted: this.settingsManager.isProjectTrusted(),
-                onSelect: (selection) => {
-                    trustStore.setMany(selection.updates);
-                    done();
-                    this.showStatus(`Saved trust decision: ${selection.trusted ? "trusted" : "untrusted"}. Restart pi for this to take effect.`);
-                },
-                onCancel: () => {
-                    done();
-                    this.ui.requestRender();
-                },
-            });
-            return { component: selector, focus: selector };
-        });
-    }
-    formatUsageLimitDuration(ms) {
-        const totalMinutes = Math.ceil(ms / 60000);
-        const hours = Math.floor(totalMinutes / 60);
-        const minutes = totalMinutes % 60;
-        const parts = [];
-        if (hours > 0) parts.push(hours + "h");
-        if (minutes > 0 || parts.length === 0) parts.push(minutes + "min");
-        return parts.join(" ");
-    }
-    humanizeUsageLimitError(errorMessage) {
-        return String(errorMessage || "").replace(/(~|about\s*)?(\d+)\s*min\b/gi, (_match, prefix, minutes) => {
-            return (prefix || "") + this.formatUsageLimitDuration(Number(minutes) * 60 * 1000);
-        });
-    }
-    extractUsageLimitWaitMs(errorMessage) {
-        const text = String(errorMessage || "");
-        const parsedSeconds = text.match(/"(?:resets_in_seconds|X-Codex-Primary-Reset-After-Seconds|Retry-After)"\s*:?\s*"?(\d+)"?/i)?.[1];
-        if (parsedSeconds) return Number(parsedSeconds) * 1000;
-        const resetAt = text.match(/"(?:resets_at|X-Codex-Primary-Reset-At)"\s*:?\s*"?(\d+)"?/i)?.[1];
-        if (resetAt) {
-            const resetMs = Number(resetAt) * 1000 - Date.now();
-            if (Number.isFinite(resetMs) && resetMs > 0) return resetMs;
-        }
-        const hours = text.match(/(?:~|about\s*)?(\d+)\s*h(?:our)?/i)?.[1];
-        if (hours) return Number(hours) * 60 * 60 * 1000;
-        const minutes = text.match(/(?:~|about\s*)?(\d+)\s*min/i)?.[1];
-        if (minutes) return Number(minutes) * 60 * 1000;
-        const seconds = text.match(/(?:~|about\s*)?(\d+)\s*s(?:ec|econd)?/i)?.[1];
-        if (seconds) return Number(seconds) * 1000;
-        return 5 * 60 * 1000;
-    }
-    getUsageLimitError(event) {
-        const last = event?.messages?.[event.messages.length - 1];
-        const errorMessage = last?.errorMessage || last?.content?.find?.((block) => block?.type === "text")?.text || "";
-        if (last?.role !== "assistant" || last?.stopReason !== "error") return undefined;
-        return /usage limit|try again in/i.test(errorMessage) ? String(errorMessage) : undefined;
-    }
-    removeLastAssistantErrorFromState() {
-        const messages = this.agent.state.messages;
-        const last = messages[messages.length - 1];
-        if (last?.role === "assistant" && last?.stopReason === "error") this.agent.state.messages = messages.slice(0, -1);
-    }
-    async continueAfterUsageLimitRecovery() {
-        try {
-            await this.agent.continue();
-        } catch (error) {
-            this.showError(error instanceof Error ? error.message : String(error));
-        }
-    }
-    maybeShowUsageLimitRecoveryMenu(event) {
-        const errorMessage = this.getUsageLimitError(event);
-        if (!errorMessage) return;
-        const delayMs = this.extractUsageLimitWaitMs(errorMessage);
-        const waitLabel = "Wait " + this.formatUsageLimitDuration(delayMs) + " then retry";
-        this.showSelector((done) => {
-            const selector = new ExtensionSelectorComponent("Usage limit hit", [waitLabel, "Change model and retry", "Cancel"], async (selected) => {
-                done();
-                if (selected === "Cancel") return;
-                this.removeLastAssistantErrorFromState();
-                if (selected === waitLabel) {
-                    const endTime = Date.now() + delayMs;
-                    const updateCountdown = () => {
-                        const remaining = Math.max(0, endTime - Date.now());
-                        this.showStatus("Waiting " + this.formatUsageLimitDuration(remaining) + " for usage limit, then retrying...");
-                        this.ui.requestRender();
-                    };
-                    updateCountdown();
-                    const countdownInterval = setInterval(updateCountdown, 60000);
-                    setTimeout(() => { clearInterval(countdownInterval); void this.continueAfterUsageLimitRecovery(); }, delayMs);
-                    return;
-                }
-                this.showUsageLimitModelSelector();
-            }, () => {
-                done();
-                this.ui.requestRender();
-            }, { tui: this.ui });
-            return { component: selector, focus: selector };
-        });
-    }
-    showUsageLimitModelSelector(initialSearchInput) {
-        this.showSelector((done) => {
-            const selector = new ModelSelectorComponent(this.ui, this.session.model, this.settingsManager, this.session.modelRegistry, this.session.scopedModels, async (model) => {
-                try {
-                    await this.session.setModel(model);
-                    this.footer.invalidate();
-                    this.updateEditorBorderColor();
-                    done();
-                    this.showStatus("Model: " + model.id + "; retrying...");
-                    void this.maybeWarnAboutAnthropicSubscriptionAuth(model);
-                    this.checkDaxnutsEasterEgg(model);
-                    void this.continueAfterUsageLimitRecovery();
-                } catch (error) {
-                    done();
-                    this.showError(error instanceof Error ? error.message : String(error));
-                }
-            }, () => {
-                done();
-                this.ui.requestRender();
-            }, initialSearchInput);
-            return { component: selector, focus: selector };
-        });
-    }
-    getPrismReadOnlyToolNames() {
-        const readOnly = new Set(["read", "grep", "find", "ls", "obsidian_memory_read", "obsidian_memory_search", "obsidian_memory_list", "web_search", "web_fetch"]);
-        return this.session.getActiveToolNames().filter((name) => readOnly.has(name));
-    }
-    setPrismPlanStatus(enabled) {
-        this.prismPlanMode = enabled;
-        this.setExtensionStatus("prism-mode", enabled ? "[Plan]" : undefined);
-        this.footer.invalidate();
-    }
-    async startPrismPlanMode(task) {
-        if (!this.prismPlanPreviousTools) this.prismPlanPreviousTools = this.session.getActiveToolNames();
-        if (this.prismPlanLeafId === undefined) this.prismPlanLeafId = this.session.sessionManager.getLeafId();
-        this.session.setActiveToolsByName(this.getPrismReadOnlyToolNames());
-        this.setPrismPlanStatus(true);
-        globalThis.__PRISM_MANIFEST_TIER_OVERRIDE__ = "plan";
-        const prompt = "PLAN MODE ACTIVE. You must only inspect and plan. Do not modify files or run mutating commands. Ask concise clarification questions if needed. When ready, write the full implementation plan, then end with exactly: /plan:ready\n\nTask: " + (task || "Create an implementation plan for the user's next change.");
-        await this.session.prompt(prompt);
-    }
-    getPrismLastAssistantText(event) {
-        const last = event?.messages?.[event.messages.length - 1];
-        if (last?.role !== "assistant") return "";
-        return (last.content || []).map((block) => block?.type === "text" ? block.text || "" : "").join("\n");
-    }
-    maybeShowPrismPlanApprovalMenu(event) {
-        if (!this.prismPlanMode) return;
-        const text = this.getPrismLastAssistantText(event);
-        if (!text.includes("/plan:ready")) return;
-        this.prismPlanText = text.replace("/plan:ready", "").trim();
-        this.showSelector((done) => {
-            const selector = new ExtensionSelectorComponent("Plan ready", ["Approve -> make changes", "Reject -> add more context", "Cancel plan"], async (selected) => {
-                done();
-                if (selected.startsWith("Approve")) return void this.approvePrismPlan();
-                if (selected.startsWith("Reject")) return this.rejectPrismPlan();
-                this.cancelPrismPlan();
-            }, () => {
-                done();
-                this.ui.requestRender();
-            }, { tui: this.ui });
-            return { component: selector, focus: selector };
-        });
-    }
-    restorePrismPlanTools() {
-        if (this.prismPlanPreviousTools) this.session.setActiveToolsByName(this.prismPlanPreviousTools);
-        this.prismPlanPreviousTools = undefined;
-        if (globalThis.__PRISM_MANIFEST_TIER_OVERRIDE__ === "plan") globalThis.__PRISM_MANIFEST_TIER_OVERRIDE__ = undefined;
-        this.setPrismPlanStatus(false);
-    }
-    restorePrismPlanBranch() {
-        if (this.prismPlanLeafId === undefined) return;
-        if (this.prismPlanLeafId === null) {
-            this.session.sessionManager.resetLeaf();
-        } else {
-            this.session.sessionManager.branch(this.prismPlanLeafId);
-        }
-        this.agent.state.messages = this.session.sessionManager.buildSessionContext().messages;
-        this.prismPlanLeafId = undefined;
-    }
-    async approvePrismPlan() {
-        if (!this.prismPlanMode) return this.showWarning("No active plan to approve.");
-        const planText = this.prismPlanText || "";
-        this.prismPlanText = undefined;
-        this.restorePrismPlanBranch();
-        this.restorePrismPlanTools();
-        await this.session.prompt("Implement this plan:\n\n" + planText);
-    }
-    rejectPrismPlan() {
-        if (!this.prismPlanMode) return this.showWarning("No active plan to reject.");
-        this.prismPlanText = undefined;
-        this.editor.setText("/plan ");
-        this.showStatus("Add more context after /plan and submit.");
-        this.ui.requestRender();
-    }
-    cancelPrismPlan() {
-        if (!this.prismPlanMode) return this.showWarning("No active plan to cancel.");
-        this.restorePrismPlanBranch();
-        this.prismPlanText = undefined;
-        this.restorePrismPlanTools();
-        this.showStatus("Plan cancelled");
-        this.ui.requestRender();
-    }
-    showModelSelector(initialSearchInput) {
-        this.showSelector((done) => {
-            const selector = new ModelSelectorComponent(this.ui, this.session.model, this.settingsManager, this.session.modelRuntime, this.session.scopedModels, async (model) => {
-                try {
-                    await this.session.setModel(model);
-                    this.footer.invalidate();
-                    this.updateEditorBorderColor();
-                    done();
-                    this.showStatus(`Model: ${model.id}`);
-                    void this.maybeWarnAboutAnthropicSubscriptionAuth(model);
-                    this.checkDaxnutsEasterEgg(model);
-                }
-                catch (error) {
-                    done();
-                    this.showError(error instanceof Error ? error.message : String(error));
-                }
-            }, () => {
-                done();
-                this.ui.requestRender();
-            }, initialSearchInput);
-            return { component: selector, focus: selector };
-        });
-    }
-    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}`));
-        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) => {
-            currentEnabledIds = enabledIds === null ? null : [...enabledIds];
-            const hasEnabledAvailableModel = enabledIds?.some((id) => allModelIds.has(id)) ?? false;
-            const allAvailableModelsEnabled = enabledIds !== null && [...allModelIds].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,
-                })));
-            }
-            else {
-                // All enabled or none enabled = no filter
-                this.session.setScopedModels([]);
-            }
-            await this.updateAvailableProviderCount();
-            this.ui.requestRender();
-        };
-        this.showSelector((done) => {
-            const selector = new ScopedModelsSelectorComponent({
-                allModels,
-                enabledModelIds: currentEnabledIds,
-            }, {
-                onChange: async (enabledIds) => {
-                    await updateSessionModels(enabledIds);
-                },
-                onPersist: (enabledIds) => {
-                    // Persist to settings
-                    const allEnabled = enabledIds !== null &&
-                        enabledIds.length === allModels.length &&
-                        enabledIds.every((id) => allModelIds.has(id));
-                    const newPatterns = enabledIds === null || allEnabled ? undefined : enabledIds;
-                    this.settingsManager.setEnabledModels(newPatterns ? [...newPatterns] : undefined);
-                    this.showStatus("Model selection saved to settings");
-                },
-                onCancel: () => {
-                    done();
-                    this.ui.requestRender();
-                },
-            });
-            return { component: selector, focus: selector };
-        });
-    }
-    showUserMessageSelector() {
-        const userMessages = this.session.getUserMessagesForForking();
-        if (userMessages.length === 0) {
-            this.showStatus("No messages to fork from");
-            return;
-        }
-        const initialSelectedId = userMessages[userMessages.length - 1]?.entryId;
-        this.showSelector((done) => {
-            const selector = new UserMessageSelectorComponent(userMessages.map((m) => ({ id: m.entryId, text: m.text })), async (entryId) => {
-                done();
-                try {
-                    const result = await this.runtimeHost.fork(entryId);
-                    if (result.cancelled) {
-                        this.ui.requestRender();
-                        return;
-                    }
-                    this.editor.setText(result.selectedText ?? "");
-                    this.showStatus("Forked to new session");
-                }
-                catch (error) {
-                    this.showError(error instanceof Error ? error.message : String(error));
-                }
-            }, () => {
-                done();
-                this.ui.requestRender();
-            }, initialSelectedId);
-            return { component: selector, focus: selector.getMessageList() };
-        });
-    }
-    async handleCloneCommand() {
-        const leafId = this.sessionManager.getLeafId();
-        if (!leafId) {
-            this.showStatus("Nothing to clone yet");
-            return;
-        }
-        try {
-            const result = await this.runtimeHost.fork(leafId, { position: "at" });
-            if (result.cancelled) {
-                this.ui.requestRender();
-                return;
-            }
-            this.editor.setText("");
-            this.showStatus("Cloned to new session");
-        }
-        catch (error) {
-            this.showError(error instanceof Error ? error.message : String(error));
-        }
-    }
-    showTreeSelector(initialSelectedId) {
-        const tree = this.sessionManager.getTree();
-        const realLeafId = this.sessionManager.getLeafId();
-        const initialFilterMode = this.settingsManager.getTreeFilterMode();
-        if (tree.length === 0) {
-            this.showStatus("No entries in session");
-            return;
-        }
-        this.showSelector((done) => {
-            const selector = new TreeSelectorComponent(tree, realLeafId, this.ui.terminal.rows, async (entryId) => {
-                // Selecting the current leaf is a no-op (already there)
-                if (entryId === this.sessionManager.getLeafId()) {
-                    done();
-                    this.showStatus("Already at this point");
-                    return;
-                }
-                // Ask about summarization
-                done(); // Close selector first
-                // Loop until user makes a complete choice or cancels to tree
-                let wantsSummary = false;
-                let customInstructions;
-                // Check if we should skip the prompt (user preference to always default to no summary)
-                if (!this.settingsManager.getBranchSummarySkipPrompt()) {
-                    while (true) {
-                        const summaryChoice = await this.showExtensionSelector("Summarize branch?", [
-                            "No summary",
-                            "Summarize",
-                            "Summarize with custom prompt",
-                        ]);
-                        if (summaryChoice === undefined) {
-                            // User pressed escape - re-show tree selector with same selection
-                            this.showTreeSelector(entryId);
-                            return;
-                        }
-                        wantsSummary = summaryChoice !== "No summary";
-                        if (summaryChoice === "Summarize with custom prompt") {
-                            customInstructions = await this.showExtensionEditor("Custom summarization instructions");
-                            if (customInstructions === undefined) {
-                                // User cancelled - loop back to summary selector
-                                continue;
-                            }
-                        }
-                        // User made a complete choice
-                        break;
-                    }
-                }
-                // The user committed to navigating: stop the active response first.
-                if (this.session.isStreaming) {
-                    this.restoreQueuedMessagesToEditor();
-                    await this.session.abort();
-                }
-                // Set up escape handler and status indicator if summarizing
-                let showingSummaryIndicator = false;
-                const originalOnEscape = this.defaultEditor.onEscape;
-                if (wantsSummary) {
-                    this.defaultEditor.onEscape = () => {
-                        this.session.abortBranchSummary();
-                    };
-                    this.chatContainer.addChild(new Spacer(1));
-                    this.showStatusIndicator(new BranchSummaryStatusIndicator(this.ui));
-                    showingSummaryIndicator = true;
-                    this.ui.requestRender();
-                }
-                try {
-                    const result = await this.session.navigateTree(entryId, {
-                        summarize: wantsSummary,
-                        customInstructions,
-                    });
-                    if (result.aborted) {
-                        // Summarization aborted - re-show tree selector with same selection
-                        this.showStatus("Branch summarization cancelled");
-                        this.showTreeSelector(entryId);
-                        return;
-                    }
-                    if (result.cancelled) {
-                        this.showStatus("Navigation cancelled");
-                        return;
-                    }
-                    // Update UI
-                    this.chatContainer.clear();
-                    this.renderInitialMessages();
-                    if (result.editorText && !this.editor.getText().trim()) {
-                        this.editor.setText(result.editorText);
-                    }
-                    this.showStatus("Navigated to selected point");
-                    void this.flushCompactionQueue({ willRetry: false });
-                }
-                catch (error) {
-                    this.showError(error instanceof Error ? error.message : String(error));
-                }
-                finally {
-                    if (showingSummaryIndicator) {
-                        this.clearStatusIndicator("branchSummary");
-                    }
-                    this.defaultEditor.onEscape = originalOnEscape;
-                }
-            }, () => {
-                done();
-                this.ui.requestRender();
-            }, (entryId, label) => {
-                this.sessionManager.appendLabelChange(entryId, label);
-                this.ui.requestRender();
-            }, initialSelectedId, initialFilterMode);
-            selector.onCopy = async (text) => {
-                if (!text) {
-                    this.showError("Selected entry has no text to copy");
-                    return;
-                }
-                try {
-                    await copyToClipboard(text);
-                    this.showStatus("Copied selected message to clipboard");
-                }
-                catch (error) {
-                    this.showError(error instanceof Error ? error.message : String(error));
-                }
-            };
-            return { component: selector, focus: selector };
-        });
-    }
-    showSessionSelector() {
-        this.showSelector((done) => {
-            const selector = new SessionSelectorComponent((onProgress) => SessionManager.list(this.sessionManager.getCwd(), this.sessionManager.getSessionDir(), onProgress), (onProgress) => this.sessionManager.usesDefaultSessionDir()
-                ? SessionManager.listAll(onProgress)
-                : SessionManager.listAll(this.sessionManager.getSessionDir(), onProgress), async (sessionPath) => {
-                done();
-                await this.handleResumeSession(sessionPath);
-            }, () => {
-                done();
-                this.ui.requestRender();
-            }, () => {
-                void this.shutdown();
-            }, () => this.ui.requestRender(), {
-                renameSession: async (sessionFilePath, nextName) => {
-                    const next = (nextName ?? "").trim();
-                    if (!next)
-                        return;
-                    const mgr = SessionManager.open(sessionFilePath);
-                    mgr.appendSessionInfo(next);
-                },
-                showRenameHint: true,
-                keybindings: this.keybindings,
-            }, this.sessionManager.getSessionFile());
-            return { component: selector, focus: selector };
-        });
-    }
-    async handleResumeSession(sessionPath, options) {
-        this.clearStatusIndicator();
-        try {
-            const result = await this.runtimeHost.switchSession(sessionPath, {
-                withSession: options?.withSession,
-                projectTrustContextFactory: (cwd) => this.createProjectTrustContext(cwd),
-            });
-            if (result.cancelled) {
-                return result;
-            }
-            this.showStatus("Resumed session");
-            return result;
-        }
-        catch (error) {
-            if (error instanceof MissingSessionCwdError) {
-                const selectedCwd = await this.promptForMissingSessionCwd(error);
-                if (!selectedCwd) {
-                    this.showStatus("Resume cancelled");
-                    return { cancelled: true };
-                }
-                const result = await this.runtimeHost.switchSession(sessionPath, {
-                    cwdOverride: selectedCwd,
-                    withSession: options?.withSession,
-                    projectTrustContextFactory: (cwd) => this.createProjectTrustContext(cwd),
-                });
-                if (result.cancelled) {
-                    return result;
-                }
-                this.showStatus("Resumed session in current cwd");
-                return result;
-            }
-            return this.handleFatalRuntimeError("Failed to resume session", error);
-        }
-    }
-    getLoginProviderOptions(authType) {
-        const options = [];
-        for (const provider of this.session.modelRuntime.getProviders()) {
-            const authStatus = this.session.modelRuntime.getProviderAuthStatus(provider.id);
-            const status = authStatus.configured
-                ? {
-                    type: this.session.modelRuntime.isUsingOAuth(provider.id) ? "oauth" : "api_key",
-                    source: authStatus.label ?? authStatus.source,
-                }
-                : undefined;
-            if ((!authType || authType === "oauth") && provider.auth.oauth) {
-                options.push({
-                    id: provider.id,
-                    name: provider.name,
-                    authType: "oauth",
-                    method: provider.auth.oauth,
-                    status,
-                });
-            }
-            if ((!authType || authType === "api_key") && provider.auth.apiKey) {
-                options.push({
-                    id: provider.id,
-                    name: provider.name,
-                    authType: "api_key",
-                    method: provider.auth.apiKey,
-                    status,
-                });
-            }
-        }
-        return options.sort((a, b) => a.name.localeCompare(b.name));
-    }
-    async getLogoutProviderOptions() {
-        return (await this.session.modelRuntime.listCredentials())
-            .map(({ providerId, type }) => ({
-            id: providerId,
-            name: this.session.modelRuntime.getProvider(providerId)?.name ?? providerId,
-            authType: type,
-            status: { type, source: "stored credential" },
-        }))
-            .sort((a, b) => a.name.localeCompare(b.name));
-    }
-    findLoginProviderOptions(providerRef) {
-        const normalizedProviderRef = providerRef.trim().toLowerCase();
-        if (!normalizedProviderRef) {
-            return [];
-        }
-        return this.getLoginProviderOptions().filter((provider) => provider.id.toLowerCase() === normalizedProviderRef ||
-            provider.name.toLowerCase() === normalizedProviderRef);
-    }
-    async handleLoginCommand(providerRef) {
-        await this.session.modelRuntime.getAvailable();
-        if (!providerRef) {
-            this.showLoginAuthTypeSelector();
-            return;
-        }
-        const providerOptions = this.findLoginProviderOptions(providerRef);
-        if (providerOptions.length === 1) {
-            await this.startProviderLogin(providerOptions[0]);
-            return;
-        }
-        if (providerOptions.length > 1) {
-            const providerIds = new Set(providerOptions.map((provider) => provider.id));
-            if (providerIds.size === 1) {
-                this.showLoginAuthTypeSelector(providerOptions);
-                return;
-            }
-        }
-        this.showLoginProviderSelector(undefined, providerRef);
-    }
-    async startProviderLogin(providerOption) {
-        if (providerOption.authType === "oauth") {
-            await this.showLoginDialog(providerOption.id, providerOption.name);
-        }
-        else if (providerOption.method?.login) {
-            await this.showApiKeyLoginDialog(providerOption.id, providerOption.name);
-        }
-        else {
-            this.showAmbientAuthDialog(providerOption);
-        }
-    }
-    showLoginAuthTypeSelector(providerOptions) {
-        const oauthProvider = providerOptions?.find((provider) => provider.authType === "oauth");
-        const oauthLoginLabel = oauthProvider?.method && "loginLabel" in oauthProvider.method ? oauthProvider.method.loginLabel : undefined;
-        const subscriptionLabel = oauthLoginLabel ?? "Sign in with an account";
-        const apiKeyLabel = "Sign in with an API key";
-        const availableAuthTypes = providerOptions
-            ? new Set(providerOptions.map((provider) => provider.authType))
-            : new Set(["oauth", "api_key"]);
-        const options = [];
-        if (availableAuthTypes.has("oauth")) {
-            options.push(subscriptionLabel);
-        }
-        if (availableAuthTypes.has("api_key")) {
-            options.push(apiKeyLabel);
-        }
-        if (options.length === 0) {
-            this.showStatus("No login methods available.");
-            return;
-        }
-        if (providerOptions && options.length === 1) {
-            const providerOption = providerOptions[0];
-            if (providerOption) {
-                void this.startProviderLogin(providerOption);
-            }
-            return;
-        }
-        const title = providerOptions?.[0]
-            ? `Select authentication method for ${providerOptions[0].name}:`
-            : "Select authentication method:";
-        this.showSelector((done) => {
-            const selector = new ExtensionSelectorComponent(title, options, (option) => {
-                done();
-                const authType = option === subscriptionLabel ? "oauth" : "api_key";
-                if (providerOptions) {
-                    const providerOption = providerOptions.find((provider) => provider.authType === authType);
-                    if (providerOption) {
-                        void this.startProviderLogin(providerOption);
-                    }
-                    return;
-                }
-                this.showLoginProviderSelector(authType);
-            }, () => {
-                done();
-                this.ui.requestRender();
-            });
-            return { component: selector, focus: selector };
-        });
-    }
-    showLoginProviderSelector(authType, initialSearchInput) {
-        const providerOptions = this.getLoginProviderOptions(authType);
-        if (providerOptions.length === 0) {
-            const message = authType === "oauth"
-                ? "No subscription providers available."
-                : authType === "api_key"
-                    ? "No API key providers available."
-                    : "No login providers available.";
-            this.showStatus(message);
-            return;
-        }
-        this.showSelector((done) => {
-            const selector = new OAuthSelectorComponent("login", providerOptions, async (providerId, selectedAuthType) => {
-                done();
-                const providerOption = providerOptions.find((provider) => provider.id === providerId && provider.authType === selectedAuthType);
-                if (!providerOption) {
-                    return;
-                }
-                await this.startProviderLogin(providerOption);
-            }, () => {
-                done();
-                if (authType) {
-                    this.showLoginAuthTypeSelector();
-                }
-                else {
-                    this.ui.requestRender();
-                }
-            }, initialSearchInput);
-            return { component: selector, focus: selector };
-        });
-    }
-    async showOAuthSelector(mode) {
-        if (mode === "login") {
-            this.showLoginAuthTypeSelector();
-            return;
-        }
-        const providerOptions = await this.getLogoutProviderOptions();
-        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;
-        }
-        this.showSelector((done) => {
-            const selector = new OAuthSelectorComponent(mode, providerOptions, async (providerId) => {
-                done();
-                const providerOption = providerOptions.find((provider) => provider.id === providerId);
-                if (!providerOption) {
-                    return;
-                }
-                try {
-                    await this.session.modelRuntime.logout(providerOption.id);
-                    await this.updateAvailableProviderCount();
-                    const message = providerOption.authType === "oauth"
-                        ? `Logged out of ${providerOption.name}`
-                        : `Removed stored API key for ${providerOption.name}. Environment variables and models.json config are unchanged.`;
-                    this.showStatus(message);
-                }
-                catch (error) {
-                    this.showError(`Logout failed: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }, () => {
-                done();
-                this.ui.requestRender();
-            });
-            return { component: selector, focus: selector };
-        });
-    }
-    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 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.`;
-            }
-            else if (providerModels.length === 0) {
-                selectionError = `${actionLabel}, but no models are available for that provider. Use /model to select a model.`;
-            }
-            else {
-                const defaultModelId = defaultModelPerProvider[providerId];
-                selectedModel = providerModels.find((model) => model.id === defaultModelId);
-                if (!selectedModel) {
-                    selectionError = `${actionLabel}, but its default model "${defaultModelId}" is not available. Use /model to select a model.`;
-                }
-                else {
-                    try {
-                        await this.session.setModel(selectedModel);
-                    }
-                    catch (error) {
-                        selectedModel = undefined;
-                        const errorMessage = error instanceof Error ? error.message : String(error);
-                        selectionError = `${actionLabel}, but selecting its default model failed: ${errorMessage}. Use /model to select a model.`;
-                    }
-                }
-            }
-        }
-        await this.updateAvailableProviderCount();
-        this.footer.invalidate();
-        this.updateEditorBorderColor();
-        if (selectedModel) {
-            this.showStatus(`${actionLabel}. Selected ${selectedModel.id}. Credentials saved to ${getAuthPath()}`);
-            void this.maybeWarnAboutAnthropicSubscriptionAuth(selectedModel);
-            this.checkDaxnutsEasterEgg(selectedModel);
-        }
-        else {
-            this.showStatus(`${actionLabel}. Credentials saved to ${getAuthPath()}`);
-            if (selectionError) {
-                this.showError(selectionError);
-            }
-            else {
-                void this.maybeWarnAboutAnthropicSubscriptionAuth();
-            }
-        }
-    }
-    showAmbientAuthDialog(providerOption) {
-        const restoreEditor = () => {
-            this.editorContainer.clear();
-            this.editorContainer.addChild(this.editor);
-            this.ui.setFocus(this.editor);
-            this.ui.requestRender();
-        };
-        const dialog = new LoginDialogComponent(this.ui, providerOption.id, () => restoreEditor(), providerOption.name, `${providerOption.name} setup`);
-        dialog.showInfo(`${providerOption.method?.name ?? "Authentication"} is configured outside pi.`, [], true);
-        this.editorContainer.clear();
-        this.editorContainer.addChild(dialog);
-        this.ui.setFocus(dialog);
-        this.ui.requestRender();
-    }
-    async showApiKeyLoginDialog(providerId, providerName) {
-        const previousModel = this.session.model;
-        const dialog = new LoginDialogComponent(this.ui, providerId, (_success, _message) => {
-            // Completion handled below
-        }, providerName);
-        if (providerId === "amazon-bedrock") {
-            dialog.showDetails([
-                theme.fg("text", "You can also use an AWS profile, IAM keys, or role-based credentials."),
-                theme.fg("muted", "See:"),
-                theme.fg("accent", `  ${path.join(getDocsPath(), "providers.md")}`),
-            ]);
-        }
-        this.editorContainer.clear();
-        this.editorContainer.addChild(dialog);
-        this.ui.setFocus(dialog);
-        this.ui.requestRender();
-        const restoreEditor = () => {
-            this.editorContainer.clear();
-            this.editorContainer.addChild(this.editor);
-            this.ui.setFocus(this.editor);
-            this.ui.requestRender();
-        };
-        try {
-            await this.loginProvider(dialog, providerId, "api_key");
-            restoreEditor();
-            await this.completeProviderAuthentication(providerId, providerName, "api_key", previousModel);
-        }
-        catch (error) {
-            restoreEditor();
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            if (errorMsg !== "Login cancelled") {
-                this.showError(`Failed to save API key for ${providerName}: ${errorMsg}`);
-            }
-        }
-    }
-    showAuthSelect(dialog, prompt) {
-        return new Promise((resolve, reject) => {
-            const restoreDialog = () => {
-                this.editorContainer.clear();
-                this.editorContainer.addChild(dialog);
-                this.ui.setFocus(dialog);
-                this.ui.requestRender();
-            };
-            const labels = prompt.options.map((option) => option.label);
-            const selector = new ExtensionSelectorComponent(prompt.message, labels, (optionLabel) => {
-                restoreDialog();
-                const id = prompt.options.find((option) => option.label === optionLabel)?.id;
-                if (id)
-                    resolve(id);
-                else
-                    reject(new Error("Login cancelled"));
-            }, () => {
-                restoreDialog();
-                reject(new Error("Login cancelled"));
-            });
-            this.editorContainer.clear();
-            this.editorContainer.addChild(selector);
-            this.ui.setFocus(selector);
-            this.ui.requestRender();
-        });
-    }
-    async showAuthPrompt(dialog, prompt) {
-        let response;
-        if (prompt.type === "select") {
-            response = this.showAuthSelect(dialog, prompt);
-        }
-        else if (prompt.type === "manual_code") {
-            response = dialog.showManualInput(prompt.message);
-        }
-        else {
-            response = dialog.showPrompt(prompt.message, prompt.placeholder);
-        }
-        if (!prompt.signal)
-            return response;
-        if (prompt.signal.aborted)
-            throw new Error("Login cancelled");
-        const signal = prompt.signal;
-        let onAbort;
-        const aborted = new Promise((_resolve, reject) => {
-            onAbort = () => reject(new Error("Login cancelled"));
-            signal.addEventListener("abort", onAbort, { once: true });
-        });
-        try {
-            return await Promise.race([response, aborted]);
-        }
-        finally {
-            if (onAbort)
-                signal.removeEventListener("abort", onAbort);
-        }
-    }
-    notifyAuthDialog(dialog, event) {
-        if (event.type === "auth_url") {
-            dialog.showAuth(event.url, event.instructions);
-        }
-        else if (event.type === "device_code") {
-            dialog.showDeviceCode(event);
-            dialog.showWaiting("Waiting for authentication...");
-        }
-        else if (event.type === "info") {
-            dialog.showInfo(event.message, event.links);
-        }
-        else {
-            dialog.showProgress(event.message);
-        }
-    }
-    async loginProvider(dialog, providerId, method) {
-        await this.session.modelRuntime.login(providerId, method, {
-            signal: dialog.signal,
-            prompt: (prompt) => this.showAuthPrompt(dialog, prompt),
-            notify: (event) => this.notifyAuthDialog(dialog, event),
-        });
-    }
-    async showLoginDialog(providerId, providerName) {
-        const previousModel = this.session.model;
-        const dialog = new LoginDialogComponent(this.ui, providerId, (_success, _message) => { }, providerName);
-        this.editorContainer.clear();
-        this.editorContainer.addChild(dialog);
-        this.ui.setFocus(dialog);
-        this.ui.requestRender();
-        const restoreEditor = () => {
-            this.editorContainer.clear();
-            this.editorContainer.addChild(this.editor);
-            this.ui.setFocus(this.editor);
-            this.ui.requestRender();
-        };
-        try {
-            await this.loginProvider(dialog, providerId, "oauth");
-            restoreEditor();
-            await this.completeProviderAuthentication(providerId, providerName, "oauth", previousModel);
-        }
-        catch (error) {
-            restoreEditor();
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            if (errorMsg !== "Login cancelled") {
-                this.showError(`Failed to login to ${providerName}: ${errorMsg}`);
-            }
-        }
-    }
-    // =========================================================================
-    // Command handlers
-    // =========================================================================
-    async handleReloadCommand() {
-        if (this.session.isStreaming) {
-            this.showWarning("Wait for the current response to finish before reloading.");
-            return;
-        }
-        if (this.session.isCompacting) {
-            this.showWarning("Wait for compaction to finish before reloading.");
-            return;
-        }
-        this.resetExtensionUI();
-        const reloadBox = new Container();
-        const borderColor = (s) => theme.fg("border", s);
-        reloadBox.addChild(new DynamicBorder(borderColor));
-        reloadBox.addChild(new Spacer(1));
-        reloadBox.addChild(new Text(theme.fg("muted", "Reloading keybindings, extensions, skills, prompts, themes, and context files..."), 1, 0));
-        reloadBox.addChild(new Spacer(1));
-        reloadBox.addChild(new DynamicBorder(borderColor));
-        const previousEditor = this.editor;
-        this.editorContainer.clear();
-        this.editorContainer.addChild(reloadBox);
-        this.ui.setFocus(reloadBox);
-        this.ui.requestRender(true);
-        await new Promise((resolve) => process.nextTick(resolve));
-        const dismissReloadBox = (editor) => {
-            this.editorContainer.clear();
-            this.editorContainer.addChild(editor);
-            this.ui.setFocus(editor);
-            this.ui.requestRender();
-        };
-        let chatRestoredBeforeSessionStart = false;
-        let reloadBoxDismissed = false;
-        const restoreChatBeforeSessionStart = () => {
-            if (chatRestoredBeforeSessionStart) {
-                return;
-            }
-            this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
-            this.outputPad = this.settingsManager.getOutputPad();
-            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)) {
-                activeHeader.setExpanded(this.toolOutputExpanded);
-            }
-            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.setupAutocompleteProvider();
-            const runner = this.session.extensionRunner;
-            this.setupExtensionShortcuts(runner);
-            this.showLoadedResources({
-                force: false,
-                showDiagnosticsWhenQuiet: true,
-            });
-            const savedImplicitProjectTrust = this.maybeSaveImplicitProjectTrustAfterReload();
-            const modelsJsonError = this.session.modelRuntime.getError();
-            if (modelsJsonError) {
-                this.showError(`models.json error: ${modelsJsonError}`);
-            }
-            this.showStatus(savedImplicitProjectTrust
-                ? "Reloaded keybindings, extensions, skills, prompts, themes, and context files; saved project trust"
-                : "Reloaded keybindings, extensions, skills, prompts, themes, and context files");
-            dismissReloadBox(this.editor);
-            reloadBoxDismissed = true;
-        }
-        catch (error) {
-            if (!reloadBoxDismissed) {
-                dismissReloadBox(previousEditor);
-            }
-            this.showError(`Reload failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async handleExportCommand(text) {
-        const outputPath = this.getPathCommandArgument(text, "/export");
-        try {
-            if (outputPath?.endsWith(".jsonl")) {
-                const filePath = this.session.exportToJsonl(outputPath);
-                this.showStatus(`Session exported to: ${filePath}`);
-            }
-            else {
-                const filePath = await this.session.exportToHtml(outputPath);
-                this.showStatus(`Session exported to: ${filePath}`);
-            }
-        }
-        catch (error) {
-            this.showError(`Failed to export session: ${error instanceof Error ? error.message : "Unknown error"}`);
-        }
-    }
-    getPathCommandArgument(text, command) {
-        if (text === command) {
-            return undefined;
-        }
-        if (!text.startsWith(`${command} `)) {
-            return undefined;
-        }
-        const argsString = text.slice(command.length + 1).trimStart();
-        if (!argsString) {
-            return undefined;
-        }
-        const firstChar = argsString[0];
-        if (firstChar === '"' || firstChar === "'") {
-            const closingQuoteIndex = argsString.indexOf(firstChar, 1);
-            if (closingQuoteIndex < 0) {
-                return undefined;
-            }
-            return argsString.slice(1, closingQuoteIndex);
-        }
-        const firstWhitespaceIndex = argsString.search(/\s/);
-        if (firstWhitespaceIndex < 0) {
-            return argsString;
-        }
-        return argsString.slice(0, firstWhitespaceIndex);
-    }
-    async handleImportCommand(text) {
-        const inputPath = this.getPathCommandArgument(text, "/import");
-        if (!inputPath) {
-            this.showError("Usage: /import <path.jsonl>");
-            return;
-        }
-        const confirmed = await this.showExtensionConfirm("Import session", `Replace current session with ${inputPath}?`);
-        if (!confirmed) {
-            this.showStatus("Import cancelled");
-            return;
-        }
-        try {
-            this.clearStatusIndicator();
-            const result = await this.runtimeHost.importFromJsonl(inputPath);
-            if (result.cancelled) {
-                this.showStatus("Import cancelled");
-                return;
-            }
-            this.showStatus(`Session imported from: ${inputPath}`);
-        }
-        catch (error) {
-            if (error instanceof MissingSessionCwdError) {
-                const selectedCwd = await this.promptForMissingSessionCwd(error);
-                if (!selectedCwd) {
-                    this.showStatus("Import cancelled");
-                    return;
-                }
-                const result = await this.runtimeHost.importFromJsonl(inputPath, selectedCwd);
-                if (result.cancelled) {
-                    this.showStatus("Import cancelled");
-                    return;
-                }
-                this.showStatus(`Session imported from: ${inputPath}`);
-                return;
-            }
-            if (error instanceof SessionImportFileNotFoundError) {
-                this.showError(`Failed to import session: ${error.message}`);
-                return;
-            }
-            await this.handleFatalRuntimeError("Failed to import session", error);
-        }
-    }
-    async handleShareCommand() {
-        // Check if gh is available and logged in
-        try {
-            const authResult = spawnSync("gh", ["auth", "status"], { encoding: "utf-8" });
-            if (authResult.status !== 0) {
-                this.showError("GitHub CLI is not logged in. Run 'gh auth login' first.");
-                return;
-            }
-        }
-        catch {
-            this.showError("GitHub CLI (gh) is not installed. Install it from https://cli.github.com/");
-            return;
-        }
-        // Export to a temp file
-        const tmpFile = path.join(os.tmpdir(), "session.html");
-        try {
-            await this.session.exportToHtml(tmpFile);
-        }
-        catch (error) {
-            this.showError(`Failed to export session: ${error instanceof Error ? error.message : "Unknown error"}`);
-            return;
-        }
-        // Show cancellable loader, replacing the editor
-        const loader = new BorderedLoader(this.ui, theme, "Creating gist...");
-        this.editorContainer.clear();
-        this.editorContainer.addChild(loader);
-        this.ui.setFocus(loader);
-        this.ui.requestRender();
-        const restoreEditor = () => {
-            loader.dispose();
-            this.editorContainer.clear();
-            this.editorContainer.addChild(this.editor);
-            this.ui.setFocus(this.editor);
-            try {
-                fs.unlinkSync(tmpFile);
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        };
-        // Create a secret gist asynchronously
-        let proc = null;
-        loader.onAbort = () => {
-            proc?.kill();
-            restoreEditor();
-            this.showStatus("Share cancelled");
-        };
-        try {
-            const result = await new Promise((resolve) => {
-                proc = spawn("gh", ["gist", "create", "--public=false", tmpFile]);
-                let stdout = "";
-                let stderr = "";
-                proc.stdout?.on("data", (data) => {
-                    stdout += data.toString();
-                });
-                proc.stderr?.on("data", (data) => {
-                    stderr += data.toString();
-                });
-                proc.on("close", (code) => resolve({ stdout, stderr, code }));
-            });
-            if (loader.signal.aborted)
-                return;
-            restoreEditor();
-            if (result.code !== 0) {
-                const errorMsg = result.stderr?.trim() || "Unknown error";
-                this.showError(`Failed to create gist: ${errorMsg}`);
-                return;
-            }
-            // Extract gist ID from the URL returned by gh
-            // gh returns something like: https://gist.github.com/username/GIST_ID
-            const gistUrl = result.stdout?.trim();
-            const gistId = gistUrl?.split("/").pop();
-            if (!gistId) {
-                this.showError("Failed to parse gist ID from gh output");
-                return;
-            }
-            // Create the preview URL
-            const previewUrl = getShareViewerUrl(gistId);
-            this.showStatus(`Share URL: ${previewUrl}\nGist: ${gistUrl}`);
-        }
-        catch (error) {
-            if (!loader.signal.aborted) {
-                restoreEditor();
-                this.showError(`Failed to create gist: ${error instanceof Error ? error.message : "Unknown error"}`);
-            }
-        }
-    }
-    async handleCopyCommand() {
-        const text = this.session.getLastAssistantText();
-        if (!text) {
-            this.showError("No agent messages to copy yet.");
-            return;
-        }
-        try {
-            await copyToClipboard(text);
-            this.showStatus("Copied last agent message to clipboard");
-        }
-        catch (error) {
-            this.showError(error instanceof Error ? error.message : String(error));
-        }
-    }
-    handleNameCommand(text) {
-        const name = text.replace(/^\/name\s*/, "").trim();
-        if (!name) {
-            const currentName = this.sessionManager.getSessionName();
-            if (currentName) {
-                this.chatContainer.addChild(new Spacer(1));
-                this.chatContainer.addChild(new Text(theme.fg("dim", `Session name: ${currentName}`), 1, 0));
-            }
-            else {
-                this.showWarning("Usage: /name <name>");
-            }
-            this.ui.requestRender();
-            return;
-        }
-        this.session.setSessionName(name);
-        const sessionName = this.sessionManager.getSessionName();
-        if (sessionName !== name) {
-            this.showWarning(`Session name was normalized from ${JSON.stringify(name)} to ${JSON.stringify(sessionName)}`);
-        }
-        this.chatContainer.addChild(new Spacer(1));
-        this.chatContainer.addChild(new Text(theme.fg("dim", `Session name set: ${sessionName ?? name}`), 1, 0));
-        this.ui.requestRender();
-    }
-    handleSessionCommand() {
-        const stats = this.session.getSessionStats();
-        const sessionName = this.sessionManager.getSessionName();
-        const entries = this.sessionManager.getEntries();
-        const cacheWaste = computeCacheWaste(entries, this.session.modelRuntime);
-        // Cost/token totals per provider/model actually used (e.g. OpenRouter `auto`
-        // resolves to a concrete responseModel). Usage without model attribution is
-        // grouped separately so the breakdown reconciles with the session total.
-        const usageBreakdown = getUsageCostBreakdown(entries);
-        let info = `${theme.bold("Session Info")}\n\n`;
-        if (sessionName) {
-            info += `${theme.fg("dim", "Name:")} ${sessionName}\n`;
-        }
-        info += `${theme.fg("dim", "File:")} ${stats.sessionFile ?? "In-memory"}\n`;
-        info += `${theme.fg("dim", "ID:")} ${stats.sessionId}\n\n`;
-        info += `${theme.bold("Messages")}\n`;
-        info += `${theme.fg("dim", "Total:")} ${stats.totalMessages}\n`;
-        info += `${theme.fg("dim", "User:")} ${stats.userMessages}\n`;
-        info += `${theme.fg("dim", "Assistant:")} ${stats.assistantMessages}\n`;
-        info += `${theme.fg("dim", "Tools:")} ${stats.toolCalls} calls, ${stats.toolResults} results\n\n`;
-        info += `${theme.bold("Tokens")}\n`;
-        // "Input" is the full prompt volume. With cache activity, split it into
-        // cached (served from cache) vs uncached (everything else) - the only
-        // provider-independent split. Cache writes, where reported, are a detail
-        // of the uncached portion.
-        const { input, cacheRead, cacheWrite } = stats.tokens;
-        const promptTokens = input + cacheRead + cacheWrite;
-        info += `${theme.fg("dim", "Input:")} ${promptTokens.toLocaleString()}\n`;
-        if (promptTokens > 0 && (cacheRead > 0 || cacheWrite > 0)) {
-            const hitRate = theme.fg("dim", `(${((cacheRead / promptTokens) * 100).toFixed(1)}%)`);
-            info += `  ${theme.fg("dim", "Cached:")} ${cacheRead.toLocaleString()} ${hitRate}\n`;
-            const written = cacheWrite > 0 ? ` ${theme.fg("dim", `(${cacheWrite.toLocaleString()} written to cache)`)}` : "";
-            info += `  ${theme.fg("dim", "Uncached:")} ${(input + cacheWrite).toLocaleString()}${written}\n`;
-        }
-        info += `${theme.fg("dim", "Output:")} ${stats.tokens.output.toLocaleString()}\n`;
-        info += `${theme.fg("dim", "Total:")} ${stats.tokens.total.toLocaleString()}\n`;
-        if (stats.cost > 0 || cacheWaste.missedTokens > 0) {
-            info += `\n${theme.bold("Cost")}\n`;
-            info += `${theme.fg("dim", "Total:")} $${stats.cost.toFixed(3)}`;
-            if (usageBreakdown.length > 1) {
-                for (const entry of usageBreakdown) {
-                    info += `\n  ${theme.fg("dim", `${entry.key}:`)} $${entry.cost.toFixed(3)} ${theme.fg("dim", `(${formatTokens(entry.tokens)} tokens)`)}`;
-                }
-            }
-            if (cacheWaste.missedTokens > 0) {
-                const missLabel = cacheWaste.missCount === 1 ? "1 miss" : `${cacheWaste.missCount} misses`;
-                const detail = `${cacheWaste.missedTokens.toLocaleString()} tokens, ${missLabel}`;
-                info +=
-                    cacheWaste.missedCost >= 0.0001
-                        ? `\n${theme.fg("dim", "Cache Re-billed:")} $${cacheWaste.missedCost.toFixed(3)} ${theme.fg("dim", `(${detail})`)}`
-                        : `\n${theme.fg("dim", "Cache Re-billed:")} ${detail}`;
-            }
-        }
-        this.chatContainer.addChild(new Spacer(1));
-        this.chatContainer.addChild(new Text(info, 1, 0));
-        this.ui.requestRender();
-    }
-    handleChangelogCommand() {
-        const changelogPath = getChangelogPath();
-        const allEntries = parseChangelog(changelogPath);
-        const changelogMarkdown = allEntries.length > 0
-            ? allEntries
-                .reverse()
-                .map((e) => normalizeChangelogLinks(e.content, e))
-                .join("\n\n")
-            : "No changelog entries found.";
-        this.chatContainer.addChild(new Spacer(1));
-        this.chatContainer.addChild(new DynamicBorder());
-        this.chatContainer.addChild(new Text(theme.bold(theme.fg("accent", "What's New")), 1, 0));
-        this.chatContainer.addChild(new Spacer(1));
-        this.chatContainer.addChild(new Markdown(changelogMarkdown, 1, 1, this.getMarkdownThemeWithSettings()));
-        this.chatContainer.addChild(new DynamicBorder());
-        this.ui.requestRender();
-    }
-    /**
-     * Get capitalized display string for an app keybinding action.
-     */
-    getAppKeyDisplay(action) {
-        return keyDisplayText(action);
-    }
-    /**
-     * Get capitalized display string for an editor keybinding action.
-     */
-    getEditorKeyDisplay(action) {
-        return keyDisplayText(action);
-    }
-    handleHotkeysCommand() {
-        // Navigation keybindings
-        const cursorUp = this.getEditorKeyDisplay("tui.editor.cursorUp");
-        const cursorDown = this.getEditorKeyDisplay("tui.editor.cursorDown");
-        const cursorLeft = this.getEditorKeyDisplay("tui.editor.cursorLeft");
-        const cursorRight = this.getEditorKeyDisplay("tui.editor.cursorRight");
-        const cursorWordLeft = this.getEditorKeyDisplay("tui.editor.cursorWordLeft");
-        const cursorWordRight = this.getEditorKeyDisplay("tui.editor.cursorWordRight");
-        const cursorLineStart = this.getEditorKeyDisplay("tui.editor.cursorLineStart");
-        const cursorLineEnd = this.getEditorKeyDisplay("tui.editor.cursorLineEnd");
-        const jumpForward = this.getEditorKeyDisplay("tui.editor.jumpForward");
-        const jumpBackward = this.getEditorKeyDisplay("tui.editor.jumpBackward");
-        const pageUp = this.getEditorKeyDisplay("tui.editor.pageUp");
-        const pageDown = this.getEditorKeyDisplay("tui.editor.pageDown");
-        // Editing keybindings
-        const submit = this.getEditorKeyDisplay("tui.input.submit");
-        const newLine = this.getEditorKeyDisplay("tui.input.newLine");
-        const deleteWordBackward = this.getEditorKeyDisplay("tui.editor.deleteWordBackward");
-        const deleteWordForward = this.getEditorKeyDisplay("tui.editor.deleteWordForward");
-        const deleteToLineStart = this.getEditorKeyDisplay("tui.editor.deleteToLineStart");
-        const deleteToLineEnd = this.getEditorKeyDisplay("tui.editor.deleteToLineEnd");
-        const yank = this.getEditorKeyDisplay("tui.editor.yank");
-        const yankPop = this.getEditorKeyDisplay("tui.editor.yankPop");
-        const undo = this.getEditorKeyDisplay("tui.editor.undo");
-        const tab = this.getEditorKeyDisplay("tui.input.tab");
-        // App keybindings
-        const interrupt = this.getAppKeyDisplay("app.interrupt");
-        const clear = this.getAppKeyDisplay("app.clear");
-        const exit = this.getAppKeyDisplay("app.exit");
-        const suspend = this.getAppKeyDisplay("app.suspend");
-        const cycleThinkingLevel = this.getAppKeyDisplay("app.thinking.cycle");
-        const cycleModelForward = this.getAppKeyDisplay("app.model.cycleForward");
-        const selectModel = this.getAppKeyDisplay("app.model.select");
-        const expandTools = this.getAppKeyDisplay("app.tools.expand");
-        const toggleThinking = this.getAppKeyDisplay("app.thinking.toggle");
-        const externalEditor = this.getAppKeyDisplay("app.editor.external");
-        const cycleModelBackward = this.getAppKeyDisplay("app.model.cycleBackward");
-        const copyMessage = this.getAppKeyDisplay("app.message.copy");
-        const followUp = this.getAppKeyDisplay("app.message.followUp");
-        const dequeue = this.getAppKeyDisplay("app.message.dequeue");
-        const pasteImage = this.getAppKeyDisplay("app.clipboard.pasteImage");
-        let hotkeys = `
-**Navigation**
-| Key | Action |
-|-----|--------|
-| \`${cursorUp}\` / \`${cursorDown}\` / \`${cursorLeft}\` / \`${cursorRight}\` | Move cursor / browse history |
-| \`${cursorWordLeft}\` / \`${cursorWordRight}\` | Move by word |
-| \`${cursorLineStart}\` | Start of line |
-| \`${cursorLineEnd}\` | End of line |
-| \`${jumpForward}\` | Jump forward to character |
-| \`${jumpBackward}\` | Jump backward to character |
-| \`${pageUp}\` / \`${pageDown}\` | Scroll by page |
-
-**Editing**
-| Key | Action |
-|-----|--------|
-| \`${submit}\` | Send message |
-| \`${newLine}\` | New line${process.platform === "win32" ? " (Ctrl+Enter on Windows Terminal)" : ""} |
-| \`${deleteWordBackward}\` | Delete word backwards |
-| \`${deleteWordForward}\` | Delete word forwards |
-| \`${deleteToLineStart}\` | Delete to start of line |
-| \`${deleteToLineEnd}\` | Delete to end of line |
-| \`${yank}\` | Paste the most-recently-deleted text |
-| \`${yankPop}\` | Cycle through the deleted text after pasting |
-| \`${undo}\` | Undo |
-
-**Other**
-| Key | Action |
-|-----|--------|
-| \`${tab}\` | Path completion / accept autocomplete |
-| \`${interrupt}\` | Cancel autocomplete / abort streaming |
-| \`${clear}\` | Clear editor (first) / exit (second) |
-| \`${exit}\` | Exit (when editor is empty) |
-| \`${suspend}\` | Suspend to background |
-| \`${cycleThinkingLevel}\` | Cycle thinking level |
-| \`${cycleModelForward}\` / \`${cycleModelBackward}\` | Cycle models |
-| \`${selectModel}\` | Open model selector |
-| \`${expandTools}\` | Toggle tool output expansion |
-| \`${toggleThinking}\` | Toggle thinking block visibility |
-| \`${externalEditor}\` | Edit message in external editor |
-| \`${copyMessage}\` | Copy last assistant message |
-| \`${followUp}\` | Queue follow-up message |
-| \`${dequeue}\` | Restore queued messages |
-| \`${pasteImage}\` | Paste image or text from clipboard |
-| \`/\` | Slash commands |
-| \`!\` | Run bash command |
-| \`!!\` | Run bash command (excluded from context) |
-`;
-        // Add extension-registered shortcuts
-        const extensionRunner = this.session.extensionRunner;
-        const shortcuts = extensionRunner.getShortcuts(this.keybindings.getEffectiveConfig());
-        if (shortcuts.size > 0) {
-            hotkeys += `
-**Extensions**
-| Key | Action |
-|-----|--------|
-`;
-            for (const [key, shortcut] of shortcuts) {
-                const description = shortcut.description ?? shortcut.extensionPath;
-                const keyDisplay = formatKeyText(key, { capitalize: true });
-                hotkeys += `| \`${keyDisplay}\` | ${description} |\n`;
-            }
-        }
-        this.chatContainer.addChild(new Spacer(1));
-        this.chatContainer.addChild(new DynamicBorder());
-        this.chatContainer.addChild(new Text(theme.bold(theme.fg("accent", "Keyboard Shortcuts")), 1, 0));
-        this.chatContainer.addChild(new Spacer(1));
-        this.chatContainer.addChild(new Markdown(hotkeys.trim(), 1, 1, this.getMarkdownThemeWithSettings()));
-        this.chatContainer.addChild(new DynamicBorder());
-        this.ui.requestRender();
-    }
-    async handleClearCommand() {
-        this.clearStatusIndicator();
-        try {
-            const result = await this.runtimeHost.newSession();
-            if (result.cancelled) {
-                return;
-            }
-            this.chatContainer.addChild(new Spacer(1));
-            this.chatContainer.addChild(new Text(`${theme.fg("accent", "✓ New session started")}`, 1, 1));
-            this.ui.requestRender();
-        }
-        catch (error) {
-            await this.handleFatalRuntimeError("Failed to create session", error);
-        }
-    }
-    handleDebugCommand() {
-        const width = this.ui.terminal.columns;
-        const height = this.ui.terminal.rows;
-        const allLines = this.ui.render(width);
-        const debugLogPath = getDebugLogPath();
-        const debugData = [
-            `Debug output at ${new Date().toISOString()}`,
-            `Terminal: ${width}x${height}`,
-            `Total lines: ${allLines.length}`,
-            "",
-            "=== All rendered lines with visible widths ===",
-            ...allLines.map((line, idx) => {
-                const vw = visibleWidth(line);
-                const escaped = JSON.stringify(line);
-                return `[${idx}] (w=${vw}) ${escaped}`;
-            }),
-            "",
-            "=== Agent messages (JSONL) ===",
-            ...this.session.messages.map((msg) => JSON.stringify(msg)),
-            "",
-        ].join("\n");
-        fs.mkdirSync(path.dirname(debugLogPath), { recursive: true });
-        fs.writeFileSync(debugLogPath, debugData);
-        this.chatContainer.addChild(new Spacer(1));
-        this.chatContainer.addChild(new Text(`${theme.fg("accent", "✓ Debug log written")}\n${theme.fg("muted", debugLogPath)}`, 1, 1));
-        this.ui.requestRender();
-    }
-    handleArminSaysHi() {
-        this.chatContainer.addChild(new Spacer(1));
-        this.chatContainer.addChild(new ArminComponent(this.ui));
-        this.ui.requestRender();
-    }
-    handleDementedDelves() {
-        this.chatContainer.addChild(new Spacer(1));
-        this.chatContainer.addChild(new EarendilAnnouncementComponent());
-        this.ui.requestRender();
-    }
-    handleDaxnuts() {
-        this.chatContainer.addChild(new Spacer(1));
-        this.chatContainer.addChild(new DaxnutsComponent(this.ui));
-        this.ui.requestRender();
-    }
-    checkDaxnutsEasterEgg(model) {
-        if (model.provider === "opencode" && model.id.toLowerCase().includes("kimi-k2.5")) {
-            this.handleDaxnuts();
-        }
-    }
-    async handleBashCommand(command, excludeFromContext = false) {
-        const extensionRunner = this.session.extensionRunner;
-        // Emit user_bash event to let extensions intercept
-        const eventResult = await extensionRunner.emitUserBash({
-            type: "user_bash",
-            command,
-            excludeFromContext,
-            cwd: this.sessionManager.getCwd(),
-        });
-        // If extension returned a full result, use it directly
-        if (eventResult?.result) {
-            const result = eventResult.result;
-            // Create UI component for display
-            this.bashComponent = new BashExecutionComponent(command, this.ui, excludeFromContext);
-            if (this.session.isStreaming) {
-                this.pendingMessagesContainer.addChild(this.bashComponent);
-                this.pendingBashComponents.push(this.bashComponent);
-            }
-            else {
-                this.chatContainer.addChild(this.bashComponent);
-            }
-            // Show output and complete
-            if (result.output) {
-                this.bashComponent.appendOutput(result.output);
-            }
-            this.bashComponent.setComplete(result.exitCode, result.cancelled, result.truncated ? { truncated: true, content: result.output } : undefined, result.fullOutputPath);
-            // Record the result in session
-            this.session.recordBashResult(command, result, { excludeFromContext });
-            this.bashComponent = undefined;
-            this.ui.requestRender();
-            return;
-        }
-        // Normal execution path (possibly with custom operations)
-        const isDeferred = this.session.isStreaming;
-        this.bashComponent = new BashExecutionComponent(command, this.ui, excludeFromContext);
-        if (isDeferred) {
-            // Show in pending area when agent is streaming
-            this.pendingMessagesContainer.addChild(this.bashComponent);
-            this.pendingBashComponents.push(this.bashComponent);
-        }
-        else {
-            // Show in chat immediately when agent is idle
-            this.chatContainer.addChild(this.bashComponent);
-        }
-        this.ui.requestRender();
-        try {
-            const result = await this.session.executeBash(command, (chunk) => {
-                if (this.bashComponent) {
-                    this.bashComponent.appendOutput(chunk);
-                    this.ui.requestRender();
-                }
-            }, { excludeFromContext, operations: eventResult?.operations });
-            if (this.bashComponent) {
-                this.bashComponent.setComplete(result.exitCode, result.cancelled, result.truncated ? { truncated: true, content: result.output } : undefined, result.fullOutputPath);
-            }
-        }
-        catch (error) {
-            if (this.bashComponent) {
-                this.bashComponent.setComplete(undefined, false);
-            }
-            this.showError(`Bash command failed: ${error instanceof Error ? error.message : "Unknown error"}`);
-        }
-        this.bashComponent = undefined;
-        this.ui.requestRender();
-    }
-    async handleCompactCommand(customInstructions) {
-        this.clearStatusIndicator();
-        try {
-            await this.session.compact(customInstructions);
-        }
-        catch {
-            // Ignore, will be emitted as an event
-        }
-    }
-    stop() {
-        if (this.settingsManager.getShowTerminalProgress()) {
-            this.ui.terminal.setProgress(false);
-        }
-        this.clearStatusIndicator();
-        this.themeController.disableAutoSync();
-        this.clearExtensionTerminalInputListeners();
-        this.footer.dispose();
-        this.footerDataProvider.dispose();
-        if (this.unsubscribe) {
-            this.unsubscribe();
-        }
-        if (this.isInitialized) {
-            this.ui.stop();
-            this.isInitialized = false;
-        }
-        this.unregisterSignalHandlers();
-    }
-}
-//# sourceMappingURL=interactive-mode.js.map
+        if (this.chatContainer.children.length >