shortcutxl 0.2.0

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

@@ -0,0 +1,3775 @@
+/**
+ * Interactive mode for the coding agent.
+ * Handles TUI rendering and user interaction, delegating business logic to AgentSession.
+ */
+import { getOAuthProviders } from '@mariozechner/pi-ai';
+import { spawnSync } from 'child_process';
+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 { APP_NAME, getAuthPath, getDebugLogPath, getUpdateInstruction, NPM_PACKAGE_NAME, NPM_REGISTRY_URL, VERSION } from '../../config.js';
+import { LoginRequiredError, parseSkillBlock } from '../../core/agent-session.js';
+import { FooterDataProvider } from '../../core/footer-data-provider.js';
+import { KeybindingsManager } from '../../core/keybindings.js';
+import { createCompactionSummaryMessage } from '../../core/messages.js';
+import { CombinedAutocompleteProvider, Container, fuzzyFilter, Loader, Markdown, matchesKey, ProcessTerminal, Spacer, Text, TruncatedText, TUI, visibleWidth } from '../../tui/index.js';
+import { SessionManager } from '../../core/session-manager.js';
+import { getBuiltinSlashCommands } from '../../core/slash-commands.js';
+import { ABORT_UI_LABEL } from '../../core/abort.js';
+import { getChangelogPath, getNewEntries, parseChangelog } from '../../utils/changelog.js';
+import { extensionForImageMimeType, readClipboardImage } from '../../utils/clipboard-image.js';
+import { copyToClipboard } from '../../utils/clipboard.js';
+// SHORTCUT PATCH: import DEV_MODE to gate tool-download messages
+import { DEV_MODE } from '../../config.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';
+import { BorderedLoader } from './components/bordered-loader.js';
+import { BranchSummaryMessageComponent } from './components/branch-summary-message.js';
+import { CompactionSummaryMessageComponent } from './components/compaction-summary-message.js';
+import { CustomEditor } from './components/custom-editor.js';
+import { CustomMessageComponent } from './components/custom-message.js';
+import { DaxnutsComponent } from './components/daxnuts.js';
+import { DynamicBorder } from './components/dynamic-border.js';
+import { ExtensionEditorComponent } from './components/extension-editor.js';
+import { ExtensionInputComponent } from './components/extension-input.js';
+import { ExtensionSelectorComponent } from './components/extension-selector.js';
+import { FooterComponent } from './components/footer.js';
+import { appKey, appKeyHint, editorKey, rawKeyHint } from './components/keybinding-hints.js';
+import { LoginDialogComponent } from './components/login-dialog.js';
+import { ModelSelectorComponent } from './components/model-selector.js';
+import { OAuthSelectorComponent } from './components/oauth-selector.js';
+import { getAvailableThemes, getAvailableThemesWithPaths, getThemeByName, initTheme, onThemeChange, setRegisteredThemes, setTheme, setThemeInstance, Theme, theme } from '../../core/theme.js';
+import { SessionSelectorComponent } from './components/session-selector.js';
+import { SettingsSelectorComponent } from './components/settings-selector.js';
+import { SkillInvocationMessageComponent } from './components/skill-invocation-message.js';
+import { ThinkingSelectorComponent } from './components/thinking-selector.js';
+import { ToolExecutionComponent } from './components/tool-execution.js';
+import { ToolGroupComponent } from './components/tool-group.js';
+import { TreeSelectorComponent } from './components/tree-selector.js';
+import { UserMessageComponent } from './components/user-message.js';
+import { appendAttachedFiles, AttachmentManager, parseAttachedFiles, stripQuotes } from './file-attachments.js';
+import { getEditorTheme, getMarkdownTheme } from './theme/theme.js';
+/** Count total streamed chars across all content blocks. */
+function getStreamingChars(content) {
+    let chars = 0;
+    for (const c of content) {
+        const block = c;
+        if (block.type === 'text' && typeof block.text === 'string') {
+            chars += block.text.length;
+        }
+        else if (block.type === 'thinking' && typeof block.thinking === 'string') {
+            chars += block.thinking.length;
+        }
+        else if (block.type === 'tool_use') {
+            chars +=
+                JSON.stringify(block.input ?? '').length +
+                    (typeof block.name === 'string' ? block.name.length : 0);
+        }
+    }
+    return chars;
+}
+function isExpandable(obj) {
+    return (typeof obj === 'object' &&
+        obj !== null &&
+        'setExpanded' in obj &&
+        typeof obj.setExpanded === 'function');
+}
+export class InteractiveMode {
+    options;
+    session;
+    ui;
+    chatContainer;
+    pendingMessagesContainer;
+    statusContainer;
+    defaultEditor;
+    editor;
+    autocompleteProvider;
+    fdPath;
+    editorContainer;
+    footer;
+    footerDataProvider;
+    keybindings;
+    version;
+    isInitialized = false;
+    onInputCallback;
+    attachments;
+    loadingAnimation = undefined;
+    pendingWorkingMessage = undefined;
+    defaultWorkingMessage = 'Working...';
+    lastSigintTime = 0;
+    lastEscapeTime = 0;
+    changelogMarkdown = undefined;
+    // Status line tracking (for mutating immediately-sequential status updates)
+    lastStatusSpacer = undefined;
+    lastStatusText = undefined;
+    // Streaming message tracking
+    streamingComponent = undefined;
+    streamingMessage = undefined;
+    streamingStartTime = 0;
+    // Tool execution tracking: toolCallId -> component
+    pendingTools = new Map();
+    // Active tool groups for concurrent grouped tool calls (e.g., task).
+    // Keyed by tool name — supports multiple groups of different tool types per turn.
+    // Reset between assistant turns so each batch of parallel calls gets its own groups.
+    activeToolGroups = new Map();
+    // Tool call IDs that were pre-created during streaming (via maybeStreamGroupMembers).
+    // These are skipped in tool_execution_start to avoid double-creation.
+    streamedGroupMembers = new Set();
+    /** Clear all active tool groups (call alongside pendingTools.clear) */
+    clearActiveToolGroups() {
+        this.activeToolGroups.clear();
+        this.streamedGroupMembers.clear();
+    }
+    /**
+     * Get or create a ToolGroupComponent for the given tool name.
+     * Adds the group to chatContainer if newly created.
+     */
+    getOrCreateToolGroup(toolName, toolDef) {
+        let group = this.activeToolGroups.get(toolName);
+        if (!group) {
+            group = new ToolGroupComponent(toolDef, this.ui);
+            group.setExpanded(this.toolOutputExpanded);
+            this.activeToolGroups.set(toolName, group);
+            this.chatContainer.addChild(group);
+        }
+        return group;
+    }
+    /**
+     * During message_update, check for new tool calls in the streaming content
+     * and incrementally add them to a ToolGroupComponent if the tool supports grouping.
+     * This creates entries as the LLM streams them, showing "starting..." one by one.
+     */
+    maybeStreamGroupMembers(message) {
+        const toolCalls = message.content.filter((c) => c.type === 'toolCall');
+        if (toolCalls.length === 0)
+            return;
+        for (const tc of toolCalls) {
+            // Already created — update args as more tokens stream in
+            if (this.streamedGroupMembers.has(tc.id)) {
+                const existing = this.pendingTools.get(tc.id);
+                existing?.updateArgs(tc.arguments);
+                continue;
+            }
+            const toolDef = this.getRegisteredToolDefinition(tc.name);
+            if (!toolDef?.renderGroup)
+                continue;
+            const toolOpts = { showImages: this.settingsManager.getShowImages() };
+            const group = this.getOrCreateToolGroup(tc.name, toolDef);
+            const component = group.addMember(tc.id, tc.name, tc.arguments, toolOpts);
+            this.pendingTools.set(tc.id, component);
+            this.streamedGroupMembers.add(tc.id);
+        }
+    }
+    // Tool output expansion state
+    toolOutputExpanded = false;
+    // Thinking block visibility state
+    hideThinkingBlock = false;
+    // Skill commands: command name -> skill file path
+    skillCommands = new Map();
+    // Agent subscription unsubscribe function
+    unsubscribe;
+    // Track if editor is in bash mode (text starts with !)
+    isBashMode = false;
+    // Track current bash execution component
+    bashComponent = undefined;
+    // Track pending bash components (shown in pending area, moved to chat on submit)
+    pendingBashComponents = [];
+    // Auto-compaction state
+    autoCompactionLoader = undefined;
+    autoCompactionEscapeHandler;
+    // Auto-retry state
+    retryLoader = undefined;
+    retryEscapeHandler;
+    // Messages queued while compaction is running
+    compactionQueuedMessages = [];
+    // Shutdown state
+    shutdownRequested = false;
+    // Extension UI state
+    extensionSelector = undefined;
+    extensionInput = undefined;
+    extensionEditor = undefined;
+    extensionTerminalInputUnsubscribers = new Set();
+    // Extension widgets (components rendered above/below the editor)
+    extensionWidgetsAbove = new Map();
+    extensionWidgetsBelow = new Map();
+    widgetContainerAbove;
+    widgetContainerBelow;
+    // Custom footer from extension (undefined = use built-in footer)
+    customFooter = undefined;
+    // Header container that holds the built-in or custom header
+    headerContainer;
+    // Built-in header (logo + keybinding hints + changelog)
+    builtInHeader = undefined;
+    // Custom header from extension (undefined = use built-in header)
+    customHeader = undefined;
+    // Credit balance polling during active agent turns
+    creditPollInterval = undefined;
+    static CREDIT_POLL_INTERVAL_MS = 10_000;
+    // Convenience accessors
+    get agent() {
+        return this.session.agent;
+    }
+    get sessionManager() {
+        return this.session.sessionManager;
+    }
+    get settingsManager() {
+        return this.session.settingsManager;
+    }
+    constructor(session, options = {}) {
+        this.options = options;
+        this.session = session;
+        this.version = VERSION;
+        this.ui = new TUI(new ProcessTerminal(), this.settingsManager.getShowHardwareCursor());
+        this.ui.setClearOnShrink(this.settingsManager.getClearOnShrink());
+        this.headerContainer = new Container();
+        this.chatContainer = new Container();
+        this.pendingMessagesContainer = new Container();
+        this.statusContainer = new Container();
+        this.widgetContainerAbove = new Container();
+        this.widgetContainerBelow = new Container();
+        this.keybindings = KeybindingsManager.create();
+        this.defaultEditor = new CustomEditor(this.ui, getEditorTheme(), this.keybindings, {
+            autocompleteMaxVisible: 10
+        });
+        this.editor = this.defaultEditor;
+        this.attachments = new AttachmentManager(() => this.ui.requestRender());
+        this.editorContainer = new Container();
+        this.editorContainer.addChild(this.attachments.displayComponent);
+        this.editorContainer.addChild(this.editor);
+        this.footerDataProvider = new FooterDataProvider();
+        this.footer = new FooterComponent(session, this.footerDataProvider);
+        // Load hide thinking block setting
+        this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
+        // Register themes from resource loader and initialize
+        setRegisteredThemes(this.session.resourceLoader.getThemes().themes);
+        initTheme(this.settingsManager.getTheme(), true);
+    }
+    setupAutocomplete(fdPath) {
+        // Define commands for autocomplete
+        // SHORTCUT PATCH: dev slash commands injected via options (not env var) to keep vendor code clean
+        const builtinCommands = getBuiltinSlashCommands();
+        const extraCommands = this.options.extraSlashCommands ?? [];
+        const slashCommands = [...builtinCommands, ...extraCommands].map((command) => ({
+            name: command.name,
+            description: command.description
+        }));
+        const modelCommand = slashCommands.find((command) => command.name === 'model');
+        if (modelCommand) {
+            modelCommand.getArgumentCompletions = (prefix) => {
+                // SHORTCUT PATCH: always use all available models (scoped models removed)
+                const models = this.session.modelRegistry.getAvailable();
+                if (models.length === 0)
+                    return null;
+                // Create items with provider/id format
+                const items = models.map((m) => ({
+                    id: m.id,
+                    provider: m.provider,
+                    label: `${m.provider}/${m.id}`
+                }));
+                // Fuzzy filter by model ID + provider (allows "opus anthropic" to match)
+                const filtered = fuzzyFilter(items, prefix, (item) => `${item.id} ${item.provider}`);
+                if (filtered.length === 0)
+                    return null;
+                return filtered.map((item) => ({
+                    value: item.label,
+                    label: item.id,
+                    description: item.provider
+                }));
+            };
+        }
+        // Convert prompt templates to SlashCommand format for autocomplete
+        const templateCommands = this.session.promptTemplates.map((cmd) => ({
+            name: cmd.name,
+            description: cmd.description
+        }));
+        // Convert extension commands to SlashCommand format
+        const builtinCommandNames = new Set(slashCommands.map((c) => c.name));
+        const extensionCommands = (this.session.extensionRunner?.getRegisteredCommands(builtinCommandNames) ?? []).map((cmd) => ({
+            name: cmd.name,
+            description: cmd.description ?? '(extension command)',
+            getArgumentCompletions: cmd.getArgumentCompletions
+        }));
+        // Build skill commands from session.skills (if enabled)
+        this.skillCommands.clear();
+        const skillCommandList = [];
+        if (this.settingsManager.getEnableSkillCommands()) {
+            for (const skill of this.session.resourceLoader.getSkills().skills) {
+                const commandName = `skill:${skill.name}`;
+                this.skillCommands.set(commandName, skill.filePath);
+                skillCommandList.push({ name: commandName, description: skill.description });
+            }
+        }
+        // Setup autocomplete
+        this.autocompleteProvider = new CombinedAutocompleteProvider([...slashCommands, ...templateCommands, ...extensionCommands, ...skillCommandList], process.cwd(), fdPath);
+        this.defaultEditor.setAutocompleteProvider(this.autocompleteProvider);
+        if (this.editor !== this.defaultEditor) {
+            this.editor.setAutocompleteProvider?.(this.autocompleteProvider);
+        }
+    }
+    async init() {
+        if (this.isInitialized)
+            return;
+        // Load changelog (only show new entries, skip for resumed sessions)
+        this.changelogMarkdown = this.getChangelogForDisplay();
+        // Ensure fd and rg are available (downloads if missing, adds to PATH via getBinDir)
+        // Both are needed: fd for autocomplete, rg for grep tool and bash commands
+        // SHORTCUT PATCH: only show download messages in dev mode
+        const [fdPath] = await Promise.all([ensureTool('fd', !DEV_MODE), ensureTool('rg', !DEV_MODE)]);
+        this.fdPath = fdPath;
+        // Add header container as first child
+        this.ui.addChild(this.headerContainer);
+        // Add header with keybindings from config (unless silenced)
+        if (this.options.verbose || !this.settingsManager.getQuietStartup()) {
+            const logoText = theme.bold(theme.fg('accent', `${APP_NAME}XL`)) + theme.fg('dim', ` v${this.version}`);
+            // Build startup instructions using keybinding hint helpers
+            const kb = this.keybindings;
+            const hint = (action, desc) => appKeyHint(kb, action, desc);
+            const textLines = [
+                logoText,
+                rawKeyHint('/', 'for commands'),
+                rawKeyHint('/clear', 'new chat'),
+                rawKeyHint('/resume', 'resume previous session'),
+                rawKeyHint(`${appKey(kb, 'pasteImage')} or drop files`, 'to attach files'),
+                hint('interrupt', 'to interrupt agent'),
+                rawKeyHint(`${appKey(kb, 'clear')} twice`, 'to exit out of shortcutXL')
+            ];
+            // Braille dot logo (14 chars wide x 7 lines, 28x28 effective pixels)
+            const brailleLines = [
+                '⠹⣿⣆⠙⣿⣆⢀⣼⡿⠁⣼⡿⠃',
+                '⠀⠙⣿⣦⠘⣿⣿⡿⢁⣾⡿⠁',
+                '⠀⠀⠘⣿⣧⣾⣿⣧⣾⡿⠁',
+                '⠀⠀⠀⠈⢿⣿⡈⢿⣿⡀',
+                '⠀⠀⣠⣷⠈⢿⣷⡈⢻⣷⡀',
+                '⠀⣰⣿⠏⣠⡌⢻⣷⡀⢻⣿⡄',
+                '⠴⠿⠋⠰⠿⠏⠀⠻⠿⠄⠻⠿⠄'
+            ];
+            const LOGO_COL_WIDTH = 18; // fixed column width for logo side
+            // Compose side-by-side: logo left, text right
+            // Vertically center the logo (7 lines) against text lines
+            const logoOffset = Math.max(0, Math.ceil((textLines.length - brailleLines.length) / 2));
+            const maxLines = Math.max(brailleLines.length + logoOffset, textLines.length);
+            const composed = [];
+            for (let i = 0; i < maxLines; i++) {
+                const logoIdx = i - logoOffset;
+                const braille = logoIdx >= 0 && logoIdx < brailleLines.length ? brailleLines[logoIdx] : '';
+                const pad = LOGO_COL_WIDTH - braille.length;
+                const paddedLogo = braille + '⠀'.repeat(Math.max(0, pad));
+                const text = i < textLines.length ? textLines[i] : '';
+                composed.push(`${theme.fg('accent', paddedLogo)} ${text}`);
+            }
+            this.builtInHeader = new Text(composed.join('\n'), 1, 0);
+            // Setup UI layout
+            this.headerContainer.addChild(this.builtInHeader);
+            // Add changelog if provided
+            if (this.changelogMarkdown) {
+                this.headerContainer.addChild(new DynamicBorder());
+                if (this.settingsManager.getCollapseChangelog()) {
+                    const versionMatch = this.changelogMarkdown.match(/##\s+\[?(\d+\.\d+\.\d+)\]?/);
+                    const latestVersion = versionMatch ? versionMatch[1] : this.version;
+                    const condensedText = `Updated to v${latestVersion}. Use ${theme.bold('/changelog')} to view full changelog.`;
+                    this.headerContainer.addChild(new Text(condensedText, 1, 0));
+                }
+                else {
+                    this.headerContainer.addChild(new Text(theme.bold(theme.fg('accent', "What's New")), 1, 0));
+                    this.headerContainer.addChild(new Spacer(1));
+                    this.headerContainer.addChild(new Markdown(this.changelogMarkdown.trim(), 1, 0, this.getMarkdownThemeWithSettings()));
+                    this.headerContainer.addChild(new Spacer(1));
+                }
+                this.headerContainer.addChild(new DynamicBorder());
+            }
+        }
+        else {
+            // Minimal header when silenced
+            this.builtInHeader = new Text('', 0, 0);
+            this.headerContainer.addChild(this.builtInHeader);
+            if (this.changelogMarkdown) {
+                // Still show changelog notification even in silent mode
+                this.headerContainer.addChild(new Spacer(1));
+                const versionMatch = this.changelogMarkdown.match(/##\s+\[?(\d+\.\d+\.\d+)\]?/);
+                const latestVersion = versionMatch ? versionMatch[1] : this.version;
+                const condensedText = `Updated to v${latestVersion}. Use ${theme.bold('/changelog')} to view full changelog.`;
+                this.headerContainer.addChild(new Text(condensedText, 1, 0));
+            }
+        }
+        this.ui.addChild(this.chatContainer);
+        this.ui.addChild(this.pendingMessagesContainer);
+        this.ui.addChild(this.statusContainer);
+        this.renderWidgets(); // Initialize with default spacer
+        this.ui.addChild(this.widgetContainerAbove);
+        this.ui.addChild(this.editorContainer);
+        this.ui.addChild(this.widgetContainerBelow);
+        this.ui.addChild(this.footer);
+        this.ui.setFocus(this.editor);
+        this.setupKeyHandlers();
+        this.setupEditorSubmitHandler();
+        // Initialize extensions first so resources are shown before messages
+        await this.initExtensions();
+        // Render initial messages AFTER showing loaded resources
+        this.renderInitialMessages();
+        // Start the UI
+        this.ui.start();
+        this.isInitialized = true;
+        // SHORTCUT PATCH: intercept raw stdin file drops before the terminal buffer
+        // File drops from macOS arrive as raw quoted paths (no bracketed paste markers)
+        this.attachments.interceptStdinFileDrops(this.ui.terminal);
+        // Set terminal title
+        this.updateTerminalTitle();
+        // Subscribe to agent events
+        this.subscribeToAgent();
+        // Set up theme file watcher
+        onThemeChange(() => {
+            this.ui.invalidate();
+            this.updateEditorBorderColor();
+            this.ui.requestRender();
+        });
+        // Set up git branch watcher (uses provider instead of footer)
+        this.footerDataProvider.onBranchChange(() => {
+            this.ui.requestRender();
+        });
+        // Initialize available provider count for footer display
+        await this.updateAvailableProviderCount();
+    }
+    /**
+     * Update terminal title with session name and cwd.
+     */
+    updateTerminalTitle() {
+        const cwdBasename = path.basename(process.cwd());
+        const sessionName = this.sessionManager.getSessionName();
+        if (sessionName) {
+            this.ui.terminal.setTitle(`𝕏 - ${sessionName} - ${cwdBasename}`);
+        }
+        else {
+            this.ui.terminal.setTitle(`𝕏 - ${cwdBasename}`);
+        }
+    }
+    /**
+     * 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();
+        // SHORTCUT PATCH: expose setStatus/setWidget to custom code (cron, todo, etc.)
+        this.options.onReady?.({
+            setStatus: (key, text) => this.setExtensionStatus(key, text),
+            setWidget: (key, lines, options) => this.setExtensionWidget(key, lines, options)
+        });
+        this.checkForNewVersion().then((newVersion) => {
+            if (newVersion) {
+                this.showNewVersionNotification(newVersion);
+            }
+        });
+        // 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);
+        }
+        if (this.options.startupWarnings) {
+            for (const warning of this.options.startupWarnings) {
+                this.showWarning(warning);
+            }
+        }
+        if (this.options.startupInfos) {
+            for (const info of this.options.startupInfos) {
+                this.showInfo(info);
+            }
+        }
+        // SHORTCUT PATCH: Eagerly validate Shortcut credentials on startup.
+        // Try to refresh the token — if refresh fails the credentials are dead,
+        // so show the login dialog immediately instead of waiting for first message.
+        await this.ensureShortcutAuth();
+        // Fetch initial credit balance (non-blocking)
+        this.refreshCreditBalance().catch(() => { });
+        // Process initial messages
+        if (initialMessage) {
+            await this.promptWithLoginRetry(() => this.session.prompt(initialMessage, { images: initialImages }));
+        }
+        if (initialMessages) {
+            for (const message of initialMessages) {
+                const ok = await this.promptWithLoginRetry(() => this.session.prompt(message));
+                if (!ok)
+                    break;
+            }
+        }
+        // Main interactive loop
+        while (true) {
+            const userInput = await this.getUserInput();
+            await this.promptWithLoginRetry(() => this.session.prompt(userInput));
+        }
+    }
+    /**
+     * Check npm registry for a newer version.
+     */
+    async checkForNewVersion() {
+        // SHORTCUT PATCH: renamed from PI_*
+        if (process.env.SHORTCUT_SKIP_VERSION_CHECK || process.env.SHORTCUT_OFFLINE)
+            return undefined;
+        try {
+            const response = await fetch(NPM_REGISTRY_URL, {
+                signal: AbortSignal.timeout(10000)
+            });
+            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) {
+            // Fresh install - just record the version, don't show changelog
+            this.settingsManager.setLastChangelogVersion(VERSION);
+            return undefined;
+        }
+        else {
+            const newEntries = getNewEntries(entries, lastVersion);
+            if (newEntries.length > 0) {
+                this.settingsManager.setLastChangelogVersion(VERSION);
+                return newEntries.map((e) => e.content).join('\n\n');
+            }
+            // Version changed but no changelog entries — still record the update
+            // so the UI can show a condensed "Updated to vX.Y.Z" notification.
+            if (lastVersion !== VERSION) {
+                this.settingsManager.setLastChangelogVersion(VERSION);
+                return `## ${VERSION}\n\nNo changelog entries for this release.`;
+            }
+        }
+        return undefined;
+    }
+    getMarkdownThemeWithSettings() {
+        return {
+            ...getMarkdownTheme(),
+            codeBlockIndent: this.settingsManager.getCodeBlockIndent()
+        };
+    }
+    // =========================================================================
+    // Extension System
+    // =========================================================================
+    formatDisplayPath(p) {
+        const home = os.homedir();
+        let result = p;
+        // Replace home directory with ~
+        if (result.startsWith(home)) {
+            result = `~${result.slice(home.length)}`;
+        }
+        return result;
+    }
+    /**
+     * Get a short path relative to the package root for display.
+     */
+    getShortPath(fullPath, source) {
+        // For npm packages, show path relative to node_modules/pkg/
+        const npmMatch = fullPath.match(/node_modules\/(@?[^/]+(?:\/[^/]+)?)\/(.*)/);
+        if (npmMatch && source.startsWith('npm:')) {
+            return npmMatch[2];
+        }
+        // For git packages, show path relative to repo root
+        const gitMatch = fullPath.match(/git\/[^/]+\/[^/]+\/(.*)/);
+        if (gitMatch && source.startsWith('git:')) {
+            return gitMatch[1];
+        }
+        // For local/auto, just use formatDisplayPath
+        return this.formatDisplayPath(fullPath);
+    }
+    getDisplaySourceInfo(source, scope) {
+        if (source === 'local') {
+            if (scope === 'user') {
+                return { label: 'user', color: 'muted' };
+            }
+            if (scope === 'project') {
+                return { label: 'project', color: 'muted' };
+            }
+            if (scope === 'temporary') {
+                return { label: 'path', scopeLabel: 'temp', color: 'muted' };
+            }
+            return { label: 'path', color: 'muted' };
+        }
+        if (source === 'cli') {
+            return {
+                label: 'path',
+                scopeLabel: scope === 'temporary' ? 'temp' : undefined,
+                color: 'muted'
+            };
+        }
+        const scopeLabel = scope === 'user'
+            ? 'user'
+            : scope === 'project'
+                ? 'project'
+                : scope === 'temporary'
+                    ? 'temp'
+                    : undefined;
+        return { label: source, scopeLabel, color: 'accent' };
+    }
+    getScopeGroup(source, scope) {
+        if (source === 'cli' || scope === 'temporary')
+            return 'path';
+        if (scope === 'user')
+            return 'user';
+        if (scope === 'project')
+            return 'project';
+        return 'path';
+    }
+    isPackageSource(source) {
+        return source.startsWith('npm:') || source.startsWith('git:');
+    }
+    buildScopeGroups(paths, metadata) {
+        const groups = {
+            user: { scope: 'user', paths: [], packages: new Map() },
+            project: { scope: 'project', paths: [], packages: new Map() },
+            path: { scope: 'path', paths: [], packages: new Map() }
+        };
+        for (const p of paths) {
+            const meta = this.findMetadata(p, metadata);
+            const source = meta?.source ?? 'local';
+            const scope = meta?.scope ?? 'project';
+            const groupKey = this.getScopeGroup(source, scope);
+            const group = groups[groupKey];
+            if (this.isPackageSource(source)) {
+                const list = group.packages.get(source) ?? [];
+                list.push(p);
+                group.packages.set(source, list);
+            }
+            else {
+                group.paths.push(p);
+            }
+        }
+        return [groups.project, groups.user, groups.path].filter((group) => group.paths.length > 0 || group.packages.size > 0);
+    }
+    formatScopeGroups(groups, options) {
+        const lines = [];
+        for (const group of groups) {
+            lines.push(`  ${theme.fg('accent', group.scope)}`);
+            const sortedPaths = [...group.paths].sort((a, b) => a.localeCompare(b));
+            for (const p of sortedPaths) {
+                lines.push(theme.fg('dim', `    ${options.formatPath(p)}`));
+            }
+            const sortedPackages = Array.from(group.packages.entries()).sort(([a], [b]) => a.localeCompare(b));
+            for (const [source, paths] of sortedPackages) {
+                lines.push(`    ${theme.fg('mdLink', source)}`);
+                const sortedPackagePaths = [...paths].sort((a, b) => a.localeCompare(b));
+                for (const p of sortedPackagePaths) {
+                    lines.push(theme.fg('dim', `      ${options.formatPackagePath(p, source)}`));
+                }
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Find metadata for a path, checking parent directories if exact match fails.
+     * Package manager stores metadata for directories, but we display file paths.
+     */
+    findMetadata(p, metadata) {
+        // Try exact match first
+        const exact = metadata.get(p);
+        if (exact)
+            return exact;
+        // Try parent directories (package manager stores directory paths)
+        let current = p;
+        while (current.includes('/')) {
+            current = current.substring(0, current.lastIndexOf('/'));
+            const parent = metadata.get(current);
+            if (parent)
+                return parent;
+        }
+        return undefined;
+    }
+    /**
+     * Format a path with its source/scope info from metadata.
+     */
+    formatPathWithSource(p, metadata) {
+        const meta = this.findMetadata(p, metadata);
+        if (meta) {
+            const shortPath = this.getShortPath(p, meta.source);
+            const { label, scopeLabel } = this.getDisplaySourceInfo(meta.source, meta.scope);
+            const labelText = scopeLabel ? `${label} (${scopeLabel})` : label;
+            return `${labelText} ${shortPath}`;
+        }
+        return this.formatDisplayPath(p);
+    }
+    /**
+     * Format resource diagnostics with nice collision display using metadata.
+     */
+    formatDiagnostics(diagnostics, metadata) {
+        const lines = [];
+        // Group collision diagnostics by name
+        const collisions = new Map();
+        const otherDiagnostics = [];
+        for (const d of diagnostics) {
+            if (d.type === 'collision' && d.collision) {
+                const list = collisions.get(d.collision.name) ?? [];
+                list.push(d);
+                collisions.set(d.collision.name, list);
+            }
+            else {
+                otherDiagnostics.push(d);
+            }
+        }
+        // Format collision diagnostics grouped by name
+        for (const [name, collisionList] of collisions) {
+            const first = collisionList[0]?.collision;
+            if (!first)
+                continue;
+            lines.push(theme.fg('warning', `  "${name}" collision:`));
+            // Show winner
+            lines.push(theme.fg('dim', `    ${theme.fg('success', '✓')} ${this.formatPathWithSource(first.winnerPath, metadata)}`));
+            // Show all losers
+            for (const d of collisionList) {
+                if (d.collision) {
+                    lines.push(theme.fg('dim', `    ${theme.fg('warning', '✗')} ${this.formatPathWithSource(d.collision.loserPath, metadata)} (skipped)`));
+                }
+            }
+        }
+        // Format other diagnostics (skill name collisions, parse errors, etc.)
+        for (const d of otherDiagnostics) {
+            if (d.path) {
+                // Use metadata-aware formatting for paths
+                const sourceInfo = this.formatPathWithSource(d.path, metadata);
+                lines.push(theme.fg(d.type === 'error' ? 'error' : 'warning', `  ${sourceInfo}`));
+                lines.push(theme.fg(d.type === 'error' ? 'error' : 'warning', `    ${d.message}`));
+            }
+            else {
+                lines.push(theme.fg(d.type === 'error' ? 'error' : 'warning', `  ${d.message}`));
+            }
+        }
+        return lines.join('\n');
+    }
+    showLoadedResources(options) {
+        const showListing = options?.force || this.options.verbose || !this.settingsManager.getQuietStartup();
+        const showDiagnostics = showListing || options?.showDiagnosticsWhenQuiet === true;
+        if (!showListing && !showDiagnostics) {
+            return;
+        }
+        const metadata = this.session.resourceLoader.getPathMetadata();
+        const sectionHeader = (name, color = 'mdHeading') => theme.fg(color, `[${name}]`);
+        const skillsResult = this.session.resourceLoader.getSkills();
+        const promptsResult = this.session.resourceLoader.getPrompts();
+        const themesResult = this.session.resourceLoader.getThemes();
+        if (showListing) {
+            // SHORTCUT PATCH: context files (AGENTS.md/CLAUDE.md) are loaded into system prompt
+            // but not displayed on startup — use /trace to inspect the full system prompt.
+            // SHORTCUT PATCH: skills hidden from startup — use /skills to list them
+            const templates = this.session.promptTemplates;
+            if (templates.length > 0) {
+                const templatePaths = templates.map((t) => t.filePath);
+                const groups = this.buildScopeGroups(templatePaths, metadata);
+                const templateByPath = new Map(templates.map((t) => [t.filePath, t]));
+                const templateList = this.formatScopeGroups(groups, {
+                    formatPath: (p) => {
+                        const template = templateByPath.get(p);
+                        return template ? `/${template.name}` : this.formatDisplayPath(p);
+                    },
+                    formatPackagePath: (p) => {
+                        const template = templateByPath.get(p);
+                        return template ? `/${template.name}` : this.formatDisplayPath(p);
+                    }
+                });
+                this.chatContainer.addChild(new Text(`${sectionHeader('Prompts')}\n${templateList}`, 0, 0));
+                this.chatContainer.addChild(new Spacer(1));
+            }
+            const extensionPaths = options?.extensionPaths ?? [];
+            if (extensionPaths.length > 0) {
+                const groups = this.buildScopeGroups(extensionPaths, metadata);
+                const extList = this.formatScopeGroups(groups, {
+                    formatPath: (p) => this.formatDisplayPath(p),
+                    formatPackagePath: (p, source) => this.getShortPath(p, source)
+                });
+                this.chatContainer.addChild(new Text(`${sectionHeader('Extensions', 'mdHeading')}\n${extList}`, 0, 0));
+                this.chatContainer.addChild(new Spacer(1));
+            }
+            // Show loaded themes (excluding built-in)
+            const loadedThemes = themesResult.themes;
+            const customThemes = loadedThemes.filter((t) => t.sourcePath);
+            if (customThemes.length > 0) {
+                const themePaths = customThemes.map((t) => t.sourcePath);
+                const groups = this.buildScopeGroups(themePaths, metadata);
+                const themeList = this.formatScopeGroups(groups, {
+                    formatPath: (p) => this.formatDisplayPath(p),
+                    formatPackagePath: (p, source) => this.getShortPath(p, source)
+                });
+                this.chatContainer.addChild(new Text(`${sectionHeader('Themes')}\n${themeList}`, 0, 0));
+                this.chatContainer.addChild(new Spacer(1));
+            }
+        }
+        if (showDiagnostics) {
+            const skillDiagnostics = skillsResult.diagnostics;
+            if (skillDiagnostics.length > 0) {
+                const warningLines = this.formatDiagnostics(skillDiagnostics, metadata);
+                this.chatContainer.addChild(new Text(`${theme.fg('warning', '[Skill conflicts]')}\n${warningLines}`, 0, 0));
+                this.chatContainer.addChild(new Spacer(1));
+            }
+            const promptDiagnostics = promptsResult.diagnostics;
+            if (promptDiagnostics.length > 0) {
+                const warningLines = this.formatDiagnostics(promptDiagnostics, metadata);
+                this.chatContainer.addChild(new Text(`${theme.fg('warning', '[Prompt conflicts]')}\n${warningLines}`, 0, 0));
+                this.chatContainer.addChild(new Spacer(1));
+            }
+            const extensionDiagnostics = [];
+            const extensionErrors = this.session.resourceLoader.getExtensions().errors;
+            if (extensionErrors.length > 0) {
+                for (const error of extensionErrors) {
+                    extensionDiagnostics.push({ type: 'error', message: error.error, path: error.path });
+                }
+            }
+            const commandDiagnostics = this.session.extensionRunner?.getCommandDiagnostics() ?? [];
+            extensionDiagnostics.push(...commandDiagnostics);
+            const shortcutDiagnostics = this.session.extensionRunner?.getShortcutDiagnostics() ?? [];
+            extensionDiagnostics.push(...shortcutDiagnostics);
+            if (extensionDiagnostics.length > 0) {
+                const warningLines = this.formatDiagnostics(extensionDiagnostics, metadata);
+                this.chatContainer.addChild(new Text(`${theme.fg('warning', '[Extension issues]')}\n${warningLines}`, 0, 0));
+                this.chatContainer.addChild(new Spacer(1));
+            }
+            const themeDiagnostics = themesResult.diagnostics;
+            if (themeDiagnostics.length > 0) {
+                const warningLines = this.formatDiagnostics(themeDiagnostics, metadata);
+                this.chatContainer.addChild(new Text(`${theme.fg('warning', '[Theme conflicts]')}\n${warningLines}`, 0, 0));
+                this.chatContainer.addChild(new Spacer(1));
+            }
+        }
+    }
+    /**
+     * Initialize the extension system with TUI-based UI context.
+     */
+    async initExtensions() {
+        const uiContext = this.createExtensionUIContext();
+        await this.session.bindExtensions({
+            uiContext,
+            commandContextActions: {
+                waitForIdle: () => this.session.agent.waitForIdle(),
+                newSession: async (options) => {
+                    if (this.loadingAnimation) {
+                        this.loadingAnimation.stop();
+                        this.loadingAnimation = undefined;
+                    }
+                    this.statusContainer.clear();
+                    // Delegate to AgentSession (handles setup + agent state sync)
+                    const success = await this.session.newSession(options);
+                    if (!success) {
+                        return { cancelled: true };
+                    }
+                    // Clear UI state
+                    this.chatContainer.clear();
+                    this.pendingMessagesContainer.clear();
+                    this.compactionQueuedMessages = [];
+                    this.streamingComponent = undefined;
+                    this.streamingMessage = undefined;
+                    this.pendingTools.clear();
+                    this.clearActiveToolGroups();
+                    // Render any messages added via setup, or show empty session
+                    this.renderInitialMessages();
+                    this.ui.requestRender();
+                    return { cancelled: false };
+                },
+                fork: async (entryId) => {
+                    const result = await this.session.fork(entryId);
+                    if (result.cancelled) {
+                        return { cancelled: true };
+                    }
+                    this.chatContainer.clear();
+                    this.renderInitialMessages();
+                    this.editor.setText(result.selectedText);
+                    this.showStatus('Forked to new session');
+                    return { cancelled: false };
+                },
+                navigateTree: async (targetId, options) => {
+                    const result = await this.session.navigateTree(targetId, {
+                        summarize: options?.summarize,
+                        customInstructions: options?.customInstructions,
+                        replaceInstructions: options?.replaceInstructions,
+                        label: options?.label
+                    });
+                    if (result.cancelled) {
+                        return { cancelled: true };
+                    }
+                    this.chatContainer.clear();
+                    this.renderInitialMessages();
+                    if (result.editorText && !this.editor.getText().trim()) {
+                        this.editor.setText(result.editorText);
+                    }
+                    this.showStatus('Navigated to selected point');
+                    return { cancelled: false };
+                },
+                switchSession: async (sessionPath) => {
+                    await this.handleResumeSession(sessionPath);
+                    return { cancelled: false };
+                },
+                reload: async () => {
+                    await this.handleReloadCommand();
+                }
+            },
+            shutdownHandler: () => {
+                this.shutdownRequested = true;
+                if (!this.session.isStreaming) {
+                    void this.shutdown();
+                }
+            },
+            onError: (error) => {
+                this.showExtensionError(error.extensionPath, error.error, error.stack);
+            }
+        });
+        setRegisteredThemes(this.session.resourceLoader.getThemes().themes);
+        this.setupAutocomplete(this.fdPath);
+        const extensionRunner = this.session.extensionRunner;
+        if (!extensionRunner) {
+            this.showLoadedResources({ extensionPaths: [], force: false });
+            return;
+        }
+        this.setupExtensionShortcuts(extensionRunner);
+        this.showLoadedResources({ extensionPaths: extensionRunner.getExtensionPaths(), force: false });
+    }
+    /**
+     * Get a registered tool definition by name (for custom rendering).
+     */
+    getRegisteredToolDefinition(toolName) {
+        // Check extension-registered tools first
+        const tools = this.session.extensionRunner?.getAllRegisteredTools() ?? [];
+        const registeredTool = tools.find((t) => t.definition.name === toolName);
+        if (registeredTool)
+            return registeredTool.definition;
+        // Then check SDK custom tools (e.g. excel_exec)
+        return this.session.customTools.find((t) => t.name === toolName);
+    }
+    /**
+     * Set up keyboard shortcuts registered by extensions.
+     */
+    setupExtensionShortcuts(extensionRunner) {
+        const shortcuts = extensionRunner.getShortcuts(this.keybindings.getEffectiveConfig());
+        if (shortcuts.size === 0)
+            return;
+        // Create a context for shortcut handlers
+        const createContext = () => ({
+            ui: this.createExtensionUIContext(),
+            hasUI: true,
+            cwd: process.cwd(),
+            sessionManager: this.sessionManager,
+            modelRegistry: this.session.modelRegistry,
+            model: this.session.model,
+            isIdle: () => !this.session.isStreaming,
+            abort: () => this.session.abort(),
+            hasPendingMessages: () => this.session.pendingMessageCount > 0,
+            shutdown: () => {
+                this.shutdownRequested = true;
+            },
+            getContextUsage: () => this.session.getContextUsage(),
+            compact: (options) => {
+                void (async () => {
+                    try {
+                        const result = await this.executeCompaction(options?.customInstructions, false);
+                        if (result) {
+                            options?.onComplete?.(result);
+                        }
+                    }
+                    catch (error) {
+                        const err = error instanceof Error ? error : new Error(String(error));
+                        options?.onError?.(err);
+                    }
+                })();
+            },
+            getSystemPrompt: () => this.session.systemPrompt
+        });
+        // 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)) {
+                    // Run handler async, don't block input
+                    Promise.resolve(shortcut.handler(createContext())).catch((err) => {
+                        this.showError(`Shortcut handler error: ${err instanceof Error ? err.message : String(err)}`);
+                    });
+                    return true;
+                }
+            }
+            return false;
+        };
+    }
+    /**
+     * Set extension status text in the footer.
+     */
+    setExtensionStatus(key, text) {
+        this.footerDataProvider.setExtensionStatus(key, text);
+        this.ui.requestRender();
+    }
+    /**
+     * Set an extension widget (string array or custom component).
+     */
+    setExtensionWidget(key, content, options) {
+        const placement = options?.placement ?? 'aboveEditor';
+        const removeExisting = (map) => {
+            const existing = map.get(key);
+            if (existing?.dispose)
+                existing.dispose();
+            map.delete(key);
+        };
+        removeExisting(this.extensionWidgetsAbove);
+        removeExisting(this.extensionWidgetsBelow);
+        if (content === undefined) {
+            this.renderWidgets();
+            return;
+        }
+        let component;
+        if (Array.isArray(content)) {
+            // Wrap string array in a Container with Text components
+            const container = new Container();
+            for (const line of content.slice(0, InteractiveMode.MAX_WIDGET_LINES)) {
+                container.addChild(new Text(line, 1, 0));
+            }
+            if (content.length > InteractiveMode.MAX_WIDGET_LINES) {
+                container.addChild(new Text(theme.fg('muted', '... (widget truncated)'), 1, 0));
+            }
+            component = container;
+        }
+        else {
+            // Factory function - create component
+            component = content(this.ui, theme);
+        }
+        const targetMap = placement === 'belowEditor' ? this.extensionWidgetsBelow : this.extensionWidgetsAbove;
+        targetMap.set(key, component);
+        this.renderWidgets();
+    }
+    clearExtensionWidgets() {
+        for (const widget of this.extensionWidgetsAbove.values()) {
+            widget.dispose?.();
+        }
+        for (const widget of this.extensionWidgetsBelow.values()) {
+            widget.dispose?.();
+        }
+        this.extensionWidgetsAbove.clear();
+        this.extensionWidgetsBelow.clear();
+        this.renderWidgets();
+    }
+    resetExtensionUI() {
+        if (this.extensionSelector) {
+            this.hideExtensionSelector();
+        }
+        if (this.extensionInput) {
+            this.hideExtensionInput();
+        }
+        if (this.extensionEditor) {
+            this.hideExtensionEditor();
+        }
+        this.ui.hideOverlay();
+        this.clearExtensionTerminalInputListeners();
+        this.setExtensionFooter(undefined);
+        this.setExtensionHeader(undefined);
+        this.clearExtensionWidgets();
+        this.footerDataProvider.clearExtensionStatuses();
+        this.footer.invalidate();
+        this.setCustomEditorComponent(undefined);
+        this.defaultEditor.onExtensionShortcut = undefined;
+        this.updateTerminalTitle();
+        if (this.loadingAnimation) {
+            this.loadingAnimation.setMessage(`${this.defaultWorkingMessage} (${appKey(this.keybindings, 'interrupt')} to interrupt)`);
+        }
+    }
+    // Maximum total widget lines to prevent viewport overflow
+    static MAX_WIDGET_LINES = 10;
+    /**
+     * Render all extension widgets to the widget container.
+     */
+    renderWidgets() {
+        if (!this.widgetContainerAbove || !this.widgetContainerBelow)
+            return;
+        this.renderWidgetContainer(this.widgetContainerAbove, this.extensionWidgetsAbove, true, true);
+        this.renderWidgetContainer(this.widgetContainerBelow, this.extensionWidgetsBelow, false, false);
+        this.ui.requestRender();
+    }
+    renderWidgetContainer(container, widgets, spacerWhenEmpty, leadingSpacer) {
+        container.clear();
+        if (widgets.size === 0) {
+            if (spacerWhenEmpty) {
+                container.addChild(new Spacer(1));
+            }
+            return;
+        }
+        if (leadingSpacer) {
+            container.addChild(new Spacer(1));
+        }
+        for (const component of widgets.values()) {
+            container.addChild(component);
+        }
+    }
+    /**
+     * Set a custom footer component, or restore the built-in footer.
+     */
+    setExtensionFooter(factory) {
+        // Dispose existing custom footer
+        if (this.customFooter?.dispose) {
+            this.customFooter.dispose();
+        }
+        // Remove current footer from UI
+        if (this.customFooter) {
+            this.ui.removeChild(this.customFooter);
+        }
+        else {
+            this.ui.removeChild(this.footer);
+        }
+        if (factory) {
+            // Create and add custom footer, passing the data provider
+            this.customFooter = factory(this.ui, theme, this.footerDataProvider);
+            this.ui.addChild(this.customFooter);
+        }
+        else {
+            // Restore built-in footer
+            this.customFooter = undefined;
+            this.ui.addChild(this.footer);
+        }
+        this.ui.requestRender();
+    }
+    /**
+     * Set a custom header component, or restore the built-in header.
+     */
+    setExtensionHeader(factory) {
+        // Header may not be initialized yet if called during early initialization
+        if (!this.builtInHeader) {
+            return;
+        }
+        // Dispose existing custom header
+        if (this.customHeader?.dispose) {
+            this.customHeader.dispose();
+        }
+        // Find the index of the current header in the header container
+        const currentHeader = this.customHeader || this.builtInHeader;
+        const index = this.headerContainer.children.indexOf(currentHeader);
+        if (factory) {
+            // Create and add custom header
+            this.customHeader = factory(this.ui, theme);
+            if (index !== -1) {
+                this.headerContainer.children[index] = this.customHeader;
+            }
+            else {
+                // If not found (e.g. builtInHeader was never added), add at the top
+                this.headerContainer.children.unshift(this.customHeader);
+            }
+        }
+        else {
+            // Restore built-in header
+            this.customHeader = undefined;
+            if (index !== -1) {
+                this.headerContainer.children[index] = this.builtInHeader;
+            }
+        }
+        this.ui.requestRender();
+    }
+    addExtensionTerminalInputListener(handler) {
+        const unsubscribe = this.ui.addInputListener(handler);
+        this.extensionTerminalInputUnsubscribers.add(unsubscribe);
+        return () => {
+            unsubscribe();
+            this.extensionTerminalInputUnsubscribers.delete(unsubscribe);
+        };
+    }
+    clearExtensionTerminalInputListeners() {
+        for (const unsubscribe of this.extensionTerminalInputUnsubscribers) {
+            unsubscribe();
+        }
+        this.extensionTerminalInputUnsubscribers.clear();
+    }
+    /**
+     * Create the ExtensionUIContext for extensions.
+     */
+    createExtensionUIContext() {
+        return {
+            select: (title, options, opts) => this.showExtensionSelector(title, options, opts),
+            confirm: (title, message, opts) => this.showExtensionConfirm(title, message, opts),
+            input: (title, placeholder, opts) => this.showExtensionInput(title, placeholder, opts),
+            notify: (message, type) => this.showExtensionNotify(message, type),
+            onTerminalInput: (handler) => this.addExtensionTerminalInputListener(handler),
+            setStatus: (key, text) => this.setExtensionStatus(key, text),
+            setWorkingMessage: (message) => {
+                if (this.loadingAnimation) {
+                    if (message) {
+                        this.loadingAnimation.setMessage(message);
+                    }
+                    else {
+                        this.loadingAnimation.setMessage(`${this.defaultWorkingMessage} (${appKey(this.keybindings, 'interrupt')} to interrupt)`);
+                    }
+                }
+                else {
+                    // Queue message for when loadingAnimation is created (handles agent_start race)
+                    this.pendingWorkingMessage = message;
+                }
+            },
+            setWidget: (key, content, options) => this.setExtensionWidget(key, content, options),
+            setFooter: (factory) => this.setExtensionFooter(factory),
+            setHeader: (factory) => this.setExtensionHeader(factory),
+            setTitle: (title) => this.ui.terminal.setTitle(title),
+            custom: (factory, options) => this.showExtensionCustom(factory, options),
+            pasteToEditor: (text) => this.editor.handleInput(`\x1b[200~${text}\x1b[201~`),
+            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) {
+                    if (this.settingsManager.getTheme() !== themeOrName) {
+                        this.settingsManager.setTheme(themeOrName);
+                    }
+                    this.ui.requestRender();
+                }
+                return result;
+            },
+            getToolsExpanded: () => this.toolOutputExpanded,
+            setToolsExpanded: (expanded) => this.setToolsExpanded(expanded)
+        };
+    }
+    /**
+     * Show a selector for extensions.
+     */
+    showExtensionSelector(title, options, opts) {
+        return new Promise((resolve) => {
+            if (opts?.signal?.aborted) {
+                resolve(undefined);
+                return;
+            }
+            const onAbort = () => {
+                this.hideExtensionSelector();
+                resolve(undefined);
+            };
+            opts?.signal?.addEventListener('abort', onAbort, { once: true });
+            this.extensionSelector = new ExtensionSelectorComponent(title, options, (option) => {
+                opts?.signal?.removeEventListener('abort', onAbort);
+                this.hideExtensionSelector();
+                resolve(option);
+            }, () => {
+                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);
+            this.ui.requestRender();
+        });
+    }
+    /**
+     * Hide the extension selector.
+     */
+    hideExtensionSelector() {
+        this.extensionSelector?.dispose();
+        this.restoreEditorToContainer();
+        this.extensionSelector = undefined;
+        this.ui.setFocus(this.editor);
+        this.ui.requestRender();
+    }
+    /**
+     * Show a confirmation dialog for extensions.
+     */
+    async showExtensionConfirm(title, message, opts) {
+        const result = await this.showExtensionSelector(`${title}\n${message}`, ['Yes', 'No'], opts);
+        return result === 'Yes';
+    }
+    /**
+     * Show a text input for extensions.
+     */
+    showExtensionInput(title, placeholder, opts) {
+        return new Promise((resolve) => {
+            if (opts?.signal?.aborted) {
+                resolve(undefined);
+                return;
+            }
+            const onAbort = () => {
+                this.hideExtensionInput();
+                resolve(undefined);
+            };
+            opts?.signal?.addEventListener('abort', onAbort, { once: true });
+            this.extensionInput = new ExtensionInputComponent(title, placeholder, (value) => {
+                opts?.signal?.removeEventListener('abort', onAbort);
+                this.hideExtensionInput();
+                resolve(value);
+            }, () => {
+                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);
+            this.ui.requestRender();
+        });
+    }
+    /**
+     * Hide the extension input.
+     */
+    hideExtensionInput() {
+        this.extensionInput?.dispose();
+        this.restoreEditorToContainer();
+        this.extensionInput = undefined;
+        this.ui.setFocus(this.editor);
+        this.ui.requestRender();
+    }
+    /**
+     * Show a multi-line editor for extensions (with Ctrl+G support).
+     */
+    showExtensionEditor(title, prefill) {
+        return new Promise((resolve) => {
+            this.extensionEditor = new ExtensionEditorComponent(this.ui, this.keybindings, title, prefill, (value) => {
+                this.hideExtensionEditor();
+                resolve(value);
+            }, () => {
+                this.hideExtensionEditor();
+                resolve(undefined);
+            });
+            this.editorContainer.clear();
+            this.editorContainer.addChild(this.extensionEditor);
+            this.ui.setFocus(this.extensionEditor);
+            this.ui.requestRender();
+        });
+    }
+    /**
+     * Hide the extension editor.
+     */
+    hideExtensionEditor() {
+        this.restoreEditorToContainer();
+        this.extensionEditor = undefined;
+        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;
+            }
+            if (newEditor.setPaddingX !== undefined) {
+                newEditor.setPaddingX(this.defaultEditor.getPaddingX());
+            }
+            // 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.onFilePaste = (fp) => this.defaultEditor.onFilePaste?.(fp) ?? false;
+                customEditor.onExtensionShortcut = (data) => this.defaultEditor.onExtensionShortcut?.(data);
+                // 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.attachments.displayComponent);
+        this.editorContainer.addChild(this.editor);
+        this.ui.setFocus(this.editor);
+        this.ui.requestRender();
+    }
+    /**
+     * Show a notification for extensions.
+     */
+    showExtensionNotify(message, type) {
+        if (type === 'error') {
+            this.showError(message);
+        }
+        else if (type === 'warning') {
+            this.showWarning(message);
+        }
+        else {
+            this.showStatus(message);
+        }
+    }
+    /** Show a custom component with keyboard focus. Overlay mode renders on top of existing content. */
+    async showExtensionCustom(factory, options) {
+        const savedText = this.editor.getText();
+        const isOverlay = options?.overlay ?? false;
+        const restoreEditor = () => {
+            this.restoreEditorToContainer();
+            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) => {
+                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, this.keybindings, close))
+                .then((c) => {
+                if (closed)
+                    return;
+                component = c;
+                if (isOverlay) {
+                    // Resolve overlay options - can be static or dynamic function
+                    const resolveOptions = () => {
+                        if (options?.overlayOptions) {
+                            const opts = typeof options.overlayOptions === 'function'
+                                ? options.overlayOptions()
+                                : options.overlayOptions;
+                            return opts;
+                        }
+                        // Fallback: use component's width property if available
+                        const w = component.width;
+                        return w ? { width: w } : undefined;
+                    };
+                    const handle = this.ui.showOverlay(component, resolveOptions());
+                    // Expose handle to caller for visibility control
+                    options?.onHandle?.(handle);
+                }
+                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);
+            });
+        });
+    }
+    /**
+     * Show an extension error in the UI.
+     */
+    showExtensionError(extensionPath, error, stack) {
+        const errorMsg = `Extension "${extensionPath}" error: ${error}`;
+        const errorText = new Text(theme.fg('error', errorMsg), 1, 0);
+        this.chatContainer.addChild(errorText);
+        if (stack) {
+            // Show stack trace in dim color, indented
+            const stackLines = stack
+                .split('\n')
+                .slice(1) // Skip first line (duplicates error message)
+                .map((line) => theme.fg('dim', `  ${line.trim()}`))
+                .join('\n');
+            if (stackLines) {
+                this.chatContainer.addChild(new Text(stackLines, 1, 0));
+            }
+        }
+        this.ui.requestRender();
+    }
+    // =========================================================================
+    // Key Handlers
+    // =========================================================================
+    setupKeyHandlers() {
+        // 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) {
+                this.restoreQueuedMessagesToEditor({ abort: true });
+            }
+            else if (this.session.isBashRunning) {
+                this.session.abortBash();
+            }
+            else if (this.isBashMode) {
+                this.editor.setText('');
+                this.isBashMode = false;
+                this.updateEditorBorderColor();
+            }
+            else if (!this.editor.getText().trim()) {
+                // Double-escape with empty editor triggers /tree
+                const now = Date.now();
+                if (now - this.lastEscapeTime < 500) {
+                    this.showTreeSelector();
+                    this.lastEscapeTime = 0;
+                }
+                else {
+                    this.lastEscapeTime = now;
+                }
+            }
+        };
+        // Register app action handlers
+        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.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.onAction('dequeue', () => this.handleDequeue());
+        this.defaultEditor.onAction('newSession', () => this.handleClearCommand());
+        this.defaultEditor.onAction('tree', () => this.showTreeSelector());
+        this.defaultEditor.onAction('resume', () => this.showSessionSelector());
+        this.defaultEditor.onChange = (text) => {
+            const wasBashMode = this.isBashMode;
+            this.isBashMode = text.trimStart().startsWith('!');
+            if (wasBashMode !== this.isBashMode) {
+                this.updateEditorBorderColor();
+            }
+        };
+        // Handle file path paste (drag-and-drop)
+        this.defaultEditor.onFilePaste = (filePath) => this.attachments.add(filePath);
+        // Handle clipboard image paste (triggered on Ctrl+V)
+        this.defaultEditor.onPasteImage = () => {
+            this.handleClipboardImagePaste();
+        };
+    }
+    /** Restore the editor (with attachments display) into editorContainer. */
+    restoreEditorToContainer() {
+        this.editorContainer.clear();
+        this.editorContainer.addChild(this.attachments.displayComponent);
+        this.editorContainer.addChild(this.editor);
+    }
+    async handleClipboardImagePaste() {
+        try {
+            const image = await readClipboardImage();
+            if (image) {
+                // Write to temp file
+                const tmpDir = os.tmpdir();
+                const ext = extensionForImageMimeType(image.mimeType) ?? 'png';
+                const fileName = `pi-clipboard-${crypto.randomUUID()}.${ext}`;
+                const filePath = path.join(tmpDir, fileName);
+                fs.writeFileSync(filePath, Buffer.from(image.bytes));
+                // Add as attachment instead of inserting path as text
+                this.attachments.add(filePath);
+                this.ui.requestRender();
+                return;
+            }
+            // No image — check if clipboard contains a file path
+            if (this.tryAttachClipboardFilePath()) {
+                this.ui.requestRender();
+            }
+        }
+        catch {
+            // Silently ignore clipboard errors (may not have permission, etc.)
+        }
+    }
+    /**
+     * Read clipboard text and, if it looks like a file path, attach it.
+     * Returns true if a file was attached.
+     */
+    tryAttachClipboardFilePath() {
+        try {
+            // Use PowerShell to get file paths from clipboard (handles both Explorer file copies and text paths)
+            const result = spawnSync('powershell.exe', [
+                '-NoProfile',
+                '-Command',
+                // Try to get file drop list first (Explorer copy), fall back to text
+                'try { (Get-Clipboard -Format FileDropList | ForEach-Object { $_.FullName }) -join "`n" } catch { Get-Clipboard -Raw }'
+            ], { timeout: 2000, maxBuffer: 4096 });
+            if (result.status !== 0 || !result.stdout)
+                return false;
+            const output = result.stdout.toString('utf-8').trim();
+            if (!output)
+                return false;
+            // Attach each file path (supports multiple files copied at once)
+            let attached = false;
+            for (const line of output.split('\n')) {
+                const filePath = stripQuotes(line.trim());
+                if (filePath && this.attachments.add(filePath)) {
+                    attached = true;
+                }
+            }
+            return attached;
+        }
+        catch {
+            return false;
+        }
+    }
+    setupEditorSubmitHandler() {
+        this.defaultEditor.onSubmit = async (text) => {
+            text = text.trim();
+            if (!text)
+                return;
+            // Handle commands
+            if (text === '/settings') {
+                this.showSettingsSelector();
+                this.editor.setText('');
+                return;
+            }
+            // SHORTCUT PATCH: removed /scoped-models command
+            if (text === '/model' || text.startsWith('/model ')) {
+                const searchTerm = text.startsWith('/model ') ? text.slice(7).trim() : undefined;
+                this.editor.setText('');
+                await this.handleModelCommand(searchTerm);
+                return;
+            }
+            if (text === '/thinking') {
+                this.showThinkingLevelSelector();
+                this.editor.setText('');
+                return;
+            }
+            if (text === '/hide-thinking') {
+                this.handleHideThinkingToggle();
+                this.editor.setText('');
+                return;
+            }
+            if (text === '/copy') {
+                this.handleCopyCommand();
+                this.editor.setText('');
+                return;
+            }
+            if (text === '/name' || text.startsWith('/name ')) {
+                this.handleNameCommand(text);
+                this.editor.setText('');
+                return;
+            }
+            if (text === '/session') {
+                this.handleSessionCommand();
+                this.editor.setText('');
+                return;
+            }
+            if (text === '/changelog') {
+                this.handleChangelogCommand();
+                this.editor.setText('');
+                return;
+            }
+            if (text === '/hotkeys') {
+                this.handleHotkeysCommand();
+                this.editor.setText('');
+                return;
+            }
+            if (text === '/skills') {
+                this.handleSkillsCommand();
+                this.editor.setText('');
+                return;
+            }
+            if (text === '/tree') {
+                this.showTreeSelector();
+                this.editor.setText('');
+                return;
+            }
+            if (text === '/login') {
+                // SHORTCUT PATCH: skip provider selector — go straight to Shortcut login
+                this.editor.setText('');
+                await this.showLoginDialog('shortcut');
+                return;
+            }
+            if (text === '/logout') {
+                this.showOAuthSelector('logout');
+                this.editor.setText('');
+                return;
+            }
+            if (text === '/clear') {
+                this.editor.setText('');
+                await this.handleClearCommand();
+                return;
+            }
+            if (text === '/compact' || text.startsWith('/compact ')) {
+                const customInstructions = text.startsWith('/compact ') ? text.slice(9).trim() : undefined;
+                this.editor.setText('');
+                await this.handleCompactCommand(customInstructions);
+                return;
+            }
+            if (text === '/reload') {
+                this.editor.setText('');
+                await this.handleReloadCommand();
+                return;
+            }
+            if (text === '/debug') {
+                this.handleDebugCommand();
+                this.editor.setText('');
+                return;
+            }
+            if (text === '/arminsayshi') {
+                this.handleArminSaysHi();
+                this.editor.setText('');
+                return;
+            }
+            if (text === '/resume') {
+                this.showSessionSelector();
+                this.editor.setText('');
+                return;
+            }
+            if (text === '/quit') {
+                this.editor.setText('');
+                await this.shutdown();
+                return;
+            }
+            // SHORTCUT PATCH: dispatch extra slash commands (dev-only)
+            if (text.startsWith('/') && this.options.onDevCommand) {
+                if (this.options.onDevCommand(text, (msg) => this.showStatus(msg))) {
+                    this.editor.setText('');
+                    return;
+                }
+            }
+            // Handle bash command (! for normal, !! for excluded from context)
+            if (text.startsWith('!')) {
+                const isExcluded = text.startsWith('!!');
+                const command = isExcluded ? text.slice(2).trim() : text.slice(1).trim();
+                if (command) {
+                    if (this.session.isBashRunning) {
+                        this.showWarning('A bash command is already running. Press Esc to cancel it first.');
+                        this.editor.setText(text);
+                        return;
+                    }
+                    this.editor.addToHistory?.(text);
+                    await this.handleBashCommand(command, isExcluded);
+                    this.isBashMode = false;
+                    this.updateEditorBorderColor();
+                    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;
+            }
+            // If streaming, queue as follow-up (delivered after agent finishes)
+            // This handles extension commands (execute immediately), prompt template expansion, and queueing
+            if (this.session.isStreaming) {
+                this.editor.addToHistory?.(text);
+                this.editor.setText('');
+                const finalText = appendAttachedFiles(text, this.attachments.take());
+                await this.session.prompt(finalText, {
+                    streamingBehavior: 'followUp'
+                });
+                this.updatePendingMessagesDisplay();
+                this.ui.requestRender();
+                return;
+            }
+            // Normal message submission
+            // First, move any pending bash components to chat
+            this.flushPendingBashComponents();
+            // Append attached file paths to the message
+            const finalText = appendAttachedFiles(text, this.attachments.take());
+            if (this.onInputCallback) {
+                this.onInputCallback(finalText);
+            }
+            this.editor.addToHistory?.(text);
+        };
+    }
+    subscribeToAgent() {
+        this.unsubscribe = this.session.subscribe(async (event) => {
+            await this.handleEvent(event);
+        });
+    }
+    async handleEvent(event) {
+        if (!this.isInitialized) {
+            await this.init();
+        }
+        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();
+                }
+                this.statusContainer.clear();
+                this.loadingAnimation = new Loader(this.ui, (spinner) => theme.fg('accent', spinner), (text) => theme.fg('muted', text), this.defaultWorkingMessage);
+                this.statusContainer.addChild(this.loadingAnimation);
+                // Apply any pending working message queued before loader existed
+                if (this.pendingWorkingMessage !== undefined) {
+                    if (this.pendingWorkingMessage) {
+                        this.loadingAnimation.setMessage(this.pendingWorkingMessage);
+                    }
+                    this.pendingWorkingMessage = undefined;
+                }
+                // Start polling credit balance while agent is working
+                this.startCreditPolling();
+                this.ui.requestRender();
+                break;
+            case 'message_start':
+                if (event.message.role === 'custom') {
+                    this.addMessageToChat(event.message);
+                    this.ui.requestRender();
+                }
+                else if (event.message.role === 'user') {
+                    this.addMessageToChat(event.message);
+                    this.updatePendingMessagesDisplay();
+                    this.ui.requestRender();
+                }
+                else if (event.message.role === 'assistant') {
+                    // Defer rendering — we'll create and populate the component at message_end
+                    this.streamingMessage = event.message;
+                    this.streamingStartTime = Date.now();
+                }
+                break;
+            case 'message_update':
+                // Keep message reference up to date; render at message_end.
+                if (event.message.role === 'assistant') {
+                    this.streamingMessage = event.message;
+                    // Update loader with live streaming stats
+                    if (this.loadingAnimation) {
+                        const chars = getStreamingChars(event.message.content);
+                        const elapsed = ((Date.now() - this.streamingStartTime) / 1000).toFixed(1);
+                        this.loadingAnimation.setMessage(chars > 0
+                            ? `Streaming... (${chars} chars, ${elapsed}s)`
+                            : `Streaming... (${elapsed}s)`);
+                    }
+                    // Incrementally add group members as tool calls stream in.
+                    // This makes entries appear one-by-one as the LLM emits them,
+                    // rather than all at once at message_end.
+                    this.maybeStreamGroupMembers(event.message);
+                    this.ui.requestRender();
+                }
+                break;
+            case 'message_end':
+                if (event.message.role === 'user')
+                    break;
+                if (event.message.role === 'assistant') {
+                    this.streamingMessage = event.message;
+                    // Reset loader to plain "Streaming..." between turns so stale
+                    // char counts from the previous message don't hang around.
+                    if (this.loadingAnimation) {
+                        this.loadingAnimation.setMessage('Streaming...');
+                    }
+                    // Create component now and render the complete message at once
+                    this.streamingComponent = new AssistantMessageComponent(undefined, this.hideThinkingBlock, this.getMarkdownThemeWithSettings());
+                    this.chatContainer.addChild(this.streamingComponent);
+                    // Reposition only tool groups that still have pending members.
+                    // Completed groups stay where they are to avoid a visible jump
+                    // when the assistant summary materializes above them.
+                    for (const group of this.activeToolGroups.values()) {
+                        if (group.hasPendingMembers() && this.chatContainer.children.includes(group)) {
+                            this.chatContainer.removeChild(group);
+                            this.chatContainer.addChild(group);
+                        }
+                    }
+                    let errorMessage;
+                    if (this.streamingMessage.stopReason === 'aborted') {
+                        const retryAttempt = this.session.retryAttempt;
+                        errorMessage =
+                            retryAttempt > 0
+                                ? `Aborted after ${retryAttempt} retry attempt${retryAttempt > 1 ? 's' : ''}`
+                                : ABORT_UI_LABEL;
+                        this.streamingMessage.errorMessage = errorMessage;
+                    }
+                    this.streamingComponent.updateContent(this.streamingMessage);
+                    if (this.streamingMessage.stopReason === 'aborted' ||
+                        this.streamingMessage.stopReason === 'error') {
+                        if (!errorMessage) {
+                            errorMessage = this.streamingMessage.errorMessage || 'Error';
+                        }
+                        for (const [, component] of this.pendingTools.entries()) {
+                            component.updateResult({
+                                content: [{ type: 'text', text: errorMessage }],
+                                isError: true
+                            });
+                        }
+                        this.pendingTools.clear();
+                        this.clearActiveToolGroups();
+                    }
+                    else {
+                        // Args are now complete - trigger diff computation for edit tools
+                        for (const [, component] of this.pendingTools.entries()) {
+                            component.setArgsComplete();
+                        }
+                    }
+                    this.streamingComponent = undefined;
+                    this.streamingMessage = undefined;
+                    this.footer.invalidate();
+                }
+                this.ui.requestRender();
+                break;
+            case 'tool_execution_start': {
+                // If pre-created during streaming (grouped tool), update args to final values and skip
+                const preCreated = this.pendingTools.get(event.toolCallId);
+                if (preCreated) {
+                    preCreated.updateArgs(event.args);
+                    break;
+                }
+                const toolDef = this.getRegisteredToolDefinition(event.toolName);
+                const toolOpts = { showImages: this.settingsManager.getShowImages() };
+                // Grouped rendering: if the tool defines renderGroup, use a ToolGroupComponent
+                if (toolDef?.renderGroup) {
+                    const group = this.getOrCreateToolGroup(event.toolName, toolDef);
+                    const component = group.addMember(event.toolCallId, event.toolName, event.args, toolOpts);
+                    this.pendingTools.set(event.toolCallId, component);
+                }
+                else {
+                    const component = new ToolExecutionComponent(event.toolName, event.args, toolOpts, toolDef, this.ui);
+                    component.setExpanded(this.toolOutputExpanded);
+                    this.chatContainer.addChild(component);
+                    this.pendingTools.set(event.toolCallId, component);
+                }
+                this.ui.requestRender();
+                break;
+            }
+            case 'tool_execution_update': {
+                const component = this.pendingTools.get(event.toolCallId);
+                if (component) {
+                    component.updateResult({ ...event.partialResult, isError: false }, true);
+                    this.ui.requestRender();
+                }
+                break;
+            }
+            case 'tool_execution_end': {
+                const component = this.pendingTools.get(event.toolCallId);
+                if (component) {
+                    component.updateResult({ ...event.result, isError: event.isError });
+                    this.pendingTools.delete(event.toolCallId);
+                    this.ui.requestRender();
+                }
+                break;
+            }
+            case 'agent_end':
+                if (this.loadingAnimation) {
+                    this.loadingAnimation.stop();
+                    this.loadingAnimation = undefined;
+                    this.statusContainer.clear();
+                }
+                if (this.streamingComponent) {
+                    this.chatContainer.removeChild(this.streamingComponent);
+                    this.streamingComponent = undefined;
+                    this.streamingMessage = undefined;
+                }
+                this.pendingTools.clear();
+                this.clearActiveToolGroups();
+                // Stop polling and do one final refresh
+                this.stopCreditPolling();
+                this.refreshCreditBalance().catch(() => { });
+                await this.checkShutdownRequested();
+                // SHORTCUT PATCH: invoke post-query callback for dev trace export
+                this.options.onAgentEnd?.();
+                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.defaultEditor.onEscape;
+                this.defaultEditor.onEscape = () => {
+                    this.session.abortCompaction();
+                };
+                // Show compacting indicator with reason
+                this.statusContainer.clear();
+                const reasonText = event.reason === 'overflow' ? 'Context overflow detected, ' : '';
+                this.autoCompactionLoader = new Loader(this.ui, (spinner) => theme.fg('accent', spinner), (text) => theme.fg('muted', text), `${reasonText}Auto-compacting... (${appKey(this.keybindings, 'interrupt')} to cancel)`);
+                this.statusContainer.addChild(this.autoCompactionLoader);
+                this.ui.requestRender();
+                break;
+            }
+            case 'auto_compaction_end': {
+                // Restore escape handler
+                if (this.autoCompactionEscapeHandler) {
+                    this.defaultEditor.onEscape = this.autoCompactionEscapeHandler;
+                    this.autoCompactionEscapeHandler = undefined;
+                }
+                // Stop loader
+                if (this.autoCompactionLoader) {
+                    this.autoCompactionLoader.stop();
+                    this.autoCompactionLoader = undefined;
+                    this.statusContainer.clear();
+                }
+                // Handle result
+                if (event.aborted) {
+                    this.showStatus('Auto-compaction cancelled');
+                }
+                else if (event.result) {
+                    // Rebuild chat to show compacted state
+                    this.chatContainer.clear();
+                    this.rebuildChatFromMessages();
+                    // Add compaction component at bottom so user sees it without scrolling
+                    this.addMessageToChat({
+                        role: 'compactionSummary',
+                        tokensBefore: event.result.tokensBefore,
+                        summary: event.result.summary,
+                        timestamp: Date.now()
+                    });
+                    this.footer.invalidate();
+                }
+                else if (event.errorMessage) {
+                    // Compaction failed (e.g., quota exceeded, API error)
+                    this.chatContainer.addChild(new Spacer(1));
+                    this.chatContainer.addChild(new Text(theme.fg('error', event.errorMessage), 1, 0));
+                }
+                void this.flushCompactionQueue({ willRetry: event.willRetry });
+                this.ui.requestRender();
+                break;
+            }
+            case 'auto_retry_start': {
+                // Set up escape to abort retry
+                this.retryEscapeHandler = this.defaultEditor.onEscape;
+                this.defaultEditor.onEscape = () => {
+                    this.session.abortRetry();
+                };
+                // Show retry indicator
+                this.statusContainer.clear();
+                const delaySeconds = Math.round(event.delayMs / 1000);
+                this.retryLoader = new Loader(this.ui, (spinner) => theme.fg('warning', spinner), (text) => theme.fg('muted', text), `Retrying (${event.attempt}/${event.maxAttempts}) in ${delaySeconds}s... (${appKey(this.keybindings, 'interrupt')} to cancel)`);
+                this.statusContainer.addChild(this.retryLoader);
+                this.ui.requestRender();
+                break;
+            }
+            case 'auto_retry_end': {
+                // Restore escape handler
+                if (this.retryEscapeHandler) {
+                    this.defaultEditor.onEscape = this.retryEscapeHandler;
+                    this.retryEscapeHandler = undefined;
+                }
+                // Stop loader
+                if (this.retryLoader) {
+                    this.retryLoader.stop();
+                    this.retryLoader = undefined;
+                    this.statusContainer.clear();
+                }
+                // Show error only on final failure (success shows normal response)
+                if (!event.success) {
+                    this.showError(`Retry failed after ${event.attempt} attempts: ${event.finalError || 'Unknown error'}`);
+                }
+                this.ui.requestRender();
+                break;
+            }
+        }
+    }
+    /** Annotate a user message component with workbook names from prePromptContext if available. */
+    annotateWithWorkbooks(component) {
+        const details = this.session.lastPrePromptDetails;
+        if (details?.workbooks?.length) {
+            component.setAnnotation(`📗 ${details.workbooks.join(', ')}`);
+        }
+    }
+    /** Extract text content from a user message */
+    getUserMessageText(message) {
+        if (message.role !== 'user')
+            return '';
+        const textBlocks = typeof message.content === 'string'
+            ? [{ type: 'text', text: message.content }]
+            : message.content.filter((c) => c.type === 'text');
+        return textBlocks.map((c) => c.text).join('');
+    }
+    /**
+     * Show a status message in the chat.
+     *
+     * If multiple status messages are emitted back-to-back (without anything else being added to the chat),
+     * we update the previous status line instead of appending new ones to avoid log spam.
+     */
+    showStatus(message) {
+        const children = this.chatContainer.children;
+        const last = children.length > 0 ? children[children.length - 1] : undefined;
+        const secondLast = children.length > 1 ? children[children.length - 2] : undefined;
+        if (last &&
+            secondLast &&
+            last === this.lastStatusText &&
+            secondLast === this.lastStatusSpacer) {
+            this.lastStatusText.setText(theme.fg('dim', message));
+            this.ui.requestRender();
+            return;
+        }
+        const spacer = new Spacer(1);
+        const text = new Text(theme.fg('dim', message), 1, 0);
+        this.chatContainer.addChild(spacer);
+        this.chatContainer.addChild(text);
+        this.lastStatusSpacer = spacer;
+        this.lastStatusText = text;
+        this.ui.requestRender();
+    }
+    addMessageToChat(message, options) {
+        switch (message.role) {
+            case 'bashExecution': {
+                const component = new BashExecutionComponent(message.command, this.ui, message.excludeFromContext);
+                if (message.output) {
+                    component.appendOutput(message.output);
+                }
+                component.setComplete(message.exitCode, message.cancelled, message.truncated ? { truncated: true } : undefined, message.fullOutputPath);
+                this.chatContainer.addChild(component);
+                break;
+            }
+            case 'custom': {
+                if (message.display) {
+                    const renderer = this.session.extensionRunner?.getMessageRenderer(message.customType);
+                    const component = new CustomMessageComponent(message, renderer, this.getMarkdownThemeWithSettings());
+                    component.setExpanded(this.toolOutputExpanded);
+                    this.chatContainer.addChild(component);
+                }
+                break;
+            }
+            case 'compactionSummary': {
+                this.chatContainer.addChild(new Spacer(1));
+                const component = new CompactionSummaryMessageComponent(message, this.getMarkdownThemeWithSettings());
+                component.setExpanded(this.toolOutputExpanded);
+                this.chatContainer.addChild(component);
+                break;
+            }
+            case 'branchSummary': {
+                this.chatContainer.addChild(new Spacer(1));
+                const component = new BranchSummaryMessageComponent(message, this.getMarkdownThemeWithSettings());
+                component.setExpanded(this.toolOutputExpanded);
+                this.chatContainer.addChild(component);
+                break;
+            }
+            case 'user': {
+                const textContent = this.getUserMessageText(message);
+                if (textContent) {
+                    const { displayText, attachedFiles } = parseAttachedFiles(textContent);
+                    const skillBlock = parseSkillBlock(textContent);
+                    if (skillBlock) {
+                        // Render skill block (collapsible)
+                        this.chatContainer.addChild(new Spacer(1));
+                        const component = new SkillInvocationMessageComponent(skillBlock, this.getMarkdownThemeWithSettings());
+                        component.setExpanded(this.toolOutputExpanded);
+                        this.chatContainer.addChild(component);
+                        // Render user message separately if present
+                        if (skillBlock.userMessage) {
+                            const userComponent = new UserMessageComponent(skillBlock.userMessage, this.getMarkdownThemeWithSettings());
+                            this.annotateWithWorkbooks(userComponent);
+                            if (attachedFiles.length > 0) {
+                                userComponent.setAttachments(attachedFiles);
+                            }
+                            this.chatContainer.addChild(userComponent);
+                        }
+                    }
+                    else {
+                        const userComponent = new UserMessageComponent(displayText || '(attached files)', this.getMarkdownThemeWithSettings());
+                        this.annotateWithWorkbooks(userComponent);
+                        if (attachedFiles.length > 0) {
+                            userComponent.setAttachments(attachedFiles);
+                        }
+                        this.chatContainer.addChild(userComponent);
+                    }
+                    if (options?.populateHistory) {
+                        this.editor.addToHistory?.(textContent);
+                    }
+                }
+                break;
+            }
+            case 'assistant': {
+                const assistantComponent = new AssistantMessageComponent(message, this.hideThinkingBlock, this.getMarkdownThemeWithSettings());
+                this.chatContainer.addChild(assistantComponent);
+                break;
+            }
+            case 'toolResult': {
+                // Tool results are rendered inline with tool calls, handled separately
+                break;
+            }
+            default: {
+                const _exhaustive = message;
+            }
+        }
+    }
+    /**
+     * Render session context to chat. Used for initial load and rebuild after compaction.
+     * @param sessionContext Session context to render
+     * @param options.updateFooter Update footer state
+     * @param options.populateHistory Add user messages to editor history
+     */
+    renderSessionContext(sessionContext, options = {}) {
+        this.pendingTools.clear();
+        this.clearActiveToolGroups();
+        if (options.updateFooter) {
+            this.footer.invalidate();
+            this.updateEditorBorderColor();
+        }
+        for (const message of sessionContext.messages) {
+            // Assistant messages need special handling for tool calls
+            if (message.role === 'assistant') {
+                this.addMessageToChat(message);
+                // Render tool call components
+                // Reset group per-message so each assistant turn gets its own group
+                this.clearActiveToolGroups();
+                for (const content of message.content) {
+                    if (content.type === 'toolCall') {
+                        const toolDef = this.getRegisteredToolDefinition(content.name);
+                        const toolOpts = { showImages: this.settingsManager.getShowImages() };
+                        let component;
+                        if (toolDef?.renderGroup) {
+                            const group = this.getOrCreateToolGroup(content.name, toolDef);
+                            component = group.addMember(content.id, content.name, content.arguments, toolOpts);
+                        }
+                        else {
+                            component = new ToolExecutionComponent(content.name, content.arguments, toolOpts, toolDef, this.ui);
+                            component.setExpanded(this.toolOutputExpanded);
+                            this.chatContainer.addChild(component);
+                        }
+                        if (message.stopReason === 'aborted' || message.stopReason === 'error') {
+                            let errorMessage;
+                            if (message.stopReason === 'aborted') {
+                                const retryAttempt = this.session.retryAttempt;
+                                errorMessage =
+                                    retryAttempt > 0
+                                        ? `Aborted after ${retryAttempt} retry attempt${retryAttempt > 1 ? 's' : ''}`
+                                        : ABORT_UI_LABEL;
+                            }
+                            else {
+                                errorMessage = message.errorMessage || 'Error';
+                            }
+                            component.updateResult({
+                                content: [{ type: 'text', text: errorMessage }],
+                                isError: true
+                            });
+                        }
+                        else {
+                            this.pendingTools.set(content.id, component);
+                        }
+                    }
+                }
+            }
+            else if (message.role === 'toolResult') {
+                // Match tool results to pending tool components
+                const component = this.pendingTools.get(message.toolCallId);
+                if (component) {
+                    component.updateResult(message);
+                    this.pendingTools.delete(message.toolCallId);
+                }
+            }
+            else {
+                // All other messages use standard rendering
+                this.addMessageToChat(message, options);
+            }
+        }
+        this.pendingTools.clear();
+        this.clearActiveToolGroups();
+        this.ui.requestRender();
+    }
+    renderInitialMessages() {
+        // Get aligned messages and entries from session context
+        const context = this.sessionManager.buildSessionContext();
+        this.renderSessionContext(context, {
+            updateFooter: true,
+            populateHistory: true
+        });
+        // Show compaction info if session was compacted
+        const allEntries = this.sessionManager.getEntries();
+        const compactionCount = allEntries.filter((e) => e.type === 'compaction').length;
+        if (compactionCount > 0) {
+            const times = compactionCount === 1 ? '1 time' : `${compactionCount} times`;
+            this.showStatus(`Session compacted ${times}`);
+        }
+    }
+    async getUserInput() {
+        return new Promise((resolve) => {
+            this.onInputCallback = (text) => {
+                this.onInputCallback = undefined;
+                resolve(text);
+            };
+        });
+    }
+    rebuildChatFromMessages() {
+        this.chatContainer.clear();
+        const context = this.sessionManager.buildSessionContext();
+        this.renderSessionContext(context);
+    }
+    // =========================================================================
+    // 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.
+     * 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')) {
+            await extensionRunner.emit({
+                type: 'session_shutdown'
+            });
+        }
+        // Wait for any pending renders to complete
+        // requestRender() uses process.nextTick(), so we wait one tick
+        await new Promise((resolve) => process.nextTick(resolve));
+        // Drain any in-flight Kitty key release events before stopping.
+        // This prevents escape sequences from leaking to the parent shell over slow SSH.
+        await this.ui.terminal.drainInput(1000);
+        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() {
+        // 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', () => {
+            process.removeListener('SIGINT', ignoreSigint);
+            this.ui.start();
+            this.ui.requestRender(true);
+        });
+        // 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');
+    }
+    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.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 = '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}`);
+            }
+        }
+        catch (error) {
+            this.showError(error instanceof Error ? error.message : String(error));
+        }
+    }
+    toggleToolOutputExpansion() {
+        this.toolOutputExpanded = !this.toolOutputExpanded;
+        this.setToolsExpanded(this.toolOutputExpanded);
+    }
+    setToolsExpanded(expanded) {
+        this.toolOutputExpanded = expanded;
+        for (const child of this.chatContainer.children) {
+            if (isExpandable(child)) {
+                child.setExpanded(expanded);
+            }
+        }
+        this.ui.requestRender();
+    }
+    // =========================================================================
+    // Tool Browse Mode
+    // =========================================================================
+    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'}`);
+    }
+    openExternalEditor() {
+        // Determine editor (respect $VISUAL, then $EDITOR)
+        const editorCmd = process.env.VISUAL || process.env.EDITOR;
+        if (!editorCmd) {
+            this.showWarning('No editor configured. Set $VISUAL or $EDITOR environment variable.');
+            return;
+        }
+        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
+            fs.writeFileSync(tmpFile, currentText, 'utf-8');
+            // Stop TUI to release terminal
+            this.ui.stop();
+            // Split by space to support editor arguments (e.g., "code --wait")
+            const [editor, ...editorArgs] = editorCmd.split(' ');
+            // Spawn editor synchronously with inherited stdio for interactive editing
+            const result = spawnSync(editor, [...editorArgs, tmpFile], {
+                stdio: 'inherit'
+            });
+            // On successful exit (status 0), replace editor content
+            if (result.status === 0) {
+                const newContent = fs.readFileSync(tmpFile, 'utf-8').replace(/\n$/, '');
+                this.editor.setText(newContent);
+            }
+            // On non-zero exit, keep original text (no action needed)
+        }
+        finally {
+            // Clean up temp file
+            try {
+                fs.unlinkSync(tmpFile);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            // Restart TUI
+            this.ui.start();
+            // Force full re-render since external editor uses alternate screen
+            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}`), 1, 0));
+        this.ui.requestRender();
+    }
+    showWarning(warningMessage) {
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new Text(theme.fg('warning', `Warning: ${warningMessage}`), 1, 0));
+        this.ui.requestRender();
+    }
+    showInfo(infoMessage) {
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new Text(theme.fg('dim', infoMessage), 1, 0));
+        this.ui.requestRender();
+    }
+    showNewVersionNotification(newVersion) {
+        const action = theme.fg('accent', getUpdateInstruction(NPM_PACKAGE_NAME));
+        const updateInstruction = theme.fg('muted', `New version ${newVersion} is available. `) + action;
+        const changelogHint = theme.fg('muted', `After updating, run ${theme.bold('/changelog')} to see what's new.`);
+        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}\n${changelogHint}`, 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('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;
+        if (!extensionRunner)
+            return false;
+        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);
+            }
+            // Send first prompt (starts streaming)
+            const promptPromise = this.session.prompt(firstPrompt.text).catch((error) => {
+                restoreQueue(error);
+            });
+            // Queue remaining messages
+            for (const message of rest) {
+                if (this.isExtensionCommand(message.text)) {
+                    await this.session.prompt(message.text);
+                }
+                else if (message.mode === 'followUp') {
+                    await this.session.followUp(message.text);
+                }
+                else {
+                    await this.session.steer(message.text);
+                }
+            }
+            this.updatePendingMessagesDisplay();
+            void promptPromise;
+        }
+        catch (error) {
+            restoreQueue(error);
+        }
+    }
+    /** Move pending bash components from pending area to chat */
+    flushPendingBashComponents() {
+        for (const component of this.pendingBashComponents) {
+            this.pendingMessagesContainer.removeChild(component);
+            this.chatContainer.addChild(component);
+        }
+        this.pendingBashComponents = [];
+    }
+    // =========================================================================
+    // Selectors
+    // =========================================================================
+    /**
+     * Shows a selector component in place of the editor.
+     * @param create Factory that receives a `done` callback and returns the component and focus target
+     */
+    showSelector(create) {
+        const done = () => {
+            this.restoreEditorToContainer();
+            this.ui.setFocus(this.editor);
+        };
+        const { component, focus } = create(done);
+        this.editorContainer.clear();
+        this.editorContainer.addChild(component);
+        this.ui.setFocus(focus);
+        this.ui.requestRender();
+    }
+    showSettingsSelector() {
+        this.showSelector((done) => {
+            const selector = new SettingsSelectorComponent({
+                showImages: this.settingsManager.getShowImages(),
+                currentTheme: this.settingsManager.getTheme() || 'dark',
+                availableThemes: getAvailableThemes(),
+                collapseChangelog: this.settingsManager.getCollapseChangelog(),
+                quietStartup: this.settingsManager.getQuietStartup()
+            }, {
+                onShowImagesChange: (enabled) => {
+                    this.settingsManager.setShowImages(enabled);
+                    for (const child of this.chatContainer.children) {
+                        if (child instanceof ToolExecutionComponent) {
+                            child.setShowImages(enabled);
+                        }
+                    }
+                },
+                onThemeChange: (themeName) => {
+                    const result = setTheme(themeName, true);
+                    this.settingsManager.setTheme(themeName);
+                    this.ui.invalidate();
+                    if (!result.success) {
+                        this.showError(`Failed to load theme "${themeName}": ${result.error}\nFell back to dark theme.`);
+                    }
+                },
+                onThemePreview: (themeName) => {
+                    const result = setTheme(themeName, true);
+                    if (result.success) {
+                        this.ui.invalidate();
+                        this.ui.requestRender();
+                    }
+                },
+                onCollapseChangelogChange: (collapsed) => {
+                    this.settingsManager.setCollapseChangelog(collapsed);
+                },
+                onQuietStartupChange: (enabled) => {
+                    this.settingsManager.setQuietStartup(enabled);
+                },
+                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}`);
+                this.checkDaxnutsEasterEgg(model);
+            }
+            catch (error) {
+                this.showError(error instanceof Error ? error.message : String(error));
+            }
+            return;
+        }
+        this.showModelSelector(searchTerm);
+    }
+    async findExactModelMatch(searchTerm) {
+        const term = searchTerm.trim();
+        if (!term)
+            return undefined;
+        let targetProvider;
+        let targetModelId = '';
+        if (term.includes('/')) {
+            const parts = term.split('/', 2);
+            targetProvider = parts[0]?.trim().toLowerCase();
+            targetModelId = parts[1]?.trim().toLowerCase() ?? '';
+        }
+        else {
+            targetModelId = term.toLowerCase();
+        }
+        if (!targetModelId)
+            return undefined;
+        const models = await this.getModelCandidates();
+        const exactMatches = models.filter((item) => {
+            const idMatch = item.id.toLowerCase() === targetModelId;
+            const providerMatch = !targetProvider || item.provider.toLowerCase() === targetProvider;
+            return idMatch && providerMatch;
+        });
+        return exactMatches.length === 1 ? exactMatches[0] : undefined;
+    }
+    // SHORTCUT PATCH: simplified — always returns all available models
+    async getModelCandidates() {
+        this.session.modelRegistry.refresh();
+        try {
+            return await this.session.modelRegistry.getAvailable();
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Update the footer's available provider count from current model candidates */
+    async updateAvailableProviderCount() {
+        const models = await this.getModelCandidates();
+        const uniqueProviders = new Set(models.map((m) => m.provider));
+        this.footerDataProvider.setAvailableProviderCount(uniqueProviders.size);
+    }
+    showModelSelector(initialSearchInput) {
+        this.showSelector((done) => {
+            const selector = new ModelSelectorComponent(this.ui, this.session.model, this.settingsManager, this.session.modelRegistry, [], // SHORTCUT PATCH: no scoped models — all authed models available
+            async (model) => {
+                try {
+                    await this.session.setModel(model);
+                    this.footer.invalidate();
+                    this.updateEditorBorderColor();
+                    done();
+                    this.showStatus(`Model: ${model.id}`);
+                    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 };
+        });
+    }
+    // SHORTCUT PATCH: removed showModelsSelector — scoped models removed
+    // SHORTCUT PATCH: removed showUserMessageSelector — forking removed
+    showThinkingLevelSelector() {
+        this.showSelector((done) => {
+            const selector = new ThinkingSelectorComponent(this.session.thinkingLevel, this.session.getAvailableThinkingLevels(), (level) => {
+                this.session.setThinkingLevel(level);
+                this.footer.invalidate();
+                this.updateEditorBorderColor();
+                done();
+                this.showStatus(`Thinking: ${level}`);
+            }, () => {
+                done();
+                this.ui.requestRender();
+            });
+            return { component: selector, focus: selector.getSelectList() };
+        });
+    }
+    handleHideThinkingToggle() {
+        this.hideThinkingBlock = !this.hideThinkingBlock;
+        this.settingsManager.setHideThinkingBlock(this.hideThinkingBlock);
+        for (const child of this.chatContainer.children) {
+            if (child instanceof AssistantMessageComponent) {
+                child.setHideThinkingBlock(this.hideThinkingBlock);
+            }
+        }
+        this.chatContainer.clear();
+        this.rebuildChatFromMessages();
+        this.showStatus(`Thinking blocks: ${this.hideThinkingBlock ? 'hidden' : 'visible'}`);
+    }
+    showTreeSelector(initialSelectedId) {
+        const tree = this.sessionManager.getTree();
+        const realLeafId = this.sessionManager.getLeafId();
+        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 === realLeafId) {
+                    done();
+                    this.showStatus('Already at this point');
+                    return;
+                }
+                done(); // Close selector
+                try {
+                    const result = await this.session.navigateTree(entryId);
+                    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');
+                }
+                catch (error) {
+                    this.showError(error instanceof Error ? error.message : String(error));
+                }
+            }, () => {
+                done();
+                this.ui.requestRender();
+            }, (entryId, label) => {
+                this.sessionManager.appendLabelChange(entryId, label);
+                this.ui.requestRender();
+            }, initialSelectedId);
+            return { component: selector, focus: selector };
+        });
+    }
+    showSessionSelector() {
+        this.showSelector((done) => {
+            const selector = new SessionSelectorComponent((onProgress) => SessionManager.list(this.sessionManager.getCwd(), this.sessionManager.getSessionDir(), onProgress), SessionManager.listAll, 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) {
+        // Stop loading animation
+        if (this.loadingAnimation) {
+            this.loadingAnimation.stop();
+            this.loadingAnimation = undefined;
+        }
+        this.statusContainer.clear();
+        // Clear UI state
+        this.pendingMessagesContainer.clear();
+        this.compactionQueuedMessages = [];
+        this.streamingComponent = undefined;
+        this.streamingMessage = undefined;
+        this.pendingTools.clear();
+        this.clearActiveToolGroups();
+        // Switch session via AgentSession (emits extension session events)
+        await this.session.switchSession(sessionPath);
+        // Clear and re-render the chat
+        this.chatContainer.clear();
+        this.renderInitialMessages();
+        this.showStatus('Resumed session');
+    }
+    async showOAuthSelector(mode) {
+        if (mode === 'logout') {
+            const providers = this.session.modelRegistry.authStorage.list();
+            const loggedInProviders = providers.filter((p) => this.session.modelRegistry.authStorage.get(p)?.type === 'oauth');
+            if (loggedInProviders.length === 0) {
+                this.showStatus('No OAuth providers logged in. Use /login first.');
+                return;
+            }
+        }
+        this.showSelector((done) => {
+            const selector = new OAuthSelectorComponent({
+                mode,
+                authStorage: this.session.modelRegistry.authStorage,
+                providerOrder: this.options.oauthProviderOrder,
+                onSelect: async (providerId) => {
+                    done();
+                    if (mode === 'login') {
+                        await this.showLoginDialog(providerId);
+                    }
+                    else {
+                        // Logout flow
+                        const providerInfo = getOAuthProviders().find((p) => p.id === providerId);
+                        const providerName = providerInfo?.name || providerId;
+                        try {
+                            this.session.modelRegistry.authStorage.logout(providerId);
+                            this.session.modelRegistry.refresh();
+                            await this.updateAvailableProviderCount();
+                            this.showStatus(`Logged out of ${providerName}`);
+                        }
+                        catch (error) {
+                            this.showError(`Logout failed: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                    }
+                },
+                onCancel: () => {
+                    done();
+                    this.ui.requestRender();
+                }
+            });
+            return { component: selector, focus: selector };
+        });
+    }
+    /**
+     * SHORTCUT PATCH: Eagerly validate Shortcut credentials on startup.
+     * If the user has stored OAuth credentials, try to refresh them.
+     * If refresh fails (expired refresh token, revoked, etc.), show login immediately.
+     * If no credentials exist at all, also show login immediately.
+     */
+    async ensureShortcutAuth() {
+        const authStorage = this.session.modelRegistry.authStorage;
+        const providerId = 'shortcut';
+        if (!authStorage.has(providerId)) {
+            // Never logged in — show login dialog right away
+            this.showStatus('Welcome! Please log in to get started.');
+            await this.showLoginDialog(providerId);
+            return;
+        }
+        // Has credentials — try to refresh (getApiKey auto-refreshes if expired)
+        const apiKey = await authStorage.getApiKey(providerId);
+        if (!apiKey) {
+            // Refresh failed — credentials are dead, re-login
+            this.showStatus('Session expired. Logging in to Shortcut...');
+            await this.showLoginDialog(providerId);
+        }
+    }
+    /**
+     * SHORTCUT PATCH: Run a prompt callback, auto-triggering Shortcut login if auth is missing.
+     * On LoginRequiredError, shows the login dialog then retries once.
+     * Returns false if the prompt failed (after retry or otherwise).
+     */
+    async promptWithLoginRetry(fn) {
+        try {
+            await fn();
+            return true;
+        }
+        catch (error) {
+            if (error instanceof LoginRequiredError) {
+                this.showStatus('Logging in to Shortcut...');
+                await this.showLoginDialog('shortcut');
+                try {
+                    await fn();
+                    return true;
+                }
+                catch (retryError) {
+                    this.showError(retryError instanceof Error ? retryError.message : String(retryError));
+                    return false;
+                }
+            }
+            this.showError(error instanceof Error ? error.message : String(error));
+            return false;
+        }
+    }
+    async showLoginDialog(providerId) {
+        const providerInfo = getOAuthProviders().find((p) => p.id === providerId);
+        const providerName = providerInfo?.name || providerId;
+        // Providers that use callback servers (can paste redirect URL)
+        const usesCallbackServer = providerInfo?.usesCallbackServer ?? false;
+        // Create login dialog component
+        const dialog = new LoginDialogComponent(this.ui, providerId, (_success, _message) => {
+            // Completion handled below
+        });
+        // Show dialog in editor container
+        this.editorContainer.clear();
+        this.editorContainer.addChild(dialog);
+        this.ui.setFocus(dialog);
+        this.ui.requestRender();
+        // Promise for manual code input (racing with callback server)
+        let manualCodeResolve;
+        let manualCodeReject;
+        const manualCodePromise = new Promise((resolve, reject) => {
+            manualCodeResolve = resolve;
+            manualCodeReject = reject;
+        });
+        // Restore editor helper
+        const restoreEditor = () => {
+            this.restoreEditorToContainer();
+            this.ui.setFocus(this.editor);
+            this.ui.requestRender();
+        };
+        try {
+            await this.session.modelRegistry.authStorage.login(providerId, {
+                onAuth: (info) => {
+                    dialog.showAuth(info.url, info.instructions);
+                    if (usesCallbackServer) {
+                        // Show input for manual paste, racing with callback
+                        dialog
+                            .showManualInput('Paste redirect URL below, or complete login in browser:')
+                            .then((value) => {
+                            if (value && manualCodeResolve) {
+                                manualCodeResolve(value);
+                                manualCodeResolve = undefined;
+                            }
+                        })
+                            .catch(() => {
+                            if (manualCodeReject) {
+                                manualCodeReject(new Error('Login cancelled'));
+                                manualCodeReject = undefined;
+                            }
+                        });
+                    }
+                    else if (providerId === 'github-copilot') {
+                        // GitHub Copilot polls after onAuth
+                        dialog.showWaiting('Waiting for browser authentication...');
+                    }
+                    // For Anthropic: onPrompt is called immediately after
+                },
+                onPrompt: async (prompt) => {
+                    return dialog.showPrompt(prompt.message, prompt.placeholder);
+                },
+                onProgress: (message) => {
+                    dialog.showProgress(message);
+                },
+                onManualCodeInput: () => manualCodePromise,
+                signal: dialog.signal
+            });
+            // Success
+            restoreEditor();
+            this.session.modelRegistry.refresh();
+            await this.updateAvailableProviderCount();
+            // Auto-switch to the newly authenticated provider's default model if needed.
+            await this.autoSwitchToProvider(providerId);
+            // Fetch credit balance for Shortcut provider
+            await this.refreshCreditBalance();
+            this.showStatus(`Logged in to ${providerName}. Credentials saved to ${getAuthPath()}`);
+        }
+        catch (error) {
+            restoreEditor();
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            if (errorMsg !== 'Login cancelled') {
+                this.showError(`Failed to login to ${providerName}: ${errorMsg}`);
+            }
+        }
+    }
+    /**
+     * Refresh credit balance and update footer.
+     * No-op if no fetchCreditBalance callback was injected.
+     */
+    startCreditPolling() {
+        // Avoid duplicate intervals
+        this.stopCreditPolling();
+        this.creditPollInterval = setInterval(() => {
+            this.refreshCreditBalance().catch(() => { });
+        }, InteractiveMode.CREDIT_POLL_INTERVAL_MS);
+    }
+    stopCreditPolling() {
+        if (this.creditPollInterval !== undefined) {
+            clearInterval(this.creditPollInterval);
+            this.creditPollInterval = undefined;
+        }
+    }
+    async refreshCreditBalance() {
+        const fetchBalance = this.options.fetchCreditBalance;
+        if (!fetchBalance) {
+            this.footerDataProvider.setCreditBalance(null);
+            this.footerDataProvider.setUsesCredits(false);
+            return;
+        }
+        const model = this.session.model;
+        if (!model) {
+            this.footerDataProvider.setUsesCredits(false);
+            return;
+        }
+        const apiKey = await this.session.modelRegistry.getApiKey(model);
+        if (!apiKey) {
+            this.footerDataProvider.setUsesCredits(false);
+            return;
+        }
+        const result = await fetchBalance(apiKey);
+        if (result === 'not_applicable') {
+            this.footerDataProvider.setUsesCredits(false);
+            this.footerDataProvider.setCreditBalance(null);
+        }
+        else {
+            this.footerDataProvider.setUsesCredits(true);
+            this.footerDataProvider.setCreditBalance(result);
+        }
+        this.ui.requestRender();
+    }
+    // SHORTCUT PATCH: simplified post-login — just auto-switch to new provider's default model
+    /**
+     * After login, auto-switch to the newly authenticated provider's default model
+     * if the current model isn't from this provider.
+     */
+    async autoSwitchToProvider(providerId) {
+        const available = this.session.modelRegistry.getAvailable();
+        const providerModels = available.filter((m) => m.provider === providerId);
+        if (providerModels.length === 0)
+            return;
+        // Auto-switch if current model isn't from this provider
+        const currentModel = this.session.model;
+        if (!currentModel || currentModel.provider !== providerId) {
+            try {
+                await this.session.setModel(providerModels[0]);
+                this.footer.invalidate();
+                this.updateEditorBorderColor();
+            }
+            catch {
+                // If setModel fails (e.g. key not ready yet), no big deal — user can /model manually.
+            }
+        }
+    }
+    // =========================================================================
+    // 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 loader = new BorderedLoader(this.ui, theme, 'Reloading extensions, skills, prompts, themes...', {
+            cancellable: false
+        });
+        const previousEditor = this.editor;
+        this.editorContainer.clear();
+        this.editorContainer.addChild(loader);
+        this.ui.setFocus(loader);
+        this.ui.requestRender();
+        const dismissLoader = (editor) => {
+            loader.dispose();
+            this.editorContainer.clear();
+            this.editorContainer.addChild(editor);
+            this.ui.setFocus(editor);
+            this.ui.requestRender();
+        };
+        try {
+            await this.session.reload();
+            setRegisteredThemes(this.session.resourceLoader.getThemes().themes);
+            this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
+            const themeName = this.settingsManager.getTheme();
+            const themeResult = themeName ? setTheme(themeName, true) : { success: true };
+            if (!themeResult.success) {
+                this.showError(`Failed to load theme "${themeName}": ${themeResult.error}\nFell back to dark theme.`);
+            }
+            this.ui.setShowHardwareCursor(this.settingsManager.getShowHardwareCursor());
+            this.ui.setClearOnShrink(this.settingsManager.getClearOnShrink());
+            this.setupAutocomplete(this.fdPath);
+            const runner = this.session.extensionRunner;
+            if (runner) {
+                this.setupExtensionShortcuts(runner);
+            }
+            this.rebuildChatFromMessages();
+            dismissLoader(this.editor);
+            this.showLoadedResources({
+                extensionPaths: runner?.getExtensionPaths() ?? [],
+                force: false,
+                showDiagnosticsWhenQuiet: true
+            });
+            const modelsJsonError = this.session.modelRegistry.getError();
+            if (modelsJsonError) {
+                this.showError(`models.json error: ${modelsJsonError}`);
+            }
+            this.showStatus('Reloaded extensions, skills, prompts, themes');
+        }
+        catch (error) {
+            dismissLoader(previousEditor);
+            this.showError(`Reload failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    handleCopyCommand() {
+        const text = this.session.getLastAssistantText();
+        if (!text) {
+            this.showError('No agent messages to copy yet.');
+            return;
+        }
+        try {
+            copyToClipboard(text);
+            this.showStatus('Copied last agent message to clipboard');
+        }
+        catch (error) {
+            this.showError(error instanceof Error ? error.message : String(error));
+        }
+    }
+    handleNameCommand(text) {
+        const name = text.replace(/^\/name\s*/, '').trim();
+        if (!name) {
+            const currentName = this.sessionManager.getSessionName();
+            if (currentName) {
+                this.chatContainer.addChild(new Spacer(1));
+                this.chatContainer.addChild(new Text(theme.fg('dim', `Session name: ${currentName}`), 1, 0));
+            }
+            else {
+                this.showWarning('Usage: /name <name>');
+            }
+            this.ui.requestRender();
+            return;
+        }
+        this.sessionManager.appendSessionInfo(name);
+        this.updateTerminalTitle();
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new Text(theme.fg('dim', `Session name set: ${name}`), 1, 0));
+        this.ui.requestRender();
+    }
+    handleSessionCommand() {
+        const stats = this.session.getSessionStats();
+        const sessionName = this.sessionManager.getSessionName();
+        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', 'User:')} ${stats.userMessages}\n`;
+        info += `${theme.fg('dim', 'Assistant:')} ${stats.assistantMessages}\n`;
+        info += `${theme.fg('dim', 'Tool Calls:')} ${stats.toolCalls}\n`;
+        info += `${theme.fg('dim', 'Tool Results:')} ${stats.toolResults}\n`;
+        info += `${theme.fg('dim', 'Total:')} ${stats.totalMessages}\n\n`;
+        info += `${theme.bold('Tokens')}\n`;
+        info += `${theme.fg('dim', 'Input:')} ${stats.tokens.input.toLocaleString()}\n`;
+        info += `${theme.fg('dim', 'Output:')} ${stats.tokens.output.toLocaleString()}\n`;
+        if (stats.tokens.cacheRead > 0) {
+            info += `${theme.fg('dim', 'Cache Read:')} ${stats.tokens.cacheRead.toLocaleString()}\n`;
+        }
+        if (stats.tokens.cacheWrite > 0) {
+            info += `${theme.fg('dim', 'Cache Write:')} ${stats.tokens.cacheWrite.toLocaleString()}\n`;
+        }
+        info += `${theme.fg('dim', 'Total:')} ${stats.tokens.total.toLocaleString()}\n`;
+        const creditBalance = this.footerDataProvider.getCreditBalance();
+        if (creditBalance) {
+            info += `\n${theme.bold('Credits')}\n`;
+            info += `${theme.fg('dim', 'Used this session:')} ${creditBalance.isUnlimited ? '∞' : this.footerDataProvider.getCreditsUsed()}`;
+        }
+        else if (!this.footerDataProvider.usesCredits && stats.cost > 0) {
+            info += `\n${theme.bold('Cost')}\n`;
+            info += `${theme.fg('dim', 'Total:')} $${stats.cost.toFixed(4)}`;
+        }
+        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) => e.content)
+                .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();
+    }
+    /**
+     * Capitalize keybinding for display (e.g., "ctrl+c" -> "Ctrl+C").
+     */
+    capitalizeKey(key) {
+        return key
+            .split('/')
+            .map((k) => k
+            .split('+')
+            .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+            .join('+'))
+            .join('/');
+    }
+    /**
+     * Get capitalized display string for an app keybinding action.
+     */
+    getAppKeyDisplay(action) {
+        return this.capitalizeKey(appKey(this.keybindings, action));
+    }
+    /**
+     * Get capitalized display string for an editor keybinding action.
+     */
+    getEditorKeyDisplay(action) {
+        return this.capitalizeKey(editorKey(action));
+    }
+    handleHotkeysCommand() {
+        // Navigation keybindings
+        const cursorWordLeft = this.getEditorKeyDisplay('cursorWordLeft');
+        const cursorWordRight = this.getEditorKeyDisplay('cursorWordRight');
+        const cursorLineStart = this.getEditorKeyDisplay('cursorLineStart');
+        const cursorLineEnd = this.getEditorKeyDisplay('cursorLineEnd');
+        const jumpForward = this.getEditorKeyDisplay('jumpForward');
+        const jumpBackward = this.getEditorKeyDisplay('jumpBackward');
+        const pageUp = this.getEditorKeyDisplay('pageUp');
+        const pageDown = this.getEditorKeyDisplay('pageDown');
+        // Editing keybindings
+        const submit = this.getEditorKeyDisplay('submit');
+        const newLine = this.getEditorKeyDisplay('newLine');
+        const deleteWordBackward = this.getEditorKeyDisplay('deleteWordBackward');
+        const deleteWordForward = this.getEditorKeyDisplay('deleteWordForward');
+        const deleteToLineStart = this.getEditorKeyDisplay('deleteToLineStart');
+        const deleteToLineEnd = this.getEditorKeyDisplay('deleteToLineEnd');
+        const yank = this.getEditorKeyDisplay('yank');
+        const yankPop = this.getEditorKeyDisplay('yankPop');
+        const undo = this.getEditorKeyDisplay('undo');
+        const tab = this.getEditorKeyDisplay('tab');
+        // App keybindings
+        const interrupt = this.getAppKeyDisplay('interrupt');
+        const clear = this.getAppKeyDisplay('clear');
+        const exit = this.getAppKeyDisplay('exit');
+        const suspend = this.getAppKeyDisplay('suspend');
+        const cycleThinkingLevel = this.getAppKeyDisplay('cycleThinkingLevel');
+        const cycleModelForward = this.getAppKeyDisplay('cycleModelForward');
+        const selectModel = this.getAppKeyDisplay('selectModel');
+        const expandTools = this.getAppKeyDisplay('expandTools');
+        const toggleThinking = this.getAppKeyDisplay('toggleThinking');
+        const externalEditor = this.getAppKeyDisplay('externalEditor');
+        const followUp = this.getAppKeyDisplay('followUp');
+        const dequeue = this.getAppKeyDisplay('dequeue');
+        let hotkeys = `
+**Navigation**
+| Key | Action |
+|-----|--------|
+| \`Arrow keys\` | Move cursor / browse history (Up when empty) |
+| \`${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}\` | Cycle models |
+| \`${selectModel}\` | Open model selector |
+| \`${expandTools}\` | Toggle tool output expansion |
+| \`${toggleThinking}\` | Toggle thinking block visibility |
+| \`${externalEditor}\` | Edit message in external editor |
+| \`${followUp}\` | Queue follow-up message |
+| \`${dequeue}\` | Restore queued messages |
+| \`Esc\` twice | Open conversation tree |
+| \`Ctrl+V\` | Paste image from clipboard |
+| \`/\` | Slash commands |
+| \`!\` | Run bash command |
+| \`!!\` | Run bash command (excluded from context) |
+`;
+        // Add extension-registered shortcuts
+        const extensionRunner = this.session.extensionRunner;
+        if (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 = key.replace(/\b\w/g, (c) => c.toUpperCase());
+                    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();
+    }
+    handleSkillsCommand() {
+        const skillsResult = this.session.resourceLoader.getSkills();
+        const skills = skillsResult.skills;
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new DynamicBorder());
+        this.chatContainer.addChild(new Text(theme.bold(theme.fg('accent', 'Loaded Skills')), 1, 0));
+        this.chatContainer.addChild(new Spacer(1));
+        if (skills.length === 0) {
+            this.chatContainer.addChild(new Text(theme.fg('dim', '  No skills loaded.'), 0, 0));
+        }
+        else {
+            const metadata = this.session.resourceLoader.getPathMetadata();
+            const groups = this.buildScopeGroups(skills.map((s) => s.filePath), metadata);
+            const skillByPath = new Map(skills.map((s) => [s.filePath, s]));
+            const lines = [];
+            for (const group of groups) {
+                const allPaths = [...group.paths, ...Array.from(group.packages.values()).flat()];
+                const groupSkills = allPaths
+                    .map((p) => skillByPath.get(p))
+                    .filter((s) => s != null)
+                    .sort((a, b) => a.name.localeCompare(b.name));
+                const parentDirs = [...new Set(groupSkills.map((s) => path.dirname(s.baseDir)))];
+                const dir = this.formatDisplayPath(parentDirs[0]);
+                lines.push(`  ${theme.fg('dim', dir)}`);
+                for (const skill of groupSkills) {
+                    const desc = skill.description ? theme.fg('dim', ` — ${skill.description}`) : '';
+                    lines.push(`    ${theme.fg('accent', `/${skill.name}`)}${desc}`);
+                }
+            }
+            this.chatContainer.addChild(new Text(lines.join('\n'), 0, 0));
+        }
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new DynamicBorder());
+        this.ui.requestRender();
+    }
+    async handleClearCommand() {
+        // Stop loading animation
+        if (this.loadingAnimation) {
+            this.loadingAnimation.stop();
+            this.loadingAnimation = undefined;
+        }
+        this.statusContainer.clear();
+        // New session via session (emits extension session events)
+        await this.session.newSession();
+        // Clear UI state
+        this.chatContainer.clear();
+        this.pendingMessagesContainer.clear();
+        this.compactionQueuedMessages = [];
+        this.streamingComponent = undefined;
+        this.streamingMessage = undefined;
+        this.pendingTools.clear();
+        this.clearActiveToolGroups();
+        // SHORTCUT PATCH: clear extension statuses (dev traces, etc.) on new session
+        this.footerDataProvider.clearExtensionStatuses();
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new Text(`${theme.fg('accent', '✓ New session started')}`, 1, 1));
+        this.ui.requestRender();
+    }
+    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();
+    }
+    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 = 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) {
+            // 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) {
+        const entries = this.sessionManager.getEntries();
+        const messageCount = entries.filter((e) => e.type === 'message').length;
+        if (messageCount < 2) {
+            this.showWarning('Nothing to compact (no messages yet)');
+            return;
+        }
+        await this.executeCompaction(customInstructions, false);
+    }
+    async executeCompaction(customInstructions, isAuto = false) {
+        // Stop loading animation
+        if (this.loadingAnimation) {
+            this.loadingAnimation.stop();
+            this.loadingAnimation = undefined;
+        }
+        this.statusContainer.clear();
+        // Set up escape handler during compaction
+        const originalOnEscape = this.defaultEditor.onEscape;
+        this.defaultEditor.onEscape = () => {
+            this.session.abortCompaction();
+        };
+        // Show compacting status
+        this.chatContainer.addChild(new Spacer(1));
+        const cancelHint = `(${appKey(this.keybindings, 'interrupt')} to cancel)`;
+        const label = isAuto
+            ? `Auto-compacting context... ${cancelHint}`
+            : `Compacting context... ${cancelHint}`;
+        const compactingLoader = new Loader(this.ui, (spinner) => theme.fg('accent', spinner), (text) => theme.fg('muted', text), label);
+        this.statusContainer.addChild(compactingLoader);
+        this.ui.requestRender();
+        let result;
+        try {
+            result = await this.session.compact(customInstructions);
+            // Rebuild UI
+            this.rebuildChatFromMessages();
+            // Add compaction component at bottom so user sees it without scrolling
+            const msg = createCompactionSummaryMessage(result.summary, result.tokensBefore, new Date().toISOString());
+            this.addMessageToChat(msg);
+            this.footer.invalidate();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message === 'Compaction cancelled' ||
+                (error instanceof Error && error.name === 'AbortError')) {
+                this.showError('Compaction cancelled');
+            }
+            else {
+                this.showError(`Compaction failed: ${message}`);
+            }
+        }
+        finally {
+            compactingLoader.stop();
+            this.statusContainer.clear();
+            this.defaultEditor.onEscape = originalOnEscape;
+        }
+        void this.flushCompactionQueue({ willRetry: false });
+        return result;
+    }
+    stop() {
+        if (this.loadingAnimation) {
+            this.loadingAnimation.stop();
+            this.loadingAnimation = undefined;
+        }
+        this.clearExtensionTerminalInputListeners();
+        this.stopCreditPolling();
+        this.footer.dispose();
+        this.footerDataProvider.dispose();
+        if (this.unsubscribe) {
+            this.unsubscribe();
+        }
+        if (this.isInitialized) {
+            this.ui.stop();
+            this.isInitialized = false;
+        }
+    }
+}
+//# sourceMappingURL=interactive-mode.js.map