@sammorrowdrums/mcpi 0.70.9 → 0.85.0-bootstrap.0

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

@@ -6,56 +6,70 @@ 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, setKeybindings, Text, TruncatedText, TUI, visibleWidth, } from "@mariozechner/pi-tui";
-import { getProviders, } from "@sammorrowdrums/mcpi-ai";
+import * as TuiLayouts from "@sammorrowdrums/mcpi-tui";
+import { CombinedAutocompleteProvider, Container, fuzzyFilter, getCapabilities, hyperlink, Markdown, matchesKey, ProcessTerminal, Spacer, setKeybindings, Text, TruncatedText, TuiAltScreen, TuiMainScreen, visibleWidth, } from "@sammorrowdrums/mcpi-tui";
+import chalk from "chalk";
 import { spawn, spawnSync } from "child_process";
-import { APP_NAME, APP_TITLE, getAgentDir, getAuthPath, getDebugLogPath, getDocsPath, getShareViewerUrl, getUpdateInstruction, VERSION, } from "../../config.js";
+import { APP_NAME, APP_TITLE, CONFIG_DIR_NAME, ENV_SHARE_VIEWER_URL, getAgentDir, getAuthPath, getDebugLogPath, getDocsPath, getShareViewerUrl, getStateDir, VERSION, } from "../../config.js";
 import { parseSkillBlock } from "../../core/agent-session.js";
 import { SessionImportFileNotFoundError } from "../../core/agent-session-runtime.js";
+import { CACHE_TTL_MS, collectCacheMisses, computeCacheWaste, detectCacheMiss, } from "../../core/cache-stats.js";
 import { FooterDataProvider } from "../../core/footer-data-provider.js";
+import { configureHttpDispatcher, formatHttpIdleTimeoutMs } from "../../core/http-dispatcher.js";
 import { KeybindingsManager } from "../../core/keybindings.js";
 import { createCompactionSummaryMessage } from "../../core/messages.js";
-import { defaultModelPerProvider, findExactModelReferenceMatch, resolveModelScope } from "../../core/model-resolver.js";
+import { defaultModelPerProvider, findExactModelReferenceMatch, resolveModelScopeFromModels, } from "../../core/model-resolver.js";
+import { CredentialSynchronizationError } from "../../core/model-runtime.js";
 import { DefaultPackageManager } from "../../core/package-manager.js";
 import { formatMissingSessionCwdPrompt, MissingSessionCwdError } from "../../core/session-cwd.js";
-import { SessionManager } from "../../core/session-manager.js";
+import { SessionManager, sessionEntryToContextMessages } 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 { hasTrustRequiringProjectResources, ProjectTrustStore } from "../../core/trust-manager.js";
+import { getUsageCostBreakdown } from "../../core/usage-totals.js";
+import { getChangelogPath, getNewEntries, normalizeChangelogLinks, parseChangelog } from "../../utils/changelog.js";
+import { copyToClipboard, readClipboardText } from "../../utils/clipboard.js";
 import { extensionForImageMimeType, readClipboardImage } from "../../utils/clipboard-image.js";
 import { parseGitUrl } from "../../utils/git.js";
+import { openBrowser } from "../../utils/open-browser.js";
+import { getCwdRelativePath } from "../../utils/paths.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 { CustomEntryComponent } from "./components/custom-entry.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 { keyHint, keyText, rawKeyHint } from "./components/keybinding-hints.js";
+import { FooterComponent, formatTokens } from "./components/footer.js";
+import { formatKeyText, keyDisplayText, keyHint, keyText, rawKeyHint } from "./components/keybinding-hints.js";
 import { LoginDialogComponent } from "./components/login-dialog.js";
+import { createMermaidMarkdownTransformer } from "./components/mermaid.js";
 import { ModelSelectorComponent } from "./components/model-selector.js";
-import { OAuthSelectorComponent } from "./components/oauth-selector.js";
+import { formatAuthSelectorProviderType, OAuthSelectorComponent, } from "./components/oauth-selector.js";
 import { ScopedModelsSelectorComponent } from "./components/scoped-models-selector.js";
 import { SessionSelectorComponent } from "./components/session-selector.js";
 import { SettingsSelectorComponent } from "./components/settings-selector.js";
 import { SkillInvocationMessageComponent } from "./components/skill-invocation-message.js";
+import { BranchSummaryStatusIndicator, CompactionStatusIndicator, IdleStatus, RetryStatusIndicator, WorkingStatusIndicator, } from "./components/status-indicator.js";
 import { ToolExecutionComponent } from "./components/tool-execution.js";
 import { TreeSelectorComponent } from "./components/tree-selector.js";
+import { TrustSelectorComponent } from "./components/trust-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, stopThemeWatcher, Theme, theme, } from "./theme/theme.js";
+import { editInExternalEditor } from "./external-editor.js";
+import { refreshModelCatalogs } from "./model-catalog-refresh.js";
+import { getModelSearchText } from "./model-search.js";
+import { getAvailableThemes, getAvailableThemesWithPaths, getEditorTheme, getMarkdownTheme, getThemeByName, onThemeChange, setRegisteredThemes, stopThemeWatcher, Theme, theme, } from "./theme/theme.js";
+import { InteractiveThemeController } from "./theme/theme-controller.js";
 function isExpandable(obj) {
     return typeof obj === "object" && obj !== null && "setExpanded" in obj && typeof obj.setExpanded === "function";
 }
@@ -71,75 +85,172 @@ class ExpandableText extends Text {
         this.setText(expanded ? this.getExpandedText() : this.getCollapsedText());
     }
 }
-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 isCustomSessionEntry(item) {
+    return "type" in item && item.type === "custom";
+}
+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. Disable this warning in /settings.";
 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 quoteIfNeeded(value) {
+    if (value.length > 0 && !/[^a-zA-Z0-9_\-./~:@]/.test(value)) {
+        return value;
+    }
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+export function formatResumeCommand(sessionManager) {
+    if (!process.stdout.isTTY)
+        return undefined;
+    if (!sessionManager.isPersisted())
+        return undefined;
+    const sessionFile = sessionManager.getSessionFile();
+    if (!sessionFile || !fs.existsSync(sessionFile))
+        return undefined;
+    const args = [APP_NAME];
+    if (!sessionManager.usesDefaultSessionDir()) {
+        args.push("--session-dir", quoteIfNeeded(sessionManager.getSessionDir()));
+    }
+    args.push("--session", sessionManager.getSessionId());
+    return args.join(" ");
+}
 function hasDefaultModelProvider(providerId) {
     return providerId in defaultModelPerProvider;
 }
-const BEDROCK_PROVIDER_ID = "amazon-bedrock";
-const API_KEY_LOGIN_PROVIDERS = {
-    anthropic: "Anthropic",
-    [BEDROCK_PROVIDER_ID]: "Amazon Bedrock",
-    "azure-openai-responses": "Azure OpenAI Responses",
-    cerebras: "Cerebras",
-    fireworks: "Fireworks",
-    google: "Google Gemini",
-    "google-vertex": "Google Vertex AI",
-    groq: "Groq",
-    huggingface: "Hugging Face",
-    "kimi-coding": "Kimi For Coding",
-    mistral: "Mistral",
-    minimax: "MiniMax",
-    "minimax-cn": "MiniMax (China)",
-    opencode: "OpenCode Zen",
-    "opencode-go": "OpenCode Go",
-    openai: "OpenAI",
-    openrouter: "OpenRouter",
-    "vercel-ai-gateway": "Vercel AI Gateway",
-    xai: "xAI",
-    zai: "ZAI",
-};
-const BUILT_IN_API_KEY_LOGIN_PROVIDERS = new Set(Object.keys(API_KEY_LOGIN_PROVIDERS));
-const BUILT_IN_MODEL_PROVIDERS = new Set(getProviders());
-export function isApiKeyLoginProvider(providerId, oauthProviderIds, builtInProviderIds = BUILT_IN_MODEL_PROVIDERS) {
-    if (BUILT_IN_API_KEY_LOGIN_PROVIDERS.has(providerId)) {
-        return true;
+const AUTH_TYPE_ORDER = { oauth: 0, api_key: 1 };
+function createFuzzyAutocompleteItems(items, prefix, getSearchText, toAutocompleteItem) {
+    const filtered = fuzzyFilter(items, prefix, getSearchText);
+    if (filtered.length === 0)
+        return null;
+    return filtered.map(toAutocompleteItem);
+}
+function getLoginProviderCompletionOptions(providerOptions) {
+    const byId = new Map();
+    for (const provider of providerOptions) {
+        const existing = byId.get(provider.id);
+        if (existing) {
+            if (!existing.authTypes.includes(provider.authType)) {
+                existing.authTypes.push(provider.authType);
+                existing.authTypes.sort((a, b) => AUTH_TYPE_ORDER[a] - AUTH_TYPE_ORDER[b]);
+            }
+            continue;
+        }
+        byId.set(provider.id, {
+            id: provider.id,
+            name: provider.name,
+            authTypes: [provider.authType],
+        });
     }
-    if (builtInProviderIds.has(providerId)) {
-        return false;
+    return Array.from(byId.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+function getLoginProviderSearchText(provider) {
+    const authTypes = provider.authTypes
+        .map((authType) => `${authType} ${formatAuthSelectorProviderType(authType)}`)
+        .join(" ");
+    return `${provider.id} ${provider.name} ${authTypes}`;
+}
+function formatLoginProviderCompletionDescription(provider) {
+    const authTypes = provider.authTypes.map(formatAuthSelectorProviderType).join("/");
+    return provider.name === provider.id ? authTypes : `${provider.name} · ${authTypes}`;
+}
+/** Composition root for selecting the interactive terminal renderer. */
+export function createInteractiveTui(options) {
+    const terminal = options.terminal ?? new ProcessTerminal();
+    if (options.tuiMode === "fullscreen") {
+        const styleSearchMatch = (text) => theme.bg("searchMatchBg", theme.fg("searchMatchText", text));
+        return new TuiAltScreen(terminal, options.showHardwareCursor, options.logDirectory, {
+            searchMatchStyle: (text) => theme.underline(styleSearchMatch(text)),
+            searchCurrentMatchStyle: (text) => theme.bold(theme.inverse(styleSearchMatch(text))),
+            openUrl: openBrowser,
+            onRightClickPaste: options.onRightClickPaste,
+            copySelection: async (text) => {
+                try {
+                    await copyToClipboard(text);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            },
+        });
     }
-    return !oauthProviderIds.has(providerId);
+    return new TuiMainScreen(terminal, options.showHardwareCursor, options.logDirectory);
 }
-export function getApiKeyProviderDisplayName(providerId) {
-    return API_KEY_LOGIN_PROVIDERS[providerId] ?? providerId;
+/** Stable reference for components while InteractiveMode replaces the active renderer. */
+export function createInteractiveTuiReference(getTui) {
+    return new Proxy({}, {
+        get: (_target, property) => {
+            const tui = getTui();
+            const value = Reflect.get(tui, property, tui);
+            if (typeof value !== "function")
+                return value;
+            let methodTui = tui;
+            let method = value;
+            return (...args) => {
+                const currentTui = getTui();
+                if (currentTui !== methodTui) {
+                    const currentMethod = Reflect.get(currentTui, property, currentTui);
+                    if (typeof currentMethod !== "function") {
+                        throw new TypeError(`TUI property ${String(property)} is not callable`);
+                    }
+                    methodTui = currentTui;
+                    method = currentMethod;
+                }
+                return Reflect.apply(method, methodTui, args);
+            };
+        },
+        set: (_target, property, value) => {
+            const tui = getTui();
+            return Reflect.set(tui, property, value, tui);
+        },
+        has: (_target, property) => Reflect.has(getTui(), property),
+        getPrototypeOf: () => Reflect.getPrototypeOf(getTui()),
+    });
 }
 export class InteractiveMode {
-    options;
     runtimeHost;
+    renderer;
     ui;
+    mainScreenRenderState;
+    loadedResourcesContainer;
     chatContainer;
+    documentContainer;
+    transcriptScrollView;
+    fullscreenLayoutRoot;
     pendingMessagesContainer;
     statusContainer;
     defaultEditor;
     editor;
+    editorComponentFactory;
     autocompleteProvider;
     autocompleteProviderWrappers = [];
     fdPath;
     editorContainer;
+    activeSelectorToken;
+    activeSelectorDispose;
     footer;
+    footerContainer;
     footerDataProvider;
     // Stored so the same manager can be injected into custom editors, selectors, and extension UI.
     keybindings;
     version;
     isInitialized = false;
     onInputCallback;
-    loadingAnimation = undefined;
+    pendingUserInputs = [];
+    activeStatusIndicator = undefined;
+    idleStatus = new IdleStatus();
     workingMessage = undefined;
+    workingVisible = true;
     workingIndicatorOptions = undefined;
     defaultWorkingMessage = "Working...";
     defaultHiddenThinkingLabel = "Thinking...";
@@ -152,6 +263,7 @@ export class InteractiveMode {
     // Status line tracking (for mutating immediately-sequential status updates)
     lastStatusSpacer = undefined;
     lastStatusText = undefined;
+    managedToolStatusStarted = false;
     // Streaming message tracking
     streamingComponent = undefined;
     streamingMessage = undefined;
@@ -161,6 +273,11 @@ export class InteractiveMode {
     toolOutputExpanded = false;
     // Thinking block visibility state
     hideThinkingBlock = false;
+    outputPad = 1;
+    mermaidMarkdownTransformer = createMermaidMarkdownTransformer({
+        getMode: () => this.settingsManager.getMermaidRenderingMode(),
+        theme,
+    });
     // Skill commands: command name -> skill file path
     skillCommands = new Map();
     // Agent subscription unsubscribe function
@@ -173,11 +290,8 @@ export class InteractiveMode {
     // 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 = [];
@@ -187,7 +301,7 @@ export class InteractiveMode {
     extensionSelector = undefined;
     extensionInput = undefined;
     extensionEditor = undefined;
-    extensionTerminalInputUnsubscribers = new Set();
+    extensionTerminalInputSubscriptions = new Set();
     // Extension widgets (components rendered above/below the editor)
     extensionWidgetsAbove = new Map();
     extensionWidgetsBelow = new Map();
@@ -201,6 +315,12 @@ export class InteractiveMode {
     builtInHeader = undefined;
     // Custom header from extension (undefined = use built-in header)
     customHeader = undefined;
+    options;
+    onRightClickPaste = () => {
+        void this.handleRightClickPaste();
+    };
+    autoTrustOnReloadCwd;
+    themeController;
     // Convenience accessors
     get session() {
         return this.runtimeHost.session;
@@ -215,19 +335,33 @@ export class InteractiveMode {
         return this.session.settingsManager;
     }
     constructor(runtimeHost, options = {}) {
-        this.options = options;
         this.runtimeHost = runtimeHost;
+        const tuiMode = options.tuiMode ?? this.settingsManager.getTuiMode();
+        this.options = { ...options, tuiMode };
+        this.autoTrustOnReloadCwd = options.autoTrustOnReloadCwd;
         this.runtimeHost.setBeforeSessionInvalidate(() => {
             this.resetExtensionUI();
         });
         this.runtimeHost.setRebindSession(async () => {
-            await this.rebindCurrentSession();
+            await this.rebindCurrentSession({ renderBeforeBind: true });
+            await this.themeController.applyFromSettings();
         });
         this.version = VERSION;
-        this.ui = new TUI(new ProcessTerminal(), this.settingsManager.getShowHardwareCursor());
+        this.renderer = createInteractiveTui({
+            tuiMode,
+            showHardwareCursor: this.settingsManager.getShowHardwareCursor(),
+            logDirectory: getStateDir(),
+            onRightClickPaste: this.onRightClickPaste,
+        });
+        this.ui = createInteractiveTuiReference(() => this.renderer);
         this.ui.setClearOnShrink(this.settingsManager.getClearOnShrink());
         this.headerContainer = new Container();
+        this.loadedResourcesContainer = new Container();
         this.chatContainer = new Container();
+        this.documentContainer = new Container();
+        this.documentContainer.addChild(this.headerContainer);
+        this.documentContainer.addChild(this.loadedResourcesContainer);
+        this.documentContainer.addChild(this.chatContainer);
         this.pendingMessagesContainer = new Container();
         this.statusContainer = new Container();
         this.widgetContainerAbove = new Container();
@@ -246,11 +380,19 @@ export class InteractiveMode {
         this.footerDataProvider = new FooterDataProvider(this.sessionManager.getCwd());
         this.footer = new FooterComponent(this.session, this.footerDataProvider);
         this.footer.setAutoCompactEnabled(this.session.autoCompactionEnabled);
+        this.footerContainer = new Container();
+        this.footerContainer.addChild(this.footer);
         // Load hide thinking block setting
         this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
+        this.outputPad = this.settingsManager.getOutputPad();
         // Register themes from resource loader and initialize
         setRegisteredThemes(this.session.resourceLoader.getThemes().themes);
-        initTheme(this.settingsManager.getTheme(), true);
+        this.themeController = new InteractiveThemeController(this.ui, {
+            getSettingsManager: () => this.settingsManager,
+            showError: (message) => this.showError(message),
+            onChanged: () => this.updateEditorBorderColor(),
+            initialThemeSetting: options.initialThemeSetting,
+        });
     }
     getAutocompleteSourceTag(sourceInfo) {
         if (!sourceInfo) {
@@ -296,33 +438,41 @@ export class InteractiveMode {
         const slashCommands = BUILTIN_SLASH_COMMANDS.map((command) => ({
             name: command.name,
             description: command.description,
+            ...(command.argumentHint && { argumentHint: command.argumentHint }),
         }));
         const modelCommand = slashCommands.find((command) => command.name === "model");
         if (modelCommand) {
             modelCommand.getArgumentCompletions = (prefix) => {
-                // Get available models (scoped or from registry)
                 const models = this.session.scopedModels.length > 0
                     ? this.session.scopedModels.map((s) => s.model)
-                    : this.session.modelRegistry.getAvailable();
+                    : this.session.modelRuntime.getAvailableSnapshot();
                 if (models.length === 0)
                     return null;
                 // Create items with provider/id format
                 const items = models.map((m) => ({
                     id: m.id,
                     provider: m.provider,
+                    name: m.name,
                     label: `${m.provider}/${m.id}`,
                 }));
-                // Fuzzy filter by model ID + provider (allows "opus anthropic" to match)
-                const filtered = fuzzyFilter(items, prefix, (item) => `${item.id} ${item.provider}`);
-                if (filtered.length === 0)
-                    return null;
-                return filtered.map((item) => ({
+                return createFuzzyAutocompleteItems(items, prefix, getModelSearchText, (item) => ({
                     value: item.label,
                     label: item.id,
                     description: item.provider,
                 }));
             };
         }
+        const loginCommand = slashCommands.find((command) => command.name === "login");
+        if (loginCommand) {
+            loginCommand.getArgumentCompletions = (prefix) => {
+                const providers = getLoginProviderCompletionOptions(this.getLoginProviderOptions());
+                return createFuzzyAutocompleteItems(providers, prefix, getLoginProviderSearchText, (provider) => ({
+                    value: provider.id,
+                    label: provider.id,
+                    description: formatLoginProviderCompletionDescription(provider),
+                }));
+            };
+        }
         // Convert prompt templates to SlashCommand format for autocomplete
         const templateCommands = this.session.promptTemplates.map((cmd) => ({
             name: cmd.name,
@@ -356,8 +506,13 @@ export class InteractiveMode {
     }
     setupAutocompleteProvider() {
         let provider = this.createBaseAutocompleteProvider();
+        const triggerCharacters = [];
         for (const wrapProvider of this.autocompleteProviderWrappers) {
             provider = wrapProvider(provider);
+            triggerCharacters.push(...(provider.triggerCharacters ?? []));
+        }
+        if (triggerCharacters.length > 0) {
+            provider.triggerCharacters = [...new Set(triggerCharacters)];
         }
         this.autocompleteProvider = provider;
         this.defaultEditor.setAutocompleteProvider(provider);
@@ -391,18 +546,131 @@ export class InteractiveMode {
         }
         this.chatContainer.addChild(new DynamicBorder());
     }
+    mountInteractiveTui(tui, components) {
+        for (const component of components)
+            tui.addChild(component);
+        if (TuiLayouts.isViewportTUI(tui)) {
+            if (!this.fullscreenLayoutRoot)
+                throw new Error("Fullscreen layout is not initialized");
+            tui.setLayoutRoot(this.fullscreenLayoutRoot);
+        }
+    }
+    stopInteractiveTui(fullscreenExitOutput) {
+        if (this.renderer.mode === "fullscreen" && fullscreenExitOutput === "transcript") {
+            while (this.renderer.hasOverlayEntries)
+                this.renderer.hideOverlay();
+            this.switchTuiMode("regular", false, false);
+            this.renderer.renderNow();
+        }
+        this.ui.stop({ preserveScreen: this.renderer.mode === "fullscreen" });
+    }
+    switchTuiMode(mode, restoreProgress = true, startRenderer = true) {
+        const previousUi = this.renderer;
+        if (mode === previousUi.mode)
+            return true;
+        if (previousUi.hasOverlayEntries)
+            return false;
+        const components = [...previousUi.children];
+        const focus = previousUi.getFocusedComponent();
+        const terminal = previousUi.terminal;
+        const showHardwareCursor = previousUi.getShowHardwareCursor();
+        const clearOnShrink = previousUi.getClearOnShrink();
+        const onDebug = previousUi.onDebug;
+        if (previousUi instanceof TuiMainScreen) {
+            this.mainScreenRenderState = previousUi.captureRenderState();
+        }
+        previousUi.stop({ preserveScreen: true });
+        previousUi.setFocus(null);
+        previousUi.clear();
+        if (TuiLayouts.isViewportTUI(previousUi))
+            previousUi.setLayoutRoot(undefined);
+        const nextUi = createInteractiveTui({
+            tuiMode: mode,
+            showHardwareCursor,
+            logDirectory: getStateDir(),
+            terminal,
+            onRightClickPaste: this.onRightClickPaste,
+        });
+        nextUi.setClearOnShrink(clearOnShrink);
+        nextUi.onDebug = onDebug;
+        if (nextUi instanceof TuiMainScreen && this.mainScreenRenderState) {
+            nextUi.restoreRenderState(this.mainScreenRenderState);
+        }
+        this.renderer = nextUi;
+        this.options.tuiMode = mode;
+        this.mountInteractiveTui(nextUi, components);
+        nextUi.invalidate();
+        nextUi.setFocus(focus);
+        if (!startRenderer)
+            return true;
+        nextUi.start();
+        this.themeController.rebindTui();
+        this.rebindExtensionTerminalInputListeners();
+        if (restoreProgress &&
+            this.settingsManager.getShowTerminalProgress() &&
+            (this.session.isStreaming || this.session.isCompacting)) {
+            terminal.setProgress(true);
+        }
+        return true;
+    }
     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)
-        // Both are needed: fd for autocomplete, rg for grep tool and bash commands
-        const [fdPath] = await Promise.all([ensureTool("fd"), ensureTool("rg")]);
-        this.fdPath = fdPath;
-        // Add header container as first child
-        this.ui.addChild(this.headerContainer);
+        if (this.session.scopedModels.length > 0 && (this.options.verbose || !this.settingsManager.getQuietStartup())) {
+            const modelList = this.session.scopedModels
+                .map((sm) => {
+                const thinkingStr = sm.thinkingLevel ? `:${sm.thinkingLevel}` : "";
+                return `${sm.model.id}${thinkingStr}`;
+            })
+                .join(", ");
+            const cycleKeys = this.keybindings.getKeys("app.model.cycleForward");
+            const cycleHint = cycleKeys.length > 0
+                ? theme.fg("muted", ` (${formatKeyText(cycleKeys.join("/"), { capitalize: true })} to cycle)`)
+                : "";
+            console.log(theme.fg("dim", `Model scope: ${modelList}${cycleHint}`));
+        }
+        // Keep one component tree and remount it when changing renderers.
+        this.renderWidgets(); // Initialize with default spacer
+        this.transcriptScrollView = new TuiLayouts.ScrollView(this.documentContainer, {
+            follow: "end",
+            primary: true,
+            overscroll: "chain",
+            scrollbar: this.settingsManager.getFullscreenScrollbar(),
+            scrollbarStyle: (text) => theme.bg("scrollbarThumb", text),
+        });
+        const dock = new TuiLayouts.VStack([
+            { component: this.pendingMessagesContainer, shrink: 1, minSize: 0 },
+            { component: this.statusContainer, shrink: 1, minSize: 0 },
+            { component: this.widgetContainerAbove, shrink: 1, minSize: 0 },
+            { component: this.editorContainer, shrink: 1, minSize: 3 },
+            { component: this.widgetContainerBelow, shrink: 1, minSize: 0 },
+            { component: this.footerContainer, shrink: 1, minSize: 1 },
+        ]);
+        this.fullscreenLayoutRoot = new TuiLayouts.VStack([
+            { component: this.transcriptScrollView, basis: 0, grow: 1, shrink: 1, minSize: 1 },
+            { component: dock, basis: "auto", grow: 0, shrink: 1, minSize: 1 },
+        ]);
+        this.mountInteractiveTui(this.renderer, [
+            this.documentContainer,
+            this.pendingMessagesContainer,
+            this.statusContainer,
+            this.widgetContainerAbove,
+            this.editorContainer,
+            this.widgetContainerBelow,
+            this.footerContainer,
+        ]);
+        // Accept text while startup completes, but only enable interrupt, exit, and submission feedback.
+        this.defaultEditor.onAction("app.clear", () => this.handleCtrlC());
+        this.defaultEditor.onCtrlD = () => this.handleCtrlD();
+        this.defaultEditor.onSubmit = (text) => this.handleStartupSubmit(text);
+        this.ui.setFocus(this.editor);
+        // Start the UI before initializing extensions so session_start handlers can use interactive dialogs
+        this.ui.start();
+        this.isInitialized = true;
+        await this.themeController.applyFromSettings();
         // Add header with keybindings from config (unless silenced)
         if (this.options.verbose || !this.settingsManager.getQuietStartup()) {
             const logo = theme.bold(theme.fg("accent", APP_NAME)) + theme.fg("dim", ` v${this.version}`);
@@ -426,7 +694,7 @@ export class InteractiveMode {
                 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"),
+                hint("app.clipboard.pasteImage", "to paste image (with text fallback)"),
                 rawKeyHint("drop files", "to attach"),
             ].join("\n");
             const compactInstructions = [
@@ -437,7 +705,7 @@ export class InteractiveMode {
                 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.`);
+            const onboarding = theme.fg("dim", `${APP_NAME} can explain its own features and look up its docs. Ask it how to use or extend ${APP_NAME}.`);
             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));
@@ -449,20 +717,19 @@ export class InteractiveMode {
             this.builtInHeader = new Text("", 0, 0);
             this.headerContainer.addChild(this.builtInHeader);
         }
-        this.ui.addChild(this.chatContainer);
-        this.ui.addChild(this.pendingMessagesContainer);
-        this.ui.addChild(this.statusContainer);
-        this.renderWidgets(); // Initialize with default spacer
-        this.ui.addChild(this.widgetContainerAbove);
-        this.ui.addChild(this.editorContainer);
-        this.ui.addChild(this.widgetContainerBelow);
-        this.ui.addChild(this.footer);
-        this.ui.setFocus(this.editor);
+        this.ui.requestRender();
+        // Ensure fd and rg are available after mounting the TUI (downloads if missing, adds to PATH via getBinDir)
+        // so slow downloads do not make startup appear frozen.
+        // Both are needed: fd for autocomplete, rg for grep tool and bash commands.
+        const [fdPath] = await Promise.all([
+            ensureTool("fd", (status) => this.showManagedToolStatus(status)),
+            ensureTool("rg", (status) => this.showManagedToolStatus(status)),
+        ]);
+        this.fdPath = fdPath;
+        // Enable the remaining input handlers only after managed-tool setup completes.
         this.setupKeyHandlers();
         this.setupEditorSubmitHandler();
-        // Start the UI before initializing extensions so session_start handlers can use interactive dialogs
-        this.ui.start();
-        this.isInitialized = true;
+        this.ui.requestRender();
         // Initialize extensions first so resources are shown before messages
         await this.rebindCurrentSession();
         // Render initial messages AFTER showing loaded resources
@@ -499,17 +766,33 @@ export class InteractiveMode {
      */
     async run() {
         await this.init();
+        if (!process.env.MCPI_OFFLINE) {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 15_000);
+            void refreshModelCatalogs(this.session.modelRuntime, controller.signal)
+                .then(() => this.updateAvailableProviderCount())
+                .catch(() => { })
+                .finally(() => clearTimeout(timeout));
+        }
         // Start version check asynchronously
-        this.checkForNewVersion().then((newVersion) => {
-            if (newVersion) {
-                this.showNewVersionNotification(newVersion);
+        checkForNewPiVersion(this.version).then((newRelease) => {
+            if (newRelease) {
+                this.showNewVersionNotification(newRelease);
             }
         });
         // Start package update check asynchronously
-        this.checkForPackageUpdates().then((updates) => {
+        this.checkForPackageUpdates()
+            .then((updates) => {
             if (updates.length > 0) {
                 this.showPackageUpdateNotification(updates);
             }
+        })
+            .finally(() => {
+            // On Windows, npm can overwrite the shared console title while checking
+            // extension package versions. Restore mcpi's title after the startup check.
+            if (process.platform === "win32" && this.isInitialized) {
+                this.updateTerminalTitle();
+            }
         });
         // Check tmux keyboard setup asynchronously
         this.checkTmuxKeyboardSetup().then((warning) => {
@@ -522,7 +805,7 @@ export class InteractiveMode {
         if (migratedProviders && migratedProviders.length > 0) {
             this.showWarning(`Migrated credentials to auth.json: ${migratedProviders.join(", ")}`);
         }
-        const modelsJsonError = this.session.modelRegistry.getError();
+        const modelsJsonError = this.session.modelRuntime.getError();
         if (modelsJsonError) {
             this.showError(`models.json error: ${modelsJsonError}`);
         }
@@ -563,31 +846,8 @@ 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;
-        try {
-            const response = await fetch("https://registry.npmjs.org/mcpi/latest", {
-                signal: AbortSignal.timeout(10000),
-            });
-            if (!response.ok)
-                return undefined;
-            const data = (await response.json());
-            const latestVersion = data.version;
-            if (latestVersion && latestVersion !== this.version) {
-                return latestVersion;
-            }
-            return undefined;
-        }
-        catch {
-            return undefined;
-        }
-    }
     async checkForPackageUpdates() {
-        if (process.env.PI_OFFLINE) {
+        if (process.env.MCPI_OFFLINE) {
             return [];
         }
         try {
@@ -640,7 +900,7 @@ export class InteractiveMode {
             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 `${APP_NAME} works best with csi-u, but tmux extended-keys-format is xterm. Add \`set -g extended-keys-format csi-u\` to ~/.tmux.conf and restart tmux.`;
         }
         return undefined;
     }
@@ -657,32 +917,17 @@ export class InteractiveMode {
         const changelogPath = getChangelogPath();
         const entries = parseChangelog(changelogPath);
         if (!lastVersion) {
-            // Fresh install - record the version, send telemetry, don't show changelog
+            // Fresh install - record the version, don't show changelog
             this.settingsManager.setLastChangelogVersion(VERSION);
-            this.reportInstallTelemetry(VERSION);
             return undefined;
         }
         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 newEntries.map((e) => normalizeChangelogLinks(e.content, e)).join("\n\n");
         }
         return undefined;
     }
-    reportInstallTelemetry(version) {
-        if (process.env.PI_OFFLINE) {
-            return;
-        }
-        if (!isInstallTelemetryEnabled(this.settingsManager)) {
-            return;
-        }
-        void fetch(`https://pi.dev/install?version=${encodeURIComponent(version)}`, {
-            signal: AbortSignal.timeout(5000),
-        })
-            .then(() => undefined)
-            .catch(() => undefined);
-    }
     getMarkdownThemeWithSettings() {
         return {
             ...getMarkdownTheme(),
@@ -709,13 +954,9 @@ export class InteractiveMode {
     formatContextPath(p) {
         const cwd = path.resolve(this.sessionManager.getCwd());
         const absolutePath = path.isAbsolute(p) ? path.resolve(p) : path.resolve(cwd, p);
-        const relativePath = path.relative(cwd, absolutePath);
-        const isInsideCwd = relativePath === "" ||
-            (!relativePath.startsWith("..") &&
-                !relativePath.startsWith(`..${path.sep}`) &&
-                !path.isAbsolute(relativePath));
-        if (isInsideCwd) {
-            return relativePath || ".";
+        const relativePath = getCwdRelativePath(absolutePath, cwd);
+        if (relativePath !== undefined) {
+            return relativePath;
         }
         return this.formatDisplayPath(absolutePath);
     }
@@ -726,8 +967,15 @@ export class InteractiveMode {
      * Get a short path relative to the package root for display.
      */
     getShortPath(fullPath, sourceInfo) {
+        const normalizedFullPath = fullPath.replace(/\\/g, "/");
         const baseDir = sourceInfo?.baseDir;
         if (baseDir && this.isPackageSource(sourceInfo)) {
+            const normalizedBaseDir = baseDir.replace(/\\/g, "/");
+            const npmRootMatch = normalizedBaseDir.match(/^(.*\/node_modules)\/(@?[^/]+(?:\/[^/]+)?)$/);
+            // If fullPath is under the same node_modules root as baseDir, preserve that relative topology.
+            if (npmRootMatch?.[1] && normalizedFullPath.startsWith(`${npmRootMatch[1]}/`)) {
+                return path.posix.relative(normalizedBaseDir, normalizedFullPath);
+            }
             const relativePath = path.relative(path.resolve(baseDir), path.resolve(fullPath));
             if (relativePath &&
                 relativePath !== "." &&
@@ -738,11 +986,11 @@ export class InteractiveMode {
             }
         }
         const source = sourceInfo?.source ?? "";
-        const npmMatch = fullPath.match(/node_modules\/(@?[^/]+(?:\/[^/]+)?)\/(.*)/);
+        const npmMatch = normalizedFullPath.match(/node_modules\/(@?[^/]+(?:\/[^/]+)?)\/(.*)/);
         if (npmMatch && source.startsWith("npm:")) {
             return npmMatch[2];
         }
-        const gitMatch = fullPath.match(/git\/[^/]+\/[^/]+\/(.*)/);
+        const gitMatch = normalizedFullPath.match(/git\/[^/]+\/[^/]+\/(.*)/);
         if (gitMatch && source.startsWith("git:")) {
             return gitMatch[1];
         }
@@ -974,6 +1222,8 @@ export class InteractiveMode {
         return lines.join("\n");
     }
     showLoadedResources(options) {
+        // Resource rendering is idempotent; chat clears no longer clear this separate container.
+        this.loadedResourcesContainer.clear();
         const showListing = options?.force || this.options.verbose || !this.settingsManager.getQuietStartup();
         const showDiagnostics = showListing || options?.showDiagnosticsWhenQuiet === true;
         if (!showListing && !showDiagnostics) {
@@ -989,14 +1239,17 @@ export class InteractiveMode {
         };
         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));
+            this.loadedResourcesContainer.addChild(section);
+            this.loadedResourcesContainer.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) => ({
+            this.session.resourceLoader
+                .getExtensions()
+                .extensions.filter((extension) => !extension.hidden)
+                .map((extension) => ({
                 path: extension.path,
                 sourceInfo: extension.sourceInfo,
             }));
@@ -1022,9 +1275,14 @@ export class InteractiveMode {
             }
         }
         if (showListing) {
-            const contextFiles = this.session.resourceLoader.getAgentsFiles().agentsFiles;
+            const systemPromptSource = this.session.resourceLoader.getSystemPromptSource();
+            const contextFiles = [
+                ...(systemPromptSource ? [systemPromptSource] : []),
+                ...this.session.resourceLoader.getAppendSystemPromptSources(),
+                ...this.session.resourceLoader.getAgentsFiles().agentsFiles,
+            ];
             if (contextFiles.length > 0) {
-                this.chatContainer.addChild(new Spacer(1));
+                this.loadedResourcesContainer.addChild(new Spacer(1));
                 const contextList = contextFiles
                     .map((f) => theme.fg("dim", `  ${this.formatDisplayPath(f.path)}`))
                     .join("\n");
@@ -1087,14 +1345,14 @@ export class InteractiveMode {
             const skillDiagnostics = skillsResult.diagnostics;
             if (skillDiagnostics.length > 0) {
                 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));
+                this.loadedResourcesContainer.addChild(new Text(`${theme.fg("warning", "[Skill conflicts]")}\n${warningLines}`, 0, 0));
+                this.loadedResourcesContainer.addChild(new Spacer(1));
             }
             const promptDiagnostics = promptsResult.diagnostics;
             if (promptDiagnostics.length > 0) {
                 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));
+                this.loadedResourcesContainer.addChild(new Text(`${theme.fg("warning", "[Prompt conflicts]")}\n${warningLines}`, 0, 0));
+                this.loadedResourcesContainer.addChild(new Spacer(1));
             }
             const extensionDiagnostics = [];
             const extensionErrors = this.session.resourceLoader.getExtensions().errors;
@@ -1110,14 +1368,14 @@ export class InteractiveMode {
             extensionDiagnostics.push(...shortcutDiagnostics);
             if (extensionDiagnostics.length > 0) {
                 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));
+                this.loadedResourcesContainer.addChild(new Text(`${theme.fg("warning", "[Extension issues]")}\n${warningLines}`, 0, 0));
+                this.loadedResourcesContainer.addChild(new Spacer(1));
             }
             const themeDiagnostics = themesResult.diagnostics;
             if (themeDiagnostics.length > 0) {
                 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));
+                this.loadedResourcesContainer.addChild(new Text(`${theme.fg("warning", "[Theme conflicts]")}\n${warningLines}`, 0, 0));
+                this.loadedResourcesContainer.addChild(new Spacer(1));
             }
         }
     }
@@ -1128,21 +1386,16 @@ export class InteractiveMode {
         const uiContext = this.createExtensionUIContext();
         await this.session.bindExtensions({
             uiContext,
+            mode: "tui",
+            abortHandler: () => {
+                this.restoreQueuedMessagesToEditor({ abort: true });
+            },
             commandContextActions: {
-                waitForIdle: () => this.session.agent.waitForIdle(),
+                waitForIdle: () => this.session.waitForIdle(),
                 newSession: async (options) => {
-                    if (this.loadingAnimation) {
-                        this.loadingAnimation.stop();
-                        this.loadingAnimation = undefined;
-                    }
-                    this.statusContainer.clear();
+                    this.clearStatusIndicator();
                     try {
-                        const result = await this.runtimeHost.newSession(options);
-                        if (!result.cancelled) {
-                            this.renderCurrentSessionState();
-                            this.ui.requestRender();
-                        }
-                        return result;
+                        return await this.runtimeHost.newSession(options);
                     }
                     catch (error) {
                         return this.handleFatalRuntimeError("Failed to create session", error);
@@ -1152,7 +1405,6 @@ export class InteractiveMode {
                     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");
                         }
@@ -1190,7 +1442,7 @@ export class InteractiveMode {
             },
             shutdownHandler: () => {
                 this.shutdownRequested = true;
-                if (!this.session.isStreaming) {
+                if (this.session.isIdle) {
                     void this.shutdown();
                 }
             },
@@ -1205,13 +1457,23 @@ export class InteractiveMode {
         this.showLoadedResources({ force: false, showDiagnosticsWhenQuiet: true });
         this.showStartupNoticesIfNeeded();
     }
+    applyFullscreenScrollbarSetting() {
+        this.transcriptScrollView?.setScrollbar(this.settingsManager.getFullscreenScrollbar());
+    }
     applyRuntimeSettings() {
+        configureHttpDispatcher(this.settingsManager.getHttpIdleTimeoutMs());
+        this.applyFullscreenScrollbarSetting();
         this.footer.setSession(this.session);
         this.footer.setAutoCompactEnabled(this.session.autoCompactionEnabled);
         this.footerDataProvider.setCwd(this.sessionManager.getCwd());
         this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
+        this.outputPad = this.settingsManager.getOutputPad();
         this.ui.setShowHardwareCursor(this.settingsManager.getShowHardwareCursor());
-        this.ui.setClearOnShrink(this.settingsManager.getClearOnShrink());
+        const clearOnShrink = this.settingsManager.getClearOnShrink();
+        this.ui.setClearOnShrink(clearOnShrink);
+        if (!clearOnShrink && !this.activeStatusIndicator) {
+            this.statusContainer.clear();
+        }
         const editorPaddingX = this.settingsManager.getEditorPaddingX();
         const autocompleteMaxVisible = this.settingsManager.getAutocompleteMaxVisible();
         this.defaultEditor.setPaddingX(editorPaddingX);
@@ -1221,12 +1483,22 @@ export class InteractiveMode {
             this.editor.setAutocompleteMaxVisible?.(autocompleteMaxVisible);
         }
     }
-    async rebindCurrentSession() {
+    async rebindCurrentSession(options = {}) {
+        const session = this.session;
         this.unsubscribe?.();
         this.unsubscribe = undefined;
         this.applyRuntimeSettings();
+        if (options.renderBeforeBind) {
+            this.renderCurrentSessionState();
+            this.subscribeToAgent();
+        }
         await this.bindCurrentSessionExtensions();
-        this.subscribeToAgent();
+        if (this.session !== session) {
+            return;
+        }
+        if (!options.renderBeforeBind) {
+            this.subscribeToAgent();
+        }
         await this.updateAvailableProviderCount();
         this.updateEditorBorderColor();
         this.updateTerminalTitle();
@@ -1235,10 +1507,11 @@ export class InteractiveMode {
         const message = error instanceof Error ? error.message : String(error);
         this.showError(`${prefix}: ${message}`);
         stopThemeWatcher();
-        this.stop();
+        this.stop("transcript");
         process.exit(1);
     }
     renderCurrentSessionState() {
+        this.loadedResourcesContainer.clear();
         this.chatContainer.clear();
         this.pendingMessagesContainer.clear();
         this.compactionQueuedMessages = [];
@@ -1253,6 +1526,9 @@ export class InteractiveMode {
     getRegisteredToolDefinition(toolName) {
         return this.session.getToolDefinition(toolName);
     }
+    getMarkdownTransformers() {
+        return [this.mermaidMarkdownTransformer, ...this.session.extensionRunner.getMarkdownTransformers()];
+    }
     /**
      * Set up keyboard shortcuts registered by extensions.
      */
@@ -1263,14 +1539,20 @@ export class InteractiveMode {
         // Create a context for shortcut handlers
         const createContext = () => ({
             ui: this.createExtensionUIContext(),
+            mode: "tui",
             hasUI: true,
             cwd: this.sessionManager.getCwd(),
             sessionManager: this.sessionManager,
-            modelRegistry: this.session.modelRegistry,
+            modelRegistry: extensionRunner.getModelRegistry(),
             model: this.session.model,
-            isIdle: () => !this.session.isStreaming,
+            scopedModels: this.session.scopedModels,
+            thinkingLevel: this.session.thinkingLevel,
+            isIdle: () => this.session.isIdle,
+            isProjectTrusted: () => this.settingsManager.isProjectTrusted(),
             signal: this.session.agent.signal,
-            abort: () => this.session.abort(),
+            abort: () => {
+                this.restoreQueuedMessagesToEditor({ abort: true });
+            },
             hasPendingMessages: () => this.session.pendingMessageCount > 0,
             shutdown: () => {
                 this.shutdownRequested = true;
@@ -1312,9 +1594,41 @@ export class InteractiveMode {
         this.footerDataProvider.setExtensionStatus(key, text);
         this.ui.requestRender();
     }
+    showStatusIndicator(indicator) {
+        this.activeStatusIndicator?.dispose();
+        this.activeStatusIndicator = indicator;
+        this.statusContainer.clear();
+        this.statusContainer.addChild(indicator);
+    }
+    clearStatusIndicator(kind) {
+        if (kind && this.activeStatusIndicator?.kind !== kind) {
+            return;
+        }
+        const hadActiveStatusIndicator = this.activeStatusIndicator !== undefined;
+        this.activeStatusIndicator?.dispose();
+        this.activeStatusIndicator = undefined;
+        this.statusContainer.clear();
+        if (hadActiveStatusIndicator && this.options.tuiMode === "regular" && this.ui.getClearOnShrink()) {
+            this.statusContainer.addChild(this.idleStatus);
+        }
+    }
+    setWorkingVisible(visible) {
+        this.workingVisible = visible;
+        if (!visible) {
+            this.clearStatusIndicator("working");
+            this.ui.requestRender();
+            return;
+        }
+        if (this.session.isStreaming && this.activeStatusIndicator?.kind !== "working") {
+            this.showStatusIndicator(new WorkingStatusIndicator(this.ui, this.workingMessage ?? this.defaultWorkingMessage, this.workingIndicatorOptions));
+        }
+        this.ui.requestRender();
+    }
     setWorkingIndicator(options) {
         this.workingIndicatorOptions = options;
-        this.loadingAnimation?.setIndicator(options);
+        if (this.activeStatusIndicator?.kind === "working") {
+            this.activeStatusIndicator.setIndicator(options);
+        }
         this.ui.requestRender();
     }
     setHiddenThinkingLabel(label) {
@@ -1400,9 +1714,10 @@ export class InteractiveMode {
         this.defaultEditor.onExtensionShortcut = undefined;
         this.updateTerminalTitle();
         this.workingMessage = undefined;
+        this.workingVisible = true;
         this.setWorkingIndicator();
-        if (this.loadingAnimation) {
-            this.loadingAnimation.setMessage(`${this.defaultWorkingMessage} (${keyText("app.interrupt")} to interrupt)`);
+        if (this.activeStatusIndicator?.kind === "working") {
+            this.activeStatusIndicator.setMessage(`${this.defaultWorkingMessage} (${keyText("app.interrupt")} to interrupt)`);
         }
         this.setHiddenThinkingLabel();
     }
@@ -1441,22 +1756,16 @@ export class InteractiveMode {
         if (this.customFooter?.dispose) {
             this.customFooter.dispose();
         }
-        // Remove current footer from UI
-        if (this.customFooter) {
-            this.ui.removeChild(this.customFooter);
-        }
-        else {
-            this.ui.removeChild(this.footer);
-        }
+        this.footerContainer.clear();
         if (factory) {
             // Create and add custom footer, passing the data provider
             this.customFooter = factory(this.ui, theme, this.footerDataProvider);
-            this.ui.addChild(this.customFooter);
+            this.footerContainer.addChild(this.customFooter);
         }
         else {
             // Restore built-in footer
             this.customFooter = undefined;
-            this.ui.addChild(this.footer);
+            this.footerContainer.addChild(this.footer);
         }
         this.ui.requestRender();
     }
@@ -1502,22 +1811,41 @@ export class InteractiveMode {
         this.ui.requestRender();
     }
     addExtensionTerminalInputListener(handler) {
-        const unsubscribe = this.ui.addInputListener(handler);
-        this.extensionTerminalInputUnsubscribers.add(unsubscribe);
+        const subscription = { handler, unsubscribe: this.ui.addInputListener(handler) };
+        this.extensionTerminalInputSubscriptions.add(subscription);
         return () => {
-            unsubscribe();
-            this.extensionTerminalInputUnsubscribers.delete(unsubscribe);
+            subscription.unsubscribe();
+            this.extensionTerminalInputSubscriptions.delete(subscription);
         };
     }
-    clearExtensionTerminalInputListeners() {
-        for (const unsubscribe of this.extensionTerminalInputUnsubscribers) {
-            unsubscribe();
+    rebindExtensionTerminalInputListeners() {
+        for (const subscription of this.extensionTerminalInputSubscriptions) {
+            subscription.unsubscribe();
+            subscription.unsubscribe = this.ui.addInputListener(subscription.handler);
         }
-        this.extensionTerminalInputUnsubscribers.clear();
+    }
+    clearExtensionTerminalInputListeners() {
+        for (const subscription of this.extensionTerminalInputSubscriptions)
+            subscription.unsubscribe();
+        this.extensionTerminalInputSubscriptions.clear();
     }
     /**
      * Create the ExtensionUIContext for extensions.
      */
+    createProjectTrustContext(cwd) {
+        const ui = this.createExtensionUIContext();
+        return {
+            cwd,
+            mode: "tui",
+            hasUI: true,
+            ui: {
+                select: ui.select,
+                confirm: ui.confirm,
+                input: ui.input,
+                notify: ui.notify,
+            },
+        };
+    }
     createExtensionUIContext() {
         return {
             select: (title, options, opts) => this.showExtensionSelector(title, options, opts),
@@ -1528,15 +1856,11 @@ export class InteractiveMode {
             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} (${keyText("app.interrupt")} to interrupt)`);
-                    }
+                if (this.activeStatusIndicator?.kind === "working") {
+                    this.activeStatusIndicator.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),
@@ -1553,6 +1877,7 @@ export class InteractiveMode {
                 this.setupAutocompleteProvider();
             },
             setEditorComponent: (factory) => this.setCustomEditorComponent(factory),
+            getEditorComponent: () => this.editorComponentFactory,
             get theme() {
                 return theme;
             },
@@ -1560,16 +1885,13 @@ export class InteractiveMode {
             getTheme: (name) => getThemeByName(name),
             setTheme: (themeOrName) => {
                 if (themeOrName instanceof Theme) {
-                    setThemeInstance(themeOrName);
-                    this.ui.requestRender();
-                    return { success: true };
+                    return this.themeController.setThemeInstance(themeOrName);
                 }
-                const result = setTheme(themeOrName, true);
+                const result = this.themeController.setThemeName(themeOrName);
                 if (result.success) {
                     if (this.settingsManager.getTheme() !== themeOrName) {
                         this.settingsManager.setTheme(themeOrName);
                     }
-                    this.ui.requestRender();
                 }
                 return result;
             },
@@ -1599,7 +1921,8 @@ export class InteractiveMode {
                 opts?.signal?.removeEventListener("abort", onAbort);
                 this.hideExtensionSelector();
                 resolve(undefined);
-            }, { tui: this.ui, timeout: opts?.timeout });
+            }, { tui: this.ui, timeout: opts?.timeout, onToggleToolsExpanded: () => this.toggleToolOutputExpansion() });
+            this.disposeActiveSelector();
             this.editorContainer.clear();
             this.editorContainer.addChild(this.extensionSelector);
             this.ui.setFocus(this.extensionSelector);
@@ -1651,6 +1974,7 @@ export class InteractiveMode {
                 this.hideExtensionInput();
                 resolve(undefined);
             }, { tui: this.ui, timeout: opts?.timeout });
+            this.disposeActiveSelector();
             this.editorContainer.clear();
             this.editorContainer.addChild(this.extensionInput);
             this.ui.setFocus(this.extensionInput);
@@ -1679,7 +2003,8 @@ export class InteractiveMode {
             }, () => {
                 this.hideExtensionEditor();
                 resolve(undefined);
-            });
+            }, undefined, this.settingsManager.getExternalEditorCommand());
+            this.disposeActiveSelector();
             this.editorContainer.clear();
             this.editorContainer.addChild(this.extensionEditor);
             this.ui.setFocus(this.extensionEditor);
@@ -1701,8 +2026,10 @@ 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.disposeActiveSelector();
         this.editorContainer.clear();
         if (factory) {
             // Create the custom editor with tui, theme, and keybindings
@@ -1719,6 +2046,9 @@ export class InteractiveMode {
             if (newEditor.setPaddingX !== undefined) {
                 newEditor.setPaddingX(this.defaultEditor.getPaddingX());
             }
+            if (newEditor.setAutocompleteMaxVisible !== undefined) {
+                newEditor.setAutocompleteMaxVisible(this.defaultEditor.getAutocompleteMaxVisible());
+            }
             // Set autocomplete if supported
             if (newEditor.setAutocompleteProvider && this.autocompleteProvider) {
                 newEditor.setAutocompleteProvider(this.autocompleteProvider);
@@ -1823,6 +2153,7 @@ export class InteractiveMode {
                     options?.onHandle?.(handle);
                 }
                 else {
+                    this.disposeActiveSelector();
                     this.editorContainer.clear();
                     this.editorContainer.addChild(component);
                     this.ui.setFocus(component);
@@ -1865,7 +2196,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) {
@@ -1908,7 +2239,8 @@ export class InteractiveMode {
         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.editor.external", () => void this.handleOpenExternalEditor());
+        this.defaultEditor.onAction("app.message.copy", () => void this.handleCopyCommand({ flashConfirmation: true }));
         this.defaultEditor.onAction("app.message.followUp", () => this.handleFollowUp());
         this.defaultEditor.onAction("app.message.dequeue", () => this.handleDequeue());
         this.defaultEditor.onAction("app.session.new", () => this.handleClearCommand());
@@ -1922,31 +2254,55 @@ export class InteractiveMode {
                 this.updateEditorBorderColor();
             }
         };
-        // Handle clipboard image paste (triggered on Ctrl+V)
+        // Handle clipboard paste (triggered on Ctrl+V). Images are attached by path;
+        // otherwise, paste plain text from the system clipboard.
         this.defaultEditor.onPasteImage = () => {
-            this.handleClipboardImagePaste();
+            void this.handleClipboardPaste();
         };
     }
-    async handleClipboardImagePaste() {
+    async handleRightClickPaste() {
+        const target = this.renderer.getFocusedComponent();
+        const handleInput = target?.handleInput;
+        if (!target || !handleInput)
+            return;
+        try {
+            const text = await readClipboardText();
+            if (!text || this.renderer.getFocusedComponent() !== target)
+                return;
+            handleInput.call(target, `\x1b[200~${text}\x1b[201~`);
+            this.ui.requestRender();
+        }
+        catch {
+            // Silently ignore clipboard errors (may not have permission, etc.)
+        }
+    }
+    async handleClipboardPaste() {
         try {
             const image = await readClipboardImage();
-            if (!image) {
+            if (image) {
+                const tmpDir = os.tmpdir();
+                const ext = extensionForImageMimeType(image.mimeType) ?? "png";
+                const fileName = `mcpi-clipboard-${crypto.randomUUID()}.${ext}`;
+                const filePath = path.join(tmpDir, fileName);
+                fs.writeFileSync(filePath, Buffer.from(image.bytes));
+                this.editor.insertTextAtCursor?.(filePath);
+                this.ui.requestRender();
                 return;
             }
-            // Write to temp file
-            const tmpDir = os.tmpdir();
-            const ext = extensionForImageMimeType(image.mimeType) ?? "png";
-            const fileName = `pi-clipboard-${crypto.randomUUID()}.${ext}`;
-            const filePath = path.join(tmpDir, fileName);
-            fs.writeFileSync(filePath, Buffer.from(image.bytes));
-            // Insert file path directly
-            this.editor.insertTextAtCursor?.(filePath);
-            this.ui.requestRender();
+            const text = await readClipboardText();
+            if (text) {
+                this.editor.insertTextAtCursor?.(text);
+                this.ui.requestRender();
+            }
         }
         catch {
             // Silently ignore clipboard errors (may not have permission, etc.)
         }
     }
+    handleStartupSubmit(text) {
+        this.editor.setText(text);
+        this.showStatus("Startup is still in progress");
+    }
     setupEditorSubmitHandler() {
         this.defaultEditor.onSubmit = async (text) => {
             text = text.trim();
@@ -2024,9 +2380,15 @@ export class InteractiveMode {
                 this.editor.setText("");
                 return;
             }
-            if (text === "/login") {
-                this.showOAuthSelector("login");
+            if (text === "/trust") {
+                this.showTrustSelector();
+                this.editor.setText("");
+                return;
+            }
+            if (text === "/login" || text.startsWith("/login ")) {
+                const providerRef = text.startsWith("/login ") ? text.slice(7).trim() : undefined;
                 this.editor.setText("");
+                await this.handleLoginCommand(providerRef);
                 return;
             }
             if (text === "/logout") {
@@ -2060,11 +2422,6 @@ export class InteractiveMode {
                 this.editor.setText("");
                 return;
             }
-            if (text === "/dementedelves") {
-                this.handleDementedDelves();
-                this.editor.setText("");
-                return;
-            }
             if (text === "/resume") {
                 this.showSessionSelector();
                 this.editor.setText("");
@@ -2120,6 +2477,9 @@ export class InteractiveMode {
             if (this.onInputCallback) {
                 this.onInputCallback(text);
             }
+            else {
+                this.pendingUserInputs.push(text);
+            }
             this.editor.addToHistory?.(text);
         };
     }
@@ -2135,6 +2495,7 @@ export class InteractiveMode {
         this.footer.invalidate();
         switch (event.type) {
             case "agent_start":
+                this.pendingTools.clear();
                 if (this.settingsManager.getShowTerminalProgress()) {
                     this.ui.terminal.setProgress(true);
                 }
@@ -2144,26 +2505,33 @@ export class InteractiveMode {
                     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.workingVisible) {
+                    this.showStatusIndicator(new WorkingStatusIndicator(this.ui, this.workingMessage ?? this.defaultWorkingMessage, this.workingIndicatorOptions));
                 }
-                if (this.loadingAnimation) {
-                    this.loadingAnimation.stop();
+                else {
+                    this.clearStatusIndicator();
                 }
-                this.statusContainer.clear();
-                this.loadingAnimation = new Loader(this.ui, (spinner) => theme.fg("accent", spinner), (text) => theme.fg("muted", text), this.workingMessage || this.defaultWorkingMessage, this.workingIndicatorOptions);
-                this.statusContainer.addChild(this.loadingAnimation);
                 this.ui.requestRender();
                 break;
             case "queue_update":
                 this.updatePendingMessagesDisplay();
                 this.ui.requestRender();
                 break;
+            case "entry_appended":
+                if (event.entry.type === "custom") {
+                    this.addCustomEntryToChat(event.entry);
+                    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);
@@ -2175,17 +2543,17 @@ export class InteractiveMode {
                     this.ui.requestRender();
                 }
                 else if (event.message.role === "assistant") {
-                    this.streamingComponent = new AssistantMessageComponent(undefined, this.hideThinkingBlock, this.getMarkdownThemeWithSettings(), this.hiddenThinkingLabel);
+                    this.streamingComponent = new AssistantMessageComponent(undefined, this.hideThinkingBlock, this.getMarkdownThemeWithSettings(), this.hiddenThinkingLabel, this.outputPad, this.getMarkdownTransformers());
                     this.streamingMessage = event.message;
                     this.chatContainer.addChild(this.streamingComponent);
-                    this.streamingComponent.updateContent(this.streamingMessage);
+                    this.streamingComponent.updateContent(this.streamingMessage, true);
                     this.ui.requestRender();
                 }
                 break;
             case "message_update":
                 if (this.streamingComponent && event.message.role === "assistant") {
                     this.streamingMessage = event.message;
-                    this.streamingComponent.updateContent(this.streamingMessage);
+                    this.streamingComponent.updateContent(this.streamingMessage, true);
                     for (const content of this.streamingMessage.content) {
                         if (content.type === "toolCall") {
                             if (!this.pendingTools.has(content.id)) {
@@ -2222,7 +2590,7 @@ export class InteractiveMode {
                                 : "Operation aborted";
                         this.streamingMessage.errorMessage = errorMessage;
                     }
-                    this.streamingComponent.updateContent(this.streamingMessage);
+                    this.streamingComponent.updateContent(this.streamingMessage, false);
                     if (this.streamingMessage.stopReason === "aborted" || this.streamingMessage.stopReason === "error") {
                         if (!errorMessage) {
                             errorMessage = this.streamingMessage.errorMessage || "Error";
@@ -2240,6 +2608,7 @@ export class InteractiveMode {
                         for (const [, component] of this.pendingTools.entries()) {
                             component.setArgsComplete();
                         }
+                        this.maybeShowCacheMissNotice(this.streamingMessage);
                     }
                     this.streamingComponent = undefined;
                     this.streamingMessage = undefined;
@@ -2247,6 +2616,9 @@ export class InteractiveMode {
                 }
                 this.ui.requestRender();
                 break;
+            case "bash_execution_update":
+                // The bash execution callback handles TUI output rendering.
+                break;
             case "tool_execution_start": {
                 let component = this.pendingTools.get(event.toolCallId);
                 if (!component) {
@@ -2283,20 +2655,18 @@ export class InteractiveMode {
                 if (this.settingsManager.getShowTerminalProgress()) {
                     this.ui.terminal.setProgress(false);
                 }
-                if (this.loadingAnimation) {
-                    this.loadingAnimation.stop();
-                    this.loadingAnimation = undefined;
-                    this.statusContainer.clear();
-                }
+                this.clearStatusIndicator("working");
                 if (this.streamingComponent) {
                     this.chatContainer.removeChild(this.streamingComponent);
                     this.streamingComponent = undefined;
                     this.streamingMessage = undefined;
                 }
                 this.pendingTools.clear();
-                await this.checkShutdownRequested();
                 this.ui.requestRender();
                 break;
+            case "agent_settled":
+                await this.checkShutdownRequested();
+                break;
             case "compaction_start": {
                 if (this.settingsManager.getShowTerminalProgress()) {
                     this.ui.terminal.setProgress(true);
@@ -2306,13 +2676,7 @@ export class InteractiveMode {
                 this.defaultEditor.onEscape = () => {
                     this.session.abortCompaction();
                 };
-                this.statusContainer.clear();
-                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.showStatusIndicator(new CompactionStatusIndicator(this.ui, event.reason));
                 this.ui.requestRender();
                 break;
             }
@@ -2324,11 +2688,7 @@ export class InteractiveMode {
                     this.defaultEditor.onEscape = this.autoCompactionEscapeHandler;
                     this.autoCompactionEscapeHandler = undefined;
                 }
-                if (this.autoCompactionLoader) {
-                    this.autoCompactionLoader.stop();
-                    this.autoCompactionLoader = undefined;
-                    this.statusContainer.clear();
-                }
+                this.clearStatusIndicator("compaction");
                 if (event.aborted) {
                     if (event.reason === "manual") {
                         this.showError("Compaction cancelled");
@@ -2362,17 +2722,7 @@ export class InteractiveMode {
                 this.defaultEditor.onEscape = () => {
                     this.session.abortRetry();
                 };
-                // Show retry indicator
-                this.statusContainer.clear();
-                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.showStatusIndicator(new RetryStatusIndicator(this.ui, event.attempt, event.maxAttempts, event.delayMs));
                 this.ui.requestRender();
                 break;
             }
@@ -2382,16 +2732,7 @@ 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();
-                    this.retryLoader = undefined;
-                    this.statusContainer.clear();
-                }
+                this.clearStatusIndicator("retry");
                 // Show error only on final failure (success shows normal response)
                 if (!event.success) {
                     this.showError(`Retry failed after ${event.attempt} attempts: ${event.finalError || "Unknown error"}`);
@@ -2399,6 +2740,28 @@ export class InteractiveMode {
                 this.ui.requestRender();
                 break;
             }
+            case "summarization_retry_scheduled": {
+                this.showError(event.errorMessage);
+                this.showStatusIndicator(new RetryStatusIndicator(this.ui, event.attempt, event.maxAttempts, event.delayMs));
+                this.ui.requestRender();
+                break;
+            }
+            case "summarization_retry_attempt_start": {
+                this.clearStatusIndicator("retry");
+                if (event.source === "branchSummary") {
+                    this.showStatusIndicator(new BranchSummaryStatusIndicator(this.ui));
+                }
+                else {
+                    this.showStatusIndicator(new CompactionStatusIndicator(this.ui, event.reason));
+                }
+                this.ui.requestRender();
+                break;
+            }
+            case "summarization_retry_finished": {
+                this.clearStatusIndicator("retry");
+                this.ui.requestRender();
+                break;
+            }
         }
     }
     /** Extract text content from a user message */
@@ -2410,6 +2773,19 @@ export class InteractiveMode {
             : message.content.filter((c) => c.type === "text");
         return textBlocks.map((c) => c.text).join("");
     }
+    /** Show a managed-tool status update in the chat. */
+    showManagedToolStatus(status) {
+        if (!this.managedToolStatusStarted) {
+            this.chatContainer.addChild(new Spacer(1));
+            this.managedToolStatusStarted = true;
+        }
+        const message = status.type === "warning" ? `Warning: ${status.message}` : status.message;
+        const color = status.type === "warning" ? "warning" : "dim";
+        this.chatContainer.addChild(new Text(theme.fg(color, message), 1, 0));
+        this.lastStatusSpacer = undefined;
+        this.lastStatusText = undefined;
+        this.ui.requestRender();
+    }
     /**
      * Show a status message in the chat.
      *
@@ -2433,6 +2809,25 @@ export class InteractiveMode {
         this.lastStatusText = text;
         this.ui.requestRender();
     }
+    addCustomEntryToChat(entry) {
+        const renderer = this.session.extensionRunner.getEntryRenderer(entry.customType);
+        if (!renderer) {
+            return;
+        }
+        const component = new CustomEntryComponent(entry, renderer);
+        component.setExpanded(this.toolOutputExpanded);
+        if (!component.hasContent()) {
+            return;
+        }
+        if (this.streamingComponent) {
+            const streamingIndex = this.chatContainer.children.indexOf(this.streamingComponent);
+            if (streamingIndex >= 0) {
+                this.chatContainer.children.splice(streamingIndex, 0, component);
+                return;
+            }
+        }
+        this.chatContainer.addChild(component);
+    }
     addMessageToChat(message, options) {
         switch (message.role) {
             case "bashExecution": {
@@ -2447,7 +2842,7 @@ export class InteractiveMode {
             case "custom": {
                 if (message.display) {
                     const renderer = this.session.extensionRunner.getMessageRenderer(message.customType);
-                    const component = new CustomMessageComponent(message, renderer, this.getMarkdownThemeWithSettings());
+                    const component = new CustomMessageComponent(message, renderer, this.getMarkdownThemeWithSettings(), this.outputPad);
                     component.setExpanded(this.toolOutputExpanded);
                     this.chatContainer.addChild(component);
                 }
@@ -2481,12 +2876,13 @@ export class InteractiveMode {
                         this.chatContainer.addChild(component);
                         // Render user message separately if present
                         if (skillBlock.userMessage) {
-                            const userComponent = new UserMessageComponent(skillBlock.userMessage, this.getMarkdownThemeWithSettings());
+                            this.chatContainer.addChild(new Spacer(1));
+                            const userComponent = new UserMessageComponent(skillBlock.userMessage, this.getMarkdownThemeWithSettings(), this.outputPad, this.getMarkdownTransformers());
                             this.chatContainer.addChild(userComponent);
                         }
                     }
                     else {
-                        const userComponent = new UserMessageComponent(textContent, this.getMarkdownThemeWithSettings());
+                        const userComponent = new UserMessageComponent(textContent, this.getMarkdownThemeWithSettings(), this.outputPad, this.getMarkdownTransformers());
                         this.chatContainer.addChild(userComponent);
                     }
                     if (options?.populateHistory) {
@@ -2496,7 +2892,7 @@ export class InteractiveMode {
                 break;
             }
             case "assistant": {
-                const assistantComponent = new AssistantMessageComponent(message, this.hideThinkingBlock, this.getMarkdownThemeWithSettings(), this.hiddenThinkingLabel);
+                const assistantComponent = new AssistantMessageComponent(message, this.hideThinkingBlock, this.getMarkdownThemeWithSettings(), this.hiddenThinkingLabel, this.outputPad, this.getMarkdownTransformers());
                 this.chatContainer.addChild(assistantComponent);
                 break;
             }
@@ -2509,19 +2905,24 @@ export class InteractiveMode {
             }
         }
     }
-    /**
-     * Render session context to chat. Used for initial load and rebuild after compaction.
-     * @param sessionContext Session context to render
-     * @param options.updateFooter Update footer state
-     * @param options.populateHistory Add user messages to editor history
-     */
-    renderSessionContext(sessionContext, options = {}) {
+    renderSessionItems(items, options = {}) {
         this.pendingTools.clear();
+        const renderedPendingTools = new Map();
+        // Cache-miss notices are not persisted; re-derive them from the full entry
+        // list and re-inject them after the assistant messages that paid for them.
+        const cacheMisses = this.settingsManager.getShowCacheMissNotices()
+            ? collectCacheMisses(this.sessionManager.getEntries(), this.session.modelRuntime)
+            : new Map();
         if (options.updateFooter) {
             this.footer.invalidate();
             this.updateEditorBorderColor();
         }
-        for (const message of sessionContext.messages) {
+        for (const item of items) {
+            if (isCustomSessionEntry(item)) {
+                this.addCustomEntryToChat(item);
+                continue;
+            }
+            const message = item;
             // Assistant messages need special handling for tool calls
             if (message.role === "assistant") {
                 this.addMessageToChat(message);
@@ -2549,17 +2950,22 @@ export class InteractiveMode {
                             component.updateResult({ content: [{ type: "text", text: errorMessage }], isError: true });
                         }
                         else {
-                            this.pendingTools.set(content.id, component);
+                            renderedPendingTools.set(content.id, component);
                         }
                     }
                 }
+                if (message.stopReason !== "aborted" && message.stopReason !== "error") {
+                    const miss = cacheMisses.get(message);
+                    if (miss)
+                        this.addCacheMissNotice(miss);
+                }
             }
             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 {
@@ -2567,16 +2973,62 @@ export class InteractiveMode {
                 this.addMessageToChat(message, options);
             }
         }
-        this.pendingTools.clear();
+        for (const [toolCallId, component] of renderedPendingTools) {
+            this.pendingTools.set(toolCallId, component);
+        }
         this.ui.requestRender();
     }
+    /**
+     * Render session entries to chat. Used for initial load and rebuild after compaction.
+     * @param entries Compaction-aware session entries to render
+     * @param options.updateFooter Update footer state
+     * @param options.populateHistory Add user messages to editor history
+     */
+    renderSessionEntries(entries, options = {}) {
+        const items = entries.flatMap((entry) => {
+            if (entry.type === "custom") {
+                return [entry];
+            }
+            return sessionEntryToContextMessages(entry);
+        });
+        this.renderSessionItems(items, options);
+    }
+    /**
+     * Show a transcript notice when a completed assistant message paid for a
+     * significant cache miss. Only states observable facts: the miss itself,
+     * a model switch, or an idle gap past the cache TTL.
+     */
+    maybeShowCacheMissNotice(message) {
+        if (!this.settingsManager.getShowCacheMissNotices())
+            return;
+        // Entries don't contain `message` yet: message_end fires before persistence.
+        const miss = detectCacheMiss(this.sessionManager.getEntries(), message, this.session.modelRuntime);
+        if (miss)
+            this.addCacheMissNotice(miss);
+    }
+    addCacheMissNotice(miss) {
+        if (miss.missedTokens < 20_000 && miss.missedCost < 0.1)
+            return;
+        const cost = miss.missedCost >= 0.01 ? ` (~$${miss.missedCost.toFixed(2)})` : "";
+        const reBilled = `${formatTokens(miss.missedTokens)} tokens re-billed${cost}`;
+        let label = "Cache miss";
+        if (miss.modelChanged) {
+            label = "Cache miss after model switch";
+        }
+        else if (miss.idleMs >= CACHE_TTL_MS) {
+            label = `Cache miss after ${Math.round(miss.idleMs / 60_000)}m idle`;
+        }
+        const text = theme.fg("warning", `${label}: ${reBilled}`);
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new Text(text, 1, 0));
+    }
     renderInitialMessages() {
-        // Get aligned messages and entries from session context
-        const context = this.sessionManager.buildSessionContext();
-        this.renderSessionContext(context, {
+        const entries = this.sessionManager.buildContextEntries();
+        this.renderSessionEntries(entries, {
             updateFooter: true,
             populateHistory: true,
         });
+        this.renderProjectTrustWarningIfNeeded();
         // Show compaction info if session was compacted
         const allEntries = this.sessionManager.getEntries();
         const compactionCount = allEntries.filter((e) => e.type === "compaction").length;
@@ -2585,7 +3037,20 @@ export class InteractiveMode {
             this.showStatus(`Session compacted ${times}`);
         }
     }
+    renderProjectTrustWarningIfNeeded() {
+        if (this.settingsManager.isProjectTrusted() || !hasTrustRequiringProjectResources(this.sessionManager.getCwd())) {
+            return;
+        }
+        if (this.chatContainer.children.length > 0) {
+            this.chatContainer.addChild(new Spacer(1));
+        }
+        this.chatContainer.addChild(new Text(theme.fg("warning", `This project is not trusted. Project ${CONFIG_DIR_NAME} resources and packages are ignored. Use /trust to save a trust decision, then restart mcpi.`), 1, 0));
+    }
     async getUserInput() {
+        const queuedInput = this.pendingUserInputs.shift();
+        if (queuedInput !== undefined) {
+            return queuedInput;
+        }
         return new Promise((resolve) => {
             this.onInputCallback = (text) => {
                 this.onInputCallback = undefined;
@@ -2595,8 +3060,7 @@ export class InteractiveMode {
     }
     rebuildChatFromMessages() {
         this.chatContainer.clear();
-        const context = this.sessionManager.buildSessionContext();
-        this.renderSessionContext(context);
+        this.renderSessionEntries(this.sessionManager.buildContextEntries());
     }
     // =========================================================================
     // Key handlers
@@ -2621,20 +3085,84 @@ export class InteractiveMode {
      * repaint the final frame while the process is exiting.
      */
     isShuttingDown = false;
-    async shutdown() {
+    async shutdown(options) {
         if (this.isShuttingDown)
             return;
         this.isShuttingDown = true;
-        this.unregisterSignalHandlers();
+        // Keep signal handlers registered until terminal cleanup has completed.
+        // `signal-exit` checks the listener list during the same SIGTERM/SIGHUP
+        // dispatch and re-sends the signal if only its own listeners remain.
+        if (options?.fromSignal) {
+            // Signal-triggered shutdown (SIGTERM/SIGHUP). Emit extension cleanup
+            // (session_shutdown) BEFORE touching the terminal. Extension teardown
+            // such as removing sockets does not write to the tty, so it must not be
+            // skipped if a later terminal-restore write fails on a dead or stalled
+            // terminal. If the terminal is gone, the restore writes below emit EIO,
+            // which the stdout/stderr error handler turns into emergencyTerminalExit;
+            // the render loop is already idle, so this cannot hot-spin (see #4144).
+            await this.runtimeHost.dispose();
+            this.themeController.disableAutoSync();
+            await this.ui.terminal.drainInput(1000);
+            this.stop();
+            process.exit(0);
+        }
+        // Interactive quit (Ctrl+D, Ctrl+C, /quit, extension shutdown()). Stop the
+        // TUI before emitting shutdown events so extension UI cleanup cannot repaint
+        // the final frame while the process is exiting.
         // Drain any in-flight Kitty key release events before stopping.
         // This prevents escape sequences from leaking to the parent shell over slow SSH.
+        this.themeController.disableAutoSync();
         await this.ui.terminal.drainInput(1000);
         this.stop();
         await this.runtimeHost.dispose();
+        const resumeCommand = formatResumeCommand(this.sessionManager);
+        if (resumeCommand) {
+            process.stdout.write(`${chalk.dim("To resume this session:")} ${resumeCommand}\n`);
+        }
         process.exit(0);
     }
+    emergencyTerminalExit() {
+        this.isShuttingDown = true;
+        this.unregisterSignalHandlers();
+        killTrackedDetachedChildren();
+        // The terminal is gone. Do not run normal shutdown because TUI and
+        // extension cleanup can write restore sequences and re-trigger EIO.
+        process.exit(129);
+    }
     /**
-     * Check if shutdown was requested and perform shutdown if so.
+     * Last-resort handler for uncaught exceptions. The TUI puts stdin into raw
+     * mode and hides the cursor; without this handler, an uncaught throw from
+     * anywhere (e.g. an extension's async `ChildProcess.on("exit")` callback)
+     * tears down the process while leaving the terminal in raw mode with no
+     * cursor, requiring `stty sane && reset` to recover.
+     *
+     * Unlike emergencyTerminalExit, the terminal is still alive here, so we
+     * call ui.stop() to restore cooked mode, the cursor, and disable bracketed
+     * paste / Kitty / modifyOtherKeys sequences.
+     */
+    uncaughtCrash(error) {
+        if (this.isShuttingDown) {
+            process.exit(1);
+        }
+        this.isShuttingDown = true;
+        try {
+            this.unregisterSignalHandlers();
+        }
+        catch { }
+        try {
+            killTrackedDetachedChildren();
+        }
+        catch { }
+        try {
+            this.ui.stop();
+        }
+        catch { }
+        console.error(`${APP_NAME} exiting due to uncaughtException:`);
+        console.error(error);
+        process.exit(1);
+    }
+    /**
+     * Check if shutdown was requested and perform shutdown if so.
      */
     async checkShutdownRequested() {
         if (!this.shutdownRequested)
@@ -2649,12 +3177,32 @@ export class InteractiveMode {
         }
         for (const signal of signals) {
             const handler = () => {
+                // SIGHUP no longer hard-exits: graceful shutdown emits session_shutdown
+                // first, then attempts terminal restore. A genuinely dead terminal
+                // surfaces as an EIO on the restore writes, which the stdout/stderr
+                // error handler converts into emergencyTerminalExit (see #4144, #5080).
                 killTrackedDetachedChildren();
-                void this.shutdown();
+                void this.shutdown({ fromSignal: true });
             };
-            process.on(signal, handler);
+            process.prependListener(signal, handler);
             this.signalCleanupHandlers.push(() => process.off(signal, handler));
         }
+        const terminalErrorHandler = (error) => {
+            if (isDeadTerminalError(error)) {
+                this.emergencyTerminalExit();
+            }
+            throw error;
+        };
+        process.stdout.on("error", terminalErrorHandler);
+        process.stderr.on("error", terminalErrorHandler);
+        this.signalCleanupHandlers.push(() => process.stdout.off("error", terminalErrorHandler));
+        this.signalCleanupHandlers.push(() => process.stderr.off("error", terminalErrorHandler));
+        // Restore the terminal before the process dies on any uncaught throw.
+        // Without this, an unhandled exception from extension code (or anywhere
+        // in mcpi) leaves the terminal in raw mode with no cursor.
+        const uncaughtExceptionHandler = (error) => this.uncaughtCrash(error);
+        process.prependListener("uncaughtException", uncaughtExceptionHandler);
+        this.signalCleanupHandlers.push(() => process.off("uncaughtException", uncaughtExceptionHandler));
     }
     unregisterSignalHandlers() {
         for (const cleanup of this.signalCleanupHandlers) {
@@ -2721,6 +3269,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);
         }
     }
@@ -2777,17 +3326,21 @@ export class InteractiveMode {
         this.setToolsExpanded(!this.toolOutputExpanded);
     }
     setToolsExpanded(expanded) {
+        if (expanded === this.toolOutputExpanded)
+            return;
         this.toolOutputExpanded = expanded;
         const activeHeader = this.customHeader ?? this.builtInHeader;
         if (isExpandable(activeHeader)) {
             activeHeader.setExpanded(expanded);
         }
-        for (const child of this.chatContainer.children) {
-            if (isExpandable(child)) {
-                child.setExpanded(expanded);
+        for (const container of [this.loadedResourcesContainer, this.chatContainer]) {
+            for (const child of container.children) {
+                if (isExpandable(child)) {
+                    child.setExpanded(expanded);
+                }
             }
         }
-        this.ui.requestRender();
+        this.showStatus(`Tool output: ${expanded ? "expanded" : "collapsed"}`);
     }
     toggleThinkingBlockVisibility() {
         this.hideThinkingBlock = !this.hideThinkingBlock;
@@ -2803,45 +3356,21 @@ export class InteractiveMode {
         }
         this.showStatus(`Thinking blocks: ${this.hideThinkingBlock ? "hidden" : "visible"}`);
     }
-    openExternalEditor() {
-        // Determine editor (respect $VISUAL, then $EDITOR)
-        const editorCmd = process.env.VISUAL || process.env.EDITOR;
-        if (!editorCmd) {
-            this.showWarning("No editor configured. Set $VISUAL or $EDITOR environment variable.");
-            return;
-        }
-        const currentText = this.editor.getExpandedText?.() ?? this.editor.getText();
-        const tmpFile = path.join(os.tmpdir(), `pi-editor-${Date.now()}.pi.md`);
+    async handleOpenExternalEditor() {
+        const editorCmd = this.settingsManager.getExternalEditorCommand();
+        const content = this.editor.getExpandedText?.() ?? this.editor.getText();
+        this.ui.stop();
         try {
-            // Write current content to temp file
-            fs.writeFileSync(tmpFile, currentText, "utf-8");
-            // Stop TUI to release terminal
-            this.ui.stop();
-            // Split by space to support editor arguments (e.g., "code --wait")
-            const [editor, ...editorArgs] = editorCmd.split(" ");
-            // Spawn editor synchronously with inherited stdio for interactive editing
-            const result = spawnSync(editor, [...editorArgs, tmpFile], {
-                stdio: "inherit",
-                shell: process.platform === "win32",
+            const result = await editInExternalEditor({
+                command: editorCmd,
+                content,
             });
-            // On successful exit (status 0), replace editor content
-            if (result.status === 0) {
-                const newContent = fs.readFileSync(tmpFile, "utf-8").replace(/\n$/, "");
-                this.editor.setText(newContent);
+            if (result.status === "complete") {
+                this.editor.setText(result.content);
             }
-            // On non-zero exit, keep original text (no action needed)
         }
         finally {
-            // Clean up temp file
-            try {
-                fs.unlinkSync(tmpFile);
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-            // Restart TUI
             this.ui.start();
-            // Force full re-render since external editor uses alternate screen
             this.ui.requestRender(true);
         }
     }
@@ -2854,7 +3383,7 @@ export class InteractiveMode {
     }
     showError(errorMessage) {
         this.chatContainer.addChild(new Spacer(1));
-        this.chatContainer.addChild(new Text(theme.fg("error", `Error: ${errorMessage}`), 1, 0));
+        this.chatContainer.addChild(new Text(theme.fg("error", `Error: ${errorMessage}`), this.outputPad, 0));
         this.ui.requestRender();
     }
     showWarning(warningMessage) {
@@ -2862,19 +3391,23 @@ export class InteractiveMode {
         this.chatContainer.addChild(new Text(theme.fg("warning", `Warning: ${warningMessage}`), 1, 0));
         this.ui.requestRender();
     }
-    showNewVersionNotification(newVersion) {
-        const action = theme.fg("accent", getUpdateInstruction("@sammorrowdrums/mcpi"));
-        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;
+    showNewVersionNotification(release) {
+        const action = theme.fg("accent", `${APP_NAME} update`);
+        const updateInstruction = theme.fg("muted", `New version ${release.version} is available. Run `) + action;
+        const changelogUrl = "https://github.com/SamMorrowDrums/mcpi/releases";
+        const changelogLink = getCapabilities().hyperlinks
+            ? hyperlink(theme.fg("accent", changelogUrl), 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 Text(`${theme.bold(theme.fg("warning", "Update Available"))}\n${updateInstruction}`, 1, 0));
+        this.chatContainer.addChild(new Text(changelogLine, 1, 0));
         this.chatContainer.addChild(new DynamicBorder((text) => theme.fg("warning", text)));
         this.ui.requestRender();
     }
     showPackageUpdateNotification(packages) {
-        const action = theme.fg("accent", `${APP_NAME} update`);
+        const action = theme.fg("accent", `${APP_NAME} update --extensions`);
         const updateInstruction = theme.fg("muted", "Package updates are available. Run ") + action;
         const packageLines = packages.map((pkg) => `- ${pkg}`).join("\n");
         this.chatContainer.addChild(new Spacer(1));
@@ -3016,8 +3549,10 @@ export class InteractiveMode {
             for (const message of preCommands) {
                 await this.session.prompt(message.text);
             }
-            // Send first prompt (starts streaming)
-            const promptPromise = this.session.prompt(firstPrompt.text).catch((error) => {
+            // Start a prompt when idle, or queue it into a run still finishing compaction.
+            const promptPromise = this.session
+                .prompt(firstPrompt.text, { streamingBehavior: firstPrompt.mode })
+                .catch((error) => {
                 restoreQueue(error);
             });
             // Queue remaining messages
@@ -3050,25 +3585,43 @@ export class InteractiveMode {
     // =========================================================================
     // Selectors
     // =========================================================================
+    disposeActiveSelector() {
+        const dispose = this.activeSelectorDispose;
+        this.activeSelectorToken = undefined;
+        this.activeSelectorDispose = undefined;
+        dispose?.();
+    }
     /**
      * Shows a selector component in place of the editor.
      * @param create Factory that receives a `done` callback and returns the component and focus target
      */
     showSelector(create) {
+        const token = {};
+        let dispose;
         const done = () => {
+            dispose?.();
+            if (this.activeSelectorToken !== token)
+                return;
+            this.activeSelectorToken = undefined;
+            this.activeSelectorDispose = undefined;
             this.editorContainer.clear();
             this.editorContainer.addChild(this.editor);
             this.ui.setFocus(this.editor);
         };
-        const { component, focus } = create(done);
+        const created = create(done);
+        dispose = created.dispose;
+        this.disposeActiveSelector();
+        this.activeSelectorToken = token;
+        this.activeSelectorDispose = dispose;
         this.editorContainer.clear();
-        this.editorContainer.addChild(component);
-        this.ui.setFocus(focus);
+        this.editorContainer.addChild(created.component);
+        this.ui.setFocus(created.focus);
         this.ui.requestRender();
     }
     showSettingsSelector() {
         this.showSelector((done) => {
-            const selector = new SettingsSelectorComponent({
+            let selector;
+            selector = new SettingsSelectorComponent({
                 autoCompact: this.session.autoCompactionEnabled,
                 showImages: this.settingsManager.getShowImages(),
                 imageWidthCells: this.settingsManager.getImageWidthCells(),
@@ -3078,21 +3631,31 @@ export class InteractiveMode {
                 steeringMode: this.session.steeringMode,
                 followUpMode: this.session.followUpMode,
                 transport: this.settingsManager.getTransport(),
+                httpIdleTimeoutMs: this.settingsManager.getHttpIdleTimeoutMs(),
                 thinkingLevel: this.session.thinkingLevel,
                 availableThinkingLevels: this.session.getAvailableThinkingLevels(),
-                currentTheme: this.settingsManager.getTheme() || "dark",
+                currentTheme: this.themeController.getThemeSelection() || "dark",
+                terminalTheme: this.themeController.getTerminalTheme(),
                 availableThemes: getAvailableThemes(),
                 hideThinkingBlock: this.hideThinkingBlock,
+                mermaidRenderingMode: this.settingsManager.getMermaidRenderingMode(),
                 collapseChangelog: this.settingsManager.getCollapseChangelog(),
                 enableInstallTelemetry: this.settingsManager.getEnableInstallTelemetry(),
                 doubleEscapeAction: this.settingsManager.getDoubleEscapeAction(),
                 treeFilterMode: this.settingsManager.getTreeFilterMode(),
                 showHardwareCursor: this.settingsManager.getShowHardwareCursor(),
+                showCacheMissNotices: this.settingsManager.getShowCacheMissNotices(),
+                defaultProjectTrust: this.settingsManager.getDefaultProjectTrust(),
                 editorPaddingX: this.settingsManager.getEditorPaddingX(),
+                outputPad: this.settingsManager.getOutputPad(),
                 autocompleteMaxVisible: this.settingsManager.getAutocompleteMaxVisible(),
                 quietStartup: this.settingsManager.getQuietStartup(),
                 clearOnShrink: this.settingsManager.getClearOnShrink(),
                 showTerminalProgress: this.settingsManager.getShowTerminalProgress(),
+                tuiMode: this.ui.mode,
+                fullscreenExitOutput: this.settingsManager.getFullscreenExitOutput(),
+                fullscreenScrollbar: this.settingsManager.getFullscreenScrollbar(),
+                warnings: this.settingsManager.getWarnings(),
             }, {
                 onAutoCompactChange: (enabled) => {
                     this.session.setAutoCompactionEnabled(enabled);
@@ -3134,26 +3697,21 @@ export class InteractiveMode {
                     this.settingsManager.setTransport(transport);
                     this.session.agent.transport = transport;
                 },
+                onHttpIdleTimeoutMsChange: (timeoutMs) => {
+                    this.settingsManager.setHttpIdleTimeoutMs(timeoutMs);
+                    configureHttpDispatcher(timeoutMs);
+                    this.showStatus(`HTTP idle timeout: ${formatHttpIdleTimeoutMs(timeoutMs)}`);
+                },
                 onThinkingLevelChange: (level) => {
                     this.session.setThinkingLevel(level);
                     this.footer.invalidate();
                     this.updateEditorBorderColor();
                 },
-                onThemeChange: (themeName) => {
-                    const result = setTheme(themeName, true);
-                    this.settingsManager.setTheme(themeName);
-                    this.ui.invalidate();
-                    if (!result.success) {
-                        this.showError(`Failed to load theme "${themeName}": ${result.error}\nFell back to dark theme.`);
-                    }
-                },
-                onThemePreview: (themeName) => {
-                    const result = setTheme(themeName, true);
-                    if (result.success) {
-                        this.ui.invalidate();
-                        this.ui.requestRender();
-                    }
+                onThemeChange: (themeSetting) => {
+                    this.settingsManager.setTheme(themeSetting);
+                    void this.themeController.setThemeSetting(themeSetting);
                 },
+                onThemePreview: (themeName) => this.themeController.preview(themeName),
                 onHideThinkingBlockChange: (hidden) => {
                     this.hideThinkingBlock = hidden;
                     this.settingsManager.setHideThinkingBlock(hidden);
@@ -3165,6 +3723,15 @@ export class InteractiveMode {
                     this.chatContainer.clear();
                     this.rebuildChatFromMessages();
                 },
+                onMermaidRenderingModeChange: (mode) => {
+                    this.settingsManager.setMermaidRenderingMode(mode);
+                    this.chatContainer.invalidate();
+                    this.ui.requestRender();
+                },
+                onShowCacheMissNoticesChange: (shown) => {
+                    this.settingsManager.setShowCacheMissNotices(shown);
+                    this.rebuildChatFromMessages();
+                },
                 onCollapseChangelogChange: (collapsed) => {
                     this.settingsManager.setCollapseChangelog(collapsed);
                 },
@@ -3174,6 +3741,9 @@ export class InteractiveMode {
                 onQuietStartupChange: (enabled) => {
                     this.settingsManager.setQuietStartup(enabled);
                 },
+                onDefaultProjectTrustChange: (defaultProjectTrust) => {
+                    this.settingsManager.setDefaultProjectTrust(defaultProjectTrust);
+                },
                 onDoubleEscapeActionChange: (action) => {
                     this.settingsManager.setDoubleEscapeAction(action);
                 },
@@ -3191,6 +3761,25 @@ export class InteractiveMode {
                         this.editor.setPaddingX(padding);
                     }
                 },
+                onOutputPadChange: (padding) => {
+                    this.settingsManager.setOutputPad(padding);
+                    this.outputPad = padding;
+                    if (this.streamingComponent || this.session.isStreaming) {
+                        for (const child of this.chatContainer.children) {
+                            if (child instanceof AssistantMessageComponent ||
+                                child instanceof CustomMessageComponent ||
+                                child instanceof UserMessageComponent) {
+                                child.setOutputPad(padding);
+                            }
+                        }
+                        if (this.streamingComponent) {
+                            this.streamingComponent.setOutputPad(padding);
+                        }
+                        this.ui.requestRender();
+                        return;
+                    }
+                    this.rebuildChatFromMessages();
+                },
                 onAutocompleteMaxVisibleChange: (maxVisible) => {
                     this.settingsManager.setAutocompleteMaxVisible(maxVisible);
                     this.defaultEditor.setAutocompleteMaxVisible(maxVisible);
@@ -3201,10 +3790,34 @@ export class InteractiveMode {
                 onClearOnShrinkChange: (enabled) => {
                     this.settingsManager.setClearOnShrink(enabled);
                     this.ui.setClearOnShrink(enabled);
+                    if (!enabled && !this.activeStatusIndicator) {
+                        this.statusContainer.clear();
+                    }
                 },
                 onShowTerminalProgressChange: (enabled) => {
                     this.settingsManager.setShowTerminalProgress(enabled);
                 },
+                onTuiModeChange: (mode) => {
+                    if (!this.switchTuiMode(mode)) {
+                        selector?.getSettingsList().updateValue("tui-mode", this.ui.mode);
+                        this.showStatus("Close active overlays before changing TUI mode");
+                        return;
+                    }
+                    this.settingsManager.setTuiMode(mode);
+                    if (!this.activeStatusIndicator)
+                        this.statusContainer.clear();
+                    this.showStatus(`TUI mode: ${mode}`);
+                },
+                onFullscreenExitOutputChange: (output) => {
+                    this.settingsManager.setFullscreenExitOutput(output);
+                },
+                onFullscreenScrollbarChange: (mode) => {
+                    this.settingsManager.setFullscreenScrollbar(mode);
+                    this.applyFullscreenScrollbarSetting();
+                },
+                onWarningsChange: (warnings) => {
+                    this.settingsManager.setWarnings(warnings);
+                },
                 onCancel: () => {
                     done();
                     this.ui.requestRender();
@@ -3236,42 +3849,63 @@ export class InteractiveMode {
         this.showModelSelector(searchTerm);
     }
     async findExactModelMatch(searchTerm) {
-        const models = await this.getModelCandidates();
-        return findExactModelReferenceMatch(searchTerm, models);
-    }
-    async getModelCandidates() {
-        if (this.session.scopedModels.length > 0) {
-            return this.session.scopedModels.map((scoped) => scoped.model);
-        }
-        this.session.modelRegistry.refresh();
+        const cachedModels = this.session.scopedModels.length > 0
+            ? this.session.scopedModels.map((scoped) => scoped.model)
+            : [...this.session.modelRuntime.getAvailableSnapshot()];
+        const cachedMatch = findExactModelReferenceMatch(searchTerm, cachedModels);
+        if (cachedMatch || this.session.scopedModels.length > 0)
+            return cachedMatch;
+        this.showStatus("Refreshing model catalogs…");
+        const controller = new AbortController();
+        let timedOut = false;
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, 15_000);
         try {
-            return await this.session.modelRegistry.getAvailable();
+            const result = await refreshModelCatalogs(this.session.modelRuntime, controller.signal);
+            if (result.aborted && timedOut) {
+                this.showWarning("Model refresh timed out; searching cached models.");
+            }
+            else if (result.errors.size > 0) {
+                this.showWarning(`Could not refresh ${[...result.errors.keys()].join(", ")}; searching cached models.`);
+            }
         }
-        catch {
-            return [];
+        catch (error) {
+            this.showWarning(timedOut
+                ? "Model refresh timed out; searching cached models."
+                : `Could not refresh model catalogs: ${error instanceof Error ? error.message : String(error)}`);
         }
+        finally {
+            clearTimeout(timeout);
+        }
+        return findExactModelReferenceMatch(searchTerm, [...this.session.modelRuntime.getAvailableSnapshot()]);
     }
-    /** Update the footer's available provider count from current model candidates */
-    async updateAvailableProviderCount() {
-        const models = await this.getModelCandidates();
-        const uniqueProviders = new Set(models.map((m) => m.provider));
+    /** Update the footer's available provider count from the current snapshot without refreshing catalogs. */
+    updateAvailableProviderCount() {
+        const models = this.session.scopedModels.length > 0
+            ? this.session.scopedModels.map((scoped) => scoped.model)
+            : this.session.modelRuntime.getAvailableSnapshot();
+        const uniqueProviders = new Set(models.map((model) => model.provider));
         this.footerDataProvider.setAvailableProviderCount(uniqueProviders.size);
     }
     async maybeWarnAboutAnthropicSubscriptionAuth(model = this.session.model) {
-        if (this.anthropicSubscriptionWarningShown) {
+        if (this.settingsManager.getWarnings().anthropicExtraUsage === false) {
             return;
         }
-        if (!model || model.provider !== "anthropic") {
+        if (this.anthropicSubscriptionWarningShown) {
             return;
         }
-        const storedCredential = this.session.modelRegistry.authStorage.get("anthropic");
-        if (storedCredential?.type === "oauth") {
-            this.anthropicSubscriptionWarningShown = true;
-            this.showWarning(ANTHROPIC_SUBSCRIPTION_AUTH_WARNING);
+        if (!model || model.provider !== "anthropic") {
             return;
         }
         try {
-            const apiKey = await this.session.modelRegistry.getApiKeyForProvider(model.provider);
+            if ((await this.session.modelRuntime.checkAuth("anthropic"))?.type === "oauth") {
+                this.anthropicSubscriptionWarningShown = true;
+                this.showWarning(ANTHROPIC_SUBSCRIPTION_AUTH_WARNING);
+                return;
+            }
+            const apiKey = (await this.session.modelRuntime.getAuth(model.provider))?.auth.apiKey;
             if (!isAnthropicSubscriptionAuthKey(apiKey)) {
                 return;
             }
@@ -3282,9 +3916,54 @@ export class InteractiveMode {
             // Ignore auth lookup failures for warning-only checks.
         }
     }
+    maybeSaveImplicitProjectTrustAfterReload() {
+        const cwd = this.sessionManager.getCwd();
+        if (this.autoTrustOnReloadCwd !== cwd) {
+            return false;
+        }
+        if (!this.settingsManager.isProjectTrusted() || !hasTrustRequiringProjectResources(cwd)) {
+            return false;
+        }
+        const trustStore = new ProjectTrustStore(this.runtimeHost.services.agentDir);
+        try {
+            if (trustStore.get(cwd) !== null) {
+                this.autoTrustOnReloadCwd = undefined;
+                return false;
+            }
+            trustStore.set(cwd, true);
+            this.autoTrustOnReloadCwd = undefined;
+            return true;
+        }
+        catch (error) {
+            this.showWarning(`Could not save project trust after reload: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+    }
+    showTrustSelector() {
+        const cwd = this.sessionManager.getCwd();
+        const trustStore = new ProjectTrustStore(this.runtimeHost.services.agentDir);
+        const savedDecision = trustStore.getEntry(cwd);
+        this.showSelector((done) => {
+            const selector = new TrustSelectorComponent({
+                cwd,
+                savedDecision,
+                projectTrusted: this.settingsManager.isProjectTrusted(),
+                onSelect: (selection) => {
+                    trustStore.setMany(selection.updates);
+                    done();
+                    this.showStatus(`Saved trust decision: ${selection.trusted ? "trusted" : "untrusted"}. Restart ${APP_NAME} for this to take effect.`);
+                },
+                onCancel: () => {
+                    done();
+                    this.ui.requestRender();
+                },
+            });
+            return { component: selector, focus: selector };
+        });
+    }
     showModelSelector(initialSearchInput) {
         this.showSelector((done) => {
-            const selector = new ModelSelectorComponent(this.ui, this.session.model, this.settingsManager, this.session.modelRegistry, this.session.scopedModels, async (model) => {
+            const selector = new ModelSelectorComponent(this.ui, this.session.model, this.settingsManager, this.session.modelRuntime, this.session.scopedModels, async (model) => {
                 try {
                     await this.session.setModel(model);
                     this.footer.invalidate();
@@ -3302,64 +3981,68 @@ export class InteractiveMode {
                 done();
                 this.ui.requestRender();
             }, initialSearchInput);
-            return { component: selector, focus: selector };
+            return { component: selector, focus: selector, dispose: () => selector.dispose() };
         });
     }
-    async showModelsSelector() {
-        // Get all available models
-        this.session.modelRegistry.refresh();
-        const allModels = this.session.modelRegistry.getAvailable();
-        if (allModels.length === 0) {
-            this.showStatus("No models available");
-            return;
-        }
-        // Check if session has scoped models (from previous session-only changes or CLI --models)
+    showModelsSelector() {
+        let availableModels = [...this.session.modelRuntime.getAvailableSnapshot()];
+        let availableModelIds = new Set(availableModels.map((model) => `${model.provider}/${model.id}`));
+        const configuredPatterns = this.settingsManager.getEnabledModels();
         const sessionScopedModels = this.session.scopedModels;
-        const hasSessionScope = sessionScopedModels.length > 0;
-        // Build enabled model IDs from session state or settings
-        let currentEnabledIds = null;
-        if (hasSessionScope) {
-            // Use current session's scoped models
-            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) {
-                const scopedModels = await resolveModelScope(patterns, this.session.modelRegistry);
-                currentEnabledIds = scopedModels.map((scoped) => `${scoped.model.provider}/${scoped.model.id}`);
-            }
-        }
-        // Helper to update session's scoped models (session-only, no persist)
-        const updateSessionModels = async (enabledIds) => {
+        const configuredEnabledIds = (models) => {
+            if (!configuredPatterns?.length)
+                return null;
+            const resolved = resolveModelScopeFromModels(configuredPatterns, models);
+            const ids = resolved.scopedModels.map((scoped) => `${scoped.model.provider}/${scoped.model.id}`);
+            for (const diagnostic of resolved.diagnostics) {
+                if (diagnostic.code === "no-match" && !ids.includes(diagnostic.pattern))
+                    ids.push(diagnostic.pattern);
+            }
+            return ids;
+        };
+        let currentEnabledIds = sessionScopedModels.length > 0
+            ? sessionScopedModels.map((scoped) => `${scoped.model.provider}/${scoped.model.id}`)
+            : configuredEnabledIds(availableModels);
+        let selectionChanged = false;
+        const updateSessionModels = (enabledIds) => {
             currentEnabledIds = enabledIds === null ? null : [...enabledIds];
-            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,
+            const hasEnabledAvailableModel = enabledIds?.some((id) => availableModelIds.has(id)) ?? false;
+            const allAvailableModelsEnabled = enabledIds !== null && [...availableModelIds].every((id) => enabledIds.includes(id));
+            if (enabledIds && hasEnabledAvailableModel && !allAvailableModelsEnabled) {
+                const newScopedModels = resolveModelScopeFromModels(enabledIds, availableModels).scopedModels;
+                this.session.setScopedModels(newScopedModels.map((scoped) => ({
+                    model: scoped.model,
+                    thinkingLevel: scoped.thinkingLevel,
                 })));
             }
             else {
-                // All enabled or none enabled = no filter
                 this.session.setScopedModels([]);
             }
-            await this.updateAvailableProviderCount();
+            this.updateAvailableProviderCount();
             this.ui.requestRender();
         };
         this.showSelector((done) => {
+            let disposed = false;
+            let timedOut = false;
+            const controller = new AbortController();
+            const timeout = setTimeout(() => {
+                timedOut = true;
+                controller.abort();
+            }, 15_000);
             const selector = new ScopedModelsSelectorComponent({
-                allModels,
+                allModels: availableModels,
                 enabledModelIds: currentEnabledIds,
+                refreshStatus: "Refreshing model catalogs…",
             }, {
-                onChange: async (enabledIds) => {
-                    await updateSessionModels(enabledIds);
+                onChange: (enabledIds) => {
+                    selectionChanged = true;
+                    updateSessionModels(enabledIds);
                 },
                 onPersist: (enabledIds) => {
-                    // Persist to settings
-                    const newPatterns = enabledIds === null || enabledIds.length === allModels.length
-                        ? undefined // All enabled = clear filter
-                        : enabledIds;
+                    const allEnabled = enabledIds !== null &&
+                        enabledIds.length === availableModels.length &&
+                        enabledIds.every((id) => availableModelIds.has(id));
+                    const newPatterns = enabledIds === null || allEnabled ? undefined : enabledIds;
                     this.settingsManager.setEnabledModels(newPatterns ? [...newPatterns] : undefined);
                     this.showStatus("Model selection saved to settings");
                 },
@@ -3368,7 +4051,50 @@ export class InteractiveMode {
                     this.ui.requestRender();
                 },
             });
-            return { component: selector, focus: selector };
+            void refreshModelCatalogs(this.session.modelRuntime, controller.signal)
+                .then((result) => {
+                if (disposed)
+                    return;
+                availableModels = [...this.session.modelRuntime.getAvailableSnapshot()];
+                availableModelIds = new Set(availableModels.map((model) => `${model.provider}/${model.id}`));
+                if (!selectionChanged && sessionScopedModels.length === 0) {
+                    currentEnabledIds = configuredEnabledIds(availableModels);
+                    selector.updateModels(availableModels, currentEnabledIds);
+                }
+                else {
+                    selector.updateModels(availableModels);
+                }
+                if (currentEnabledIds !== null)
+                    updateSessionModels(currentEnabledIds);
+                if (result.aborted && timedOut) {
+                    selector.setRefreshStatus("Model refresh timed out; showing cached models.", "warning");
+                }
+                else if (result.errors.size > 0) {
+                    selector.setRefreshStatus(`Could not refresh ${[...result.errors.keys()].join(", ")}; showing cached models.`, "warning");
+                }
+                else {
+                    selector.setRefreshStatus("Model catalogs refreshed.", "success");
+                }
+                this.ui.requestRender();
+            })
+                .catch((error) => {
+                if (disposed)
+                    return;
+                selector.setRefreshStatus(timedOut
+                    ? "Model refresh timed out; showing cached models."
+                    : `Could not refresh model catalogs: ${error instanceof Error ? error.message : String(error)}`, "warning");
+                this.ui.requestRender();
+            })
+                .finally(() => clearTimeout(timeout));
+            return {
+                component: selector,
+                focus: selector,
+                dispose: () => {
+                    disposed = true;
+                    clearTimeout(timeout);
+                    controller.abort();
+                },
+            };
         });
     }
     showUserMessageSelector() {
@@ -3380,20 +4106,17 @@ export class InteractiveMode {
         const initialSelectedId = userMessages[userMessages.length - 1]?.entryId;
         this.showSelector((done) => {
             const selector = new UserMessageSelectorComponent(userMessages.map((m) => ({ id: m.entryId, text: m.text })), async (entryId) => {
+                done();
                 try {
                     const result = await this.runtimeHost.fork(entryId);
                     if (result.cancelled) {
-                        done();
                         this.ui.requestRender();
                         return;
                     }
-                    this.renderCurrentSessionState();
                     this.editor.setText(result.selectedText ?? "");
-                    done();
                     this.showStatus("Forked to new session");
                 }
                 catch (error) {
-                    done();
                     this.showError(error instanceof Error ? error.message : String(error));
                 }
             }, () => {
@@ -3415,7 +4138,6 @@ export class InteractiveMode {
                 this.ui.requestRender();
                 return;
             }
-            this.renderCurrentSessionState();
             this.editor.setText("");
             this.showStatus("Cloned to new session");
         }
@@ -3434,7 +4156,7 @@ export class InteractiveMode {
         this.showSelector((done) => {
             const selector = new TreeSelectorComponent(tree, realLeafId, this.ui.terminal.rows, async (entryId) => {
                 // Selecting the current leaf is a no-op (already there)
-                if (entryId === realLeafId) {
+                if (entryId === this.sessionManager.getLeafId()) {
                     done();
                     this.showStatus("Already at this point");
                     return;
@@ -3469,16 +4191,21 @@ export class InteractiveMode {
                         break;
                     }
                 }
-                // Set up escape handler and loader if summarizing
-                let summaryLoader;
+                // The user committed to navigating: stop the active response first.
+                if (this.session.isStreaming) {
+                    this.restoreQueuedMessagesToEditor();
+                    await this.session.abort();
+                }
+                // Set up escape handler and status indicator if summarizing
+                let showingSummaryIndicator = false;
                 const originalOnEscape = this.defaultEditor.onEscape;
                 if (wantsSummary) {
                     this.defaultEditor.onEscape = () => {
                         this.session.abortBranchSummary();
                     };
                     this.chatContainer.addChild(new Spacer(1));
-                    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.showStatusIndicator(new BranchSummaryStatusIndicator(this.ui));
+                    showingSummaryIndicator = true;
                     this.ui.requestRender();
                 }
                 try {
@@ -3509,9 +4236,8 @@ export class InteractiveMode {
                     this.showError(error instanceof Error ? error.message : String(error));
                 }
                 finally {
-                    if (summaryLoader) {
-                        summaryLoader.stop();
-                        this.statusContainer.clear();
+                    if (showingSummaryIndicator) {
+                        this.clearStatusIndicator("branchSummary");
                     }
                     this.defaultEditor.onEscape = originalOnEscape;
                 }
@@ -3522,12 +4248,27 @@ export class InteractiveMode {
                 this.sessionManager.appendLabelChange(entryId, label);
                 this.ui.requestRender();
             }, initialSelectedId, initialFilterMode);
+            selector.onCopy = async (text) => {
+                if (!text) {
+                    this.showError("Selected entry has no text to copy");
+                    return;
+                }
+                try {
+                    await copyToClipboard(text);
+                    this.showStatus("Copied selected message to clipboard");
+                }
+                catch (error) {
+                    this.showError(error instanceof Error ? error.message : String(error));
+                }
+            };
             return { component: selector, focus: selector };
         });
     }
     showSessionSelector() {
         this.showSelector((done) => {
-            const selector = new SessionSelectorComponent((onProgress) => SessionManager.list(this.sessionManager.getCwd(), this.sessionManager.getSessionDir(), onProgress), SessionManager.listAll, async (sessionPath) => {
+            const selector = new SessionSelectorComponent((onProgress) => SessionManager.list(this.sessionManager.getCwd(), this.sessionManager.getSessionDir(), onProgress), (onProgress) => this.sessionManager.usesDefaultSessionDir()
+                ? SessionManager.listAll(onProgress)
+                : SessionManager.listAll(this.sessionManager.getSessionDir(), onProgress), async (sessionPath) => {
                 done();
                 await this.handleResumeSession(sessionPath);
             }, () => {
@@ -3550,19 +4291,15 @@ export class InteractiveMode {
         });
     }
     async handleResumeSession(sessionPath, options) {
-        if (this.loadingAnimation) {
-            this.loadingAnimation.stop();
-            this.loadingAnimation = undefined;
-        }
-        this.statusContainer.clear();
+        this.clearStatusIndicator();
         try {
             const result = await this.runtimeHost.switchSession(sessionPath, {
                 withSession: options?.withSession,
+                projectTrustContextFactory: (cwd) => this.createProjectTrustContext(cwd),
             });
             if (result.cancelled) {
                 return result;
             }
-            this.renderCurrentSessionState();
             this.showStatus("Resumed session");
             return result;
         }
@@ -3576,11 +4313,11 @@ export class InteractiveMode {
                 const result = await this.runtimeHost.switchSession(sessionPath, {
                     cwdOverride: selectedCwd,
                     withSession: options?.withSession,
+                    projectTrustContextFactory: (cwd) => this.createProjectTrustContext(cwd),
                 });
                 if (result.cancelled) {
                     return result;
                 }
-                this.renderCurrentSessionState();
                 this.showStatus("Resumed session in current cwd");
                 return result;
             }
@@ -3588,54 +4325,124 @@ export class InteractiveMode {
         }
     }
     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;
+        const options = [];
+        for (const provider of this.session.modelRuntime.getProviders()) {
+            const authStatus = this.session.modelRuntime.getProviderAuthStatus(provider.id);
+            const status = authStatus.configured
+                ? {
+                    type: this.session.modelRuntime.isUsingOAuth(provider.id) ? "oauth" : "api_key",
+                    source: authStatus.label ?? authStatus.source,
+                }
+                : undefined;
+            if ((!authType || authType === "oauth") && provider.auth.oauth) {
+                options.push({
+                    id: provider.id,
+                    name: provider.name,
+                    authType: "oauth",
+                    method: provider.auth.oauth,
+                    status,
+                });
             }
-            options.push({
-                id: providerId,
-                name: getApiKeyProviderDisplayName(providerId),
-                authType: "api_key",
-            });
+            if ((!authType || authType === "api_key") && provider.auth.apiKey) {
+                options.push({
+                    id: provider.id,
+                    name: provider.name,
+                    authType: "api_key",
+                    method: provider.auth.apiKey,
+                    status,
+                });
+            }
+        }
+        return options.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    async getLogoutProviderOptions() {
+        return (await this.session.modelRuntime.listCredentials({ signal: AbortSignal.timeout(15_000) }))
+            .map(({ providerId, type }) => ({
+            id: providerId,
+            name: this.session.modelRuntime.getProvider(providerId)?.name ?? providerId,
+            authType: type,
+            status: { type, source: "stored credential" },
+        }))
+            .sort((a, b) => a.name.localeCompare(b.name));
+    }
+    findLoginProviderOptions(providerRef) {
+        const normalizedProviderRef = providerRef.trim().toLowerCase();
+        if (!normalizedProviderRef) {
+            return [];
         }
-        const filteredOptions = authType ? options.filter((option) => option.authType === authType) : options;
-        return filteredOptions.sort((a, b) => a.name.localeCompare(b.name));
+        return this.getLoginProviderOptions().filter((provider) => provider.id.toLowerCase() === normalizedProviderRef ||
+            provider.name.toLowerCase() === normalizedProviderRef);
     }
-    getLogoutProviderOptions() {
-        const authStorage = this.session.modelRegistry.authStorage;
-        const oauthNameById = new Map(authStorage.getOAuthProviders().map((provider) => [provider.id, provider.name]));
-        const options = [];
-        for (const providerId of authStorage.list()) {
-            const credential = authStorage.get(providerId);
-            if (!credential) {
-                continue;
+    async handleLoginCommand(providerRef) {
+        if (!providerRef) {
+            this.showLoginAuthTypeSelector();
+            return;
+        }
+        const providerOptions = this.findLoginProviderOptions(providerRef);
+        if (providerOptions.length === 1) {
+            await this.startProviderLogin(providerOptions[0]);
+            return;
+        }
+        if (providerOptions.length > 1) {
+            const providerIds = new Set(providerOptions.map((provider) => provider.id));
+            if (providerIds.size === 1) {
+                this.showLoginAuthTypeSelector(providerOptions);
+                return;
             }
-            options.push({
-                id: providerId,
-                name: credential.type === "oauth"
-                    ? (oauthNameById.get(providerId) ?? providerId)
-                    : getApiKeyProviderDisplayName(providerId),
-                authType: credential.type,
-            });
         }
-        return options.sort((a, b) => a.name.localeCompare(b.name));
+        this.showLoginProviderSelector(undefined, providerRef);
+    }
+    async startProviderLogin(providerOption) {
+        if (providerOption.authType === "oauth") {
+            await this.showLoginDialog(providerOption.id, providerOption.name);
+        }
+        else if (providerOption.method?.login) {
+            await this.showApiKeyLoginDialog(providerOption.id, providerOption.name);
+        }
+        else {
+            this.showAmbientAuthDialog(providerOption);
+        }
     }
-    showLoginAuthTypeSelector() {
-        const subscriptionLabel = "Use a subscription";
-        const apiKeyLabel = "Use an API key";
+    showLoginAuthTypeSelector(providerOptions) {
+        const oauthProvider = providerOptions?.find((provider) => provider.authType === "oauth");
+        const oauthLoginLabel = oauthProvider?.method && "loginLabel" in oauthProvider.method ? oauthProvider.method.loginLabel : undefined;
+        const subscriptionLabel = oauthLoginLabel ?? "Sign in with an account";
+        const apiKeyLabel = "Sign in with an API key";
+        const availableAuthTypes = providerOptions
+            ? new Set(providerOptions.map((provider) => provider.authType))
+            : new Set(["oauth", "api_key"]);
+        const options = [];
+        if (availableAuthTypes.has("oauth")) {
+            options.push(subscriptionLabel);
+        }
+        if (availableAuthTypes.has("api_key")) {
+            options.push(apiKeyLabel);
+        }
+        if (options.length === 0) {
+            this.showStatus("No login methods available.");
+            return;
+        }
+        if (providerOptions && options.length === 1) {
+            const providerOption = providerOptions[0];
+            if (providerOption) {
+                void this.startProviderLogin(providerOption);
+            }
+            return;
+        }
+        const title = providerOptions?.[0]
+            ? `Select authentication method for ${providerOptions[0].name}:`
+            : "Select authentication method:";
         this.showSelector((done) => {
-            const selector = new ExtensionSelectorComponent("Select authentication method:", [subscriptionLabel, apiKeyLabel], (option) => {
+            const selector = new ExtensionSelectorComponent(title, options, (option) => {
                 done();
                 const authType = option === subscriptionLabel ? "oauth" : "api_key";
+                if (providerOptions) {
+                    const providerOption = providerOptions.find((provider) => provider.authType === authType);
+                    if (providerOption) {
+                        void this.startProviderLogin(providerOption);
+                    }
+                    return;
+                }
                 this.showLoginProviderSelector(authType);
             }, () => {
                 done();
@@ -3644,32 +4451,34 @@ export class InteractiveMode {
             return { component: selector, focus: selector };
         });
     }
-    showLoginProviderSelector(authType) {
+    showLoginProviderSelector(authType, initialSearchInput) {
         const providerOptions = this.getLoginProviderOptions(authType);
         if (providerOptions.length === 0) {
-            this.showStatus(authType === "oauth" ? "No subscription providers available." : "No API key providers available.");
+            const message = authType === "oauth"
+                ? "No subscription providers available."
+                : authType === "api_key"
+                    ? "No API key providers available."
+                    : "No login providers available.";
+            this.showStatus(message);
             return;
         }
         this.showSelector((done) => {
-            const selector = new OAuthSelectorComponent("login", this.session.modelRegistry.authStorage, providerOptions, async (providerId) => {
+            const selector = new OAuthSelectorComponent("login", providerOptions, async (providerId, selectedAuthType) => {
                 done();
-                const providerOption = providerOptions.find((provider) => provider.id === providerId);
+                const providerOption = providerOptions.find((provider) => provider.id === providerId && provider.authType === selectedAuthType);
                 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);
+                await this.startProviderLogin(providerOption);
+            }, () => {
+                done();
+                if (authType) {
+                    this.showLoginAuthTypeSelector();
                 }
                 else {
-                    await this.showApiKeyLoginDialog(providerOption.id, providerOption.name);
+                    this.ui.requestRender();
                 }
-            }, () => {
-                done();
-                this.showLoginAuthTypeSelector();
-            });
+            }, initialSearchInput);
             return { component: selector, focus: selector };
         });
     }
@@ -3678,29 +4487,40 @@ export class InteractiveMode {
             this.showLoginAuthTypeSelector();
             return;
         }
-        const providerOptions = this.getLogoutProviderOptions();
+        let providerOptions;
+        try {
+            providerOptions = await this.getLogoutProviderOptions();
+        }
+        catch (error) {
+            this.showError(`Could not read stored credentials: ${error instanceof Error ? error.message : String(error)}`);
+            return;
+        }
         if (providerOptions.length === 0) {
-            this.showStatus("No providers logged in. Use /login first.");
+            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, providerOptions, async (providerId) => {
+            const selector = new OAuthSelectorComponent(mode, providerOptions, async (providerId) => {
                 done();
                 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.session.modelRuntime.logout(providerOption.id, {
+                        signal: AbortSignal.timeout(15_000),
+                    });
                     await this.updateAvailableProviderCount();
                     const message = providerOption.authType === "oauth"
                         ? `Logged out of ${providerOption.name}`
-                        : `Removed API key for ${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)}`);
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.showError(error instanceof CredentialSynchronizationError
+                        ? `Credentials removed for ${providerOption.name}, but local model state could not be synchronized: ${message}`
+                        : `Logout failed: ${message}`);
                 }
             }, () => {
                 done();
@@ -3710,12 +4530,11 @@ export class InteractiveMode {
         });
     }
     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 availableModels = this.session.modelRuntime.getAvailableSnapshot();
             const providerModels = availableModels.filter((model) => model.provider === providerId);
             if (!hasDefaultModelProvider(providerId)) {
                 selectionError = `${actionLabel}, but no default model is configured for provider "${providerId}". Use /model to select a model.`;
@@ -3758,21 +4577,35 @@ export class InteractiveMode {
                 void this.maybeWarnAboutAnthropicSubscriptionAuth();
             }
         }
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 15_000);
+        void this.session.modelRuntime
+            .refresh({ providers: [providerId], signal: controller.signal })
+            .then((result) => {
+            if (result.aborted) {
+                this.showWarning(`${actionLabel}, but its model catalog refresh timed out; using cached models.`);
+            }
+            else if (result.errors.size > 0) {
+                this.showWarning(`${actionLabel}, but its model catalog could not be refreshed; using cached models.`);
+            }
+            this.updateAvailableProviderCount();
+            this.footer.invalidate();
+            this.ui.requestRender();
+        })
+            .catch((error) => {
+            this.showWarning(`${actionLabel}, but its model catalog could not be refreshed: ${error instanceof Error ? error.message : String(error)}`);
+        })
+            .finally(() => clearTimeout(timeout));
     }
-    showBedrockSetupDialog(providerId, providerName) {
+    showAmbientAuthDialog(providerOption) {
         const restoreEditor = () => {
             this.editorContainer.clear();
             this.editorContainer.addChild(this.editor);
             this.ui.setFocus(this.editor);
             this.ui.requestRender();
         };
-        const dialog = new LoginDialogComponent(this.ui, 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")}`),
-        ]);
+        const dialog = new LoginDialogComponent(this.ui, providerOption.id, () => restoreEditor(), providerOption.name, `${providerOption.name} setup`);
+        dialog.showInfo(`${providerOption.method?.name ?? "Authentication"} is configured outside ${APP_NAME}.`, [], true);
         this.editorContainer.clear();
         this.editorContainer.addChild(dialog);
         this.ui.setFocus(dialog);
@@ -3783,6 +4616,13 @@ export class InteractiveMode {
         const dialog = new LoginDialogComponent(this.ui, providerId, (_success, _message) => {
             // Completion handled below
         }, providerName);
+        if (providerId === "amazon-bedrock") {
+            dialog.showDetails([
+                theme.fg("text", "You can also use an AWS profile, IAM keys, or role-based credentials."),
+                theme.fg("muted", "See:"),
+                theme.fg("accent", `  ${path.join(getDocsPath(), "providers.md")}`),
+            ]);
+        }
         this.editorContainer.clear();
         this.editorContainer.addChild(dialog);
         this.ui.setFocus(dialog);
@@ -3794,46 +4634,105 @@ export class InteractiveMode {
             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 });
+            await this.loginProvider(dialog, providerId, "api_key");
             restoreEditor();
             await this.completeProviderAuthentication(providerId, providerName, "api_key", previousModel);
         }
         catch (error) {
             restoreEditor();
             const errorMsg = error instanceof Error ? error.message : String(error);
-            if (errorMsg !== "Login cancelled") {
+            if (error instanceof CredentialSynchronizationError) {
+                this.showError(`Saved API key for ${providerName}, but local model state could not be synchronized: ${errorMsg}`);
+            }
+            else if (errorMsg !== "Login cancelled") {
                 this.showError(`Failed to save API key for ${providerName}: ${errorMsg}`);
             }
         }
     }
+    showAuthSelect(dialog, prompt) {
+        return new Promise((resolve, reject) => {
+            const restoreDialog = () => {
+                this.editorContainer.clear();
+                this.editorContainer.addChild(dialog);
+                this.ui.setFocus(dialog);
+                this.ui.requestRender();
+            };
+            const labels = prompt.options.map((option) => option.label);
+            const selector = new ExtensionSelectorComponent(prompt.message, labels, (optionLabel) => {
+                restoreDialog();
+                const id = prompt.options.find((option) => option.label === optionLabel)?.id;
+                if (id)
+                    resolve(id);
+                else
+                    reject(new Error("Login cancelled"));
+            }, () => {
+                restoreDialog();
+                reject(new Error("Login cancelled"));
+            });
+            this.editorContainer.clear();
+            this.editorContainer.addChild(selector);
+            this.ui.setFocus(selector);
+            this.ui.requestRender();
+        });
+    }
+    async showAuthPrompt(dialog, prompt) {
+        let response;
+        if (prompt.type === "select") {
+            response = this.showAuthSelect(dialog, prompt);
+        }
+        else if (prompt.type === "manual_code") {
+            response = dialog.showManualInput(prompt.message);
+        }
+        else {
+            response = dialog.showPrompt(prompt.message, prompt.placeholder);
+        }
+        if (!prompt.signal)
+            return response;
+        if (prompt.signal.aborted)
+            throw new Error("Login cancelled");
+        const signal = prompt.signal;
+        let onAbort;
+        const aborted = new Promise((_resolve, reject) => {
+            onAbort = () => reject(new Error("Login cancelled"));
+            signal.addEventListener("abort", onAbort, { once: true });
+        });
+        try {
+            return await Promise.race([response, aborted]);
+        }
+        finally {
+            if (onAbort)
+                signal.removeEventListener("abort", onAbort);
+        }
+    }
+    notifyAuthDialog(dialog, event) {
+        if (event.type === "auth_url") {
+            dialog.showAuth(event.url, event.instructions);
+        }
+        else if (event.type === "device_code") {
+            dialog.showDeviceCode(event);
+            dialog.showWaiting("Waiting for authentication...");
+        }
+        else if (event.type === "info") {
+            dialog.showInfo(event.message, event.links);
+        }
+        else {
+            dialog.showProgress(event.message);
+        }
+    }
+    async loginProvider(dialog, providerId, method) {
+        await this.session.modelRuntime.login(providerId, method, {
+            signal: dialog.signal,
+            prompt: (prompt) => this.showAuthPrompt(dialog, prompt),
+            notify: (event) => this.notifyAuthDialog(dialog, event),
+        });
+    }
     async showLoginDialog(providerId, providerName) {
-        const 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
+        const dialog = new LoginDialogComponent(this.ui, providerId, (_success, _message) => { }, providerName);
         this.editorContainer.clear();
         this.editorContainer.addChild(dialog);
         this.ui.setFocus(dialog);
         this.ui.requestRender();
-        // Promise for manual code input (racing with callback server)
-        let manualCodeResolve;
-        let manualCodeReject;
-        const manualCodePromise = new Promise((resolve, reject) => {
-            manualCodeResolve = resolve;
-            manualCodeReject = reject;
-        });
-        // Restore editor helper
         const restoreEditor = () => {
             this.editorContainer.clear();
             this.editorContainer.addChild(this.editor);
@@ -3841,49 +4740,17 @@ export class InteractiveMode {
             this.ui.requestRender();
         };
         try {
-            await this.session.modelRegistry.authStorage.login(providerId, {
-                onAuth: (info) => {
-                    dialog.showAuth(info.url, info.instructions);
-                    if (usesCallbackServer) {
-                        // Show input for manual paste, racing with callback
-                        dialog
-                            .showManualInput("Paste redirect URL below, or complete login in browser:")
-                            .then((value) => {
-                            if (value && manualCodeResolve) {
-                                manualCodeResolve(value);
-                                manualCodeResolve = undefined;
-                            }
-                        })
-                            .catch(() => {
-                            if (manualCodeReject) {
-                                manualCodeReject(new Error("Login cancelled"));
-                                manualCodeReject = undefined;
-                            }
-                        });
-                    }
-                    else if (providerId === "github-copilot") {
-                        // GitHub Copilot polls after onAuth
-                        dialog.showWaiting("Waiting for browser authentication...");
-                    }
-                    // For Anthropic: onPrompt is called immediately after
-                },
-                onPrompt: async (prompt) => {
-                    return dialog.showPrompt(prompt.message, prompt.placeholder);
-                },
-                onProgress: (message) => {
-                    dialog.showProgress(message);
-                },
-                onManualCodeInput: () => manualCodePromise,
-                signal: dialog.signal,
-            });
-            // Success
+            await this.loginProvider(dialog, providerId, "oauth");
             restoreEditor();
             await this.completeProviderAuthentication(providerId, providerName, "oauth", previousModel);
         }
         catch (error) {
             restoreEditor();
             const errorMsg = error instanceof Error ? error.message : String(error);
-            if (errorMsg !== "Login cancelled") {
+            if (error instanceof CredentialSynchronizationError) {
+                this.showError(`Logged in to ${providerName}, but local model state could not be synchronized: ${errorMsg}`);
+            }
+            else if (errorMsg !== "Login cancelled") {
                 this.showError(`Failed to login to ${providerName}: ${errorMsg}`);
             }
         }
@@ -3905,7 +4772,7 @@ export class InteractiveMode {
         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 Text(theme.fg("muted", "Reloading keybindings, extensions, skills, prompts, themes, and context files..."), 1, 0));
         reloadBox.addChild(new Spacer(1));
         reloadBox.addChild(new DynamicBorder(borderColor));
         const previousEditor = this.editor;
@@ -3920,47 +4787,50 @@ export class InteractiveMode {
             this.ui.setFocus(editor);
             this.ui.requestRender();
         };
+        let chatRestoredBeforeSessionStart = false;
+        let reloadBoxDismissed = false;
+        const restoreChatBeforeSessionStart = () => {
+            if (chatRestoredBeforeSessionStart) {
+                return;
+            }
+            this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
+            this.outputPad = this.settingsManager.getOutputPad();
+            this.rebuildChatFromMessages();
+            chatRestoredBeforeSessionStart = true;
+        };
         try {
-            await this.session.reload();
+            await this.session.reload({ beforeSessionStart: restoreChatBeforeSessionStart });
+            restoreChatBeforeSessionStart();
             this.keybindings.reload();
             const activeHeader = this.customHeader ?? this.builtInHeader;
             if (isExpandable(activeHeader)) {
                 activeHeader.setExpanded(this.toolOutputExpanded);
             }
             setRegisteredThemes(this.session.resourceLoader.getThemes().themes);
-            this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
-            const themeName = this.settingsManager.getTheme();
-            const themeResult = themeName ? setTheme(themeName, true) : { success: true };
-            if (!themeResult.success) {
-                this.showError(`Failed to load theme "${themeName}": ${themeResult.error}\nFell back to dark theme.`);
-            }
-            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);
-            }
-            this.ui.setShowHardwareCursor(this.settingsManager.getShowHardwareCursor());
-            this.ui.setClearOnShrink(this.settingsManager.getClearOnShrink());
+            await this.themeController.applyFromSettings();
+            this.applyRuntimeSettings();
             this.setupAutocompleteProvider();
             const runner = this.session.extensionRunner;
             this.setupExtensionShortcuts(runner);
-            this.rebuildChatFromMessages();
-            dismissReloadBox(this.editor);
             this.showLoadedResources({
                 force: false,
                 showDiagnosticsWhenQuiet: true,
             });
-            const modelsJsonError = this.session.modelRegistry.getError();
+            const savedImplicitProjectTrust = this.maybeSaveImplicitProjectTrustAfterReload();
+            const modelsJsonError = this.session.modelRuntime.getError();
             if (modelsJsonError) {
                 this.showError(`models.json error: ${modelsJsonError}`);
             }
-            this.showStatus("Reloaded keybindings, extensions, skills, prompts, themes");
+            this.showStatus(savedImplicitProjectTrust
+                ? "Reloaded keybindings, extensions, skills, prompts, themes, and context files; saved project trust"
+                : "Reloaded keybindings, extensions, skills, prompts, themes, and context files");
+            dismissReloadBox(this.editor);
+            reloadBoxDismissed = true;
         }
         catch (error) {
-            dismissReloadBox(previousEditor);
+            if (!reloadBoxDismissed) {
+                dismissReloadBox(previousEditor);
+            }
             this.showError(`Reload failed: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
@@ -3972,7 +4842,9 @@ export class InteractiveMode {
                 this.showStatus(`Session exported to: ${filePath}`);
             }
             else {
-                const filePath = await this.session.exportToHtml(outputPath);
+                const filePath = await this.session.exportToHtml(outputPath, {
+                    themeName: theme.name,
+                });
                 this.showStatus(`Session exported to: ${filePath}`);
             }
         }
@@ -4017,17 +4889,12 @@ export class InteractiveMode {
             return;
         }
         try {
-            if (this.loadingAnimation) {
-                this.loadingAnimation.stop();
-                this.loadingAnimation = undefined;
-            }
-            this.statusContainer.clear();
+            this.clearStatusIndicator();
             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) {
@@ -4042,7 +4909,6 @@ export class InteractiveMode {
                     this.showStatus("Import cancelled");
                     return;
                 }
-                this.renderCurrentSessionState();
                 this.showStatus(`Session imported from: ${inputPath}`);
                 return;
             }
@@ -4069,7 +4935,7 @@ export class InteractiveMode {
         // Export to a temp file
         const tmpFile = path.join(os.tmpdir(), "session.html");
         try {
-            await this.session.exportToHtml(tmpFile);
+            await this.session.exportToHtml(tmpFile, { themeName: theme.name });
         }
         catch (error) {
             this.showError(`Failed to export session: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -4131,7 +4997,13 @@ export class InteractiveMode {
             }
             // Create the preview URL
             const previewUrl = getShareViewerUrl(gistId);
-            this.showStatus(`Share URL: ${previewUrl}\nGist: ${gistUrl}`);
+            if (previewUrl) {
+                this.showStatus(`Share URL: ${previewUrl}\nGist: ${gistUrl}`);
+            }
+            else {
+                this.showStatus(`Gist: ${gistUrl}`);
+                this.showError(`No share viewer is configured, so no share URL was produced. Set ${ENV_SHARE_VIEWER_URL} to a share viewer base URL to enable share links.`);
+            }
         }
         catch (error) {
             if (!loader.signal.aborted) {
@@ -4140,7 +5012,7 @@ export class InteractiveMode {
             }
         }
     }
-    async handleCopyCommand() {
+    async handleCopyCommand(options = {}) {
         const text = this.session.getLastAssistantText();
         if (!text) {
             this.showError("No agent messages to copy yet.");
@@ -4148,7 +5020,12 @@ export class InteractiveMode {
         }
         try {
             await copyToClipboard(text);
-            this.showStatus("Copied last agent message to clipboard");
+            if (options.flashConfirmation && this.ui instanceof TuiAltScreen) {
+                this.ui.flash("Copied!");
+            }
+            else {
+                this.showStatus("Copied last agent message to clipboard");
+            }
         }
         catch (error) {
             this.showError(error instanceof Error ? error.message : String(error));
@@ -4168,15 +5045,24 @@ export class InteractiveMode {
             this.ui.requestRender();
             return;
         }
-        this.sessionManager.appendSessionInfo(name);
-        this.updateTerminalTitle();
+        this.session.setSessionName(name);
+        const sessionName = this.sessionManager.getSessionName();
+        if (sessionName !== name) {
+            this.showWarning(`Session name was normalized from ${JSON.stringify(name)} to ${JSON.stringify(sessionName)}`);
+        }
         this.chatContainer.addChild(new Spacer(1));
-        this.chatContainer.addChild(new Text(theme.fg("dim", `Session name set: ${name}`), 1, 0));
+        this.chatContainer.addChild(new Text(theme.fg("dim", `Session name set: ${sessionName ?? name}`), 1, 0));
         this.ui.requestRender();
     }
     handleSessionCommand() {
         const stats = this.session.getSessionStats();
         const sessionName = this.sessionManager.getSessionName();
+        const entries = this.sessionManager.getEntries();
+        const cacheWaste = computeCacheWaste(entries, this.session.modelRuntime);
+        // Cost/token totals per provider/model actually used (e.g. OpenRouter `auto`
+        // resolves to a concrete responseModel). Usage without model attribution is
+        // grouped separately so the breakdown reconciles with the session total.
+        const usageBreakdown = getUsageCostBreakdown(entries);
         let info = `${theme.bold("Session Info")}\n\n`;
         if (sessionName) {
             info += `${theme.fg("dim", "Name:")} ${sessionName}\n`;
@@ -4184,24 +5070,42 @@ export class InteractiveMode {
         info += `${theme.fg("dim", "File:")} ${stats.sessionFile ?? "In-memory"}\n`;
         info += `${theme.fg("dim", "ID:")} ${stats.sessionId}\n\n`;
         info += `${theme.bold("Messages")}\n`;
+        info += `${theme.fg("dim", "Total:")} ${stats.totalMessages}\n`;
         info += `${theme.fg("dim", "User:")} ${stats.userMessages}\n`;
         info += `${theme.fg("dim", "Assistant:")} ${stats.assistantMessages}\n`;
-        info += `${theme.fg("dim", "Tool Calls:")} ${stats.toolCalls}\n`;
-        info += `${theme.fg("dim", "Tool Results:")} ${stats.toolResults}\n`;
-        info += `${theme.fg("dim", "Total:")} ${stats.totalMessages}\n\n`;
+        info += `${theme.fg("dim", "Tools:")} ${stats.toolCalls} calls, ${stats.toolResults} results\n\n`;
         info += `${theme.bold("Tokens")}\n`;
-        info += `${theme.fg("dim", "Input:")} ${stats.tokens.input.toLocaleString()}\n`;
-        info += `${theme.fg("dim", "Output:")} ${stats.tokens.output.toLocaleString()}\n`;
-        if (stats.tokens.cacheRead > 0) {
-            info += `${theme.fg("dim", "Cache Read:")} ${stats.tokens.cacheRead.toLocaleString()}\n`;
-        }
-        if (stats.tokens.cacheWrite > 0) {
-            info += `${theme.fg("dim", "Cache Write:")} ${stats.tokens.cacheWrite.toLocaleString()}\n`;
+        // "Input" is the full prompt volume. With cache activity, split it into
+        // cached (served from cache) vs uncached (everything else) - the only
+        // provider-independent split. Cache writes, where reported, are a detail
+        // of the uncached portion.
+        const { input, cacheRead, cacheWrite } = stats.tokens;
+        const promptTokens = input + cacheRead + cacheWrite;
+        info += `${theme.fg("dim", "Input:")} ${promptTokens.toLocaleString()}\n`;
+        if (promptTokens > 0 && (cacheRead > 0 || cacheWrite > 0)) {
+            const hitRate = theme.fg("dim", `(${((cacheRead / promptTokens) * 100).toFixed(1)}%)`);
+            info += `  ${theme.fg("dim", "Cached:")} ${cacheRead.toLocaleString()} ${hitRate}\n`;
+            const written = cacheWrite > 0 ? ` ${theme.fg("dim", `(${cacheWrite.toLocaleString()} written to cache)`)}` : "";
+            info += `  ${theme.fg("dim", "Uncached:")} ${(input + cacheWrite).toLocaleString()}${written}\n`;
         }
+        info += `${theme.fg("dim", "Output:")} ${stats.tokens.output.toLocaleString()}\n`;
         info += `${theme.fg("dim", "Total:")} ${stats.tokens.total.toLocaleString()}\n`;
-        if (stats.cost > 0) {
+        if (stats.cost > 0 || cacheWaste.missedTokens > 0) {
             info += `\n${theme.bold("Cost")}\n`;
-            info += `${theme.fg("dim", "Total:")} ${stats.cost.toFixed(4)}`;
+            info += `${theme.fg("dim", "Total:")} $${stats.cost.toFixed(3)}`;
+            if (usageBreakdown.length > 1) {
+                for (const entry of usageBreakdown) {
+                    info += `\n  ${theme.fg("dim", `${entry.key}:`)} $${entry.cost.toFixed(3)} ${theme.fg("dim", `(${formatTokens(entry.tokens)} tokens)`)}`;
+                }
+            }
+            if (cacheWaste.missedTokens > 0) {
+                const missLabel = cacheWaste.missCount === 1 ? "1 miss" : `${cacheWaste.missCount} misses`;
+                const detail = `${cacheWaste.missedTokens.toLocaleString()} tokens, ${missLabel}`;
+                info +=
+                    cacheWaste.missedCost >= 0.0001
+                        ? `\n${theme.fg("dim", "Cache Re-billed:")} $${cacheWaste.missedCost.toFixed(3)} ${theme.fg("dim", `(${detail})`)}`
+                        : `\n${theme.fg("dim", "Cache Re-billed:")} ${detail}`;
+            }
         }
         this.chatContainer.addChild(new Spacer(1));
         this.chatContainer.addChild(new Text(info, 1, 0));
@@ -4213,7 +5117,7 @@ export class InteractiveMode {
         const changelogMarkdown = allEntries.length > 0
             ? allEntries
                 .reverse()
-                .map((e) => e.content)
+                .map((e) => normalizeChangelogLinks(e.content, e))
                 .join("\n\n")
             : "No changelog entries found.";
         this.chatContainer.addChild(new Spacer(1));
@@ -4224,29 +5128,17 @@ 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(keyText(action));
+        return keyDisplayText(action);
     }
     /**
      * Get capitalized display string for an editor keybinding action.
      */
     getEditorKeyDisplay(action) {
-        return this.capitalizeKey(keyText(action));
+        return keyDisplayText(action);
     }
     handleHotkeysCommand() {
         // Navigation keybindings
@@ -4285,6 +5177,7 @@ export class InteractiveMode {
         const toggleThinking = this.getAppKeyDisplay("app.thinking.toggle");
         const externalEditor = this.getAppKeyDisplay("app.editor.external");
         const cycleModelBackward = this.getAppKeyDisplay("app.model.cycleBackward");
+        const copyMessage = this.getAppKeyDisplay("app.message.copy");
         const followUp = this.getAppKeyDisplay("app.message.followUp");
         const dequeue = this.getAppKeyDisplay("app.message.dequeue");
         const pasteImage = this.getAppKeyDisplay("app.clipboard.pasteImage");
@@ -4292,7 +5185,7 @@ export class InteractiveMode {
 **Navigation**
 | Key | Action |
 |-----|--------|
-| \`${cursorUp}\` / \`${cursorDown}\` / \`${cursorLeft}\` / \`${cursorRight}\` | Move cursor / browse history (Up when empty) |
+| \`${cursorUp}\` / \`${cursorDown}\` / \`${cursorLeft}\` / \`${cursorRight}\` | Move cursor / browse history |
 | \`${cursorWordLeft}\` / \`${cursorWordRight}\` | Move by word |
 | \`${cursorLineStart}\` | Start of line |
 | \`${cursorLineEnd}\` | End of line |
@@ -4327,9 +5220,10 @@ export class InteractiveMode {
 | \`${expandTools}\` | Toggle tool output expansion |
 | \`${toggleThinking}\` | Toggle thinking block visibility |
 | \`${externalEditor}\` | Edit message in external editor |
+| \`${copyMessage}\` | Copy last assistant message |
 | \`${followUp}\` | Queue follow-up message |
 | \`${dequeue}\` | Restore queued messages |
-| \`${pasteImage}\` | Paste image from clipboard |
+| \`${pasteImage}\` | Paste image or text from clipboard |
 | \`/\` | Slash commands |
 | \`!\` | Run bash command |
 | \`!!\` | Run bash command (excluded from context) |
@@ -4345,7 +5239,7 @@ export class InteractiveMode {
 `;
             for (const [key, shortcut] of shortcuts) {
                 const description = shortcut.description ?? shortcut.extensionPath;
-                const keyDisplay = key.replace(/\b\w/g, (c) => c.toUpperCase());
+                const keyDisplay = formatKeyText(key, { capitalize: true });
                 hotkeys += `| \`${keyDisplay}\` | ${description} |\n`;
             }
         }
@@ -4358,17 +5252,12 @@ export class InteractiveMode {
         this.ui.requestRender();
     }
     async handleClearCommand() {
-        if (this.loadingAnimation) {
-            this.loadingAnimation.stop();
-            this.loadingAnimation = undefined;
-        }
-        this.statusContainer.clear();
+        this.clearStatusIndicator();
         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();
@@ -4409,11 +5298,6 @@ 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));
@@ -4490,17 +5374,7 @@ export class InteractiveMode {
         this.ui.requestRender();
     }
     async handleCompactCommand(customInstructions) {
-        const entries = this.sessionManager.getEntries();
-        const messageCount = entries.filter((e) => e.type === "message").length;
-        if (messageCount < 2) {
-            this.showWarning("Nothing to compact (no messages yet)");
-            return;
-        }
-        if (this.loadingAnimation) {
-            this.loadingAnimation.stop();
-            this.loadingAnimation = undefined;
-        }
-        this.statusContainer.clear();
+        this.clearStatusIndicator();
         try {
             await this.session.compact(customInstructions);
         }
@@ -4508,15 +5382,13 @@ export class InteractiveMode {
             // Ignore, will be emitted as an event
         }
     }
-    stop() {
-        this.unregisterSignalHandlers();
+    stop(fullscreenExitOutput = this.settingsManager.getFullscreenExitOutput()) {
+        this.disposeActiveSelector();
         if (this.settingsManager.getShowTerminalProgress()) {
             this.ui.terminal.setProgress(false);
         }
-        if (this.loadingAnimation) {
-            this.loadingAnimation.stop();
-            this.loadingAnimation = undefined;
-        }
+        this.clearStatusIndicator();
+        this.themeController.disableAutoSync();
         this.clearExtensionTerminalInputListeners();
         this.footer.dispose();
         this.footerDataProvider.dispose();
@@ -4524,9 +5396,10 @@ export class InteractiveMode {
             this.unsubscribe();
         }
         if (this.isInitialized) {
-            this.ui.stop();
+            this.stopInteractiveTui(fullscreenExitOutput);
             this.isInitialized = false;
         }
+        this.unregisterSignalHandlers();
     }
 }
 //# sourceMappingURL=interactive-mode.js.map