@daniel156161/prism 0.2.81 → 0.2.83

package/node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/interactive-mode.js

@@ -661,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.81";
+            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.83";
             // Build startup instructions using keybinding hint helpers
             const hint = (keybinding, description) => keyHint(keybinding, description);
             const expandedInstructions = [
@@ -3242,4 +3242,2367 @@ export class InteractiveMode {
         if (this.settingsManager.isProjectTrusted() || !hasTrustRequiringProjectResources(this.sessionManager.getCwd())) {
             return;
         }
-        if (this.chatContainer.children.length > 
+        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) {
+        if (expanded === this.toolOutputExpanded)
+            return;
+        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) {
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new Text(theme.fg("error", `Error: ${errorMessage}`), this.outputPad, 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
+    // =========================================================================
+    disposeActiveSelector() {
+        const dispose = this.activeSelectorDispose;
+        this.activeSelectorToken = undefined;
+        this.activeSelectorDispose = undefined;
+        dispose?.();
+    }
+    /**
+     * Shows a selector component in place of the editor.
+     * @param create Factory that receives a `done` callback and returns the component and focus target
+     */
+    showSelector(create) {
+        const token = {};
+        let dispose;
+        const done = () => {
+            dispose?.();
+            if (this.activeSelectorToken !== token)
+                return;
+            this.activeSelectorToken = undefined;
+            this.activeSelectorDispose = undefined;
+            this.editorContainer.clear();
+            this.editorContainer.addChild(this.editor);
+            this.ui.setFocus(this.editor);
+        };
+        const created = create(done);
+        dispose = created.dispose;
+        this.disposeActiveSelector();
+        this.activeSelectorToken = token;
+        this.activeSelectorDispose = dispose;
+        this.editorContainer.clear();
+        this.editorContainer.addChild(created.component);
+        this.ui.setFocus(created.focus);
+        this.ui.requestRender();
+    }
+    showSettingsSelector() {
+        this.showSelector((done) => {
+            let selector;
+            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,
+                mermaidRenderingMode: this.settingsManager.getMermaidRenderingMode(),
+                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(),
+                tuiMode: this.ui.mode,
+                fullscreenScrollbar: this.settingsManager.getFullscreenScrollbar(),
+                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();
+                },
+                onMermaidRenderingModeChange: (mode) => {
+                    this.settingsManager.setMermaidRenderingMode(mode);
+                    this.chatContainer.invalidate();
+                    this.ui.requestRender();
+                },
+                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);
+                },
+                onTuiModeChange: (mode) => {
+                    if (!this.switchTuiMode(mode)) {
+                        selector?.getSettingsList().updateValue("tui-mode", this.ui.mode);
+                        this.showStatus("Close active overlays before changing TUI mode");
+                        return;
+                    }
+                    this.settingsManager.setTuiMode(mode);
+                    if (!this.activeStatusIndicator)
+                        this.statusContainer.clear();
+                    this.showStatus(`TUI mode: ${mode}`);
+                },
+                onFullscreenScrollbarChange: (mode) => {
+                    this.settingsManager.setFullscreenScrollbar(mode);
+                    this.applyFullscreenScrollbarSetting();
+                },
+                onWarningsChange: (warnings) => {
+                    this.settingsManager.setWarnings(warnings);
+                },
+                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 cachedModels = this.session.scopedModels.length > 0
+            ? this.session.scopedModels.map((scoped) => scoped.model)
+            : [...this.session.modelRuntime.getAvailableSnapshot()];
+        const cachedMatch = findExactModelReferenceMatch(searchTerm, cachedModels);
+        if (cachedMatch || this.session.scopedModels.length > 0)
+            return cachedMatch;
+        this.showStatus("Refreshing model catalogs…");
+        const controller = new AbortController();
+        let timedOut = false;
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, 15_000);
+        try {
+            const result = await this.session.modelRuntime.refresh({ signal: controller.signal });
+            if (result.aborted && timedOut) {
+                this.showWarning("Model refresh timed out; searching cached models.");
+            }
+            else if (result.errors.size > 0) {
+                this.showWarning(`Could not refresh ${[...result.errors.keys()].join(", ")}; searching cached models.`);
+            }
+        }
+        catch (error) {
+            this.showWarning(timedOut
+                ? "Model refresh timed out; searching cached models."
+                : `Could not refresh model catalogs: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+        return findExactModelReferenceMatch(searchTerm, [...this.session.modelRuntime.getAvailableSnapshot()]);
+    }
+    /** Update the footer's available provider count from the current snapshot without refreshing catalogs. */
+    updateAvailableProviderCount() {
+        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 };
+        });
+    }
+    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, dispose: () => selector.dispose() };
+        });
+    }
+    showModelsSelector() {
+        let availableModels = [...this.session.modelRuntime.getAvailableSnapshot()];
+        let availableModelIds = new Set(availableModels.map((model) => `${model.provider}/${model.id}`));
+        const configuredPatterns = this.settingsManager.getEnabledModels();
+        const sessionScopedModels = this.session.scopedModels;
+        const configuredEnabledIds = (models) => {
+            if (!configuredPatterns?.length)
+                return null;
+            const resolved = resolveModelScopeFromModels(configuredPatterns, models);
+            const ids = resolved.scopedModels.map((scoped) => `${scoped.model.provider}/${scoped.model.id}`);
+            for (const diagnostic of resolved.diagnostics) {
+                if (diagnostic.code === "no-match" && !ids.includes(diagnostic.pattern))
+                    ids.push(diagnostic.pattern);
+            }
+            return ids;
+        };
+        let currentEnabledIds = sessionScopedModels.length > 0
+            ? sessionScopedModels.map((scoped) => `${scoped.model.provider}/${scoped.model.id}`)
+            : configuredEnabledIds(availableModels);
+        let selectionChanged = false;
+        const updateSessionModels = (enabledIds) => {
+            currentEnabledIds = enabledIds === null ? null : [...enabledIds];
+            const hasEnabledAvailableModel = enabledIds?.some((id) => availableModelIds.has(id)) ?? false;
+            const allAvailableModelsEnabled = enabledIds !== null && [...availableModelIds].every((id) => enabledIds.includes(id));
+            if (enabledIds && hasEnabledAvailableModel && !allAvailableModelsEnabled) {
+                const newScopedModels = resolveModelScopeFromModels(enabledIds, availableModels).scopedModels;
+                this.session.setScopedModels(newScopedModels.map((scoped) => ({
+                    model: scoped.model,
+                    thinkingLevel: scoped.thinkingLevel,
+                })));
+            }
+            else {
+                this.session.setScopedModels([]);
+            }
+            this.updateAvailableProviderCount();
+            this.ui.requestRender();
+        };
+        this.showSelector((done) => {
+            let disposed = false;
+            let timedOut = false;
+            const controller = new AbortController();
+            const timeout = setTimeout(() => {
+                timedOut = true;
+                controller.abort();
+            }, 15_000);
+            const selector = new ScopedModelsSelectorComponent({
+                allModels: availableModels,
+                enabledModelIds: currentEnabledIds,
+                refreshStatus: "Refreshing model catalogs…",
+            }, {
+                onChange: (enabledIds) => {
+                    selectionChanged = true;
+                    updateSessionModels(enabledIds);
+                },
+                onPersist: (enabledIds) => {
+                    const allEnabled = enabledIds !== null &&
+                        enabledIds.length === availableModels.length &&
+                        enabledIds.every((id) => availableModelIds.has(id));
+                    const newPatterns = enabledIds === null || allEnabled ? undefined : enabledIds;
+                    this.settingsManager.setEnabledModels(newPatterns ? [...newPatterns] : undefined);
+                    this.showStatus("Model selection saved to settings");
+                },
+                onCancel: () => {
+                    done();
+                    this.ui.requestRender();
+                },
+            });
+            void this.session.modelRuntime
+                .refresh({ signal: controller.signal })
+                .then((result) => {
+                if (disposed)
+                    return;
+                availableModels = [...this.session.modelRuntime.getAvailableSnapshot()];
+                availableModelIds = new Set(availableModels.map((model) => `${model.provider}/${model.id}`));
+                if (!selectionChanged && sessionScopedModels.length === 0) {
+                    currentEnabledIds = configuredEnabledIds(availableModels);
+                    selector.updateModels(availableModels, currentEnabledIds);
+                }
+                else {
+                    selector.updateModels(availableModels);
+                }
+                if (currentEnabledIds !== null)
+                    updateSessionModels(currentEnabledIds);
+                if (result.aborted && timedOut) {
+                    selector.setRefreshStatus("Model refresh timed out; showing cached models.", "warning");
+                }
+                else if (result.errors.size > 0) {
+                    selector.setRefreshStatus(`Could not refresh ${[...result.errors.keys()].join(", ")}; showing cached models.`, "warning");
+                }
+                else {
+                    selector.setRefreshStatus("Model catalogs refreshed.", "success");
+                }
+                this.ui.requestRender();
+            })
+                .catch((error) => {
+                if (disposed)
+                    return;
+                selector.setRefreshStatus(timedOut
+                    ? "Model refresh timed out; showing cached models."
+                    : `Could not refresh model catalogs: ${error instanceof Error ? error.message : String(error)}`, "warning");
+                this.ui.requestRender();
+            })
+                .finally(() => clearTimeout(timeout));
+            return {
+                component: selector,
+                focus: selector,
+                dispose: () => {
+                    disposed = true;
+                    clearTimeout(timeout);
+                    controller.abort();
+                },
+            };
+        });
+    }
+    showUserMessageSelector() {
+        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({ signal: AbortSignal.timeout(15_000) }))
+            .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) {
+        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;
+        }
+        let providerOptions;
+        try {
+            providerOptions = await this.getLogoutProviderOptions();
+        }
+        catch (error) {
+            this.showError(`Could not read stored credentials: ${error instanceof Error ? error.message : String(error)}`);
+            return;
+        }
+        if (providerOptions.length === 0) {
+            this.showStatus("No stored credentials to remove. /logout only removes credentials saved by /login; environment variables and models.json config are unchanged.");
+            return;
+        }
+        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, {
+                        signal: AbortSignal.timeout(15_000),
+                    });
+                    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) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.showError(error instanceof CredentialSynchronizationError
+                        ? `Credentials removed for ${providerOption.name}, but local model state could not be synchronized: ${message}`
+                        : `Logout failed: ${message}`);
+                }
+            }, () => {
+                done();
+                this.ui.requestRender();
+            });
+            return { component: selector, focus: selector };
+        });
+    }
+    async completeProviderAuthentication(providerId, providerName, authType, previousModel) {
+        const actionLabel = authType === "oauth" ? `Logged in to ${providerName}` : `Saved API key for ${providerName}`;
+        let selectedModel;
+        let selectionError;
+        if (isUnknownModel(previousModel)) {
+            const availableModels = this.session.modelRuntime.getAvailableSnapshot();
+            const providerModels = availableModels.filter((model) => model.provider === providerId);
+            if (!hasDefaultModelProvider(providerId)) {
+                selectionError = `${actionLabel}, but no default model is configured for provider "${providerId}". Use /model to select a model.`;
+            }
+            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();
+            }
+        }
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 15_000);
+        void this.session.modelRuntime
+            .refresh({ providers: [providerId], signal: controller.signal })
+            .then((result) => {
+            if (result.aborted) {
+                this.showWarning(`${actionLabel}, but its model catalog refresh timed out; using cached models.`);
+            }
+            else if (result.errors.size > 0) {
+                this.showWarning(`${actionLabel}, but its model catalog could not be refreshed; using cached models.`);
+            }
+            this.updateAvailableProviderCount();
+            this.footer.invalidate();
+            this.ui.requestRender();
+        })
+            .catch((error) => {
+            this.showWarning(`${actionLabel}, but its model catalog could not be refreshed: ${error instanceof Error ? error.message : String(error)}`);
+        })
+            .finally(() => clearTimeout(timeout));
+    }
+    showAmbientAuthDialog(providerOption) {
+        const restoreEditor = () => {
+            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 (error instanceof CredentialSynchronizationError) {
+                this.showError(`Saved API key for ${providerName}, but local model state could not be synchronized: ${errorMsg}`);
+            }
+            else if (errorMsg !== "Login cancelled") {
+                this.showError(`Failed to save API key for ${providerName}: ${errorMsg}`);
+            }
+        }
+    }
+    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 (error instanceof CredentialSynchronizationError) {
+                this.showError(`Logged in to ${providerName}, but local model state could not be synchronized: ${errorMsg}`);
+            }
+            else if (errorMsg !== "Login cancelled") {
+                this.showError(`Failed to login to ${providerName}: ${errorMsg}`);
+            }
+        }
+    }
+    // =========================================================================
+    // 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();
+            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();
+            this.applyRuntimeSettings();
+            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(options = {}) {
+        const text = this.session.getLastAssistantText();
+        if (!text) {
+            this.showError("No agent messages to copy yet.");
+            return;
+        }
+        try {
+            await copyToClipboard(text);
+            if (options.flashConfirmation && this.ui instanceof TuiAltScreen) {
+                this.ui.flash("Copied!");
+            }
+            else {
+                this.showStatus("Copied last agent message to clipboard");
+            }
+        }
+        catch (error) {
+            this.showError(error instanceof Error ? error.message : String(error));
+        }
+    }
+    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() {
+        this.disposeActiveSelector();
+        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.stopInteractiveTui();
+            this.isInitialized = false;
+        }
+        this.unregisterSignalHandlers();
+    }
+}
+//# sourceMappingURL=interactive-mode.js.map