@mariozechner/pi-coding-agent 0.37.8 → 0.39.0

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

@@ -6,18 +6,19 @@ import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { getOAuthProviders } from "@mariozechner/pi-ai";
+import { getOAuthProviders, } from "@mariozechner/pi-ai";
 import { CombinedAutocompleteProvider, Container, getEditorKeybindings, Loader, Markdown, matchesKey, ProcessTerminal, Spacer, Text, TruncatedText, TUI, visibleWidth, } from "@mariozechner/pi-tui";
 import { spawn, spawnSync } from "child_process";
-import { APP_NAME, getAuthPath, getDebugLogPath } from "../../config.js";
+import { APP_NAME, getAuthPath, getDebugLogPath, isBunBinary, VERSION } from "../../config.js";
 import { KeybindingsManager } from "../../core/keybindings.js";
 import { createCompactionSummaryMessage } from "../../core/messages.js";
 import { SessionManager } from "../../core/session-manager.js";
-import { loadSkills } from "../../core/skills.js";
 import { loadProjectContextFiles } from "../../core/system-prompt.js";
-import { getChangelogPath, parseChangelog } from "../../utils/changelog.js";
+import { allTools } from "../../core/tools/index.js";
+import { getChangelogPath, getNewEntries, parseChangelog } from "../../utils/changelog.js";
 import { copyToClipboard } from "../../utils/clipboard.js";
 import { extensionForImageMimeType, readClipboardImage } from "../../utils/clipboard-image.js";
+import { ensureTool } from "../../utils/tools-manager.js";
 import { ArminComponent } from "./components/armin.js";
 import { AssistantMessageComponent } from "./components/assistant-message.js";
 import { BashExecutionComponent } from "./components/bash-execution.js";
@@ -40,18 +41,20 @@ import { ToolExecutionComponent } from "./components/tool-execution.js";
 import { TreeSelectorComponent } from "./components/tree-selector.js";
 import { UserMessageComponent } from "./components/user-message.js";
 import { UserMessageSelectorComponent } from "./components/user-message-selector.js";
-import { getAvailableThemes, getEditorTheme, getMarkdownTheme, onThemeChange, setTheme, theme, } from "./theme/theme.js";
+import { getAvailableThemes, getAvailableThemesWithPaths, getEditorTheme, getMarkdownTheme, getThemeByName, initTheme, onThemeChange, setTheme, setThemeInstance, Theme, theme, } from "./theme/theme.js";
 function isExpandable(obj) {
     return typeof obj === "object" && obj !== null && "setExpanded" in obj && typeof obj.setExpanded === "function";
 }
 export class InteractiveMode {
-    setExtensionUIContext;
+    options;
     session;
     ui;
     chatContainer;
     pendingMessagesContainer;
     statusContainer;
+    defaultEditor;
     editor;
+    autocompleteProvider;
     editorContainer;
     footer;
     keybindings;
@@ -90,6 +93,8 @@ export class InteractiveMode {
     retryEscapeHandler;
     // Messages queued while compaction is running
     compactionQueuedMessages = [];
+    // Shutdown state
+    shutdownRequested = false;
     // Extension UI state
     extensionSelector = undefined;
     extensionInput = undefined;
@@ -113,22 +118,28 @@ export class InteractiveMode {
     get settingsManager() {
         return this.session.settingsManager;
     }
-    constructor(session, version, changelogMarkdown = undefined, _extensions = [], setExtensionUIContext = () => { }, fdPath = undefined) {
-        this.setExtensionUIContext = setExtensionUIContext;
+    constructor(session, options = {}) {
+        this.options = options;
         this.session = session;
-        this.version = version;
-        this.changelogMarkdown = changelogMarkdown;
+        this.version = VERSION;
         this.ui = new TUI(new ProcessTerminal());
         this.chatContainer = new Container();
         this.pendingMessagesContainer = new Container();
         this.statusContainer = new Container();
         this.widgetContainer = new Container();
         this.keybindings = KeybindingsManager.create();
-        this.editor = new CustomEditor(getEditorTheme(), this.keybindings);
+        this.defaultEditor = new CustomEditor(getEditorTheme(), this.keybindings);
+        this.editor = this.defaultEditor;
         this.editorContainer = new Container();
         this.editorContainer.addChild(this.editor);
         this.footer = new FooterComponent(session);
         this.footer.setAutoCompactEnabled(session.autoCompactionEnabled);
+        // Load hide thinking block setting
+        this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
+        // Initialize theme with watcher for interactive mode
+        initTheme(this.settingsManager.getTheme(), true);
+    }
+    setupAutocomplete(fdPath) {
         // Define commands for autocomplete
         const slashCommands = [
             { name: "settings", description: "Open settings menu" },
@@ -147,8 +158,6 @@ export class InteractiveMode {
             { name: "compact", description: "Manually compact the session context" },
             { name: "resume", description: "Resume a different session" },
         ];
-        // Load hide thinking block setting
-        this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
         // Convert prompt templates to SlashCommand format for autocomplete
         const templateCommands = this.session.promptTemplates.map((cmd) => ({
             name: cmd.name,
@@ -160,12 +169,17 @@ export class InteractiveMode {
             description: cmd.description ?? "(extension command)",
         }));
         // Setup autocomplete
-        const autocompleteProvider = new CombinedAutocompleteProvider([...slashCommands, ...templateCommands, ...extensionCommands], process.cwd(), fdPath);
-        this.editor.setAutocompleteProvider(autocompleteProvider);
+        this.autocompleteProvider = new CombinedAutocompleteProvider([...slashCommands, ...templateCommands, ...extensionCommands], process.cwd(), fdPath);
+        this.defaultEditor.setAutocompleteProvider(this.autocompleteProvider);
     }
     async init() {
         if (this.isInitialized)
             return;
+        // Load changelog (only show new entries, skip for resumed sessions)
+        this.changelogMarkdown = this.getChangelogForDisplay();
+        // Setup autocomplete with fd tool for file path completion
+        const fdPath = await ensureTool("fd");
+        this.setupAutocomplete(fdPath);
         // Add header with keybindings from config
         const logo = theme.bold(theme.fg("accent", APP_NAME)) + theme.fg("dim", ` v${this.version}`);
         // Format keybinding for startup display (lowercase, compact)
@@ -293,6 +307,112 @@ export class InteractiveMode {
             this.ui.requestRender();
         });
     }
+    /**
+     * Run the interactive mode. This is the main entry point.
+     * Initializes the UI, shows warnings, processes initial messages, and starts the interactive loop.
+     */
+    async run() {
+        await this.init();
+        // Start version check asynchronously
+        this.checkForNewVersion().then((newVersion) => {
+            if (newVersion) {
+                this.showNewVersionNotification(newVersion);
+            }
+        });
+        this.renderInitialMessages();
+        // Show startup warnings
+        const { migratedProviders, modelFallbackMessage, initialMessage, initialImages, initialMessages } = this.options;
+        if (migratedProviders && migratedProviders.length > 0) {
+            this.showWarning(`Migrated credentials to auth.json: ${migratedProviders.join(", ")}`);
+        }
+        const modelsJsonError = this.session.modelRegistry.getError();
+        if (modelsJsonError) {
+            this.showError(`models.json error: ${modelsJsonError}`);
+        }
+        if (modelFallbackMessage) {
+            this.showWarning(modelFallbackMessage);
+        }
+        // Process initial messages
+        if (initialMessage) {
+            try {
+                await this.session.prompt(initialMessage, { images: initialImages });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+                this.showError(errorMessage);
+            }
+        }
+        if (initialMessages) {
+            for (const message of initialMessages) {
+                try {
+                    await this.session.prompt(message);
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+                    this.showError(errorMessage);
+                }
+            }
+        }
+        // Main interactive loop
+        while (true) {
+            const userInput = await this.getUserInput();
+            try {
+                await this.session.prompt(userInput);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+                this.showError(errorMessage);
+            }
+        }
+    }
+    /**
+     * Check npm registry for a newer version.
+     */
+    async checkForNewVersion() {
+        if (process.env.PI_SKIP_VERSION_CHECK)
+            return undefined;
+        try {
+            const response = await fetch("https://registry.npmjs.org/@mariozechner/pi-coding-agent/latest");
+            if (!response.ok)
+                return undefined;
+            const data = (await response.json());
+            const latestVersion = data.version;
+            if (latestVersion && latestVersion !== this.version) {
+                return latestVersion;
+            }
+            return undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Get changelog entries to display on startup.
+     * Only shows new entries since last seen version, skips for resumed sessions.
+     */
+    getChangelogForDisplay() {
+        // Skip changelog for resumed/continued sessions (already have messages)
+        if (this.session.state.messages.length > 0) {
+            return undefined;
+        }
+        const lastVersion = this.settingsManager.getLastChangelogVersion();
+        const changelogPath = getChangelogPath();
+        const entries = parseChangelog(changelogPath);
+        if (!lastVersion) {
+            if (entries.length > 0) {
+                this.settingsManager.setLastChangelogVersion(VERSION);
+                return entries.map((e) => e.content).join("\n\n");
+            }
+        }
+        else {
+            const newEntries = getNewEntries(entries, lastVersion);
+            if (newEntries.length > 0) {
+                this.settingsManager.setLastChangelogVersion(VERSION);
+                return newEntries.map((e) => e.content).join("\n\n");
+            }
+        }
+        return undefined;
+    }
     // =========================================================================
     // Extension System
     // =========================================================================
@@ -307,40 +427,34 @@ export class InteractiveMode {
             this.chatContainer.addChild(new Text(theme.fg("muted", "Loaded context:\n") + contextList, 0, 0));
             this.chatContainer.addChild(new Spacer(1));
         }
-        // Show loaded skills
-        const skillsSettings = this.session.skillsSettings;
-        if (skillsSettings?.enabled !== false) {
-            const { skills, warnings: skillWarnings } = loadSkills(skillsSettings ?? {});
-            if (skills.length > 0) {
-                const skillList = skills.map((s) => theme.fg("dim", `  ${s.filePath}`)).join("\n");
-                this.chatContainer.addChild(new Text(theme.fg("muted", "Loaded skills:\n") + skillList, 0, 0));
-                this.chatContainer.addChild(new Spacer(1));
-            }
-            // Show skill warnings if any
-            if (skillWarnings.length > 0) {
-                const warningList = skillWarnings
-                    .map((w) => theme.fg("warning", `  ${w.skillPath}: ${w.message}`))
-                    .join("\n");
-                this.chatContainer.addChild(new Text(theme.fg("warning", "Skill warnings:\n") + warningList, 0, 0));
-                this.chatContainer.addChild(new Spacer(1));
-            }
+        // Show loaded skills (already discovered by SDK)
+        const skills = this.session.skills;
+        if (skills.length > 0) {
+            const skillList = skills.map((s) => theme.fg("dim", `  ${s.filePath}`)).join("\n");
+            this.chatContainer.addChild(new Text(theme.fg("muted", "Loaded skills:\n") + skillList, 0, 0));
+            this.chatContainer.addChild(new Spacer(1));
+        }
+        // Show skill warnings if any
+        const skillWarnings = this.session.skillWarnings;
+        if (skillWarnings.length > 0) {
+            const warningList = skillWarnings.map((w) => theme.fg("warning", `  ${w.skillPath}: ${w.message}`)).join("\n");
+            this.chatContainer.addChild(new Text(theme.fg("warning", "Skill warnings:\n") + warningList, 0, 0));
+            this.chatContainer.addChild(new Spacer(1));
         }
-        // Create and set extension UI context
-        const uiContext = this.createExtensionUIContext();
-        this.setExtensionUIContext(uiContext, true);
         const extensionRunner = this.session.extensionRunner;
         if (!extensionRunner) {
             return; // No extensions loaded
         }
-        extensionRunner.initialize({
-            getModel: () => this.session.model,
-            sendMessageHandler: (message, options) => {
+        // Create extension UI context
+        const uiContext = this.createExtensionUIContext();
+        extensionRunner.initialize(
+        // ExtensionActions - for pi.* API
+        {
+            sendMessage: (message, options) => {
                 const wasStreaming = this.session.isStreaming;
                 this.session
                     .sendCustomMessage(message, options)
                     .then(() => {
-                    // For non-streaming cases with display=true, update UI
-                    // (streaming cases update via message_end event)
                     if (!wasStreaming && message.display) {
                         this.rebuildChatFromMessages();
                     }
@@ -349,34 +463,53 @@ export class InteractiveMode {
                     this.showError(`Extension sendMessage failed: ${err instanceof Error ? err.message : String(err)}`);
                 });
             },
-            sendUserMessageHandler: (content, options) => {
+            sendUserMessage: (content, options) => {
                 this.session.sendUserMessage(content, options).catch((err) => {
                     this.showError(`Extension sendUserMessage failed: ${err instanceof Error ? err.message : String(err)}`);
                 });
             },
-            appendEntryHandler: (customType, data) => {
+            appendEntry: (customType, data) => {
                 this.sessionManager.appendCustomEntry(customType, data);
             },
-            getActiveToolsHandler: () => this.session.getActiveToolNames(),
-            getAllToolsHandler: () => this.session.getAllToolNames(),
-            setActiveToolsHandler: (toolNames) => this.session.setActiveToolsByName(toolNames),
-            newSessionHandler: async (options) => {
-                // Stop any loading animation
+            getActiveTools: () => this.session.getActiveToolNames(),
+            getAllTools: () => this.session.getAllToolNames(),
+            setActiveTools: (toolNames) => this.session.setActiveToolsByName(toolNames),
+            setModel: async (model) => {
+                const key = await this.session.modelRegistry.getApiKey(model);
+                if (!key)
+                    return false;
+                await this.session.setModel(model);
+                return true;
+            },
+            getThinkingLevel: () => this.session.thinkingLevel,
+            setThinkingLevel: (level) => this.session.setThinkingLevel(level),
+        }, 
+        // ExtensionContextActions - for ctx.* in event handlers
+        {
+            getModel: () => this.session.model,
+            isIdle: () => !this.session.isStreaming,
+            abort: () => this.session.abort(),
+            hasPendingMessages: () => this.session.pendingMessageCount > 0,
+            shutdown: () => {
+                this.shutdownRequested = true;
+            },
+        }, 
+        // ExtensionCommandContextActions - for ctx.* in command handlers
+        {
+            waitForIdle: () => this.session.agent.waitForIdle(),
+            newSession: async (options) => {
                 if (this.loadingAnimation) {
                     this.loadingAnimation.stop();
                     this.loadingAnimation = undefined;
                 }
                 this.statusContainer.clear();
-                // Create new session
                 const success = await this.session.newSession({ parentSession: options?.parentSession });
                 if (!success) {
                     return { cancelled: true };
                 }
-                // Call setup callback if provided
                 if (options?.setup) {
                     await options.setup(this.sessionManager);
                 }
-                // Clear UI state
                 this.chatContainer.clear();
                 this.pendingMessagesContainer.clear();
                 this.compactionQueuedMessages = [];
@@ -388,24 +521,22 @@ export class InteractiveMode {
                 this.ui.requestRender();
                 return { cancelled: false };
             },
-            branchHandler: async (entryId) => {
+            branch: async (entryId) => {
                 const result = await this.session.branch(entryId);
                 if (result.cancelled) {
                     return { cancelled: true };
                 }
-                // Update UI
                 this.chatContainer.clear();
                 this.renderInitialMessages();
                 this.editor.setText(result.selectedText);
                 this.showStatus("Branched to new session");
                 return { cancelled: false };
             },
-            navigateTreeHandler: async (targetId, options) => {
+            navigateTree: async (targetId, options) => {
                 const result = await this.session.navigateTree(targetId, { summarize: options?.summarize });
                 if (result.cancelled) {
                     return { cancelled: true };
                 }
-                // Update UI
                 this.chatContainer.clear();
                 this.renderInitialMessages();
                 if (result.editorText) {
@@ -414,24 +545,7 @@ export class InteractiveMode {
                 this.showStatus("Navigated to selected point");
                 return { cancelled: false };
             },
-            setModelHandler: async (model) => {
-                const key = await this.session.modelRegistry.getApiKey(model);
-                if (!key)
-                    return false;
-                await this.session.setModel(model);
-                return true;
-            },
-            getThinkingLevelHandler: () => this.session.thinkingLevel,
-            setThinkingLevelHandler: (level) => this.session.setThinkingLevel(level),
-            isIdle: () => !this.session.isStreaming,
-            waitForIdle: () => this.session.agent.waitForIdle(),
-            abort: () => {
-                this.session.abort();
-            },
-            hasPendingMessages: () => this.session.pendingMessageCount > 0,
-            uiContext,
-            hasUI: true,
-        });
+        }, uiContext);
         // Subscribe to extension errors
         extensionRunner.onError((error) => {
             this.showExtensionError(error.extensionPath, error.error, error.stack);
@@ -445,6 +559,14 @@ export class InteractiveMode {
             this.chatContainer.addChild(new Text(theme.fg("muted", "Loaded extensions:\n") + extList, 0, 0));
             this.chatContainer.addChild(new Spacer(1));
         }
+        // Warn about built-in tool overrides
+        const builtInToolNames = new Set(Object.keys(allTools));
+        const registeredTools = extensionRunner.getAllRegisteredTools();
+        for (const tool of registeredTools) {
+            if (builtInToolNames.has(tool.definition.name)) {
+                this.chatContainer.addChild(new Text(theme.fg("warning", `Warning: Extension "${tool.extensionPath}" overrides built-in tool "${tool.definition.name}"`), 0, 0));
+            }
+        }
         // Emit session_start event
         await extensionRunner.emit({
             type: "session_start",
@@ -476,9 +598,12 @@ export class InteractiveMode {
             isIdle: () => !this.session.isStreaming,
             abort: () => this.session.abort(),
             hasPendingMessages: () => this.session.pendingMessageCount > 0,
+            shutdown: () => {
+                this.shutdownRequested = true;
+            },
         });
-        // Set up the extension shortcut handler on the editor
-        this.editor.onExtensionShortcut = (data) => {
+        // Set up the extension shortcut handler on the default editor
+        this.defaultEditor.onExtensionShortcut = (data) => {
             for (const [shortcutStr, shortcut] of shortcuts) {
                 // Cast to KeyId - extension shortcuts use the same format
                 if (matchesKey(data, shortcutStr)) {
@@ -618,13 +743,28 @@ export class InteractiveMode {
             setFooter: (factory) => this.setExtensionFooter(factory),
             setHeader: (factory) => this.setExtensionHeader(factory),
             setTitle: (title) => this.ui.terminal.setTitle(title),
-            custom: (factory) => this.showExtensionCustom(factory),
+            custom: (factory, options) => this.showExtensionCustom(factory, options),
             setEditorText: (text) => this.editor.setText(text),
             getEditorText: () => this.editor.getText(),
             editor: (title, prefill) => this.showExtensionEditor(title, prefill),
+            setEditorComponent: (factory) => this.setCustomEditorComponent(factory),
             get theme() {
                 return theme;
             },
+            getAllThemes: () => getAvailableThemesWithPaths(),
+            getTheme: (name) => getThemeByName(name),
+            setTheme: (themeOrName) => {
+                if (themeOrName instanceof Theme) {
+                    setThemeInstance(themeOrName);
+                    this.ui.requestRender();
+                    return { success: true };
+                }
+                const result = setTheme(themeOrName, true);
+                if (result.success) {
+                    this.ui.requestRender();
+                }
+                return result;
+            },
         };
     }
     /**
@@ -649,7 +789,7 @@ export class InteractiveMode {
                 opts?.signal?.removeEventListener("abort", onAbort);
                 this.hideExtensionSelector();
                 resolve(undefined);
-            });
+            }, { tui: this.ui, timeout: opts?.timeout });
             this.editorContainer.clear();
             this.editorContainer.addChild(this.extensionSelector);
             this.ui.setFocus(this.extensionSelector);
@@ -660,6 +800,7 @@ export class InteractiveMode {
      * Hide the extension selector.
      */
     hideExtensionSelector() {
+        this.extensionSelector?.dispose();
         this.editorContainer.clear();
         this.editorContainer.addChild(this.editor);
         this.extensionSelector = undefined;
@@ -695,7 +836,7 @@ export class InteractiveMode {
                 opts?.signal?.removeEventListener("abort", onAbort);
                 this.hideExtensionInput();
                 resolve(undefined);
-            });
+            }, { tui: this.ui, timeout: opts?.timeout });
             this.editorContainer.clear();
             this.editorContainer.addChild(this.extensionInput);
             this.ui.setFocus(this.extensionInput);
@@ -706,6 +847,7 @@ export class InteractiveMode {
      * Hide the extension input.
      */
     hideExtensionInput() {
+        this.extensionInput?.dispose();
         this.editorContainer.clear();
         this.editorContainer.addChild(this.editor);
         this.extensionInput = undefined;
@@ -740,6 +882,54 @@ export class InteractiveMode {
         this.ui.setFocus(this.editor);
         this.ui.requestRender();
     }
+    /**
+     * Set a custom editor component from an extension.
+     * Pass undefined to restore the default editor.
+     */
+    setCustomEditorComponent(factory) {
+        // Save text from current editor before switching
+        const currentText = this.editor.getText();
+        this.editorContainer.clear();
+        if (factory) {
+            // Create the custom editor with tui, theme, and keybindings
+            const newEditor = factory(this.ui, getEditorTheme(), this.keybindings);
+            // Wire up callbacks from the default editor
+            newEditor.onSubmit = this.defaultEditor.onSubmit;
+            newEditor.onChange = this.defaultEditor.onChange;
+            // Copy text from previous editor
+            newEditor.setText(currentText);
+            // Copy appearance settings if supported
+            if (newEditor.borderColor !== undefined) {
+                newEditor.borderColor = this.defaultEditor.borderColor;
+            }
+            // Set autocomplete if supported
+            if (newEditor.setAutocompleteProvider && this.autocompleteProvider) {
+                newEditor.setAutocompleteProvider(this.autocompleteProvider);
+            }
+            // If extending CustomEditor, copy app-level handlers
+            // Use duck typing since instanceof fails across jiti module boundaries
+            const customEditor = newEditor;
+            if ("actionHandlers" in customEditor && customEditor.actionHandlers instanceof Map) {
+                customEditor.onEscape = this.defaultEditor.onEscape;
+                customEditor.onCtrlD = this.defaultEditor.onCtrlD;
+                customEditor.onPasteImage = this.defaultEditor.onPasteImage;
+                customEditor.onExtensionShortcut = this.defaultEditor.onExtensionShortcut;
+                // Copy action handlers (clear, suspend, model switching, etc.)
+                for (const [action, handler] of this.defaultEditor.actionHandlers) {
+                    customEditor.actionHandlers.set(action, handler);
+                }
+            }
+            this.editor = newEditor;
+        }
+        else {
+            // Restore default editor with text from custom editor
+            this.defaultEditor.setText(currentText);
+            this.editor = this.defaultEditor;
+        }
+        this.editorContainer.addChild(this.editor);
+        this.ui.setFocus(this.editor);
+        this.ui.requestRender();
+    }
     /**
      * Show a notification for extensions.
      */
@@ -754,28 +944,59 @@ export class InteractiveMode {
             this.showStatus(message);
         }
     }
-    /**
-     * Show a custom component with keyboard focus.
-     */
-    async showExtensionCustom(factory) {
+    /** Show a custom component with keyboard focus. Overlay mode renders on top of existing content. */
+    async showExtensionCustom(factory, options) {
         const savedText = this.editor.getText();
-        return new Promise((resolve) => {
+        const isOverlay = options?.overlay ?? false;
+        const restoreEditor = () => {
+            this.editorContainer.clear();
+            this.editorContainer.addChild(this.editor);
+            this.editor.setText(savedText);
+            this.ui.setFocus(this.editor);
+            this.ui.requestRender();
+        };
+        return new Promise((resolve, reject) => {
             let component;
+            let closed = false;
             const close = (result) => {
-                component.dispose?.();
-                this.editorContainer.clear();
-                this.editorContainer.addChild(this.editor);
-                this.editor.setText(savedText);
-                this.ui.setFocus(this.editor);
-                this.ui.requestRender();
+                if (closed)
+                    return;
+                closed = true;
+                if (isOverlay)
+                    this.ui.hideOverlay();
+                else
+                    restoreEditor();
+                // Note: both branches above already call requestRender
                 resolve(result);
+                try {
+                    component?.dispose?.();
+                }
+                catch {
+                    /* ignore dispose errors */
+                }
             };
-            Promise.resolve(factory(this.ui, theme, close)).then((c) => {
+            Promise.resolve(factory(this.ui, theme, this.keybindings, close))
+                .then((c) => {
+                if (closed)
+                    return;
                 component = c;
-                this.editorContainer.clear();
-                this.editorContainer.addChild(component);
-                this.ui.setFocus(component);
-                this.ui.requestRender();
+                if (isOverlay) {
+                    const w = component.width;
+                    this.ui.showOverlay(component, w ? { width: w } : undefined);
+                }
+                else {
+                    this.editorContainer.clear();
+                    this.editorContainer.addChild(component);
+                    this.ui.setFocus(component);
+                    this.ui.requestRender();
+                }
+            })
+                .catch((err) => {
+                if (closed)
+                    return;
+                if (!isOverlay)
+                    restoreEditor();
+                reject(err);
             });
         });
     }
@@ -803,7 +1024,9 @@ export class InteractiveMode {
     // Key Handlers
     // =========================================================================
     setupKeyHandlers() {
-        this.editor.onEscape = () => {
+        // Set up handlers on defaultEditor - they use this.editor for text access
+        // so they work correctly regardless of which editor is active
+        this.defaultEditor.onEscape = () => {
             if (this.loadingAnimation) {
                 // Abort and restore queued messages to editor
                 const { steering, followUp } = this.session.clearQueue();
@@ -841,20 +1064,20 @@ export class InteractiveMode {
             }
         };
         // Register app action handlers
-        this.editor.onAction("clear", () => this.handleCtrlC());
-        this.editor.onCtrlD = () => this.handleCtrlD();
-        this.editor.onAction("suspend", () => this.handleCtrlZ());
-        this.editor.onAction("cycleThinkingLevel", () => this.cycleThinkingLevel());
-        this.editor.onAction("cycleModelForward", () => this.cycleModel("forward"));
-        this.editor.onAction("cycleModelBackward", () => this.cycleModel("backward"));
+        this.defaultEditor.onAction("clear", () => this.handleCtrlC());
+        this.defaultEditor.onCtrlD = () => this.handleCtrlD();
+        this.defaultEditor.onAction("suspend", () => this.handleCtrlZ());
+        this.defaultEditor.onAction("cycleThinkingLevel", () => this.cycleThinkingLevel());
+        this.defaultEditor.onAction("cycleModelForward", () => this.cycleModel("forward"));
+        this.defaultEditor.onAction("cycleModelBackward", () => this.cycleModel("backward"));
         // Global debug handler on TUI (works regardless of focus)
         this.ui.onDebug = () => this.handleDebugCommand();
-        this.editor.onAction("selectModel", () => this.showModelSelector());
-        this.editor.onAction("expandTools", () => this.toggleToolOutputExpansion());
-        this.editor.onAction("toggleThinking", () => this.toggleThinkingBlockVisibility());
-        this.editor.onAction("externalEditor", () => this.openExternalEditor());
-        this.editor.onAction("followUp", () => this.handleFollowUp());
-        this.editor.onChange = (text) => {
+        this.defaultEditor.onAction("selectModel", () => this.showModelSelector());
+        this.defaultEditor.onAction("expandTools", () => this.toggleToolOutputExpansion());
+        this.defaultEditor.onAction("toggleThinking", () => this.toggleThinkingBlockVisibility());
+        this.defaultEditor.onAction("externalEditor", () => this.openExternalEditor());
+        this.defaultEditor.onAction("followUp", () => this.handleFollowUp());
+        this.defaultEditor.onChange = (text) => {
             const wasBashMode = this.isBashMode;
             this.isBashMode = text.trimStart().startsWith("!");
             if (wasBashMode !== this.isBashMode) {
@@ -862,7 +1085,7 @@ export class InteractiveMode {
             }
         };
         // Handle clipboard image paste (triggered on Ctrl+V)
-        this.editor.onPasteImage = () => {
+        this.defaultEditor.onPasteImage = () => {
             this.handleClipboardImagePaste();
         };
     }
@@ -879,7 +1102,7 @@ export class InteractiveMode {
             const filePath = path.join(tmpDir, fileName);
             fs.writeFileSync(filePath, Buffer.from(image.bytes));
             // Insert file path directly
-            this.editor.insertTextAtCursor(filePath);
+            this.editor.insertTextAtCursor?.(filePath);
             this.ui.requestRender();
         }
         catch {
@@ -887,7 +1110,7 @@ export class InteractiveMode {
         }
     }
     setupEditorSubmitHandler() {
-        this.editor.onSubmit = async (text) => {
+        this.defaultEditor.onSubmit = async (text) => {
             text = text.trim();
             if (!text)
                 return;
@@ -993,7 +1216,7 @@ export class InteractiveMode {
                         this.editor.setText(text);
                         return;
                     }
-                    this.editor.addToHistory(text);
+                    this.editor.addToHistory?.(text);
                     await this.handleBashCommand(command, isExcluded);
                     this.isBashMode = false;
                     this.updateEditorBorderColor();
@@ -1003,7 +1226,7 @@ export class InteractiveMode {
             // Queue input during compaction (extension commands execute immediately)
             if (this.session.isCompacting) {
                 if (this.isExtensionCommand(text)) {
-                    this.editor.addToHistory(text);
+                    this.editor.addToHistory?.(text);
                     this.editor.setText("");
                     await this.session.prompt(text);
                 }
@@ -1015,7 +1238,7 @@ export class InteractiveMode {
             // If streaming, use prompt() with steer behavior
             // This handles extension commands (execute immediately), prompt template expansion, and queueing
             if (this.session.isStreaming) {
-                this.editor.addToHistory(text);
+                this.editor.addToHistory?.(text);
                 this.editor.setText("");
                 await this.session.prompt(text, { streamingBehavior: "steer" });
                 this.updatePendingMessagesDisplay();
@@ -1028,7 +1251,7 @@ export class InteractiveMode {
             if (this.onInputCallback) {
                 this.onInputCallback(text);
             }
-            this.editor.addToHistory(text);
+            this.editor.addToHistory?.(text);
         };
     }
     subscribeToAgent() {
@@ -1043,6 +1266,16 @@ export class InteractiveMode {
         this.footer.invalidate();
         switch (event.type) {
             case "agent_start":
+                // Restore main escape handler if retry handler is still active
+                // (retry success event fires later, but we need main handler now)
+                if (this.retryEscapeHandler) {
+                    this.defaultEditor.onEscape = this.retryEscapeHandler;
+                    this.retryEscapeHandler = undefined;
+                }
+                if (this.retryLoader) {
+                    this.retryLoader.stop();
+                    this.retryLoader = undefined;
+                }
                 if (this.loadingAnimation) {
                     this.loadingAnimation.stop();
                 }
@@ -1100,11 +1333,20 @@ export class InteractiveMode {
                     break;
                 if (this.streamingComponent && event.message.role === "assistant") {
                     this.streamingMessage = event.message;
+                    let errorMessage;
+                    if (this.streamingMessage.stopReason === "aborted") {
+                        const retryAttempt = this.session.retryAttempt;
+                        errorMessage =
+                            retryAttempt > 0
+                                ? `Aborted after ${retryAttempt} retry attempt${retryAttempt > 1 ? "s" : ""}`
+                                : "Operation aborted";
+                        this.streamingMessage.errorMessage = errorMessage;
+                    }
                     this.streamingComponent.updateContent(this.streamingMessage);
                     if (this.streamingMessage.stopReason === "aborted" || this.streamingMessage.stopReason === "error") {
-                        const errorMessage = this.streamingMessage.stopReason === "aborted"
-                            ? "Operation aborted"
-                            : this.streamingMessage.errorMessage || "Error";
+                        if (!errorMessage) {
+                            errorMessage = this.streamingMessage.errorMessage || "Error";
+                        }
                         for (const [, component] of this.pendingTools.entries()) {
                             component.updateResult({
                                 content: [{ type: "text", text: errorMessage }],
@@ -1166,13 +1408,14 @@ export class InteractiveMode {
                     this.streamingMessage = undefined;
                 }
                 this.pendingTools.clear();
+                await this.checkShutdownRequested();
                 this.ui.requestRender();
                 break;
             case "auto_compaction_start": {
                 // Keep editor active; submissions are queued during compaction.
                 // Set up escape to abort auto-compaction
-                this.autoCompactionEscapeHandler = this.editor.onEscape;
-                this.editor.onEscape = () => {
+                this.autoCompactionEscapeHandler = this.defaultEditor.onEscape;
+                this.defaultEditor.onEscape = () => {
                     this.session.abortCompaction();
                 };
                 // Show compacting indicator with reason
@@ -1186,7 +1429,7 @@ export class InteractiveMode {
             case "auto_compaction_end": {
                 // Restore escape handler
                 if (this.autoCompactionEscapeHandler) {
-                    this.editor.onEscape = this.autoCompactionEscapeHandler;
+                    this.defaultEditor.onEscape = this.autoCompactionEscapeHandler;
                     this.autoCompactionEscapeHandler = undefined;
                 }
                 // Stop loader
@@ -1218,8 +1461,8 @@ export class InteractiveMode {
             }
             case "auto_retry_start": {
                 // Set up escape to abort retry
-                this.retryEscapeHandler = this.editor.onEscape;
-                this.editor.onEscape = () => {
+                this.retryEscapeHandler = this.defaultEditor.onEscape;
+                this.defaultEditor.onEscape = () => {
                     this.session.abortRetry();
                 };
                 // Show retry indicator
@@ -1233,7 +1476,7 @@ export class InteractiveMode {
             case "auto_retry_end": {
                 // Restore escape handler
                 if (this.retryEscapeHandler) {
-                    this.editor.onEscape = this.retryEscapeHandler;
+                    this.defaultEditor.onEscape = this.retryEscapeHandler;
                     this.retryEscapeHandler = undefined;
                 }
                 // Stop loader
@@ -1321,7 +1564,7 @@ export class InteractiveMode {
                     const userComponent = new UserMessageComponent(textContent);
                     this.chatContainer.addChild(userComponent);
                     if (options?.populateHistory) {
-                        this.editor.addToHistory(textContent);
+                        this.editor.addToHistory?.(textContent);
                     }
                 }
                 break;
@@ -1363,7 +1606,17 @@ export class InteractiveMode {
                         component.setExpanded(this.toolOutputExpanded);
                         this.chatContainer.addChild(component);
                         if (message.stopReason === "aborted" || message.stopReason === "error") {
-                            const errorMessage = message.stopReason === "aborted" ? "Operation aborted" : message.errorMessage || "Error";
+                            let errorMessage;
+                            if (message.stopReason === "aborted") {
+                                const retryAttempt = this.session.retryAttempt;
+                                errorMessage =
+                                    retryAttempt > 0
+                                        ? `Aborted after ${retryAttempt} retry attempt${retryAttempt > 1 ? "s" : ""}`
+                                        : "Operation aborted";
+                            }
+                            else {
+                                errorMessage = message.errorMessage || "Error";
+                            }
                             component.updateResult({ content: [{ type: "text", text: errorMessage }], isError: true });
                         }
                         else {
@@ -1437,7 +1690,11 @@ export class InteractiveMode {
      * Gracefully shutdown the agent.
      * Emits shutdown event to extensions, then exits.
      */
+    isShuttingDown = false;
     async shutdown() {
+        if (this.isShuttingDown)
+            return;
+        this.isShuttingDown = true;
         // Emit shutdown event to extensions
         const extensionRunner = this.session.extensionRunner;
         if (extensionRunner?.hasHandlers("session_shutdown")) {
@@ -1448,6 +1705,14 @@ export class InteractiveMode {
         this.stop();
         process.exit(0);
     }
+    /**
+     * Check if shutdown was requested and perform shutdown if so.
+     */
+    async checkShutdownRequested() {
+        if (!this.shutdownRequested)
+            return;
+        await this.shutdown();
+    }
     handleCtrlZ() {
         // Set up handler to restore TUI when resumed
         process.once("SIGCONT", () => {
@@ -1466,7 +1731,7 @@ export class InteractiveMode {
         // Queue input during compaction (extension commands execute immediately)
         if (this.session.isCompacting) {
             if (this.isExtensionCommand(text)) {
-                this.editor.addToHistory(text);
+                this.editor.addToHistory?.(text);
                 this.editor.setText("");
                 await this.session.prompt(text);
             }
@@ -1478,7 +1743,7 @@ export class InteractiveMode {
         // 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.addToHistory?.(text);
             this.editor.setText("");
             await this.session.prompt(text, { streamingBehavior: "followUp" });
             this.updatePendingMessagesDisplay();
@@ -1558,7 +1823,7 @@ export class InteractiveMode {
             this.showWarning("No editor configured. Set $VISUAL or $EDITOR environment variable.");
             return;
         }
-        const currentText = this.editor.getExpandedText();
+        const currentText = this.editor.getExpandedText?.() ?? this.editor.getText();
         const tmpFile = path.join(os.tmpdir(), `pi-editor-${Date.now()}.pi.md`);
         try {
             // Write current content to temp file
@@ -1609,12 +1874,14 @@ export class InteractiveMode {
         this.ui.requestRender();
     }
     showNewVersionNotification(newVersion) {
+        const updateInstruction = isBunBinary
+            ? theme.fg("muted", `New version ${newVersion} is available. Download from: `) +
+                theme.fg("accent", "https://github.com/badlogic/pi-mono/releases/latest")
+            : theme.fg("muted", `New version ${newVersion} is available. Run: `) +
+                theme.fg("accent", "npm install -g @mariozechner/pi-coding-agent");
         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" +
-            theme.fg("muted", `New version ${newVersion} is available. Run: `) +
-            theme.fg("accent", "npm install -g @mariozechner/pi-coding-agent"), 1, 0));
+        this.chatContainer.addChild(new Text(`${theme.bold(theme.fg("warning", "Update Available"))}\n${updateInstruction}`, 1, 0));
         this.chatContainer.addChild(new DynamicBorder((text) => theme.fg("warning", text)));
         this.ui.requestRender();
     }
@@ -1642,7 +1909,7 @@ export class InteractiveMode {
     }
     queueCompactionMessage(text, mode) {
         this.compactionQueuedMessages.push({ text, mode });
-        this.editor.addToHistory(text);
+        this.editor.addToHistory?.(text);
         this.editor.setText("");
         this.updatePendingMessagesDisplay();
         this.showStatus("Queued message for after compaction");
@@ -1917,9 +2184,9 @@ export class InteractiveMode {
                 const wantsSummary = await this.showExtensionConfirm("Summarize branch?", "Create a summary of the branch you're leaving?");
                 // Set up escape handler and loader if summarizing
                 let summaryLoader;
-                const originalOnEscape = this.editor.onEscape;
+                const originalOnEscape = this.defaultEditor.onEscape;
                 if (wantsSummary) {
-                    this.editor.onEscape = () => {
+                    this.defaultEditor.onEscape = () => {
                         this.session.abortBranchSummary();
                     };
                     this.chatContainer.addChild(new Spacer(1));
@@ -1955,7 +2222,7 @@ export class InteractiveMode {
                         summaryLoader.stop();
                         this.statusContainer.clear();
                     }
-                    this.editor.onEscape = originalOnEscape;
+                    this.defaultEditor.onEscape = originalOnEscape;
                 }
             }, () => {
                 done();
@@ -2438,6 +2705,40 @@ export class InteractiveMode {
         this.ui.requestRender();
     }
     async handleBashCommand(command, excludeFromContext = false) {
+        const extensionRunner = this.session.extensionRunner;
+        // Emit user_bash event to let extensions intercept
+        const eventResult = extensionRunner
+            ? await extensionRunner.emitUserBash({
+                type: "user_bash",
+                command,
+                excludeFromContext,
+                cwd: process.cwd(),
+            })
+            : undefined;
+        // 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) {
@@ -2456,7 +2757,7 @@ export class InteractiveMode {
                     this.bashComponent.appendOutput(chunk);
                     this.ui.requestRender();
                 }
-            }, { excludeFromContext });
+            }, { excludeFromContext, operations: eventResult?.operations });
             if (this.bashComponent) {
                 this.bashComponent.setComplete(result.exitCode, result.cancelled, result.truncated ? { truncated: true, content: result.output } : undefined, result.fullOutputPath);
             }
@@ -2487,8 +2788,8 @@ export class InteractiveMode {
         }
         this.statusContainer.clear();
         // Set up escape handler during compaction
-        const originalOnEscape = this.editor.onEscape;
-        this.editor.onEscape = () => {
+        const originalOnEscape = this.defaultEditor.onEscape;
+        this.defaultEditor.onEscape = () => {
             this.session.abortCompaction();
         };
         // Show compacting status
@@ -2518,7 +2819,7 @@ export class InteractiveMode {
         finally {
             compactingLoader.stop();
             this.statusContainer.clear();
-            this.editor.onEscape = originalOnEscape;
+            this.defaultEditor.onEscape = originalOnEscape;
         }
         void this.flushCompactionQueue({ willRetry: false });
     }