@mariozechner/pi-coding-agent 0.37.8 → 0.38.0

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

@@ -6,18 +6,20 @@ 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, 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";
@@ -45,13 +47,15 @@ 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 +94,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 +119,26 @@ 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();
+    }
+    setupAutocomplete(fdPath) {
         // Define commands for autocomplete
         const slashCommands = [
             { name: "settings", description: "Open settings menu" },
@@ -147,8 +157,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 +168,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 +306,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
     // =========================================================================
@@ -325,22 +444,20 @@ export class InteractiveMode {
                 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 +466,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 +524,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 +548,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 +562,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 +601,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)) {
@@ -622,6 +750,7 @@ export class InteractiveMode {
             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;
             },
@@ -649,7 +778,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 +789,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 +825,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 +836,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 +871,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.
      */
@@ -770,7 +949,7 @@ export class InteractiveMode {
                 this.ui.requestRender();
                 resolve(result);
             };
-            Promise.resolve(factory(this.ui, theme, close)).then((c) => {
+            Promise.resolve(factory(this.ui, theme, this.keybindings, close)).then((c) => {
                 component = c;
                 this.editorContainer.clear();
                 this.editorContainer.addChild(component);
@@ -803,7 +982,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 +1022,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 +1043,7 @@ export class InteractiveMode {
             }
         };
         // Handle clipboard image paste (triggered on Ctrl+V)
-        this.editor.onPasteImage = () => {
+        this.defaultEditor.onPasteImage = () => {
             this.handleClipboardImagePaste();
         };
     }
@@ -879,7 +1060,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 +1068,7 @@ export class InteractiveMode {
         }
     }
     setupEditorSubmitHandler() {
-        this.editor.onSubmit = async (text) => {
+        this.defaultEditor.onSubmit = async (text) => {
             text = text.trim();
             if (!text)
                 return;
@@ -993,7 +1174,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 +1184,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 +1196,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 +1209,7 @@ export class InteractiveMode {
             if (this.onInputCallback) {
                 this.onInputCallback(text);
             }
-            this.editor.addToHistory(text);
+            this.editor.addToHistory?.(text);
         };
     }
     subscribeToAgent() {
@@ -1166,13 +1347,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 +1368,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 +1400,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 +1415,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 +1503,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;
@@ -1437,7 +1619,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 +1634,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 +1660,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 +1672,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 +1752,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
@@ -1642,7 +1836,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 +2111,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 +2149,7 @@ export class InteractiveMode {
                         summaryLoader.stop();
                         this.statusContainer.clear();
                     }
-                    this.editor.onEscape = originalOnEscape;
+                    this.defaultEditor.onEscape = originalOnEscape;
                 }
             }, () => {
                 done();
@@ -2487,8 +2681,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 +2712,7 @@ export class InteractiveMode {
         finally {
             compactingLoader.stop();
             this.statusContainer.clear();
-            this.editor.onEscape = originalOnEscape;
+            this.defaultEditor.onEscape = originalOnEscape;
         }
         void this.flushCompactionQueue({ willRetry: false });
     }