@phi-code-admin/phi-code 0.74.2 → 0.75.0

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

@@ -6,35 +6,48 @@ import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { CombinedAutocompleteProvider, Container, fuzzyFilter, Loader, Markdown, matchesKey, ProcessTerminal, Spacer, Text, TruncatedText, TUI, visibleWidth, } from "phi-code-tui";
 import { spawn, spawnSync } from "child_process";
-import { APP_NAME, getAuthPath, getDebugLogPath, getShareViewerUrl, getUpdateInstruction, VERSION, } from "../../config.js";
+import { getProviders, } from "phi-code-ai";
+import { CombinedAutocompleteProvider, Container, fuzzyFilter, getCapabilities, hyperlink, Loader, Markdown, matchesKey, ProcessTerminal, Spacer, setKeybindings, Text, TruncatedText, TUI, visibleWidth, } from "phi-code-tui";
+import { APP_NAME, APP_TITLE, getAgentDir, getAuthPath, getDebugLogPath, getDocsPath, getShareViewerUrl, VERSION, } from "../../config.js";
 import { parseSkillBlock } from "../../core/agent-session.js";
+import { SessionImportFileNotFoundError } from "../../core/agent-session-runtime.js";
 import { FooterDataProvider } from "../../core/footer-data-provider.js";
 import { KeybindingsManager } from "../../core/keybindings.js";
 import { createCompactionSummaryMessage } from "../../core/messages.js";
-import { resolveModelScope } from "../../core/model-resolver.js";
+import { defaultModelPerProvider, findExactModelReferenceMatch, resolveModelScope } from "../../core/model-resolver.js";
+import { DefaultPackageManager } from "../../core/package-manager.js";
+import { BUILT_IN_PROVIDER_DISPLAY_NAMES } from "../../core/provider-display-names.js";
+import { formatMissingSessionCwdPrompt, MissingSessionCwdError } from "../../core/session-cwd.js";
 import { SessionManager } from "../../core/session-manager.js";
 import { BUILTIN_SLASH_COMMANDS } from "../../core/slash-commands.js";
+import { isInstallTelemetryEnabled } from "../../core/telemetry.js";
 import { getChangelogPath, getNewEntries, parseChangelog } from "../../utils/changelog.js";
 import { copyToClipboard } from "../../utils/clipboard.js";
 import { extensionForImageMimeType, readClipboardImage } from "../../utils/clipboard-image.js";
+import { parseGitUrl } from "../../utils/git.js";
+import { getCwdRelativePath } from "../../utils/paths.js";
+import { getPiUserAgent } from "../../utils/pi-user-agent.js";
+import { killTrackedDetachedChildren } from "../../utils/shell.js";
 import { ensureTool } from "../../utils/tools-manager.js";
+import { checkForNewPiVersion } from "../../utils/version-check.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 { CountdownTimer } from "./components/countdown-timer.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 { EarendilAnnouncementComponent } from "./components/earendil-announcement.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, keyHint, rawKeyHint } from "./components/keybinding-hints.js";
+import { formatKeyText, keyDisplayText, keyHint, keyText, 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";
@@ -46,12 +59,140 @@ import { ToolExecutionComponent } from "./components/tool-execution.js";
 import { TreeSelectorComponent } from "./components/tree-selector.js";
 import { UserMessageComponent } from "./components/user-message.js";
 import { UserMessageSelectorComponent } from "./components/user-message-selector.js";
-import { getAvailableThemes, getAvailableThemesWithPaths, getEditorTheme, getMarkdownTheme, getThemeByName, initTheme, onThemeChange, setRegisteredThemes, setTheme, setThemeInstance, Theme, theme, } from "./theme/theme.js";
+import { getAvailableThemes, getAvailableThemesWithPaths, getEditorTheme, getMarkdownTheme, getThemeByName, initTheme, onThemeChange, setRegisteredThemes, setTheme, setThemeInstance, stopThemeWatcher, Theme, theme, } from "./theme/theme.js";
 function isExpandable(obj) {
     return typeof obj === "object" && obj !== null && "setExpanded" in obj && typeof obj.setExpanded === "function";
 }
+class ExpandableText extends Text {
+    getCollapsedText;
+    getExpandedText;
+    constructor(getCollapsedText, getExpandedText, expanded = false, paddingX = 0, paddingY = 0) {
+        super(expanded ? getExpandedText() : getCollapsedText(), paddingX, paddingY);
+        this.getCollapsedText = getCollapsedText;
+        this.getExpandedText = getExpandedText;
+    }
+    setExpanded(expanded) {
+        this.setText(expanded ? this.getExpandedText() : this.getCollapsedText());
+    }
+}
+const DEAD_TERMINAL_ERROR_CODES = new Set(["EIO", "EPIPE", "ENOTCONN"]);
+function isDeadTerminalError(error) {
+    if (!error || typeof error !== "object" || !("code" in error)) {
+        return false;
+    }
+    const code = error.code;
+    return code !== undefined && DEAD_TERMINAL_ERROR_CODES.has(code);
+}
+const ANTHROPIC_SUBSCRIPTION_AUTH_WARNING = "Anthropic subscription auth is active. Third-party harness usage draws from extra usage and is billed per token, not your Claude plan limits. Manage extra usage at https://claude.ai/settings/usage.";
+function isAnthropicSubscriptionAuthKey(apiKey) {
+    return typeof apiKey === "string" && apiKey.startsWith("sk-ant-oat");
+}
+function isUnknownModel(model) {
+    return !!model && model.provider === "unknown" && model.id === "unknown" && model.api === "unknown";
+}
+function hasDefaultModelProvider(providerId) {
+    return providerId in defaultModelPerProvider;
+}
+const BEDROCK_PROVIDER_ID = "amazon-bedrock";
+const BUILT_IN_MODEL_PROVIDERS = new Set(getProviders());
+export function isApiKeyLoginProvider(providerId, oauthProviderIds, builtInProviderIds = BUILT_IN_MODEL_PROVIDERS) {
+    if (BUILT_IN_PROVIDER_DISPLAY_NAMES[providerId]) {
+        return true;
+    }
+    if (builtInProviderIds.has(providerId)) {
+        return false;
+    }
+    return !oauthProviderIds.has(providerId);
+}
 export class InteractiveMode {
+    options;
+    runtimeHost;
+    ui;
+    chatContainer;
+    pendingMessagesContainer;
+    statusContainer;
+    defaultEditor;
+    editor;
+    editorComponentFactory;
+    autocompleteProvider;
+    autocompleteProviderWrappers = [];
+    fdPath;
+    editorContainer;
+    footer;
+    footerDataProvider;
+    // Stored so the same manager can be injected into custom editors, selectors, and extension UI.
+    keybindings;
+    version;
+    isInitialized = false;
+    onInputCallback;
+    loadingAnimation = undefined;
+    workingMessage = undefined;
+    workingVisible = true;
+    workingIndicatorOptions = undefined;
+    defaultWorkingMessage = "Working...";
+    defaultHiddenThinkingLabel = "Thinking...";
+    hiddenThinkingLabel = this.defaultHiddenThinkingLabel;
+    lastSigintTime = 0;
+    lastEscapeTime = 0;
+    changelogMarkdown = undefined;
+    startupNoticesShown = false;
+    anthropicSubscriptionWarningShown = false;
+    // Status line tracking (for mutating immediately-sequential status updates)
+    lastStatusSpacer = undefined;
+    lastStatusText = undefined;
+    // Streaming message tracking
+    streamingComponent = undefined;
+    streamingMessage = undefined;
+    // Tool execution tracking: toolCallId -> component
+    pendingTools = new Map();
+    // 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;
+    signalCleanupHandlers = [];
+    // 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;
+    retryCountdown = 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;
     // Convenience accessors
+    get session() {
+        return this.runtimeHost.session;
+    }
     get agent() {
         return this.session.agent;
     }
@@ -61,63 +202,15 @@ export class InteractiveMode {
     get settingsManager() {
         return this.session.settingsManager;
     }
-    constructor(session, options = {}) {
+    constructor(runtimeHost, options = {}) {
         this.options = options;
-        this.isInitialized = false;
-        this.loadingAnimation = undefined;
-        this.pendingWorkingMessage = undefined;
-        this.defaultWorkingMessage = "Working...";
-        this.lastSigintTime = 0;
-        this.lastEscapeTime = 0;
-        this.changelogMarkdown = undefined;
-        // Status line tracking (for mutating immediately-sequential status updates)
-        this.lastStatusSpacer = undefined;
-        this.lastStatusText = undefined;
-        // Streaming message tracking
-        this.streamingComponent = undefined;
-        this.streamingMessage = undefined;
-        // Tool execution tracking: toolCallId -> component
-        this.pendingTools = new Map();
-        // Tool output expansion state
-        this.toolOutputExpanded = false;
-        // Thinking block visibility state
-        this.hideThinkingBlock = false;
-        // Skill commands: command name -> skill file path
-        this.skillCommands = new Map();
-        // Track if editor is in bash mode (text starts with !)
-        this.isBashMode = false;
-        // Track current bash execution component
-        this.bashComponent = undefined;
-        // Track pending bash components (shown in pending area, moved to chat on submit)
-        this.pendingBashComponents = [];
-        // Auto-compaction state
-        this.autoCompactionLoader = undefined;
-        // Auto-retry state
-        this.retryLoader = undefined;
-        // Messages queued while compaction is running
-        this.compactionQueuedMessages = [];
-        // Shutdown state
-        this.shutdownRequested = false;
-        // Extension UI state
-        this.extensionSelector = undefined;
-        this.extensionInput = undefined;
-        this.extensionEditor = undefined;
-        this.extensionTerminalInputUnsubscribers = new Set();
-        // Extension widgets (components rendered above/below the editor)
-        this.extensionWidgetsAbove = new Map();
-        this.extensionWidgetsBelow = new Map();
-        // Custom footer from extension (undefined = use built-in footer)
-        this.customFooter = undefined;
-        // Built-in header (logo + keybinding hints + changelog)
-        this.builtInHeader = undefined;
-        // Custom header from extension (undefined = use built-in header)
-        this.customHeader = undefined;
-        /**
-         * Gracefully shutdown the agent.
-         * Emits shutdown event to extensions, then exits.
-         */
-        this.isShuttingDown = false;
-        this.session = session;
+        this.runtimeHost = runtimeHost;
+        this.runtimeHost.setBeforeSessionInvalidate(() => {
+            this.resetExtensionUI();
+        });
+        this.runtimeHost.setRebindSession(async () => {
+            await this.rebindCurrentSession();
+        });
         this.version = VERSION;
         this.ui = new TUI(new ProcessTerminal(), this.settingsManager.getShowHardwareCursor());
         this.ui.setClearOnShrink(this.settingsManager.getClearOnShrink());
@@ -128,6 +221,7 @@ export class InteractiveMode {
         this.widgetContainerAbove = new Container();
         this.widgetContainerBelow = new Container();
         this.keybindings = KeybindingsManager.create();
+        setKeybindings(this.keybindings);
         const editorPaddingX = this.settingsManager.getEditorPaddingX();
         const autocompleteMaxVisible = this.settingsManager.getAutocompleteMaxVisible();
         this.defaultEditor = new CustomEditor(this.ui, getEditorTheme(), this.keybindings, {
@@ -137,16 +231,55 @@ export class InteractiveMode {
         this.editor = this.defaultEditor;
         this.editorContainer = new Container();
         this.editorContainer.addChild(this.editor);
-        this.footerDataProvider = new FooterDataProvider();
-        this.footer = new FooterComponent(session, this.footerDataProvider);
-        this.footer.setAutoCompactEnabled(session.autoCompactionEnabled);
+        this.footerDataProvider = new FooterDataProvider(this.sessionManager.getCwd());
+        this.footer = new FooterComponent(this.session, this.footerDataProvider);
+        this.footer.setAutoCompactEnabled(this.session.autoCompactionEnabled);
         // 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) {
+    getAutocompleteSourceTag(sourceInfo) {
+        if (!sourceInfo) {
+            return undefined;
+        }
+        const scopePrefix = sourceInfo.scope === "user" ? "u" : sourceInfo.scope === "project" ? "p" : "t";
+        const source = sourceInfo.source.trim();
+        if (source === "auto" || source === "local" || source === "cli") {
+            return scopePrefix;
+        }
+        if (source.startsWith("npm:")) {
+            return `${scopePrefix}:${source}`;
+        }
+        const gitSource = parseGitUrl(source);
+        if (gitSource) {
+            const ref = gitSource.ref ? `@${gitSource.ref}` : "";
+            return `${scopePrefix}:git:${gitSource.host}/${gitSource.path}${ref}`;
+        }
+        return scopePrefix;
+    }
+    prefixAutocompleteDescription(description, sourceInfo) {
+        const sourceTag = this.getAutocompleteSourceTag(sourceInfo);
+        if (!sourceTag) {
+            return description;
+        }
+        return description ? `[${sourceTag}] ${description}` : `[${sourceTag}]`;
+    }
+    getBuiltInCommandConflictDiagnostics(extensionRunner) {
+        const builtinNames = new Set(BUILTIN_SLASH_COMMANDS.map((command) => command.name));
+        return extensionRunner
+            .getRegisteredCommands()
+            .filter((command) => builtinNames.has(command.name))
+            .map((command) => ({
+            type: "warning",
+            message: command.invocationName === command.name
+                ? `Extension command '/${command.name}' conflicts with built-in interactive command. Skipping in autocomplete.`
+                : `Extension command '/${command.name}' conflicts with built-in interactive command. Available as '/${command.invocationName}'.`,
+            path: command.sourceInfo.path,
+        }));
+    }
+    createBaseAutocompleteProvider() {
         // Define commands for autocomplete
         const slashCommands = BUILTIN_SLASH_COMMANDS.map((command) => ({
             name: command.name,
@@ -181,13 +314,17 @@ export class InteractiveMode {
         // Convert prompt templates to SlashCommand format for autocomplete
         const templateCommands = this.session.promptTemplates.map((cmd) => ({
             name: cmd.name,
-            description: cmd.description,
+            description: this.prefixAutocompleteDescription(cmd.description, cmd.sourceInfo),
+            ...(cmd.argumentHint && { argumentHint: cmd.argumentHint }),
         }));
         // 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)",
+        const extensionCommands = this.session.extensionRunner
+            .getRegisteredCommands()
+            .filter((cmd) => !builtinCommandNames.has(cmd.name))
+            .map((cmd) => ({
+            name: cmd.invocationName,
+            description: this.prefixAutocompleteDescription(cmd.description, cmd.sourceInfo),
             getArgumentCompletions: cmd.getArgumentCompletions,
         }));
         // Build skill commands from session.skills (if enabled)
@@ -197,19 +334,55 @@ export class InteractiveMode {
             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 });
+                skillCommandList.push({
+                    name: commandName,
+                    description: this.prefixAutocompleteDescription(skill.description, skill.sourceInfo),
+                });
             }
         }
-        // Setup autocomplete
-        this.autocompleteProvider = new CombinedAutocompleteProvider([...slashCommands, ...templateCommands, ...extensionCommands, ...skillCommandList], process.cwd(), fdPath);
-        this.defaultEditor.setAutocompleteProvider(this.autocompleteProvider);
+        return new CombinedAutocompleteProvider([...slashCommands, ...templateCommands, ...extensionCommands, ...skillCommandList], this.sessionManager.getCwd(), this.fdPath);
+    }
+    setupAutocompleteProvider() {
+        let provider = this.createBaseAutocompleteProvider();
+        for (const wrapProvider of this.autocompleteProviderWrappers) {
+            provider = wrapProvider(provider);
+        }
+        this.autocompleteProvider = provider;
+        this.defaultEditor.setAutocompleteProvider(provider);
         if (this.editor !== this.defaultEditor) {
-            this.editor.setAutocompleteProvider?.(this.autocompleteProvider);
+            this.editor.setAutocompleteProvider?.(provider);
+        }
+    }
+    showStartupNoticesIfNeeded() {
+        if (this.startupNoticesShown) {
+            return;
+        }
+        this.startupNoticesShown = true;
+        if (!this.changelogMarkdown) {
+            return;
+        }
+        if (this.chatContainer.children.length > 0) {
+            this.chatContainer.addChild(new Spacer(1));
+        }
+        this.chatContainer.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.chatContainer.addChild(new Text(condensedText, 1, 0));
         }
+        else {
+            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(this.changelogMarkdown.trim(), 1, 0, this.getMarkdownThemeWithSettings()));
+            this.chatContainer.addChild(new Spacer(1));
+        }
+        this.chatContainer.addChild(new DynamicBorder());
     }
     async init() {
         if (this.isInitialized)
             return;
+        this.registerSignalHandlers();
         // 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)
@@ -218,39 +391,39 @@ export class InteractiveMode {
         this.fdPath = fdPath;
         // Add header container as first child
         this.ui.addChild(this.headerContainer);
-        // Always show the gradient logo
-        {
-            // Gradient colors: yellow → orange → pink → magenta
+        // Add header with keybindings from config (unless silenced)
+        if (this.options.verbose || !this.settingsManager.getQuietStartup()) {
+            // Phi Code gradient ASCII logo (yellow -> orange -> pink -> magenta)
             const gradientColors = [
-                [255, 230, 0], // yellow
-                [255, 180, 0], // orange-yellow
-                [255, 140, 0], // orange
-                [255, 100, 50], // red-orange
-                [255, 70, 100], // pink
-                [220, 50, 150], // hot pink
-                [200, 50, 180], // magenta-pink
-                [180, 50, 220], // magenta
+                [255, 220, 50],
+                [255, 165, 50],
+                [255, 100, 100],
+                [230, 80, 150],
+                [200, 50, 180],
+                [180, 50, 220],
             ];
             const applyGradient = (line) => {
                 const chars = [...line];
-                const visibleChars = chars.filter(c => c !== ' ');
+                const visibleChars = chars.filter((c) => c !== " ");
                 const totalVisible = visibleChars.length;
                 let visibleIdx = 0;
-                return chars.map(c => {
-                    if (c === ' ')
+                return chars
+                    .map((c) => {
+                    if (c === " ")
                         return c;
                     const t = totalVisible > 1 ? visibleIdx / (totalVisible - 1) : 0;
                     visibleIdx++;
                     const segLen = gradientColors.length - 1;
                     const seg = Math.min(Math.floor(t * segLen), segLen - 1);
-                    const local = (t * segLen) - seg;
+                    const local = t * segLen - seg;
                     const [r1, g1, b1] = gradientColors[seg];
                     const [r2, g2, b2] = gradientColors[seg + 1];
                     const r = Math.round(r1 + (r2 - r1) * local);
                     const g = Math.round(g1 + (g2 - g1) * local);
                     const b = Math.round(b1 + (b2 - b1) * local);
                     return `\x1b[38;2;${r};${g};${b}m${c}\x1b[0m`;
-                }).join('');
+                })
+                    .join("");
             };
             const asciiLines = [
                 "  ██████╗ ██╗  ██╗██╗",
@@ -260,59 +433,55 @@ export class InteractiveMode {
                 "  ██║     ██║  ██║██║",
                 "  ╚═╝     ╚═╝  ╚═╝╚═╝",
             ];
-            const asciiLogo = asciiLines.map(line => applyGradient(line)).join("\n");
-            const phiLabel = applyGradient("Φ " + APP_NAME.toUpperCase());
-            const logo = asciiLogo + "\n  " + phiLabel + theme.fg("dim", ` v${this.version}`) + theme.fg("dim", " — The Ultimate Coding Agent");
-            // Show keyboard shortcuts only when not quiet
-            let headerContent = logo;
-            if (this.options.verbose || !this.settingsManager.getQuietStartup()) {
-                const kb = this.keybindings;
-                const hint = (action, desc) => appKeyHint(kb, action, desc);
-                const instructions = [
-                    hint("interrupt", "to interrupt"),
-                    hint("clear", "to clear"),
-                    rawKeyHint(`${appKey(kb, "clear")} twice`, "to exit"),
-                    hint("exit", "to exit (empty)"),
-                    hint("suspend", "to suspend"),
-                    keyHint("deleteToLineEnd", "to delete to end"),
-                    hint("cycleThinkingLevel", "to cycle thinking level"),
-                    rawKeyHint(`${appKey(kb, "cycleModelForward")}/${appKey(kb, "cycleModelBackward")}`, "to cycle models"),
-                    hint("selectModel", "to select model"),
-                    hint("expandTools", "to expand tools"),
-                    hint("toggleThinking", "to expand thinking"),
-                    hint("externalEditor", "for external editor"),
-                    rawKeyHint("/", "for commands"),
-                    rawKeyHint("!", "to run bash"),
-                    rawKeyHint("!!", "to run bash (no context)"),
-                    hint("followUp", "to queue follow-up"),
-                    hint("dequeue", "to edit all queued messages"),
-                    hint("pasteImage", "to paste image"),
-                    rawKeyHint("drop files", "to attach"),
-                ].join("\n");
-                headerContent = `${logo}\n${instructions}`;
-            }
-            this.builtInHeader = new Text(headerContent, 1, 0);
+            const asciiLogo = asciiLines.map((line) => applyGradient(line)).join("\n");
+            const phiLabel = applyGradient(`φ ${APP_NAME.toUpperCase()}`);
+            const logo = asciiLogo +
+                "\n  " +
+                phiLabel +
+                theme.fg("dim", ` v${this.version}`) +
+                theme.fg("dim", " — The Ultimate Coding Agent");
+            // Build startup instructions using keybinding hint helpers
+            const hint = (keybinding, description) => keyHint(keybinding, description);
+            const expandedInstructions = [
+                hint("app.interrupt", "to interrupt"),
+                hint("app.clear", "to clear"),
+                rawKeyHint(`${keyText("app.clear")} twice`, "to exit"),
+                hint("app.exit", "to exit (empty)"),
+                hint("app.suspend", "to suspend"),
+                keyHint("tui.editor.deleteToLineEnd", "to delete to end"),
+                hint("app.thinking.cycle", "to cycle thinking level"),
+                rawKeyHint(`${keyText("app.model.cycleForward")}/${keyText("app.model.cycleBackward")}`, "to cycle models"),
+                hint("app.model.select", "to select model"),
+                hint("app.tools.expand", "to expand tools"),
+                hint("app.thinking.toggle", "to expand thinking"),
+                hint("app.editor.external", "for external editor"),
+                rawKeyHint("/", "for commands"),
+                rawKeyHint("!", "to run bash"),
+                rawKeyHint("!!", "to run bash (no context)"),
+                hint("app.message.followUp", "to queue follow-up"),
+                hint("app.message.dequeue", "to edit all queued messages"),
+                hint("app.clipboard.pasteImage", "to paste image"),
+                rawKeyHint("drop files", "to attach"),
+            ].join("\n");
+            const compactInstructions = [
+                hint("app.interrupt", "interrupt"),
+                rawKeyHint(`${keyText("app.clear")}/${keyText("app.exit")}`, "clear/exit"),
+                rawKeyHint("/", "commands"),
+                rawKeyHint("!", "bash"),
+                hint("app.tools.expand", "more"),
+            ].join(theme.fg("muted", " · "));
+            const compactOnboarding = theme.fg("dim", `Press ${keyText("app.tools.expand")} to show full startup help and loaded resources.`);
+            const onboarding = theme.fg("dim", `Pi can explain its own features and look up its docs. Ask it how to use or extend Pi.`);
+            this.builtInHeader = new ExpandableText(() => `${logo}\n${compactInstructions}\n${compactOnboarding}\n\n${onboarding}`, () => `${logo}\n${expandedInstructions}\n\n${onboarding}`, this.getStartupExpansionState(), 1, 0);
             // Setup UI layout
             this.headerContainer.addChild(new Spacer(1));
             this.headerContainer.addChild(this.builtInHeader);
             this.headerContainer.addChild(new Spacer(1));
-            // 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);
         }
         this.ui.addChild(this.chatContainer);
         this.ui.addChild(this.pendingMessagesContainer);
@@ -325,17 +494,13 @@ export class InteractiveMode {
         this.ui.setFocus(this.editor);
         this.setupKeyHandlers();
         this.setupEditorSubmitHandler();
+        // Start the UI before initializing extensions so session_start handlers can use interactive dialogs
+        this.ui.start();
+        this.isInitialized = true;
         // Initialize extensions first so resources are shown before messages
-        await this.initExtensions();
+        await this.rebindCurrentSession();
         // Render initial messages AFTER showing loaded resources
         this.renderInitialMessages();
-        // Start the UI
-        this.ui.start();
-        this.isInitialized = true;
-        // Set terminal title
-        this.updateTerminalTitle();
-        // Subscribe to agent events
-        this.subscribeToAgent();
         // Set up theme file watcher
         onThemeChange(() => {
             this.ui.invalidate();
@@ -353,13 +518,13 @@ export class InteractiveMode {
      * Update terminal title with session name and cwd.
      */
     updateTerminalTitle() {
-        const cwdBasename = path.basename(process.cwd());
+        const cwdBasename = path.basename(this.sessionManager.getCwd());
         const sessionName = this.sessionManager.getSessionName();
         if (sessionName) {
-            this.ui.terminal.setTitle(`Φ - ${sessionName} - ${cwdBasename}`);
+            this.ui.terminal.setTitle(`${APP_TITLE} - ${sessionName} - ${cwdBasename}`);
         }
         else {
-            this.ui.terminal.setTitle(`Φ - ${cwdBasename}`);
+            this.ui.terminal.setTitle(`${APP_TITLE} - ${cwdBasename}`);
         }
     }
     /**
@@ -369,11 +534,23 @@ export class InteractiveMode {
     async run() {
         await this.init();
         // Start version check asynchronously
-        this.checkForNewVersion().then((newVersion) => {
+        checkForNewPiVersion(this.version).then((newVersion) => {
             if (newVersion) {
                 this.showNewVersionNotification(newVersion);
             }
         });
+        // Start package update check asynchronously
+        this.checkForPackageUpdates().then((updates) => {
+            if (updates.length > 0) {
+                this.showPackageUpdateNotification(updates);
+            }
+        });
+        // Check tmux keyboard setup asynchronously
+        this.checkTmuxKeyboardSetup().then((warning) => {
+            if (warning) {
+                this.showWarning(warning);
+            }
+        });
         // Show startup warnings
         const { migratedProviders, modelFallbackMessage, initialMessage, initialImages, initialMessages } = this.options;
         if (migratedProviders && migratedProviders.length > 0) {
@@ -386,6 +563,7 @@ export class InteractiveMode {
         if (modelFallbackMessage) {
             this.showWarning(modelFallbackMessage);
         }
+        void this.maybeWarnAboutAnthropicSubscriptionAuth();
         // Process initial messages
         if (initialMessage) {
             try {
@@ -419,28 +597,63 @@ export class InteractiveMode {
             }
         }
     }
-    /**
-     * Check npm registry for a newer version.
-     */
-    async checkForNewVersion() {
-        if (process.env.PI_SKIP_VERSION_CHECK || process.env.PI_OFFLINE)
-            return undefined;
+    async checkForPackageUpdates() {
+        if (process.env.PI_OFFLINE) {
+            return [];
+        }
         try {
-            const response = await fetch("https://registry.npmjs.org/phi-code/latest", {
-                signal: AbortSignal.timeout(10000),
+            const packageManager = new DefaultPackageManager({
+                cwd: this.sessionManager.getCwd(),
+                agentDir: getAgentDir(),
+                settingsManager: this.settingsManager,
             });
-            if (!response.ok)
-                return undefined;
-            const data = (await response.json());
-            const latestVersion = data.version;
-            if (latestVersion && latestVersion !== this.version) {
-                return latestVersion;
-            }
-            return undefined;
+            const updates = await packageManager.checkForAvailableUpdates();
+            return updates.map((update) => update.displayName);
         }
         catch {
+            return [];
+        }
+    }
+    async checkTmuxKeyboardSetup() {
+        if (!process.env.TMUX)
+            return undefined;
+        const runTmuxShow = (option) => {
+            return new Promise((resolve) => {
+                const proc = spawn("tmux", ["show", "-gv", option], {
+                    stdio: ["ignore", "pipe", "ignore"],
+                });
+                let stdout = "";
+                const timer = setTimeout(() => {
+                    proc.kill();
+                    resolve(undefined);
+                }, 2000);
+                proc.stdout?.on("data", (data) => {
+                    stdout += data.toString();
+                });
+                proc.on("error", () => {
+                    clearTimeout(timer);
+                    resolve(undefined);
+                });
+                proc.on("close", (code) => {
+                    clearTimeout(timer);
+                    resolve(code === 0 ? stdout.trim() : undefined);
+                });
+            });
+        };
+        const [extendedKeys, extendedKeysFormat] = await Promise.all([
+            runTmuxShow("extended-keys"),
+            runTmuxShow("extended-keys-format"),
+        ]);
+        // If we couldn't query tmux (timeout, sandbox, etc.), don't warn
+        if (extendedKeys === undefined)
             return undefined;
+        if (extendedKeys !== "on" && extendedKeys !== "always") {
+            return "tmux extended-keys is off. Modified Enter keys may not work. Add `set -g extended-keys on` to ~/.tmux.conf and restart tmux.";
+        }
+        if (extendedKeysFormat === "xterm") {
+            return "tmux extended-keys-format is xterm. Pi works best with csi-u. Add `set -g extended-keys-format csi-u` to ~/.tmux.conf and restart tmux.";
         }
+        return undefined;
     }
     /**
      * Get changelog entries to display on startup.
@@ -455,19 +668,35 @@ export class InteractiveMode {
         const changelogPath = getChangelogPath();
         const entries = parseChangelog(changelogPath);
         if (!lastVersion) {
-            // Fresh install - just record the version, don't show changelog
+            // Fresh install - record the version, send telemetry, don't show changelog
             this.settingsManager.setLastChangelogVersion(VERSION);
+            this.reportInstallTelemetry(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");
-            }
+        const newEntries = getNewEntries(entries, lastVersion);
+        if (newEntries.length > 0) {
+            this.settingsManager.setLastChangelogVersion(VERSION);
+            this.reportInstallTelemetry(VERSION);
+            return newEntries.map((e) => e.content).join("\n\n");
         }
         return undefined;
     }
+    reportInstallTelemetry(version) {
+        if (process.env.PI_OFFLINE) {
+            return;
+        }
+        if (!isInstallTelemetryEnabled(this.settingsManager)) {
+            return;
+        }
+        void fetch(`https://pi.dev/api/report-install?version=${encodeURIComponent(version)}`, {
+            headers: {
+                "User-Agent": getPiUserAgent(version),
+            },
+            signal: AbortSignal.timeout(5000),
+        })
+            .then(() => undefined)
+            .catch(() => undefined);
+    }
     getMarkdownThemeWithSettings() {
         return {
             ...getMarkdownTheme(),
@@ -486,24 +715,139 @@ export class InteractiveMode {
         }
         return result;
     }
+    formatExtensionDisplayPath(path) {
+        let result = this.formatDisplayPath(path);
+        result = result.replace(/\/index\.ts$/, "").replace(/\/index\.js$/, "");
+        return result;
+    }
+    formatContextPath(p) {
+        const cwd = path.resolve(this.sessionManager.getCwd());
+        const absolutePath = path.isAbsolute(p) ? path.resolve(p) : path.resolve(cwd, p);
+        const relativePath = getCwdRelativePath(absolutePath, cwd);
+        if (relativePath !== undefined) {
+            return relativePath;
+        }
+        return this.formatDisplayPath(absolutePath);
+    }
+    getStartupExpansionState() {
+        return this.options.verbose || this.toolOutputExpanded;
+    }
     /**
      * Get a short path relative to the package root for display.
      */
-    getShortPath(fullPath, source) {
-        // For npm packages, show path relative to node_modules/pkg/
+    getShortPath(fullPath, sourceInfo) {
+        const baseDir = sourceInfo?.baseDir;
+        if (baseDir && this.isPackageSource(sourceInfo)) {
+            const relativePath = path.relative(path.resolve(baseDir), path.resolve(fullPath));
+            if (relativePath &&
+                relativePath !== "." &&
+                !relativePath.startsWith("..") &&
+                !relativePath.startsWith(`..${path.sep}`) &&
+                !path.isAbsolute(relativePath)) {
+                return relativePath.replace(/\\/g, "/");
+            }
+        }
+        const source = sourceInfo?.source ?? "";
         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) {
+    getCompactPathLabel(resourcePath, sourceInfo) {
+        const shortPath = this.getShortPath(resourcePath, sourceInfo);
+        const normalizedPath = shortPath.replace(/\\/g, "/");
+        const segments = normalizedPath.split("/").filter((segment) => segment.length > 0 && segment !== "~");
+        if (segments.length > 0) {
+            return segments[segments.length - 1];
+        }
+        return shortPath;
+    }
+    getCompactPackageSourceLabel(sourceInfo) {
+        const source = sourceInfo?.source ?? "";
+        if (source.startsWith("npm:")) {
+            return source.slice("npm:".length) || source;
+        }
+        const gitSource = parseGitUrl(source);
+        if (gitSource) {
+            return gitSource.path || source;
+        }
+        return source;
+    }
+    getCompactExtensionLabel(resourcePath, sourceInfo) {
+        if (!this.isPackageSource(sourceInfo)) {
+            return this.getCompactPathLabel(resourcePath, sourceInfo);
+        }
+        const sourceLabel = this.getCompactPackageSourceLabel(sourceInfo);
+        if (!sourceLabel) {
+            return this.getCompactPathLabel(resourcePath, sourceInfo);
+        }
+        const shortPath = this.getShortPath(resourcePath, sourceInfo).replace(/\\/g, "/");
+        const packagePath = shortPath.startsWith("extensions/") ? shortPath.slice("extensions/".length) : shortPath;
+        const parsedPath = path.posix.parse(packagePath);
+        if (parsedPath.name === "index") {
+            return !parsedPath.dir || parsedPath.dir === "." ? sourceLabel : `${sourceLabel}:${parsedPath.dir}`;
+        }
+        return `${sourceLabel}:${packagePath}`;
+    }
+    getCompactDisplayPathSegments(resourcePath) {
+        return this.formatDisplayPath(resourcePath)
+            .replace(/\\/g, "/")
+            .split("/")
+            .filter((segment) => segment.length > 0 && segment !== "~");
+    }
+    getCompactNonPackageExtensionLabel(resourcePath, index, allPaths) {
+        const segments = allPaths[index]?.segments;
+        if (!segments || segments.length === 0) {
+            return this.getCompactPathLabel(resourcePath);
+        }
+        for (let segmentCount = 1; segmentCount <= segments.length; segmentCount += 1) {
+            const candidate = segments.slice(-segmentCount).join("/");
+            const isUnique = allPaths.every((item, itemIndex) => {
+                if (itemIndex === index) {
+                    return true;
+                }
+                return item.segments.slice(-segmentCount).join("/") !== candidate;
+            });
+            if (isUnique) {
+                return candidate;
+            }
+        }
+        return segments.join("/");
+    }
+    getCompactExtensionLabels(extensions) {
+        const nonPackageExtensions = extensions
+            .map((extension) => {
+            const segments = this.getCompactDisplayPathSegments(extension.path);
+            const lastSegment = segments[segments.length - 1];
+            if (segments.length > 1 && (lastSegment === "index.ts" || lastSegment === "index.js")) {
+                segments.pop();
+            }
+            return {
+                path: extension.path,
+                sourceInfo: extension.sourceInfo,
+                segments,
+            };
+        })
+            .filter((extension) => !this.isPackageSource(extension.sourceInfo));
+        return extensions.map((extension) => {
+            if (this.isPackageSource(extension.sourceInfo)) {
+                return this.getCompactExtensionLabel(extension.path, extension.sourceInfo);
+            }
+            const nonPackageIndex = nonPackageExtensions.findIndex((item) => item.path === extension.path);
+            if (nonPackageIndex === -1) {
+                return this.getCompactPathLabel(extension.path, extension.sourceInfo);
+            }
+            return this.getCompactNonPackageExtensionLabel(extension.path, nonPackageIndex, nonPackageExtensions);
+        });
+    }
+    getDisplaySourceInfo(sourceInfo) {
+        const source = sourceInfo?.source ?? "local";
+        const scope = sourceInfo?.scope ?? "project";
         if (source === "local") {
             if (scope === "user") {
                 return { label: "user", color: "muted" };
@@ -522,7 +866,9 @@ export class InteractiveMode {
         const scopeLabel = scope === "user" ? "user" : scope === "project" ? "project" : scope === "temporary" ? "temp" : undefined;
         return { label: source, scopeLabel, color: "accent" };
     }
-    getScopeGroup(source, scope) {
+    getScopeGroup(sourceInfo) {
+        const source = sourceInfo?.source ?? "local";
+        const scope = sourceInfo?.scope ?? "project";
         if (source === "cli" || scope === "temporary")
             return "path";
         if (scope === "user")
@@ -531,28 +877,27 @@ export class InteractiveMode {
             return "project";
         return "path";
     }
-    isPackageSource(source) {
+    isPackageSource(sourceInfo) {
+        const source = sourceInfo?.source ?? "";
         return source.startsWith("npm:") || source.startsWith("git:");
     }
-    buildScopeGroups(paths, metadata) {
+    buildScopeGroups(items) {
         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);
+        for (const item of items) {
+            const groupKey = this.getScopeGroup(item.sourceInfo);
             const group = groups[groupKey];
-            if (this.isPackageSource(source)) {
+            const source = item.sourceInfo?.source ?? "local";
+            if (this.isPackageSource(item.sourceInfo)) {
                 const list = group.packages.get(source) ?? [];
-                list.push(p);
+                list.push(item);
                 group.packages.set(source, list);
             }
             else {
-                group.paths.push(p);
+                group.paths.push(item);
             }
         }
         return [groups.project, groups.user, groups.path].filter((group) => group.paths.length > 0 || group.packages.size > 0);
@@ -561,57 +906,44 @@ export class InteractiveMode {
         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 sortedPaths = [...group.paths].sort((a, b) => a.path.localeCompare(b.path));
+            for (const item of sortedPaths) {
+                lines.push(theme.fg("dim", `    ${options.formatPath(item)}`));
             }
             const sortedPackages = Array.from(group.packages.entries()).sort(([a], [b]) => a.localeCompare(b));
-            for (const [source, paths] of sortedPackages) {
+            for (const [source, items] 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)}`));
+                const sortedPackagePaths = [...items].sort((a, b) => a.path.localeCompare(b.path));
+                for (const item of sortedPackagePaths) {
+                    lines.push(theme.fg("dim", `      ${options.formatPackagePath(item, 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);
+    findSourceInfoForPath(p, sourceInfos) {
+        const exact = sourceInfos.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);
+            const parent = sourceInfos.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);
+    formatPathWithSource(p, sourceInfo) {
+        if (sourceInfo) {
+            const shortPath = this.getShortPath(p, sourceInfo);
+            const { label, scopeLabel } = this.getDisplaySourceInfo(sourceInfo);
             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) {
+    formatDiagnostics(diagnostics, sourceInfos) {
         const lines = [];
         // Group collision diagnostics by name
         const collisions = new Map();
@@ -632,21 +964,17 @@ export class InteractiveMode {
             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
+            lines.push(theme.fg("dim", `    ${theme.fg("success", "✓")} ${this.formatPathWithSource(first.winnerPath, this.findSourceInfoForPath(first.winnerPath, sourceInfos))}`));
             for (const d of collisionList) {
                 if (d.collision) {
-                    lines.push(theme.fg("dim", `    ${theme.fg("warning", "✗")} ${this.formatPathWithSource(d.collision.loserPath, metadata)} (skipped)`));
+                    lines.push(theme.fg("dim", `    ${theme.fg("warning", "✗")} ${this.formatPathWithSource(d.collision.loserPath, this.findSourceInfoForPath(d.collision.loserPath, sourceInfos))} (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}`));
+                const formattedPath = this.formatPathWithSource(d.path, this.findSourceInfoForPath(d.path, sourceInfos));
+                lines.push(theme.fg(d.type === "error" ? "error" : "warning", `  ${formattedPath}`));
                 lines.push(theme.fg(d.type === "error" ? "error" : "warning", `    ${d.message}`));
             }
             else {
@@ -661,11 +989,48 @@ export class InteractiveMode {
         if (!showListing && !showDiagnostics) {
             return;
         }
-        const metadata = this.session.resourceLoader.getPathMetadata();
         const sectionHeader = (name, color = "mdHeading") => theme.fg(color, `[${name}]`);
+        const formatCompactList = (items, options) => {
+            const labels = items.map((item) => item.trim()).filter((item) => item.length > 0);
+            if (options?.sort !== false) {
+                labels.sort((a, b) => a.localeCompare(b));
+            }
+            return theme.fg("dim", `  ${labels.join(", ")}`);
+        };
+        const addLoadedSection = (name, collapsedBody, expandedBody = collapsedBody, color = "mdHeading") => {
+            const section = new ExpandableText(() => `${sectionHeader(name, color)}\n${collapsedBody}`, () => `${sectionHeader(name, color)}\n${expandedBody}`, this.getStartupExpansionState(), 0, 0);
+            this.chatContainer.addChild(section);
+            this.chatContainer.addChild(new Spacer(1));
+        };
         const skillsResult = this.session.resourceLoader.getSkills();
         const promptsResult = this.session.resourceLoader.getPrompts();
         const themesResult = this.session.resourceLoader.getThemes();
+        const extensions = options?.extensions ??
+            this.session.resourceLoader.getExtensions().extensions.map((extension) => ({
+                path: extension.path,
+                sourceInfo: extension.sourceInfo,
+            }));
+        const sourceInfos = new Map();
+        for (const extension of extensions) {
+            if (extension.sourceInfo) {
+                sourceInfos.set(extension.path, extension.sourceInfo);
+            }
+        }
+        for (const skill of skillsResult.skills) {
+            if (skill.sourceInfo) {
+                sourceInfos.set(skill.filePath, skill.sourceInfo);
+            }
+        }
+        for (const prompt of promptsResult.prompts) {
+            if (prompt.sourceInfo) {
+                sourceInfos.set(prompt.filePath, prompt.sourceInfo);
+            }
+        }
+        for (const loadedTheme of themesResult.themes) {
+            if (loadedTheme.sourcePath && loadedTheme.sourceInfo) {
+                sourceInfos.set(loadedTheme.sourcePath, loadedTheme.sourceInfo);
+            }
+        }
         if (showListing) {
             const contextFiles = this.session.resourceLoader.getAgentsFiles().agentsFiles;
             if (contextFiles.length > 0) {
@@ -673,72 +1038,71 @@ export class InteractiveMode {
                 const contextList = contextFiles
                     .map((f) => theme.fg("dim", `  ${this.formatDisplayPath(f.path)}`))
                     .join("\n");
-                this.chatContainer.addChild(new Text(`${sectionHeader("Context")}\n${contextList}`, 0, 0));
-                this.chatContainer.addChild(new Spacer(1));
+                const contextCompactList = formatCompactList(contextFiles.map((contextFile) => this.formatContextPath(contextFile.path)), { sort: false });
+                addLoadedSection("Context", contextCompactList, contextList);
             }
             const skills = skillsResult.skills;
             if (skills.length > 0) {
-                const skillPaths = skills.map((s) => s.filePath);
-                const groups = this.buildScopeGroups(skillPaths, metadata);
+                const groups = this.buildScopeGroups(skills.map((skill) => ({ path: skill.filePath, sourceInfo: skill.sourceInfo })));
                 const skillList = this.formatScopeGroups(groups, {
-                    formatPath: (p) => this.formatDisplayPath(p),
-                    formatPackagePath: (p, source) => this.getShortPath(p, source),
+                    formatPath: (item) => this.formatDisplayPath(item.path),
+                    formatPackagePath: (item) => this.getShortPath(item.path, item.sourceInfo),
                 });
-                this.chatContainer.addChild(new Text(`${sectionHeader("Skills")}\n${skillList}`, 0, 0));
-                this.chatContainer.addChild(new Spacer(1));
+                const skillCompactList = formatCompactList(skills.map((skill) => skill.name));
+                addLoadedSection("Skills", skillCompactList, skillList);
             }
             const templates = this.session.promptTemplates;
             if (templates.length > 0) {
-                const templatePaths = templates.map((t) => t.filePath);
-                const groups = this.buildScopeGroups(templatePaths, metadata);
+                const groups = this.buildScopeGroups(templates.map((template) => ({ path: template.filePath, sourceInfo: template.sourceInfo })));
                 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);
+                    formatPath: (item) => {
+                        const template = templateByPath.get(item.path);
+                        return template ? `/${template.name}` : this.formatDisplayPath(item.path);
                     },
-                    formatPackagePath: (p) => {
-                        const template = templateByPath.get(p);
-                        return template ? `/${template.name}` : this.formatDisplayPath(p);
+                    formatPackagePath: (item) => {
+                        const template = templateByPath.get(item.path);
+                        return template ? `/${template.name}` : this.formatDisplayPath(item.path);
                     },
                 });
-                this.chatContainer.addChild(new Text(`${sectionHeader("Prompts")}\n${templateList}`, 0, 0));
-                this.chatContainer.addChild(new Spacer(1));
+                const promptCompactList = formatCompactList(templates.map((template) => `/${template.name}`));
+                addLoadedSection("Prompts", promptCompactList, templateList);
             }
-            const extensionPaths = options?.extensionPaths ?? [];
-            if (extensionPaths.length > 0) {
-                const groups = this.buildScopeGroups(extensionPaths, metadata);
+            if (extensions.length > 0) {
+                const groups = this.buildScopeGroups(extensions);
                 const extList = this.formatScopeGroups(groups, {
-                    formatPath: (p) => this.formatDisplayPath(p),
-                    formatPackagePath: (p, source) => this.getShortPath(p, source),
+                    formatPath: (item) => this.formatExtensionDisplayPath(item.path),
+                    formatPackagePath: (item) => this.formatExtensionDisplayPath(this.getShortPath(item.path, item.sourceInfo)),
                 });
-                this.chatContainer.addChild(new Text(`${sectionHeader("Extensions", "mdHeading")}\n${extList}`, 0, 0));
-                this.chatContainer.addChild(new Spacer(1));
+                const extensionCompactList = formatCompactList(this.getCompactExtensionLabels(extensions));
+                addLoadedSection("Extensions", extensionCompactList, extList, "mdHeading");
             }
             // 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 groups = this.buildScopeGroups(customThemes.map((loadedTheme) => ({
+                    path: loadedTheme.sourcePath,
+                    sourceInfo: loadedTheme.sourceInfo,
+                })));
                 const themeList = this.formatScopeGroups(groups, {
-                    formatPath: (p) => this.formatDisplayPath(p),
-                    formatPackagePath: (p, source) => this.getShortPath(p, source),
+                    formatPath: (item) => this.formatDisplayPath(item.path),
+                    formatPackagePath: (item) => this.getShortPath(item.path, item.sourceInfo),
                 });
-                this.chatContainer.addChild(new Text(`${sectionHeader("Themes")}\n${themeList}`, 0, 0));
-                this.chatContainer.addChild(new Spacer(1));
+                const themeCompactList = formatCompactList(customThemes.map((loadedTheme) => loadedTheme.name ?? this.getCompactPathLabel(loadedTheme.sourcePath, loadedTheme.sourceInfo)));
+                addLoadedSection("Themes", themeCompactList, themeList);
             }
         }
         if (showDiagnostics) {
             const skillDiagnostics = skillsResult.diagnostics;
             if (skillDiagnostics.length > 0) {
-                const warningLines = this.formatDiagnostics(skillDiagnostics, metadata);
+                const warningLines = this.formatDiagnostics(skillDiagnostics, sourceInfos);
                 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);
+                const warningLines = this.formatDiagnostics(promptDiagnostics, sourceInfos);
                 this.chatContainer.addChild(new Text(`${theme.fg("warning", "[Prompt conflicts]")}\n${warningLines}`, 0, 0));
                 this.chatContainer.addChild(new Spacer(1));
             }
@@ -749,18 +1113,19 @@ export class InteractiveMode {
                     extensionDiagnostics.push({ type: "error", message: error.error, path: error.path });
                 }
             }
-            const commandDiagnostics = this.session.extensionRunner?.getCommandDiagnostics() ?? [];
+            const commandDiagnostics = this.session.extensionRunner.getCommandDiagnostics();
             extensionDiagnostics.push(...commandDiagnostics);
-            const shortcutDiagnostics = this.session.extensionRunner?.getShortcutDiagnostics() ?? [];
+            extensionDiagnostics.push(...this.getBuiltInCommandConflictDiagnostics(this.session.extensionRunner));
+            const shortcutDiagnostics = this.session.extensionRunner.getShortcutDiagnostics();
             extensionDiagnostics.push(...shortcutDiagnostics);
             if (extensionDiagnostics.length > 0) {
-                const warningLines = this.formatDiagnostics(extensionDiagnostics, metadata);
+                const warningLines = this.formatDiagnostics(extensionDiagnostics, sourceInfos);
                 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);
+                const warningLines = this.formatDiagnostics(themeDiagnostics, sourceInfos);
                 this.chatContainer.addChild(new Text(`${theme.fg("warning", "[Theme conflicts]")}\n${warningLines}`, 0, 0));
                 this.chatContainer.addChild(new Spacer(1));
             }
@@ -769,7 +1134,7 @@ export class InteractiveMode {
     /**
      * Initialize the extension system with TUI-based UI context.
      */
-    async initExtensions() {
+    async bindCurrentSessionExtensions() {
         const uiContext = this.createExtensionUIContext();
         await this.session.bindExtensions({
             uiContext,
@@ -781,33 +1146,31 @@ export class InteractiveMode {
                         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 };
+                    try {
+                        const result = await this.runtimeHost.newSession(options);
+                        if (!result.cancelled) {
+                            this.renderCurrentSessionState();
+                            this.ui.requestRender();
+                        }
+                        return result;
+                    }
+                    catch (error) {
+                        return this.handleFatalRuntimeError("Failed to create session", error);
                     }
-                    // Clear UI state
-                    this.chatContainer.clear();
-                    this.pendingMessagesContainer.clear();
-                    this.compactionQueuedMessages = [];
-                    this.streamingComponent = undefined;
-                    this.streamingMessage = undefined;
-                    this.pendingTools.clear();
-                    // 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 };
+                fork: async (entryId, options) => {
+                    try {
+                        const result = await this.runtimeHost.fork(entryId, options);
+                        if (!result.cancelled) {
+                            this.renderCurrentSessionState();
+                            this.editor.setText(result.selectedText ?? "");
+                            this.showStatus("Forked to new session");
+                        }
+                        return { cancelled: result.cancelled };
+                    }
+                    catch (error) {
+                        return this.handleFatalRuntimeError("Failed to fork session", error);
                     }
-                    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, {
@@ -825,11 +1188,11 @@ export class InteractiveMode {
                         this.editor.setText(result.editorText);
                     }
                     this.showStatus("Navigated to selected point");
+                    void this.flushCompactionQueue({ willRetry: false });
                     return { cancelled: false };
                 },
-                switchSession: async (sessionPath) => {
-                    await this.handleResumeSession(sessionPath);
-                    return { cancelled: false };
+                switchSession: async (sessionPath, options) => {
+                    return this.handleResumeSession(sessionPath, options);
                 },
                 reload: async () => {
                     await this.handleReloadCommand();
@@ -846,22 +1209,59 @@ export class InteractiveMode {
             },
         });
         setRegisteredThemes(this.session.resourceLoader.getThemes().themes);
-        this.setupAutocomplete(this.fdPath);
+        this.setupAutocompleteProvider();
         const extensionRunner = this.session.extensionRunner;
-        if (!extensionRunner) {
-            this.showLoadedResources({ extensionPaths: [], force: false });
-            return;
-        }
         this.setupExtensionShortcuts(extensionRunner);
-        this.showLoadedResources({ extensionPaths: extensionRunner.getExtensionPaths(), force: false });
+        this.showLoadedResources({ force: false, showDiagnosticsWhenQuiet: true });
+        this.showStartupNoticesIfNeeded();
+    }
+    applyRuntimeSettings() {
+        this.footer.setSession(this.session);
+        this.footer.setAutoCompactEnabled(this.session.autoCompactionEnabled);
+        this.footerDataProvider.setCwd(this.sessionManager.getCwd());
+        this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
+        this.ui.setShowHardwareCursor(this.settingsManager.getShowHardwareCursor());
+        this.ui.setClearOnShrink(this.settingsManager.getClearOnShrink());
+        const editorPaddingX = this.settingsManager.getEditorPaddingX();
+        const autocompleteMaxVisible = this.settingsManager.getAutocompleteMaxVisible();
+        this.defaultEditor.setPaddingX(editorPaddingX);
+        this.defaultEditor.setAutocompleteMaxVisible(autocompleteMaxVisible);
+        if (this.editor !== this.defaultEditor) {
+            this.editor.setPaddingX?.(editorPaddingX);
+            this.editor.setAutocompleteMaxVisible?.(autocompleteMaxVisible);
+        }
+    }
+    async rebindCurrentSession() {
+        this.unsubscribe?.();
+        this.unsubscribe = undefined;
+        this.applyRuntimeSettings();
+        await this.bindCurrentSessionExtensions();
+        this.subscribeToAgent();
+        await this.updateAvailableProviderCount();
+        this.updateEditorBorderColor();
+        this.updateTerminalTitle();
+    }
+    async handleFatalRuntimeError(prefix, error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.showError(`${prefix}: ${message}`);
+        stopThemeWatcher();
+        this.stop();
+        process.exit(1);
+    }
+    renderCurrentSessionState() {
+        this.chatContainer.clear();
+        this.pendingMessagesContainer.clear();
+        this.compactionQueuedMessages = [];
+        this.streamingComponent = undefined;
+        this.streamingMessage = undefined;
+        this.pendingTools.clear();
+        this.renderInitialMessages();
     }
     /**
      * Get a registered tool definition by name (for custom rendering).
      */
     getRegisteredToolDefinition(toolName) {
-        const tools = this.session.extensionRunner?.getAllRegisteredTools() ?? [];
-        const registeredTool = tools.find((t) => t.definition.name === toolName);
-        return registeredTool?.definition;
+        return this.session.getToolDefinition(toolName);
     }
     /**
      * Set up keyboard shortcuts registered by extensions.
@@ -874,11 +1274,12 @@ export class InteractiveMode {
         const createContext = () => ({
             ui: this.createExtensionUIContext(),
             hasUI: true,
-            cwd: process.cwd(),
+            cwd: this.sessionManager.getCwd(),
             sessionManager: this.sessionManager,
             modelRegistry: this.session.modelRegistry,
             model: this.session.model,
             isIdle: () => !this.session.isStreaming,
+            signal: this.session.agent.signal,
             abort: () => this.session.abort(),
             hasPendingMessages: () => this.session.pendingMessageCount > 0,
             shutdown: () => {
@@ -888,10 +1289,8 @@ export class InteractiveMode {
             compact: (options) => {
                 void (async () => {
                     try {
-                        const result = await this.executeCompaction(options?.customInstructions, false);
-                        if (result) {
-                            options?.onComplete?.(result);
-                        }
+                        const result = await this.session.compact(options?.customInstructions);
+                        options?.onComplete?.(result);
                     }
                     catch (error) {
                         const err = error instanceof Error ? error : new Error(String(error));
@@ -923,6 +1322,50 @@ export class InteractiveMode {
         this.footerDataProvider.setExtensionStatus(key, text);
         this.ui.requestRender();
     }
+    getWorkingLoaderMessage() {
+        return this.workingMessage ?? this.defaultWorkingMessage;
+    }
+    createWorkingLoader() {
+        return new Loader(this.ui, (spinner) => theme.fg("accent", spinner), (text) => theme.fg("muted", text), this.getWorkingLoaderMessage(), this.workingIndicatorOptions);
+    }
+    stopWorkingLoader() {
+        if (this.loadingAnimation) {
+            this.loadingAnimation.stop();
+            this.loadingAnimation = undefined;
+        }
+        this.statusContainer.clear();
+    }
+    setWorkingVisible(visible) {
+        this.workingVisible = visible;
+        if (!visible) {
+            this.stopWorkingLoader();
+            this.ui.requestRender();
+            return;
+        }
+        if (this.session.isStreaming && !this.loadingAnimation) {
+            this.statusContainer.clear();
+            this.loadingAnimation = this.createWorkingLoader();
+            this.statusContainer.addChild(this.loadingAnimation);
+        }
+        this.ui.requestRender();
+    }
+    setWorkingIndicator(options) {
+        this.workingIndicatorOptions = options;
+        this.loadingAnimation?.setIndicator(options);
+        this.ui.requestRender();
+    }
+    setHiddenThinkingLabel(label) {
+        this.hiddenThinkingLabel = label ?? this.defaultHiddenThinkingLabel;
+        for (const child of this.chatContainer.children) {
+            if (child instanceof AssistantMessageComponent) {
+                child.setHiddenThinkingLabel(this.hiddenThinkingLabel);
+            }
+        }
+        if (this.streamingComponent) {
+            this.streamingComponent.setHiddenThinkingLabel(this.hiddenThinkingLabel);
+        }
+        this.ui.requestRender();
+    }
     /**
      * Set an extension widget (string array or custom component).
      */
@@ -988,15 +1431,21 @@ export class InteractiveMode {
         this.clearExtensionWidgets();
         this.footerDataProvider.clearExtensionStatuses();
         this.footer.invalidate();
+        this.autocompleteProviderWrappers = [];
         this.setCustomEditorComponent(undefined);
+        this.setupAutocompleteProvider();
         this.defaultEditor.onExtensionShortcut = undefined;
         this.updateTerminalTitle();
+        this.workingMessage = undefined;
+        this.workingVisible = true;
+        this.setWorkingIndicator();
         if (this.loadingAnimation) {
-            this.loadingAnimation.setMessage(`${this.defaultWorkingMessage} (${appKey(this.keybindings, "interrupt")} to interrupt)`);
+            this.loadingAnimation.setMessage(`${this.defaultWorkingMessage} (${keyText("app.interrupt")} to interrupt)`);
         }
+        this.setHiddenThinkingLabel();
     }
     // Maximum total widget lines to prevent viewport overflow
-    static { this.MAX_WIDGET_LINES = 10; }
+    static MAX_WIDGET_LINES = 10;
     /**
      * Render all extension widgets to the widget container.
      */
@@ -1067,6 +1516,9 @@ export class InteractiveMode {
         if (factory) {
             // Create and add custom header
             this.customHeader = factory(this.ui, theme);
+            if (isExpandable(this.customHeader)) {
+                this.customHeader.setExpanded(this.toolOutputExpanded);
+            }
             if (index !== -1) {
                 this.headerContainer.children[index] = this.customHeader;
             }
@@ -1078,6 +1530,9 @@ export class InteractiveMode {
         else {
             // Restore built-in header
             this.customHeader = undefined;
+            if (isExpandable(this.builtInHeader)) {
+                this.builtInHeader.setExpanded(this.toolOutputExpanded);
+            }
             if (index !== -1) {
                 this.headerContainer.children[index] = this.builtInHeader;
             }
@@ -1110,19 +1565,14 @@ export class InteractiveMode {
             onTerminalInput: (handler) => this.addExtensionTerminalInputListener(handler),
             setStatus: (key, text) => this.setExtensionStatus(key, text),
             setWorkingMessage: (message) => {
+                this.workingMessage = 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;
+                    this.loadingAnimation.setMessage(message ?? this.defaultWorkingMessage);
                 }
             },
+            setWorkingVisible: (visible) => this.setWorkingVisible(visible),
+            setWorkingIndicator: (options) => this.setWorkingIndicator(options),
+            setHiddenThinkingLabel: (label) => this.setHiddenThinkingLabel(label),
             setWidget: (key, content, options) => this.setExtensionWidget(key, content, options),
             setFooter: (factory) => this.setExtensionFooter(factory),
             setHeader: (factory) => this.setExtensionHeader(factory),
@@ -1130,9 +1580,14 @@ export class InteractiveMode {
             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(),
+            getEditorText: () => this.editor.getExpandedText?.() ?? this.editor.getText(),
             editor: (title, prefill) => this.showExtensionEditor(title, prefill),
+            addAutocompleteProvider: (factory) => {
+                this.autocompleteProviderWrappers.push(factory);
+                this.setupAutocompleteProvider();
+            },
             setEditorComponent: (factory) => this.setCustomEditorComponent(factory),
+            getEditorComponent: () => this.editorComponentFactory,
             get theme() {
                 return theme;
             },
@@ -1204,6 +1659,10 @@ export class InteractiveMode {
         const result = await this.showExtensionSelector(`${title}\n${message}`, ["Yes", "No"], opts);
         return result === "Yes";
     }
+    async promptForMissingSessionCwd(error) {
+        const confirmed = await this.showExtensionConfirm("Session cwd not found", formatMissingSessionCwdPrompt(error.issue));
+        return confirmed ? error.issue.fallbackCwd : undefined;
+    }
     /**
      * Show a text input for extensions.
      */
@@ -1277,6 +1736,7 @@ export class InteractiveMode {
      * Pass undefined to restore the default editor.
      */
     setCustomEditorComponent(factory) {
+        this.editorComponentFactory = factory;
         // Save text from current editor before switching
         const currentText = this.editor.getText();
         this.editorContainer.clear();
@@ -1441,7 +1901,7 @@ export class InteractiveMode {
         // 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) {
+            if (this.session.isStreaming) {
                 this.restoreQueuedMessagesToEditor({ abort: true });
             }
             else if (this.session.isBashRunning) {
@@ -1473,24 +1933,24 @@ export class InteractiveMode {
             }
         };
         // Register app action handlers
-        this.defaultEditor.onAction("clear", () => this.handleCtrlC());
+        this.defaultEditor.onAction("app.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"));
+        this.defaultEditor.onAction("app.suspend", () => this.handleCtrlZ());
+        this.defaultEditor.onAction("app.thinking.cycle", () => this.cycleThinkingLevel());
+        this.defaultEditor.onAction("app.model.cycleForward", () => this.cycleModel("forward"));
+        this.defaultEditor.onAction("app.model.cycleBackward", () => 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("fork", () => this.showUserMessageSelector());
-        this.defaultEditor.onAction("resume", () => this.showSessionSelector());
+        this.defaultEditor.onAction("app.model.select", () => this.showModelSelector());
+        this.defaultEditor.onAction("app.tools.expand", () => this.toggleToolOutputExpansion());
+        this.defaultEditor.onAction("app.thinking.toggle", () => this.toggleThinkingBlockVisibility());
+        this.defaultEditor.onAction("app.editor.external", () => this.openExternalEditor());
+        this.defaultEditor.onAction("app.message.followUp", () => this.handleFollowUp());
+        this.defaultEditor.onAction("app.message.dequeue", () => this.handleDequeue());
+        this.defaultEditor.onAction("app.session.new", () => this.handleClearCommand());
+        this.defaultEditor.onAction("app.session.tree", () => this.showTreeSelector());
+        this.defaultEditor.onAction("app.session.fork", () => this.showUserMessageSelector());
+        this.defaultEditor.onAction("app.session.resume", () => this.showSessionSelector());
         this.defaultEditor.onChange = (text) => {
             const wasBashMode = this.isBashMode;
             this.isBashMode = text.trimStart().startsWith("!");
@@ -1545,18 +2005,23 @@ export class InteractiveMode {
                 await this.handleModelCommand(searchTerm);
                 return;
             }
-            if (text.startsWith("/export")) {
+            if (text === "/export" || text.startsWith("/export ")) {
                 await this.handleExportCommand(text);
                 this.editor.setText("");
                 return;
             }
+            if (text === "/import" || text.startsWith("/import ")) {
+                await this.handleImportCommand(text);
+                this.editor.setText("");
+                return;
+            }
             if (text === "/share") {
                 await this.handleShareCommand();
                 this.editor.setText("");
                 return;
             }
             if (text === "/copy") {
-                this.handleCopyCommand();
+                await this.handleCopyCommand();
                 this.editor.setText("");
                 return;
             }
@@ -1585,6 +2050,11 @@ export class InteractiveMode {
                 this.editor.setText("");
                 return;
             }
+            if (text === "/clone") {
+                this.editor.setText("");
+                await this.handleCloneCommand();
+                return;
+            }
             if (text === "/tree") {
                 this.showTreeSelector();
                 this.editor.setText("");
@@ -1626,6 +2096,11 @@ export class InteractiveMode {
                 this.editor.setText("");
                 return;
             }
+            if (text === "/dementedelves") {
+                this.handleDementedDelves();
+                this.editor.setText("");
+                return;
+            }
             if (text === "/resume") {
                 this.showSessionSelector();
                 this.editor.setText("");
@@ -1696,31 +2171,44 @@ export class InteractiveMode {
         this.footer.invalidate();
         switch (event.type) {
             case "agent_start":
+                this.pendingTools.clear();
+                if (this.settingsManager.getShowTerminalProgress()) {
+                    this.ui.terminal.setProgress(true);
+                }
                 // 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.retryCountdown) {
+                    this.retryCountdown.dispose();
+                    this.retryCountdown = 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;
+                this.stopWorkingLoader();
+                if (this.workingVisible) {
+                    this.loadingAnimation = this.createWorkingLoader();
+                    this.statusContainer.addChild(this.loadingAnimation);
                 }
                 this.ui.requestRender();
                 break;
+            case "queue_update":
+                this.updatePendingMessagesDisplay();
+                this.ui.requestRender();
+                break;
+            case "session_info_changed":
+                this.updateTerminalTitle();
+                this.footer.invalidate();
+                this.ui.requestRender();
+                break;
+            case "thinking_level_changed":
+                this.footer.invalidate();
+                this.updateEditorBorderColor();
+                break;
             case "message_start":
                 if (event.message.role === "custom") {
                     this.addMessageToChat(event.message);
@@ -1732,7 +2220,7 @@ export class InteractiveMode {
                     this.ui.requestRender();
                 }
                 else if (event.message.role === "assistant") {
-                    this.streamingComponent = new AssistantMessageComponent(undefined, this.hideThinkingBlock, this.getMarkdownThemeWithSettings());
+                    this.streamingComponent = new AssistantMessageComponent(undefined, this.hideThinkingBlock, this.getMarkdownThemeWithSettings(), this.hiddenThinkingLabel);
                     this.streamingMessage = event.message;
                     this.chatContainer.addChild(this.streamingComponent);
                     this.streamingComponent.updateContent(this.streamingMessage);
@@ -1746,9 +2234,10 @@ export class InteractiveMode {
                     for (const content of this.streamingMessage.content) {
                         if (content.type === "toolCall") {
                             if (!this.pendingTools.has(content.id)) {
-                                const component = new ToolExecutionComponent(content.name, content.arguments, {
+                                const component = new ToolExecutionComponent(content.name, content.id, content.arguments, {
                                     showImages: this.settingsManager.getShowImages(),
-                                }, this.getRegisteredToolDefinition(content.name), this.ui);
+                                    imageWidthCells: this.settingsManager.getImageWidthCells(),
+                                }, this.getRegisteredToolDefinition(content.name), this.ui, this.sessionManager.getCwd());
                                 component.setExpanded(this.toolOutputExpanded);
                                 this.chatContainer.addChild(component);
                                 this.pendingTools.set(content.id, component);
@@ -1804,15 +2293,18 @@ export class InteractiveMode {
                 this.ui.requestRender();
                 break;
             case "tool_execution_start": {
-                if (!this.pendingTools.has(event.toolCallId)) {
-                    const component = new ToolExecutionComponent(event.toolName, event.args, {
+                let component = this.pendingTools.get(event.toolCallId);
+                if (!component) {
+                    component = new ToolExecutionComponent(event.toolName, event.toolCallId, event.args, {
                         showImages: this.settingsManager.getShowImages(),
-                    }, this.getRegisteredToolDefinition(event.toolName), this.ui);
+                        imageWidthCells: this.settingsManager.getImageWidthCells(),
+                    }, this.getRegisteredToolDefinition(event.toolName), this.ui, this.sessionManager.getCwd());
                     component.setExpanded(this.toolOutputExpanded);
                     this.chatContainer.addChild(component);
                     this.pendingTools.set(event.toolCallId, component);
-                    this.ui.requestRender();
                 }
+                component.markExecutionStarted();
+                this.ui.requestRender();
                 break;
             }
             case "tool_execution_update": {
@@ -1833,6 +2325,9 @@ export class InteractiveMode {
                 break;
             }
             case "agent_end":
+                if (this.settingsManager.getShowTerminalProgress()) {
+                    this.ui.terminal.setProgress(false);
+                }
                 if (this.loadingAnimation) {
                     this.loadingAnimation.stop();
                     this.loadingAnimation = undefined;
@@ -1847,54 +2342,60 @@ export class InteractiveMode {
                 await this.checkShutdownRequested();
                 this.ui.requestRender();
                 break;
-            case "auto_compaction_start": {
+            case "compaction_start": {
+                if (this.settingsManager.getShowTerminalProgress()) {
+                    this.ui.terminal.setProgress(true);
+                }
                 // 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)`);
+                const cancelHint = `(${keyText("app.interrupt")} to cancel)`;
+                const label = event.reason === "manual"
+                    ? `Compacting context... ${cancelHint}`
+                    : `${event.reason === "overflow" ? "Context overflow detected, " : ""}Auto-compacting... ${cancelHint}`;
+                this.autoCompactionLoader = new Loader(this.ui, (spinner) => theme.fg("accent", spinner), (text) => theme.fg("muted", text), label);
                 this.statusContainer.addChild(this.autoCompactionLoader);
                 this.ui.requestRender();
                 break;
             }
-            case "auto_compaction_end": {
-                // Restore escape handler
+            case "compaction_end": {
+                if (this.settingsManager.getShowTerminalProgress()) {
+                    this.ui.terminal.setProgress(false);
+                }
                 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");
+                    if (event.reason === "manual") {
+                        this.showError("Compaction cancelled");
+                    }
+                    else {
+                        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.addMessageToChat(createCompactionSummaryMessage(event.result.summary, event.result.tokensBefore, new Date().toISOString()));
                     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));
+                    if (event.reason === "manual") {
+                        this.showError(event.errorMessage);
+                    }
+                    else {
+                        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();
@@ -1908,8 +2409,14 @@ export class InteractiveMode {
                 };
                 // 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.retryCountdown?.dispose();
+                const retryMessage = (seconds) => `Retrying (${event.attempt}/${event.maxAttempts}) in ${seconds}s... (${keyText("app.interrupt")} to cancel)`;
+                this.retryLoader = new Loader(this.ui, (spinner) => theme.fg("warning", spinner), (text) => theme.fg("muted", text), retryMessage(Math.ceil(event.delayMs / 1000)));
+                this.retryCountdown = new CountdownTimer(event.delayMs, this.ui, (seconds) => {
+                    this.retryLoader?.setMessage(retryMessage(seconds));
+                }, () => {
+                    this.retryCountdown = undefined;
+                });
                 this.statusContainer.addChild(this.retryLoader);
                 this.ui.requestRender();
                 break;
@@ -1920,6 +2427,10 @@ export class InteractiveMode {
                     this.defaultEditor.onEscape = this.retryEscapeHandler;
                     this.retryEscapeHandler = undefined;
                 }
+                if (this.retryCountdown) {
+                    this.retryCountdown.dispose();
+                    this.retryCountdown = undefined;
+                }
                 // Stop loader
                 if (this.retryLoader) {
                     this.retryLoader.stop();
@@ -1980,7 +2491,7 @@ export class InteractiveMode {
             }
             case "custom": {
                 if (message.display) {
-                    const renderer = this.session.extensionRunner?.getMessageRenderer(message.customType);
+                    const renderer = this.session.extensionRunner.getMessageRenderer(message.customType);
                     const component = new CustomMessageComponent(message, renderer, this.getMarkdownThemeWithSettings());
                     component.setExpanded(this.toolOutputExpanded);
                     this.chatContainer.addChild(component);
@@ -2004,10 +2515,12 @@ export class InteractiveMode {
             case "user": {
                 const textContent = this.getUserMessageText(message);
                 if (textContent) {
+                    if (this.chatContainer.children.length > 0) {
+                        this.chatContainer.addChild(new Spacer(1));
+                    }
                     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);
@@ -2028,7 +2541,7 @@ export class InteractiveMode {
                 break;
             }
             case "assistant": {
-                const assistantComponent = new AssistantMessageComponent(message, this.hideThinkingBlock, this.getMarkdownThemeWithSettings());
+                const assistantComponent = new AssistantMessageComponent(message, this.hideThinkingBlock, this.getMarkdownThemeWithSettings(), this.hiddenThinkingLabel);
                 this.chatContainer.addChild(assistantComponent);
                 break;
             }
@@ -2049,6 +2562,7 @@ export class InteractiveMode {
      */
     renderSessionContext(sessionContext, options = {}) {
         this.pendingTools.clear();
+        const renderedPendingTools = new Map();
         if (options.updateFooter) {
             this.footer.invalidate();
             this.updateEditorBorderColor();
@@ -2060,7 +2574,10 @@ export class InteractiveMode {
                 // Render tool call components
                 for (const content of message.content) {
                     if (content.type === "toolCall") {
-                        const component = new ToolExecutionComponent(content.name, content.arguments, { showImages: this.settingsManager.getShowImages() }, this.getRegisteredToolDefinition(content.name), this.ui);
+                        const component = new ToolExecutionComponent(content.name, content.id, content.arguments, {
+                            showImages: this.settingsManager.getShowImages(),
+                            imageWidthCells: this.settingsManager.getImageWidthCells(),
+                        }, this.getRegisteredToolDefinition(content.name), this.ui, this.sessionManager.getCwd());
                         component.setExpanded(this.toolOutputExpanded);
                         this.chatContainer.addChild(component);
                         if (message.stopReason === "aborted" || message.stopReason === "error") {
@@ -2078,17 +2595,17 @@ export class InteractiveMode {
                             component.updateResult({ content: [{ type: "text", text: errorMessage }], isError: true });
                         }
                         else {
-                            this.pendingTools.set(content.id, component);
+                            renderedPendingTools.set(content.id, component);
                         }
                     }
                 }
             }
             else if (message.role === "toolResult") {
                 // Match tool results to pending tool components
-                const component = this.pendingTools.get(message.toolCallId);
+                const component = renderedPendingTools.get(message.toolCallId);
                 if (component) {
                     component.updateResult(message);
-                    this.pendingTools.delete(message.toolCallId);
+                    renderedPendingTools.delete(message.toolCallId);
                 }
             }
             else {
@@ -2096,7 +2613,9 @@ export class InteractiveMode {
                 this.addMessageToChat(message, options);
             }
         }
-        this.pendingTools.clear();
+        for (const [toolCallId, component] of renderedPendingTools) {
+            this.pendingTools.set(toolCallId, component);
+        }
         this.ui.requestRender();
     }
     renderInitialMessages() {
@@ -2144,26 +2663,32 @@ export class InteractiveMode {
         // Only called when editor is empty (enforced by CustomEditor)
         void this.shutdown();
     }
+    /**
+     * Gracefully shutdown the agent.
+     * Stops the TUI before emitting shutdown events so extension UI cleanup cannot
+     * repaint the final frame while the process is exiting.
+     */
+    isShuttingDown = false;
     async shutdown() {
         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));
+        this.unregisterSignalHandlers();
         // 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();
+        await this.runtimeHost.dispose();
         process.exit(0);
     }
+    emergencyTerminalExit() {
+        this.isShuttingDown = true;
+        this.unregisterSignalHandlers();
+        killTrackedDetachedChildren();
+        // The terminal is gone. Do not run normal shutdown because TUI and
+        // extension cleanup can write restore sequences and re-trigger EIO.
+        process.exit(129);
+    }
     /**
      * Check if shutdown was requested and perform shutdown if so.
      */
@@ -2172,21 +2697,71 @@ export class InteractiveMode {
             return;
         await this.shutdown();
     }
+    registerSignalHandlers() {
+        this.unregisterSignalHandlers();
+        const signals = ["SIGTERM"];
+        if (process.platform !== "win32") {
+            signals.push("SIGHUP");
+        }
+        for (const signal of signals) {
+            const handler = () => {
+                if (signal === "SIGHUP") {
+                    this.emergencyTerminalExit();
+                }
+                killTrackedDetachedChildren();
+                void this.shutdown();
+            };
+            process.prependListener(signal, handler);
+            this.signalCleanupHandlers.push(() => process.off(signal, handler));
+        }
+        const terminalErrorHandler = (error) => {
+            if (isDeadTerminalError(error)) {
+                this.emergencyTerminalExit();
+            }
+            throw error;
+        };
+        process.stdout.on("error", terminalErrorHandler);
+        process.stderr.on("error", terminalErrorHandler);
+        this.signalCleanupHandlers.push(() => process.stdout.off("error", terminalErrorHandler));
+        this.signalCleanupHandlers.push(() => process.stderr.off("error", terminalErrorHandler));
+    }
+    unregisterSignalHandlers() {
+        for (const cleanup of this.signalCleanupHandlers) {
+            cleanup();
+        }
+        this.signalCleanupHandlers = [];
+    }
     handleCtrlZ() {
+        if (process.platform === "win32") {
+            this.showStatus("Suspend to background is not supported on Windows");
+            return;
+        }
+        // Keep the event loop alive while suspended. Without this, stopping the TUI
+        // can leave Node with no ref'ed handles, causing the process to exit on fg
+        // before the SIGCONT handler gets a chance to restore the terminal.
+        const suspendKeepAlive = setInterval(() => { }, 2 ** 30);
         // Ignore SIGINT while suspended so Ctrl+C in the terminal does not
         // kill the backgrounded process. The handler is removed on resume.
         const ignoreSigint = () => { };
         process.on("SIGINT", ignoreSigint);
         // Set up handler to restore TUI when resumed
         process.once("SIGCONT", () => {
+            clearInterval(suspendKeepAlive);
             process.removeListener("SIGINT", ignoreSigint);
             this.ui.start();
             this.ui.requestRender(true);
         });
-        // 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");
+        try {
+            // Stop the TUI (restore terminal to normal mode)
+            this.ui.stop();
+            // Send SIGTSTP to process group (pid=0 means all processes in group)
+            process.kill(0, "SIGTSTP");
+        }
+        catch (error) {
+            clearInterval(suspendKeepAlive);
+            process.removeListener("SIGINT", ignoreSigint);
+            throw error;
+        }
     }
     async handleFollowUp() {
         const text = (this.editor.getExpandedText?.() ?? this.editor.getText()).trim();
@@ -2215,6 +2790,7 @@ export class InteractiveMode {
         }
         // If not streaming, Alt+Enter acts like regular Enter (trigger onSubmit)
         else if (this.editor.onSubmit) {
+            this.editor.setText("");
             this.editor.onSubmit(text);
         }
     }
@@ -2260,6 +2836,7 @@ export class InteractiveMode {
                 this.updateEditorBorderColor();
                 const thinkingStr = result.model.reasoning && result.thinkingLevel !== "off" ? ` (thinking: ${result.thinkingLevel})` : "";
                 this.showStatus(`Switched to ${result.model.name || result.model.id}${thinkingStr}`);
+                void this.maybeWarnAboutAnthropicSubscriptionAuth(result.model);
             }
         }
         catch (error) {
@@ -2271,6 +2848,10 @@ export class InteractiveMode {
     }
     setToolsExpanded(expanded) {
         this.toolOutputExpanded = expanded;
+        const activeHeader = this.customHeader ?? this.builtInHeader;
+        if (isExpandable(activeHeader)) {
+            activeHeader.setExpanded(expanded);
+        }
         for (const child of this.chatContainer.children) {
             if (isExpandable(child)) {
                 child.setExpanded(expanded);
@@ -2311,6 +2892,7 @@ export class InteractiveMode {
             // Spawn editor synchronously with inherited stdio for interactive editing
             const result = spawnSync(editor, [...editorArgs, tmpFile], {
                 stdio: "inherit",
+                shell: process.platform === "win32",
             });
             // On successful exit (status 0), replace editor content
             if (result.status === 0) {
@@ -2351,16 +2933,29 @@ export class InteractiveMode {
         this.ui.requestRender();
     }
     showNewVersionNotification(newVersion) {
-        const action = theme.fg("accent", getUpdateInstruction("phi-code"));
-        const updateInstruction = theme.fg("muted", `New version ${newVersion} is available. `) + action;
-        const changelogUrl = theme.fg("accent", "https://github.com/badlogic/pi-mono/blob/main/packages/coding-agent/CHANGELOG.md");
-        const changelogLine = theme.fg("muted", "Changelog: ") + changelogUrl;
+        const action = theme.fg("accent", `${APP_NAME} update`);
+        const updateInstruction = theme.fg("muted", `New version ${newVersion} is available. Run `) + action;
+        const changelogUrl = "https://github.com/earendil-works/pi-mono/blob/main/packages/coding-agent/CHANGELOG.md";
+        const changelogLink = getCapabilities().hyperlinks
+            ? hyperlink(theme.fg("accent", "open changelog"), changelogUrl)
+            : theme.fg("accent", changelogUrl);
+        const changelogLine = theme.fg("muted", "Changelog: ") + changelogLink;
         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${changelogLine}`, 1, 0));
         this.chatContainer.addChild(new DynamicBorder((text) => theme.fg("warning", text)));
         this.ui.requestRender();
     }
+    showPackageUpdateNotification(packages) {
+        const action = theme.fg("accent", `${APP_NAME} update`);
+        const updateInstruction = theme.fg("muted", "Package updates are available. Run ") + action;
+        const packageLines = packages.map((pkg) => `- ${pkg}`).join("\n");
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new DynamicBorder((text) => theme.fg("warning", text)));
+        this.chatContainer.addChild(new Text(`${theme.bold(theme.fg("warning", "Package Updates Available"))}\n${updateInstruction}\n${theme.fg("muted", "Packages:")}\n${packageLines}`, 1, 0));
+        this.chatContainer.addChild(new DynamicBorder((text) => theme.fg("warning", text)));
+        this.ui.requestRender();
+    }
     /**
      * Get all queued messages (read-only).
      * Combines session queue and compaction queue.
@@ -2408,7 +3003,7 @@ export class InteractiveMode {
                 const text = theme.fg("dim", `Follow-up: ${message}`);
                 this.pendingMessagesContainer.addChild(new TruncatedText(text, 1, 0));
             }
-            const dequeueHint = this.getAppKeyDisplay("dequeue");
+            const dequeueHint = this.getAppKeyDisplay("app.message.dequeue");
             const hintText = theme.fg("dim", `↳ ${dequeueHint} to edit all queued messages`);
             this.pendingMessagesContainer.addChild(new TruncatedText(hintText, 1, 0));
         }
@@ -2444,8 +3039,6 @@ export class InteractiveMode {
         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);
@@ -2551,6 +3144,7 @@ export class InteractiveMode {
             const selector = new SettingsSelectorComponent({
                 autoCompact: this.session.autoCompactionEnabled,
                 showImages: this.settingsManager.getShowImages(),
+                imageWidthCells: this.settingsManager.getImageWidthCells(),
                 autoResizeImages: this.settingsManager.getImageAutoResize(),
                 blockImages: this.settingsManager.getBlockImages(),
                 enableSkillCommands: this.settingsManager.getEnableSkillCommands(),
@@ -2563,6 +3157,7 @@ export class InteractiveMode {
                 availableThemes: getAvailableThemes(),
                 hideThinkingBlock: this.hideThinkingBlock,
                 collapseChangelog: this.settingsManager.getCollapseChangelog(),
+                enableInstallTelemetry: this.settingsManager.getEnableInstallTelemetry(),
                 doubleEscapeAction: this.settingsManager.getDoubleEscapeAction(),
                 treeFilterMode: this.settingsManager.getTreeFilterMode(),
                 showHardwareCursor: this.settingsManager.getShowHardwareCursor(),
@@ -2570,6 +3165,8 @@ export class InteractiveMode {
                 autocompleteMaxVisible: this.settingsManager.getAutocompleteMaxVisible(),
                 quietStartup: this.settingsManager.getQuietStartup(),
                 clearOnShrink: this.settingsManager.getClearOnShrink(),
+                showTerminalProgress: this.settingsManager.getShowTerminalProgress(),
+                warnings: this.settingsManager.getWarnings(),
             }, {
                 onAutoCompactChange: (enabled) => {
                     this.session.setAutoCompactionEnabled(enabled);
@@ -2583,6 +3180,14 @@ export class InteractiveMode {
                         }
                     }
                 },
+                onImageWidthCellsChange: (width) => {
+                    this.settingsManager.setImageWidthCells(width);
+                    for (const child of this.chatContainer.children) {
+                        if (child instanceof ToolExecutionComponent) {
+                            child.setImageWidthCells(width);
+                        }
+                    }
+                },
                 onAutoResizeImagesChange: (enabled) => {
                     this.settingsManager.setImageAutoResize(enabled);
                 },
@@ -2591,7 +3196,7 @@ export class InteractiveMode {
                 },
                 onEnableSkillCommandsChange: (enabled) => {
                     this.settingsManager.setEnableSkillCommands(enabled);
-                    this.setupAutocomplete(this.fdPath);
+                    this.setupAutocompleteProvider();
                 },
                 onSteeringModeChange: (mode) => {
                     this.session.setSteeringMode(mode);
@@ -2601,7 +3206,7 @@ export class InteractiveMode {
                 },
                 onTransportChange: (transport) => {
                     this.settingsManager.setTransport(transport);
-                    this.session.agent.setTransport(transport);
+                    this.session.agent.transport = transport;
                 },
                 onThinkingLevelChange: (level) => {
                     this.session.setThinkingLevel(level);
@@ -2637,6 +3242,9 @@ export class InteractiveMode {
                 onCollapseChangelogChange: (collapsed) => {
                     this.settingsManager.setCollapseChangelog(collapsed);
                 },
+                onEnableInstallTelemetryChange: (enabled) => {
+                    this.settingsManager.setEnableInstallTelemetry(enabled);
+                },
                 onQuietStartupChange: (enabled) => {
                     this.settingsManager.setQuietStartup(enabled);
                 },
@@ -2668,6 +3276,12 @@ export class InteractiveMode {
                     this.settingsManager.setClearOnShrink(enabled);
                     this.ui.setClearOnShrink(enabled);
                 },
+                onShowTerminalProgressChange: (enabled) => {
+                    this.settingsManager.setShowTerminalProgress(enabled);
+                },
+                onWarningsChange: (warnings) => {
+                    this.settingsManager.setWarnings(warnings);
+                },
                 onCancel: () => {
                     done();
                     this.ui.requestRender();
@@ -2688,6 +3302,7 @@ export class InteractiveMode {
                 this.footer.invalidate();
                 this.updateEditorBorderColor();
                 this.showStatus(`Model: ${model.id}`);
+                void this.maybeWarnAboutAnthropicSubscriptionAuth(model);
                 this.checkDaxnutsEasterEgg(model);
             }
             catch (error) {
@@ -2698,28 +3313,8 @@ export class InteractiveMode {
         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;
+        return findExactModelReferenceMatch(searchTerm, models);
     }
     async getModelCandidates() {
         if (this.session.scopedModels.length > 0) {
@@ -2739,6 +3334,34 @@ export class InteractiveMode {
         const uniqueProviders = new Set(models.map((m) => m.provider));
         this.footerDataProvider.setAvailableProviderCount(uniqueProviders.size);
     }
+    async maybeWarnAboutAnthropicSubscriptionAuth(model = this.session.model) {
+        if (this.settingsManager.getWarnings().anthropicExtraUsage === false) {
+            return;
+        }
+        if (this.anthropicSubscriptionWarningShown) {
+            return;
+        }
+        if (!model || model.provider !== "anthropic") {
+            return;
+        }
+        const storedCredential = this.session.modelRegistry.authStorage.get("anthropic");
+        if (storedCredential?.type === "oauth") {
+            this.anthropicSubscriptionWarningShown = true;
+            this.showWarning(ANTHROPIC_SUBSCRIPTION_AUTH_WARNING);
+            return;
+        }
+        try {
+            const apiKey = await this.session.modelRegistry.getApiKeyForProvider(model.provider);
+            if (!isAnthropicSubscriptionAuthKey(apiKey)) {
+                return;
+            }
+            this.anthropicSubscriptionWarningShown = true;
+            this.showWarning(ANTHROPIC_SUBSCRIPTION_AUTH_WARNING);
+        }
+        catch {
+            // Ignore auth lookup failures for warning-only checks.
+        }
+    }
     showModelSelector(initialSearchInput) {
         this.showSelector((done) => {
             const selector = new ModelSelectorComponent(this.ui, this.session.model, this.settingsManager, this.session.modelRegistry, this.session.scopedModels, async (model) => {
@@ -2748,6 +3371,7 @@ export class InteractiveMode {
                     this.updateEditorBorderColor();
                     done();
                     this.showStatus(`Model: ${model.id}`);
+                    void this.maybeWarnAboutAnthropicSubscriptionAuth(model);
                     this.checkDaxnutsEasterEgg(model);
                 }
                 catch (error) {
@@ -2773,33 +3397,24 @@ export class InteractiveMode {
         const sessionScopedModels = this.session.scopedModels;
         const hasSessionScope = sessionScopedModels.length > 0;
         // Build enabled model IDs from session state or settings
-        const enabledModelIds = new Set();
-        let hasFilter = false;
+        let currentEnabledIds = null;
         if (hasSessionScope) {
             // Use current session's scoped models
-            for (const sm of sessionScopedModels) {
-                enabledModelIds.add(`${sm.model.provider}/${sm.model.id}`);
-            }
-            hasFilter = true;
+            currentEnabledIds = sessionScopedModels.map((scoped) => `${scoped.model.provider}/${scoped.model.id}`);
         }
         else {
             // Fall back to settings
             const patterns = this.settingsManager.getEnabledModels();
             if (patterns !== undefined && patterns.length > 0) {
-                hasFilter = true;
                 const scopedModels = await resolveModelScope(patterns, this.session.modelRegistry);
-                for (const sm of scopedModels) {
-                    enabledModelIds.add(`${sm.model.provider}/${sm.model.id}`);
-                }
+                currentEnabledIds = scopedModels.map((scoped) => `${scoped.model.provider}/${scoped.model.id}`);
             }
         }
-        // Track current enabled state (session-only until persisted)
-        const currentEnabledIds = new Set(enabledModelIds);
-        let currentHasFilter = hasFilter;
         // Helper to update session's scoped models (session-only, no persist)
         const updateSessionModels = async (enabledIds) => {
-            if (enabledIds.size > 0 && enabledIds.size < allModels.length) {
-                const newScopedModels = await resolveModelScope(Array.from(enabledIds), this.session.modelRegistry);
+            currentEnabledIds = enabledIds === null ? null : [...enabledIds];
+            if (enabledIds && enabledIds.length > 0 && enabledIds.length < allModels.length) {
+                const newScopedModels = await resolveModelScope(enabledIds, this.session.modelRegistry);
                 this.session.setScopedModels(newScopedModels.map((sm) => ({
                     model: sm.model,
                     thinkingLevel: sm.thinkingLevel,
@@ -2816,49 +3431,16 @@ export class InteractiveMode {
             const selector = new ScopedModelsSelectorComponent({
                 allModels,
                 enabledModelIds: currentEnabledIds,
-                hasEnabledModelsFilter: currentHasFilter,
             }, {
-                onModelToggle: async (modelId, enabled) => {
-                    if (enabled) {
-                        currentEnabledIds.add(modelId);
-                    }
-                    else {
-                        currentEnabledIds.delete(modelId);
-                    }
-                    currentHasFilter = true;
-                    await updateSessionModels(currentEnabledIds);
-                },
-                onEnableAll: async (allModelIds) => {
-                    currentEnabledIds.clear();
-                    for (const id of allModelIds) {
-                        currentEnabledIds.add(id);
-                    }
-                    currentHasFilter = false;
-                    await updateSessionModels(currentEnabledIds);
-                },
-                onClearAll: async () => {
-                    currentEnabledIds.clear();
-                    currentHasFilter = true;
-                    await updateSessionModels(currentEnabledIds);
-                },
-                onToggleProvider: async (_provider, modelIds, enabled) => {
-                    for (const id of modelIds) {
-                        if (enabled) {
-                            currentEnabledIds.add(id);
-                        }
-                        else {
-                            currentEnabledIds.delete(id);
-                        }
-                    }
-                    currentHasFilter = true;
-                    await updateSessionModels(currentEnabledIds);
+                onChange: async (enabledIds) => {
+                    await updateSessionModels(enabledIds);
                 },
                 onPersist: (enabledIds) => {
                     // Persist to settings
-                    const newPatterns = enabledIds.length === allModels.length
+                    const newPatterns = enabledIds === null || enabledIds.length === allModels.length
                         ? undefined // All enabled = clear filter
                         : enabledIds;
-                    this.settingsManager.setEnabledModels(newPatterns);
+                    this.settingsManager.setEnabledModels(newPatterns ? [...newPatterns] : undefined);
                     this.showStatus("Model selection saved to settings");
                 },
                 onCancel: () => {
@@ -2875,27 +3457,52 @@ export class InteractiveMode {
             this.showStatus("No messages to fork from");
             return;
         }
+        const initialSelectedId = userMessages[userMessages.length - 1]?.entryId;
         this.showSelector((done) => {
             const selector = new UserMessageSelectorComponent(userMessages.map((m) => ({ id: m.entryId, text: m.text })), async (entryId) => {
-                const result = await this.session.fork(entryId);
-                if (result.cancelled) {
-                    // Extension cancelled the fork
+                try {
+                    const result = await this.runtimeHost.fork(entryId);
+                    if (result.cancelled) {
+                        done();
+                        this.ui.requestRender();
+                        return;
+                    }
+                    this.renderCurrentSessionState();
+                    this.editor.setText(result.selectedText ?? "");
                     done();
-                    this.ui.requestRender();
-                    return;
+                    this.showStatus("Forked to new session");
+                }
+                catch (error) {
+                    done();
+                    this.showError(error instanceof Error ? error.message : String(error));
                 }
-                this.chatContainer.clear();
-                this.renderInitialMessages();
-                this.editor.setText(result.selectedText);
-                done();
-                this.showStatus("Branched to new session");
             }, () => {
                 done();
                 this.ui.requestRender();
-            });
+            }, initialSelectedId);
             return { component: selector, focus: selector.getMessageList() };
         });
     }
+    async handleCloneCommand() {
+        const leafId = this.sessionManager.getLeafId();
+        if (!leafId) {
+            this.showStatus("Nothing to clone yet");
+            return;
+        }
+        try {
+            const result = await this.runtimeHost.fork(leafId, { position: "at" });
+            if (result.cancelled) {
+                this.ui.requestRender();
+                return;
+            }
+            this.renderCurrentSessionState();
+            this.editor.setText("");
+            this.showStatus("Cloned to new session");
+        }
+        catch (error) {
+            this.showError(error instanceof Error ? error.message : String(error));
+        }
+    }
     showTreeSelector(initialSelectedId) {
         const tree = this.sessionManager.getTree();
         const realLeafId = this.sessionManager.getLeafId();
@@ -2950,7 +3557,7 @@ export class InteractiveMode {
                         this.session.abortBranchSummary();
                     };
                     this.chatContainer.addChild(new Spacer(1));
-                    summaryLoader = new Loader(this.ui, (spinner) => theme.fg("accent", spinner), (text) => theme.fg("muted", text), `Summarizing branch... (${appKey(this.keybindings, "interrupt")} to cancel)`);
+                    summaryLoader = new Loader(this.ui, (spinner) => theme.fg("accent", spinner), (text) => theme.fg("muted", text), `Summarizing branch... (${keyText("app.interrupt")} to cancel)`);
                     this.statusContainer.addChild(summaryLoader);
                     this.ui.requestRender();
                 }
@@ -2976,6 +3583,7 @@ export class InteractiveMode {
                         this.editor.setText(result.editorText);
                     }
                     this.showStatus("Navigated to selected point");
+                    void this.flushCompactionQueue({ willRetry: false });
                 }
                 catch (error) {
                     this.showError(error instanceof Error ? error.message : String(error));
@@ -3021,73 +3629,297 @@ export class InteractiveMode {
             return { component: selector, focus: selector };
         });
     }
-    async handleResumeSession(sessionPath) {
-        // Stop loading animation
+    async handleResumeSession(sessionPath, options) {
         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();
-        // 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");
+        try {
+            const result = await this.runtimeHost.switchSession(sessionPath, {
+                withSession: options?.withSession,
+            });
+            if (result.cancelled) {
+                return result;
+            }
+            this.renderCurrentSessionState();
+            this.showStatus("Resumed session");
+            return result;
+        }
+        catch (error) {
+            if (error instanceof MissingSessionCwdError) {
+                const selectedCwd = await this.promptForMissingSessionCwd(error);
+                if (!selectedCwd) {
+                    this.showStatus("Resume cancelled");
+                    return { cancelled: true };
+                }
+                const result = await this.runtimeHost.switchSession(sessionPath, {
+                    cwdOverride: selectedCwd,
+                    withSession: options?.withSession,
+                });
+                if (result.cancelled) {
+                    return result;
+                }
+                this.renderCurrentSessionState();
+                this.showStatus("Resumed session in current cwd");
+                return result;
+            }
+            return this.handleFatalRuntimeError("Failed to resume session", error);
+        }
     }
-    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;
+    getLoginProviderOptions(authType) {
+        const authStorage = this.session.modelRegistry.authStorage;
+        const oauthProviders = authStorage.getOAuthProviders();
+        const oauthProviderIds = new Set(oauthProviders.map((provider) => provider.id));
+        const options = oauthProviders.map((provider) => ({
+            id: provider.id,
+            name: provider.name,
+            authType: "oauth",
+        }));
+        const modelProviders = new Set(this.session.modelRegistry.getAll().map((model) => model.provider));
+        for (const providerId of modelProviders) {
+            if (!isApiKeyLoginProvider(providerId, oauthProviderIds)) {
+                continue;
+            }
+            options.push({
+                id: providerId,
+                name: this.session.modelRegistry.getProviderDisplayName(providerId),
+                authType: "api_key",
+            });
+        }
+        const filteredOptions = authType ? options.filter((option) => option.authType === authType) : options;
+        return filteredOptions.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    getLogoutProviderOptions() {
+        const authStorage = this.session.modelRegistry.authStorage;
+        const options = [];
+        for (const providerId of authStorage.list()) {
+            const credential = authStorage.get(providerId);
+            if (!credential) {
+                continue;
             }
+            options.push({
+                id: providerId,
+                name: this.session.modelRegistry.getProviderDisplayName(providerId),
+                authType: credential.type,
+            });
+        }
+        return options.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    showLoginAuthTypeSelector() {
+        const subscriptionLabel = "Use a subscription";
+        const apiKeyLabel = "Use an API key";
+        this.showSelector((done) => {
+            const selector = new ExtensionSelectorComponent("Select authentication method:", [subscriptionLabel, apiKeyLabel], (option) => {
+                done();
+                const authType = option === subscriptionLabel ? "oauth" : "api_key";
+                this.showLoginProviderSelector(authType);
+            }, () => {
+                done();
+                this.ui.requestRender();
+            });
+            return { component: selector, focus: selector };
+        });
+    }
+    showLoginProviderSelector(authType) {
+        const providerOptions = this.getLoginProviderOptions(authType);
+        if (providerOptions.length === 0) {
+            this.showStatus(authType === "oauth" ? "No subscription providers available." : "No API key providers available.");
+            return;
+        }
+        this.showSelector((done) => {
+            const selector = new OAuthSelectorComponent("login", this.session.modelRegistry.authStorage, providerOptions, async (providerId) => {
+                done();
+                const providerOption = providerOptions.find((provider) => provider.id === providerId);
+                if (!providerOption) {
+                    return;
+                }
+                if (providerOption.authType === "oauth") {
+                    await this.showLoginDialog(providerOption.id, providerOption.name);
+                }
+                else if (providerOption.id === BEDROCK_PROVIDER_ID) {
+                    this.showBedrockSetupDialog(providerOption.id, providerOption.name);
+                }
+                else {
+                    await this.showApiKeyLoginDialog(providerOption.id, providerOption.name);
+                }
+            }, () => {
+                done();
+                this.showLoginAuthTypeSelector();
+            }, (providerId) => this.session.modelRegistry.getProviderAuthStatus(providerId));
+            return { component: selector, focus: selector };
+        });
+    }
+    async showOAuthSelector(mode) {
+        if (mode === "login") {
+            this.showLoginAuthTypeSelector();
+            return;
+        }
+        const providerOptions = this.getLogoutProviderOptions();
+        if (providerOptions.length === 0) {
+            this.showStatus("No stored credentials to remove. /logout only removes credentials saved by /login; environment variables and models.json config are unchanged.");
+            return;
         }
         this.showSelector((done) => {
-            const selector = new OAuthSelectorComponent(mode, this.session.modelRegistry.authStorage, async (providerId) => {
+            const selector = new OAuthSelectorComponent(mode, this.session.modelRegistry.authStorage, providerOptions, async (providerId) => {
                 done();
-                if (mode === "login") {
-                    await this.showLoginDialog(providerId);
+                const providerOption = providerOptions.find((provider) => provider.id === providerId);
+                if (!providerOption) {
+                    return;
+                }
+                try {
+                    this.session.modelRegistry.authStorage.logout(providerOption.id);
+                    this.session.modelRegistry.refresh();
+                    await this.updateAvailableProviderCount();
+                    const message = providerOption.authType === "oauth"
+                        ? `Logged out of ${providerOption.name}`
+                        : `Removed stored API key for ${providerOption.name}. Environment variables and models.json config are unchanged.`;
+                    this.showStatus(message);
+                }
+                catch (error) {
+                    this.showError(`Logout failed: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }, () => {
+                done();
+                this.ui.requestRender();
+            });
+            return { component: selector, focus: selector };
+        });
+    }
+    async completeProviderAuthentication(providerId, providerName, authType, previousModel) {
+        this.session.modelRegistry.refresh();
+        const actionLabel = authType === "oauth" ? `Logged in to ${providerName}` : `Saved API key for ${providerName}`;
+        let selectedModel;
+        let selectionError;
+        if (isUnknownModel(previousModel)) {
+            const availableModels = this.session.modelRegistry.getAvailable();
+            const providerModels = availableModels.filter((model) => model.provider === providerId);
+            if (!hasDefaultModelProvider(providerId)) {
+                selectionError = `${actionLabel}, but no default model is configured for provider "${providerId}". Use /model to select a model.`;
+            }
+            else if (providerModels.length === 0) {
+                selectionError = `${actionLabel}, but no models are available for that provider. Use /model to select a model.`;
+            }
+            else {
+                const defaultModelId = defaultModelPerProvider[providerId];
+                selectedModel = providerModels.find((model) => model.id === defaultModelId);
+                if (!selectedModel) {
+                    selectionError = `${actionLabel}, but its default model "${defaultModelId}" is not available. Use /model to select a model.`;
                 }
                 else {
-                    // Logout flow
-                    const providerInfo = this.session.modelRegistry.authStorage
-                        .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}`);
+                        await this.session.setModel(selectedModel);
                     }
                     catch (error) {
-                        this.showError(`Logout failed: ${error instanceof Error ? error.message : String(error)}`);
+                        selectedModel = undefined;
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        selectionError = `${actionLabel}, but selecting its default model failed: ${errorMessage}. Use /model to select a model.`;
                     }
                 }
-            }, () => {
-                done();
+            }
+        }
+        await this.updateAvailableProviderCount();
+        this.footer.invalidate();
+        this.updateEditorBorderColor();
+        if (selectedModel) {
+            this.showStatus(`${actionLabel}. Selected ${selectedModel.id}. Credentials saved to ${getAuthPath()}`);
+            void this.maybeWarnAboutAnthropicSubscriptionAuth(selectedModel);
+            this.checkDaxnutsEasterEgg(selectedModel);
+        }
+        else {
+            this.showStatus(`${actionLabel}. Credentials saved to ${getAuthPath()}`);
+            if (selectionError) {
+                this.showError(selectionError);
+            }
+            else {
+                void this.maybeWarnAboutAnthropicSubscriptionAuth();
+            }
+        }
+    }
+    showBedrockSetupDialog(providerId, providerName) {
+        const restoreEditor = () => {
+            this.editorContainer.clear();
+            this.editorContainer.addChild(this.editor);
+            this.ui.setFocus(this.editor);
+            this.ui.requestRender();
+        };
+        const dialog = new LoginDialogComponent(this.ui, providerId, () => restoreEditor(), providerName, "Amazon Bedrock setup");
+        dialog.showInfo([
+            theme.fg("text", "Amazon Bedrock uses AWS credentials instead of a single API key."),
+            theme.fg("text", "Configure an AWS profile, IAM keys, bearer token, or role-based credentials."),
+            theme.fg("muted", "See:"),
+            theme.fg("accent", `  ${path.join(getDocsPath(), "providers.md")}`),
+        ]);
+        this.editorContainer.clear();
+        this.editorContainer.addChild(dialog);
+        this.ui.setFocus(dialog);
+        this.ui.requestRender();
+    }
+    async showApiKeyLoginDialog(providerId, providerName) {
+        const previousModel = this.session.model;
+        const dialog = new LoginDialogComponent(this.ui, providerId, (_success, _message) => {
+            // Completion handled below
+        }, providerName);
+        this.editorContainer.clear();
+        this.editorContainer.addChild(dialog);
+        this.ui.setFocus(dialog);
+        this.ui.requestRender();
+        const restoreEditor = () => {
+            this.editorContainer.clear();
+            this.editorContainer.addChild(this.editor);
+            this.ui.setFocus(this.editor);
+            this.ui.requestRender();
+        };
+        try {
+            const apiKey = (await dialog.showPrompt("Enter API key:")).trim();
+            if (!apiKey) {
+                throw new Error("API key cannot be empty.");
+            }
+            this.session.modelRegistry.authStorage.set(providerId, { type: "api_key", key: apiKey });
+            restoreEditor();
+            await this.completeProviderAuthentication(providerId, providerName, "api_key", previousModel);
+        }
+        catch (error) {
+            restoreEditor();
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            if (errorMsg !== "Login cancelled") {
+                this.showError(`Failed to save API key for ${providerName}: ${errorMsg}`);
+            }
+        }
+    }
+    showOAuthLoginSelect(dialog, prompt) {
+        return new Promise((resolve) => {
+            const restoreDialog = () => {
+                this.editorContainer.clear();
+                this.editorContainer.addChild(dialog);
+                this.ui.setFocus(dialog);
                 this.ui.requestRender();
+            };
+            const labels = prompt.options.map((option) => option.label);
+            const selector = new ExtensionSelectorComponent(prompt.message, labels, (optionLabel) => {
+                restoreDialog();
+                resolve(prompt.options.find((option) => option.label === optionLabel)?.id);
+            }, () => {
+                restoreDialog();
+                resolve(undefined);
             });
-            return { component: selector, focus: selector };
+            this.editorContainer.clear();
+            this.editorContainer.addChild(selector);
+            this.ui.setFocus(selector);
+            this.ui.requestRender();
         });
     }
-    async showLoginDialog(providerId) {
-        const providerInfo = this.session.modelRegistry.authStorage.getOAuthProviders().find((p) => p.id === providerId);
-        const providerName = providerInfo?.name || providerId;
+    async showLoginDialog(providerId, providerName) {
+        const providerInfo = this.session.modelRegistry.authStorage
+            .getOAuthProviders()
+            .find((provider) => provider.id === providerId);
+        const previousModel = this.session.model;
         // 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
-        });
+        }, providerName);
         // Show dialog in editor container
         this.editorContainer.clear();
         this.editorContainer.addChild(dialog);
@@ -3140,14 +3972,13 @@ export class InteractiveMode {
                 onProgress: (message) => {
                     dialog.showProgress(message);
                 },
+                onSelect: (prompt) => this.showOAuthLoginSelect(dialog, prompt),
                 onManualCodeInput: () => manualCodePromise,
                 signal: dialog.signal,
             });
             // Success
             restoreEditor();
-            this.session.modelRegistry.refresh();
-            await this.updateAvailableProviderCount();
-            this.showStatus(`Logged in to ${providerName}. Credentials saved to ${getAuthPath()}`);
+            await this.completeProviderAuthentication(providerId, providerName, "oauth", previousModel);
         }
         catch (error) {
             restoreEditor();
@@ -3170,16 +4001,20 @@ export class InteractiveMode {
             return;
         }
         this.resetExtensionUI();
-        const loader = new BorderedLoader(this.ui, theme, "Reloading extensions, skills, prompts, themes...", {
-            cancellable: false,
-        });
+        const reloadBox = new Container();
+        const borderColor = (s) => theme.fg("border", s);
+        reloadBox.addChild(new DynamicBorder(borderColor));
+        reloadBox.addChild(new Spacer(1));
+        reloadBox.addChild(new Text(theme.fg("muted", "Reloading keybindings, extensions, skills, prompts, themes..."), 1, 0));
+        reloadBox.addChild(new Spacer(1));
+        reloadBox.addChild(new DynamicBorder(borderColor));
         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.addChild(reloadBox);
+        this.ui.setFocus(reloadBox);
+        this.ui.requestRender(true);
+        await new Promise((resolve) => process.nextTick(resolve));
+        const dismissReloadBox = (editor) => {
             this.editorContainer.clear();
             this.editorContainer.addChild(editor);
             this.ui.setFocus(editor);
@@ -3187,6 +4022,11 @@ export class InteractiveMode {
         };
         try {
             await this.session.reload();
+            this.keybindings.reload();
+            const activeHeader = this.customHeader ?? this.builtInHeader;
+            if (isExpandable(activeHeader)) {
+                activeHeader.setExpanded(this.toolOutputExpanded);
+            }
             setRegisteredThemes(this.session.resourceLoader.getThemes().themes);
             this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
             const themeName = this.settingsManager.getTheme();
@@ -3204,15 +4044,12 @@ export class InteractiveMode {
             }
             this.ui.setShowHardwareCursor(this.settingsManager.getShowHardwareCursor());
             this.ui.setClearOnShrink(this.settingsManager.getClearOnShrink());
-            this.setupAutocomplete(this.fdPath);
+            this.setupAutocompleteProvider();
             const runner = this.session.extensionRunner;
-            if (runner) {
-                this.setupExtensionShortcuts(runner);
-            }
+            this.setupExtensionShortcuts(runner);
             this.rebuildChatFromMessages();
-            dismissLoader(this.editor);
+            dismissReloadBox(this.editor);
             this.showLoadedResources({
-                extensionPaths: runner?.getExtensionPaths() ?? [],
                 force: false,
                 showDiagnosticsWhenQuiet: true,
             });
@@ -3220,24 +4057,102 @@ export class InteractiveMode {
             if (modelsJsonError) {
                 this.showError(`models.json error: ${modelsJsonError}`);
             }
-            this.showStatus("Reloaded extensions, skills, prompts, themes");
+            this.showStatus("Reloaded keybindings, extensions, skills, prompts, themes");
         }
         catch (error) {
-            dismissLoader(previousEditor);
+            dismissReloadBox(previousEditor);
             this.showError(`Reload failed: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     async handleExportCommand(text) {
-        const parts = text.split(/\s+/);
-        const outputPath = parts.length > 1 ? parts[1] : undefined;
+        const outputPath = this.getPathCommandArgument(text, "/export");
         try {
-            const filePath = await this.session.exportToHtml(outputPath);
-            this.showStatus(`Session exported to: ${filePath}`);
+            if (outputPath?.endsWith(".jsonl")) {
+                const filePath = this.session.exportToJsonl(outputPath);
+                this.showStatus(`Session exported to: ${filePath}`);
+            }
+            else {
+                const filePath = await this.session.exportToHtml(outputPath);
+                this.showStatus(`Session exported to: ${filePath}`);
+            }
         }
         catch (error) {
             this.showError(`Failed to export session: ${error instanceof Error ? error.message : "Unknown error"}`);
         }
     }
+    getPathCommandArgument(text, command) {
+        if (text === command) {
+            return undefined;
+        }
+        if (!text.startsWith(`${command} `)) {
+            return undefined;
+        }
+        const argsString = text.slice(command.length + 1).trimStart();
+        if (!argsString) {
+            return undefined;
+        }
+        const firstChar = argsString[0];
+        if (firstChar === '"' || firstChar === "'") {
+            const closingQuoteIndex = argsString.indexOf(firstChar, 1);
+            if (closingQuoteIndex < 0) {
+                return undefined;
+            }
+            return argsString.slice(1, closingQuoteIndex);
+        }
+        const firstWhitespaceIndex = argsString.search(/\s/);
+        if (firstWhitespaceIndex < 0) {
+            return argsString;
+        }
+        return argsString.slice(0, firstWhitespaceIndex);
+    }
+    async handleImportCommand(text) {
+        const inputPath = this.getPathCommandArgument(text, "/import");
+        if (!inputPath) {
+            this.showError("Usage: /import <path.jsonl>");
+            return;
+        }
+        const confirmed = await this.showExtensionConfirm("Import session", `Replace current session with ${inputPath}?`);
+        if (!confirmed) {
+            this.showStatus("Import cancelled");
+            return;
+        }
+        try {
+            if (this.loadingAnimation) {
+                this.loadingAnimation.stop();
+                this.loadingAnimation = undefined;
+            }
+            this.statusContainer.clear();
+            const result = await this.runtimeHost.importFromJsonl(inputPath);
+            if (result.cancelled) {
+                this.showStatus("Import cancelled");
+                return;
+            }
+            this.renderCurrentSessionState();
+            this.showStatus(`Session imported from: ${inputPath}`);
+        }
+        catch (error) {
+            if (error instanceof MissingSessionCwdError) {
+                const selectedCwd = await this.promptForMissingSessionCwd(error);
+                if (!selectedCwd) {
+                    this.showStatus("Import cancelled");
+                    return;
+                }
+                const result = await this.runtimeHost.importFromJsonl(inputPath, selectedCwd);
+                if (result.cancelled) {
+                    this.showStatus("Import cancelled");
+                    return;
+                }
+                this.renderCurrentSessionState();
+                this.showStatus(`Session imported from: ${inputPath}`);
+                return;
+            }
+            if (error instanceof SessionImportFileNotFoundError) {
+                this.showError(`Failed to import session: ${error.message}`);
+                return;
+            }
+            await this.handleFatalRuntimeError("Failed to import session", error);
+        }
+    }
     async handleShareCommand() {
         // Check if gh is available and logged in
         try {
@@ -3325,14 +4240,14 @@ export class InteractiveMode {
             }
         }
     }
-    handleCopyCommand() {
+    async handleCopyCommand() {
         const text = this.session.getLastAssistantText();
         if (!text) {
             this.showError("No agent messages to copy yet.");
             return;
         }
         try {
-            copyToClipboard(text);
+            await copyToClipboard(text);
             this.showStatus("Copied last agent message to clipboard");
         }
         catch (error) {
@@ -3353,8 +4268,7 @@ export class InteractiveMode {
             this.ui.requestRender();
             return;
         }
-        this.sessionManager.appendSessionInfo(name);
-        this.updateTerminalTitle();
+        this.session.setSessionName(name);
         this.chatContainer.addChild(new Spacer(1));
         this.chatContainer.addChild(new Text(theme.fg("dim", `Session name set: ${name}`), 1, 0));
         this.ui.requestRender();
@@ -3409,69 +4323,63 @@ export class InteractiveMode {
         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));
+        return keyDisplayText(action);
     }
     /**
      * Get capitalized display string for an editor keybinding action.
      */
     getEditorKeyDisplay(action) {
-        return this.capitalizeKey(editorKey(action));
+        return keyDisplayText(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");
+        const cursorUp = this.getEditorKeyDisplay("tui.editor.cursorUp");
+        const cursorDown = this.getEditorKeyDisplay("tui.editor.cursorDown");
+        const cursorLeft = this.getEditorKeyDisplay("tui.editor.cursorLeft");
+        const cursorRight = this.getEditorKeyDisplay("tui.editor.cursorRight");
+        const cursorWordLeft = this.getEditorKeyDisplay("tui.editor.cursorWordLeft");
+        const cursorWordRight = this.getEditorKeyDisplay("tui.editor.cursorWordRight");
+        const cursorLineStart = this.getEditorKeyDisplay("tui.editor.cursorLineStart");
+        const cursorLineEnd = this.getEditorKeyDisplay("tui.editor.cursorLineEnd");
+        const jumpForward = this.getEditorKeyDisplay("tui.editor.jumpForward");
+        const jumpBackward = this.getEditorKeyDisplay("tui.editor.jumpBackward");
+        const pageUp = this.getEditorKeyDisplay("tui.editor.pageUp");
+        const pageDown = this.getEditorKeyDisplay("tui.editor.pageDown");
         // Editing keybindings
-        const submit = this.getEditorKeyDisplay("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");
+        const submit = this.getEditorKeyDisplay("tui.input.submit");
+        const newLine = this.getEditorKeyDisplay("tui.input.newLine");
+        const deleteWordBackward = this.getEditorKeyDisplay("tui.editor.deleteWordBackward");
+        const deleteWordForward = this.getEditorKeyDisplay("tui.editor.deleteWordForward");
+        const deleteToLineStart = this.getEditorKeyDisplay("tui.editor.deleteToLineStart");
+        const deleteToLineEnd = this.getEditorKeyDisplay("tui.editor.deleteToLineEnd");
+        const yank = this.getEditorKeyDisplay("tui.editor.yank");
+        const yankPop = this.getEditorKeyDisplay("tui.editor.yankPop");
+        const undo = this.getEditorKeyDisplay("tui.editor.undo");
+        const tab = this.getEditorKeyDisplay("tui.input.tab");
         // App keybindings
-        const interrupt = this.getAppKeyDisplay("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");
+        const interrupt = this.getAppKeyDisplay("app.interrupt");
+        const clear = this.getAppKeyDisplay("app.clear");
+        const exit = this.getAppKeyDisplay("app.exit");
+        const suspend = this.getAppKeyDisplay("app.suspend");
+        const cycleThinkingLevel = this.getAppKeyDisplay("app.thinking.cycle");
+        const cycleModelForward = this.getAppKeyDisplay("app.model.cycleForward");
+        const selectModel = this.getAppKeyDisplay("app.model.select");
+        const expandTools = this.getAppKeyDisplay("app.tools.expand");
+        const toggleThinking = this.getAppKeyDisplay("app.thinking.toggle");
+        const externalEditor = this.getAppKeyDisplay("app.editor.external");
+        const cycleModelBackward = this.getAppKeyDisplay("app.model.cycleBackward");
+        const followUp = this.getAppKeyDisplay("app.message.followUp");
+        const dequeue = this.getAppKeyDisplay("app.message.dequeue");
+        const pasteImage = this.getAppKeyDisplay("app.clipboard.pasteImage");
         let hotkeys = `
 **Navigation**
 | Key | Action |
 |-----|--------|
-| \`Arrow keys\` | Move cursor / browse history (Up when empty) |
+| \`${cursorUp}\` / \`${cursorDown}\` / \`${cursorLeft}\` / \`${cursorRight}\` | Move cursor / browse history (Up when empty) |
 | \`${cursorWordLeft}\` / \`${cursorWordRight}\` | Move by word |
 | \`${cursorLineStart}\` | Start of line |
 | \`${cursorLineEnd}\` | End of line |
@@ -3501,33 +4409,31 @@ export class InteractiveMode {
 | \`${exit}\` | Exit (when editor is empty) |
 | \`${suspend}\` | Suspend to background |
 | \`${cycleThinkingLevel}\` | Cycle thinking level |
-| \`${cycleModelForward}\` | Cycle models |
+| \`${cycleModelForward}\` / \`${cycleModelBackward}\` | 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 |
-| \`Ctrl+V\` | Paste image from clipboard |
+| \`${pasteImage}\` | 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 += `
+        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`;
-                }
+            for (const [key, shortcut] of shortcuts) {
+                const description = shortcut.description ?? shortcut.extensionPath;
+                const keyDisplay = formatKeyText(key, { capitalize: true });
+                hotkeys += `| \`${keyDisplay}\` | ${description} |\n`;
             }
         }
         this.chatContainer.addChild(new Spacer(1));
@@ -3539,25 +4445,24 @@ export class InteractiveMode {
         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.headerContainer.clear();
-        this.chatContainer.clear();
-        this.pendingMessagesContainer.clear();
-        this.compactionQueuedMessages = [];
-        this.streamingComponent = undefined;
-        this.streamingMessage = undefined;
-        this.pendingTools.clear();
-        this.chatContainer.addChild(new Spacer(1));
-        this.chatContainer.addChild(new Text(`${theme.fg("accent", "✓ New session started")}`, 1, 1));
-        this.ui.requestRender();
+        try {
+            const result = await this.runtimeHost.newSession();
+            if (result.cancelled) {
+                return;
+            }
+            this.renderCurrentSessionState();
+            this.chatContainer.addChild(new Spacer(1));
+            this.chatContainer.addChild(new Text(`${theme.fg("accent", "✓ New session started")}`, 1, 1));
+            this.ui.requestRender();
+        }
+        catch (error) {
+            await this.handleFatalRuntimeError("Failed to create session", error);
+        }
     }
     handleDebugCommand() {
         const width = this.ui.terminal.columns;
@@ -3591,6 +4496,11 @@ export class InteractiveMode {
         this.chatContainer.addChild(new ArminComponent(this.ui));
         this.ui.requestRender();
     }
+    handleDementedDelves() {
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new EarendilAnnouncementComponent());
+        this.ui.requestRender();
+    }
     handleDaxnuts() {
         this.chatContainer.addChild(new Spacer(1));
         this.chatContainer.addChild(new DaxnutsComponent(this.ui));
@@ -3604,14 +4514,12 @@ export class InteractiveMode {
     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;
+        const eventResult = await extensionRunner.emitUserBash({
+            type: "user_bash",
+            command,
+            excludeFromContext,
+            cwd: this.sessionManager.getCwd(),
+        });
         // If extension returned a full result, use it directly
         if (eventResult?.result) {
             const result = eventResult.result;
@@ -3675,55 +4583,23 @@ export class InteractiveMode {
             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();
+            await this.session.compact(customInstructions);
         }
-        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;
+        catch {
+            // Ignore, will be emitted as an event
         }
-        void this.flushCompactionQueue({ willRetry: false });
-        return result;
     }
     stop() {
+        this.unregisterSignalHandlers();
+        if (this.settingsManager.getShowTerminalProgress()) {
+            this.ui.terminal.setProgress(false);
+        }
         if (this.loadingAnimation) {
             this.loadingAnimation.stop();
             this.loadingAnimation = undefined;