@ai-agent-forge/agent-forge 0.85.0

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

@@ -0,0 +1,4107 @@
+/**
+ * Interactive mode for the coding agent.
+ * Handles TUI rendering and user interaction, delegating business logic to AgentSession.
+ */
+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 { contentText } from "@agent-forge/ai";
+import * as TuiLayouts from "@agent-forge/tui";
+import { CombinedAutocompleteProvider, Container, getCapabilities, hyperlink, Markdown, ProcessTerminal, Spacer, setCapabilityOverrides, setKeybindings, Text, TruncatedText, TuiAltScreen, TuiMainScreen, visibleWidth, } from "@agent-forge/tui";
+import chalk from "chalk";
+import { spawn } from "child_process";
+import { APP_NAME, APP_TITLE, getAgentDir, getDebugLogPath, 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 { DEFAULT_THINKING_LEVEL, THINKING_LEVEL_OPTIONS } from "../../core/defaults.js";
+import { createCodingAgentFacade, createCodingAgentRuntimeFacade, } from "../../core/facade/index.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 { DefaultPackageManager } from "../../core/package-manager.js";
+import { formatMissingSessionCwdPrompt, MissingSessionCwdError } from "../../core/session-cwd.js";
+import { SessionManager, sessionEntryToContextMessages } from "../../core/session-manager.js";
+import { BUILTIN_SLASH_COMMANDS } from "../../core/slash-commands.js";
+import { getUsageCostBreakdown } from "../../core/usage-totals.js";
+import { listSuiteIds, resolveSuiteId, SUITE_ENV_VAR, SUITE_SESSION_ENTRY_TYPE } from "../../profiles/suite-loader.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 { killTrackedDetachedChildren } from "../../utils/shell.js";
+import { loadAllHighlightLanguages } from "../../utils/syntax-highlight.js";
+import { ensureTool } from "../../utils/tools-manager.js";
+import { checkForNewVersion } 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 { BranchSummaryMessageComponent } from "./components/branch-summary-message.js";
+import { CompactionSummaryMessageComponent } from "./components/compaction-summary-message.js";
+import { CustomEditor } from "./components/custom-editor.js";
+import { CustomMessageComponent } from "./components/custom-message.js";
+import { DaxnutsComponent } from "./components/daxnuts.js";
+import { DynamicBorder } from "./components/dynamic-border.js";
+import { FooterComponent, formatTokens } from "./components/footer.js";
+import { formatKeyText, keyDisplayText, keyHint, keyText, rawKeyHint } from "./components/keybinding-hints.js";
+import { createMermaidMarkdownTransformer } from "./components/mermaid.js";
+import { readSessionSuiteIdFromFile, 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 { UserMessageComponent } from "./components/user-message.js";
+import { editInExternalEditor } from "./external-editor.js";
+import * as authFlow from "./interactive-auth.js";
+import { COMMAND_DISPATCH_ENTRIES, matchCommandDispatchEntry } from "./interactive-commands.js";
+import { createInteractionHostV1, hideDialogEditor, hideDialogInput, hideDialogSelector, isExpandable, showDialogConfirm, showDialogEditor, showDialogInput, showDialogNotify, showDialogSelector, } from "./interactive-dialog-ui.js";
+import { buildScopeGroups, findSourceInfoForPath, formatContextPath, formatDiagnostics, formatDisplayPath, formatMetricsSnapshot, formatPathWithSource, formatScopeGroups, getCompactPackageSourceLabel, getCompactPathLabel, getDisplaySourceInfo, getScopeGroup, getShortPath, isPackageSource, } from "./interactive-format.js";
+import { createFuzzyAutocompleteItems, formatLoginProviderCompletionDescription, getLoginProviderCompletionOptions, getLoginProviderSearchText, isAnthropicSubscriptionAuthKey, isDeadTerminalError, quoteIfNeeded, } from "./interactive-helpers.js";
+import * as selectorsFlow from "./interactive-selectors.js";
+import { refreshModelCatalogs } from "./model-catalog-refresh.js";
+import { getModelSearchText } from "./model-search.js";
+import { getAvailableThemes, getEditorTheme, getMarkdownTheme, loadThemeFromPath, onThemeChange, setRegisteredThemes, stopThemeWatcher, Theme, theme, } from "./theme/theme.js";
+import { InteractiveThemeController } from "./theme/theme-controller.js";
+// Re-exported for existing consumers of the interactive mode module; the
+// implementation moved to ./interactive-dialog-ui.ts with the extension UI block.
+export { mapLegacyDialogResultToOutcome } from "./interactive-dialog-ui.js";
+/**
+ * Rebuilds real Theme instances from the resource loader's ThemeMetaV1
+ * projection for the theme registry (B-S2b v1). Registration points
+ * (constructor, runtime session start, reload) need loadable instances —
+ * setRegisteredThemes stores what it is given and getThemeByName returns the
+ * registered instance first — while the loader surface now projects only
+ * metadata. Re-loading is synchronous and deterministic per sourcePath;
+ * theme names come from the same JSON the loader parsed, so meta.name ===
+ * Theme.name and the registry keeps its own name-filter/dedupe semantics.
+ *
+ * Contract: a meta without a sourcePath (or one whose file no longer parses)
+ * throws — themesOverride host inputs must always carry a loadable
+ * sourcePath. This adds one extra parse per theme at registration time
+ * (constructor / session start / reload, not per turn).
+ */
+export function buildRegisteredThemes(themes) {
+    return themes.map((meta) => loadThemeFromPath(meta.sourcePath));
+}
+class ExpandableText extends Text {
+    getCollapsedText;
+    getExpandedText;
+    constructor(getCollapsedText, getExpandedText, expanded = false, paddingX = 0, paddingY = 0) {
+        super(expanded ? getExpandedText() : getCollapsedText(), paddingX, paddingY);
+        this.getCollapsedText = getCollapsedText;
+        this.getExpandedText = getExpandedText;
+    }
+    setExpanded(expanded) {
+        this.setText(expanded ? this.getExpandedText() : this.getCollapsedText());
+    }
+}
+function isCustomSessionEntry(item) {
+    return "type" in item && item.type === "custom";
+}
+function isCompactionCostNotice(item) {
+    return "type" in item && item.type === "compaction_cost";
+}
+// Empty-reply auto-continuation (#5, print-mode parity): sent at most once per
+// submitted turn when the turn ends with an empty assistant reply and the
+// model was neither aborted nor errored. The one-shot budget prevents loops.
+const EMPTY_REPLY_RETRY_PROMPT = "Your previous reply was empty. Continue the user's task now.";
+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.";
+export function formatResumeCommand(session) {
+    if (!process.stdout.isTTY)
+        return undefined;
+    if (!session.isPersisted())
+        return undefined;
+    const sessionFile = session.getSessionFile();
+    if (!sessionFile || !fs.existsSync(sessionFile))
+        return undefined;
+    const args = [APP_NAME];
+    if (!session.usesDefaultSessionDir()) {
+        args.push("--session-dir", quoteIfNeeded(session.getSessionDir()));
+    }
+    args.push("--session", session.getSessionId());
+    return args.join(" ");
+}
+/** 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,
+            copyOnSelect: options.fullscreenCopyOnSelect,
+            copySelection: async (text) => {
+                try {
+                    await copyToClipboard(text);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            },
+        });
+    }
+    return new TuiMainScreen(terminal, options.showHardwareCursor, options.logDirectory);
+}
+/** 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 {
+    runtimeHost;
+    renderer;
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    ui;
+    mainScreenRenderState;
+    loadedResourcesContainer;
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    chatContainer;
+    documentContainer;
+    transcriptScrollView;
+    fullscreenLayoutRoot;
+    pendingMessagesContainer;
+    statusContainer;
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    defaultEditor;
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    editor;
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    autocompleteProvider;
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    fdPath;
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    editorContainer;
+    activeSelectorToken;
+    activeSelectorDispose;
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    footer;
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    footerContainer;
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    footerDataProvider;
+    // Stored so the same manager can be injected into custom editors, selectors, and extension UI.
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    keybindings;
+    version;
+    isInitialized = false;
+    onInputCallback;
+    pendingUserInputs = [];
+    activeStatusIndicator = undefined;
+    idleStatus = new IdleStatus();
+    workingMessage = undefined;
+    workingVisible = true;
+    workingIndicatorOptions = undefined;
+    defaultWorkingMessage = "Working...";
+    defaultHiddenThinkingLabel = "Thinking...";
+    hiddenThinkingLabel = this.defaultHiddenThinkingLabel;
+    lastSigintTime = 0;
+    lastEscapeTime = 0;
+    changelogMarkdown = undefined;
+    startupNoticesShown = false;
+    anthropicSubscriptionWarningShown = false;
+    // Status line tracking (for mutating immediately-sequential status updates)
+    lastStatusSpacer = undefined;
+    lastStatusText = undefined;
+    managedToolStatusStarted = false;
+    // Streaming message tracking
+    streamingComponent = undefined;
+    streamingMessage = undefined;
+    // Tool execution tracking: toolCallId -> component
+    pendingTools = new Map();
+    // Tool output expansion state
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    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
+    unsubscribe;
+    signalCleanupHandlers = [];
+    // Track if editor is in bash mode (text starts with !)
+    isBashMode = false;
+    // Track current bash execution component
+    bashComponent = undefined;
+    // Track pending bash components (shown in pending area, moved to chat on submit)
+    pendingBashComponents = [];
+    // Auto-compaction state
+    autoCompactionEscapeHandler;
+    // Auto-retry state
+    retryEscapeHandler;
+    // Messages queued while compaction is running
+    compactionQueuedMessages = [];
+    // Shutdown state
+    shutdownRequested = false;
+    // Extension UI state: host-visible for ./interactive-dialog-ui.ts (S5 slice 2).
+    dialogSelector = undefined;
+    dialogInput = undefined;
+    // Settles the replaced dialog's still-pending promise when a concurrent
+    // request mounts a new dialog in the same slot (1A.8: request() settles).
+    dialogSelectorReplaced = undefined;
+    dialogInputReplaced = undefined;
+    dialogEditor = undefined;
+    // Layout spacer slots above/below the editor (fixed empty chrome; the legacy extension widget producer is retired).
+    widgetContainerAbove;
+    widgetContainerBelow;
+    // Header container that holds the built-in or custom header
+    headerContainer;
+    // Built-in header (logo + keybinding hints + changelog)
+    builtInHeader = undefined;
+    options;
+    onRightClickPaste = () => {
+        void this.handleRightClickPaste();
+    };
+    themeController;
+    // Convenience accessors
+    get session() {
+        return this.runtimeHost.session;
+    }
+    get agent() {
+        // 1B.7c: agent-loop control goes through the curated host surface.
+        return {
+            abort: () => this.session.host.abortAgent(),
+            signal: this.session.host.abortSignal,
+        };
+    }
+    /**
+     * Constructor-injected settings (D-047): the TUI reads settings from the
+     * host-provided manager, never from AgentSession. Internal collaboration
+     * surface; exposed for ./interactive-selectors.ts (S5 slice 5).
+     */
+    get settingsManager() {
+        return this.options.settingsManager;
+    }
+    // Stable facade (阶段 1 slice 1): derived on each access; the facade and
+    // `this.session` always resolve to the same AgentSession, so session rebind
+    // needs no separate handling.
+    /** Internal collaboration surface; exposed for ./interactive-selectors.ts (S5 slice 5). */
+    get facade() {
+        return createCodingAgentFacade(this.session);
+    }
+    // Stable runtime facade (阶段 4 slice 3): derived on each access, same
+    // pattern as `facade`; runtime session rebinds are picked up automatically.
+    /** Internal collaboration surface; exposed for ./interactive-selectors.ts (S5 slice 5). */
+    get runtimeFacade() {
+        return createCodingAgentRuntimeFacade(this.runtimeHost);
+    }
+    constructor(runtimeHost, options) {
+        // Assign options first: the settingsManager getter reads the injected
+        // manager (D-047) and the constructor uses it before anything else.
+        this.options = { ...options };
+        this.runtimeHost = runtimeHost;
+        setCapabilityOverrides(this.settingsManager.getTerminalCapabilityOverrides());
+        const tuiMode = options.tuiMode ?? this.settingsManager.getTuiMode();
+        this.options.tuiMode = tuiMode;
+        this.runtimeFacade.setBeforeSessionInvalidate(() => {
+            this.resetDialogUI();
+        });
+        this.runtimeFacade.setRebindSession(async () => {
+            await this.rebindCurrentSession({ renderBeforeBind: true });
+            await this.themeController.applyFromSettings();
+        });
+        this.version = VERSION;
+        this.renderer = createInteractiveTui({
+            tuiMode,
+            showHardwareCursor: this.settingsManager.getShowHardwareCursor(),
+            logDirectory: getAgentDir(),
+            onRightClickPaste: this.onRightClickPaste,
+            fullscreenCopyOnSelect: this.settingsManager.getFullscreenCopyOnSelect(),
+        });
+        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();
+        // Fixed empty state (single spacer): matches the retired widget renderer's empty layout.
+        this.widgetContainerAbove.addChild(new Spacer(1));
+        this.widgetContainerBelow = new Container();
+        this.keybindings = KeybindingsManager.create();
+        setKeybindings(this.keybindings);
+        const editorPaddingX = this.settingsManager.getEditorPaddingX();
+        const autocompleteMaxVisible = this.settingsManager.getAutocompleteMaxVisible();
+        this.defaultEditor = new CustomEditor(this.ui, getEditorTheme(), this.keybindings, {
+            paddingX: editorPaddingX,
+            autocompleteMaxVisible,
+        });
+        this.editor = this.defaultEditor;
+        this.editorContainer = new Container();
+        this.editorContainer.addChild(this.editor);
+        this.footerDataProvider = new FooterDataProvider(this.facade.getCwd());
+        this.footer = new FooterComponent(this.session, this.footerDataProvider);
+        this.footer.setAutoCompactEnabled(this.facade.isAutoCompactionEnabled());
+        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(buildRegisteredThemes(this.facade.getThemes().themes));
+        this.themeController = new InteractiveThemeController(this.ui, {
+            getSettingsManager: () => this.settingsManager,
+            showError: (message) => this.showError(message),
+            onChanged: () => this.updateEditorBorderColor(),
+            initialThemeSetting: options.initialThemeSetting,
+        });
+    }
+    getAutocompleteSourceTag(sourceInfo) {
+        if (!sourceInfo) {
+            return undefined;
+        }
+        const scopePrefix = sourceInfo.scope === "user" ? "u" : sourceInfo.scope === "project" ? "p" : "t";
+        const source = sourceInfo.source.trim();
+        if (source === "auto" || source === "local" || source === "cli") {
+            return scopePrefix;
+        }
+        if (source.startsWith("npm:")) {
+            return `${scopePrefix}:${source}`;
+        }
+        const gitSource = parseGitUrl(source);
+        if (gitSource) {
+            const ref = gitSource.ref ? `@${gitSource.ref}` : "";
+            return `${scopePrefix}:git:${gitSource.host}/${gitSource.path}${ref}`;
+        }
+        return scopePrefix;
+    }
+    prefixAutocompleteDescription(description, sourceInfo) {
+        const sourceTag = this.getAutocompleteSourceTag(sourceInfo);
+        if (!sourceTag) {
+            return description;
+        }
+        return description ? `[${sourceTag}] ${description}` : `[${sourceTag}]`;
+    }
+    createBaseAutocompleteProvider() {
+        // Define commands for autocomplete
+        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");
+        // v8 ignore next -- BUILTIN_SLASH_COMMANDS 恒含 model，find 必命中
+        if (modelCommand) {
+            modelCommand.getArgumentCompletions = (prefix) => {
+                const models = this.facade.getScopedModels().length > 0
+                    ? this.facade.getScopedModels().map((s) => s.model)
+                    : this.facade.getAvailableModels();
+                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}`,
+                }));
+                return createFuzzyAutocompleteItems(items, prefix, getModelSearchText, (item) => ({
+                    value: item.label,
+                    label: item.id,
+                    description: item.provider,
+                }));
+            };
+        }
+        const thinkingCommand = slashCommands.find((command) => command.name === "thinking");
+        // v8 ignore next -- BUILTIN_SLASH_COMMANDS 恒含 thinking，find 必命中
+        if (thinkingCommand) {
+            thinkingCommand.getArgumentCompletions = (prefix) => {
+                return createFuzzyAutocompleteItems(this.facade.getAvailableThinkingLevels(), prefix, (level) => level, (level) => ({
+                    value: level,
+                    label: level,
+                }));
+            };
+        }
+        const suiteCommand = slashCommands.find((command) => command.name === "suite");
+        // v8 ignore next -- BUILTIN_SLASH_COMMANDS 恒含 suite，find 必命中
+        if (suiteCommand) {
+            suiteCommand.getArgumentCompletions = (prefix) => {
+                return createFuzzyAutocompleteItems(listSuiteIds(getAgentDir()), prefix, (id) => id, (id) => ({
+                    value: id,
+                    label: id,
+                }));
+            };
+        }
+        const loginCommand = slashCommands.find((command) => command.name === "login");
+        // v8 ignore next -- BUILTIN_SLASH_COMMANDS 恒含 login，find 必命中
+        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),
+                }));
+            };
+        }
+        const capabilityRegistrations = this.session.getCapabilityRuntime().listCommands();
+        const capabilityCommandNames = new Set(capabilityRegistrations.map(({ definition }) => definition.name));
+        // Conflicting command names are rejected by AgentSession rather than silently
+        // selecting a source, so do not offer either side as an executable completion.
+        const templateCommands = this.facade
+            .getPromptTemplates()
+            .filter((cmd) => !capabilityCommandNames.has(cmd.name))
+            .map((cmd) => ({
+            name: cmd.name,
+            description: this.prefixAutocompleteDescription(cmd.description, cmd.sourceInfo),
+            ...(cmd.argumentHint && { argumentHint: cmd.argumentHint }),
+        }));
+        const builtinCommandNames = new Set(slashCommands.map((c) => c.name));
+        const resourceSkillCommandNames = new Set(this.facade.getSkills().skills.map((skill) => `skill:${skill.name}`));
+        const capabilityCommands = capabilityRegistrations
+            .filter(({ definition }) => !builtinCommandNames.has(definition.name) &&
+            !this.facade.getPromptTemplates().some((template) => template.name === definition.name) &&
+            !resourceSkillCommandNames.has(definition.name))
+            .map(({ definition }) => ({
+            name: definition.name,
+            description: definition.description,
+            ...(definition.argumentHint && { argumentHint: definition.argumentHint }),
+        }));
+        // Build skill commands from session.skills (if enabled)
+        this.skillCommands.clear();
+        const skillCommandList = [];
+        if (this.settingsManager.getEnableSkillCommands()) {
+            for (const skill of this.facade.getSkills().skills) {
+                const commandName = `skill:${skill.name}`;
+                if (capabilityCommandNames.has(commandName))
+                    continue;
+                this.skillCommands.set(commandName, skill.filePath);
+                skillCommandList.push({
+                    name: commandName,
+                    description: this.prefixAutocompleteDescription(skill.description, skill.sourceInfo),
+                });
+            }
+        }
+        return new CombinedAutocompleteProvider([...slashCommands, ...templateCommands, ...capabilityCommands, ...skillCommandList], this.facade.getCwd(), this.fdPath);
+    }
+    setupAutocompleteProvider() {
+        const provider = this.createBaseAutocompleteProvider();
+        this.autocompleteProvider = provider;
+        this.defaultEditor.setAutocompleteProvider(provider);
+        if (this.editor !== this.defaultEditor) {
+            this.editor.setAutocompleteProvider?.(provider);
+        }
+    }
+    showStartupNoticesIfNeeded() {
+        if (this.startupNoticesShown) {
+            return;
+        }
+        this.startupNoticesShown = true;
+        if (!this.changelogMarkdown) {
+            return;
+        }
+        if (this.chatContainer.children.length > 0) {
+            this.chatContainer.addChild(new Spacer(1));
+        }
+        this.chatContainer.addChild(new DynamicBorder());
+        if (this.settingsManager.getCollapseChangelog()) {
+            const versionMatch = this.changelogMarkdown.match(/##\s+\[?(\d+\.\d+\.\d+)\]?/);
+            const latestVersion = versionMatch ? versionMatch[1] : this.version;
+            const condensedText = `Updated to v${latestVersion}. Use ${theme.bold("/changelog")} to view full changelog.`;
+            this.chatContainer.addChild(new Text(condensedText, 1, 0));
+        }
+        else {
+            this.chatContainer.addChild(new Text(theme.bold(theme.fg("accent", "What's New")), 1, 0));
+            this.chatContainer.addChild(new Spacer(1));
+            this.chatContainer.addChild(new Markdown(this.changelogMarkdown.trim(), 1, 0, this.getMarkdownThemeWithSettings()));
+            this.chatContainer.addChild(new Spacer(1));
+        }
+        this.chatContainer.addChild(new DynamicBorder());
+    }
+    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: getAgentDir(),
+            terminal,
+            onRightClickPaste: this.onRightClickPaste,
+            fullscreenCopyOnSelect: this.settingsManager.getFullscreenCopyOnSelect(),
+        });
+        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();
+        if (restoreProgress &&
+            this.settingsManager.getShowTerminalProgress() &&
+            (this.facade.isStreaming() || this.facade.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();
+        if (this.facade.getScopedModels().length > 0 &&
+            (this.options.verbose || !this.settingsManager.getQuietStartup())) {
+            const modelList = this.facade
+                .getScopedModels()
+                .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.
+        // Widget chrome is fixed empty; no initialization render needed.
+        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}`);
+            // Build startup instructions using keybinding hint helpers
+            const hint = (keybinding, description) => keyHint(keybinding, description);
+            const expandedInstructions = [
+                hint("app.interrupt", "to interrupt"),
+                hint("app.clear", "to clear"),
+                rawKeyHint(`${keyText("app.clear")} twice`, "to exit"),
+                hint("app.exit", "to exit (empty)"),
+                hint("app.suspend", "to suspend"),
+                keyHint("tui.editor.deleteToLineEnd", "to delete to end"),
+                hint("app.thinking.cycle", "to cycle thinking level"),
+                rawKeyHint(`${keyText("app.model.cycleForward")}/${keyText("app.model.cycleBackward")}`, "to cycle models"),
+                hint("app.model.select", "to select model"),
+                hint("app.tools.expand", "to expand tools"),
+                hint("app.thinking.toggle", "to expand thinking"),
+                hint("app.editor.external", "for external editor"),
+                rawKeyHint("/", "for commands"),
+                rawKeyHint("!", "to run bash"),
+                rawKeyHint("!!", "to run bash (no context)"),
+                hint("app.message.followUp", "to queue follow-up"),
+                hint("app.message.dequeue", "to edit all queued messages"),
+                hint("app.clipboard.pasteImage", "to paste image (with text fallback)"),
+                rawKeyHint("drop files", "to attach"),
+            ].join("\n");
+            const compactInstructions = [
+                hint("app.interrupt", "interrupt"),
+                rawKeyHint(`${keyText("app.clear")}/${keyText("app.exit")}`, "clear/exit"),
+                rawKeyHint("/", "commands"),
+                rawKeyHint("!", "bash"),
+                hint("app.tools.expand", "more"),
+            ].join(theme.fg("muted", " · "));
+            const compactOnboarding = theme.fg("dim", `Press ${keyText("app.tools.expand")} to show full startup help and loaded resources.`);
+            const onboarding = theme.fg("dim", `Agent Forge can explain its own features and look up its docs. Ask it how to use or extend Agent Forge.`);
+            this.builtInHeader = new ExpandableText(() => `${logo}\n${compactInstructions}\n${compactOnboarding}\n\n${onboarding}`, () => `${logo}\n${expandedInstructions}\n\n${onboarding}`, this.getStartupExpansionState(), 1, 0);
+            // Setup UI layout
+            this.headerContainer.addChild(new Spacer(1));
+            this.headerContainer.addChild(this.builtInHeader);
+            this.headerContainer.addChild(new Spacer(1));
+        }
+        else {
+            // Minimal header when silenced
+            this.builtInHeader = new Text("", 0, 0);
+            this.headerContainer.addChild(this.builtInHeader);
+        }
+        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();
+        this.ui.requestRender();
+        // Initialize extensions first so resources are shown before messages
+        await this.rebindCurrentSession();
+        // Render initial messages AFTER showing loaded resources
+        this.renderInitialMessages();
+        // Cross-suite resume detection (设计 §10.1 最小可用版): a `-c`/resumed
+        // session may carry a binding from a different suite than the one the
+        // runtime just assembled it with. Record the fact; conversion is out of
+        // scope.
+        this.detectCrossSuiteResume();
+        // Set up theme file watcher
+        onThemeChange(() => {
+            this.ui.invalidate();
+            this.updateEditorBorderColor();
+            this.ui.requestRender();
+        });
+        // Set up git branch watcher (uses provider instead of footer)
+        this.footerDataProvider.onBranchChange(() => {
+            this.ui.requestRender();
+        });
+        // Initialize available provider count for footer display
+        await this.updateAvailableProviderCount();
+        // Unresolved startup suite id (设计 §9): with the TUI ready, let the user
+        // pick a suite before the first prompt; the session is then rebuilt with
+        // the selected suite. print/RPC never reach here (structured exit in main.ts).
+        if (this.options.pendingSuiteSelector) {
+            await this.showStartupSuiteSelector(this.options.pendingSuiteSelector);
+        }
+        // Flush the completed startup state before loading the remaining syntax grammars.
+        this.ui.renderNow();
+        void loadAllHighlightLanguages().then(() => {
+            if (!this.isInitialized)
+                return;
+            this.ui.invalidate();
+            this.ui.requestRender();
+        });
+    }
+    /**
+     * Update terminal title with session name and cwd.
+     */
+    updateTerminalTitle() {
+        const cwdBasename = path.basename(this.facade.getCwd());
+        const sessionName = this.facade.getSessionName();
+        if (sessionName) {
+            this.ui.terminal.setTitle(`${APP_TITLE} - ${sessionName} - ${cwdBasename}`);
+        }
+        else {
+            this.ui.terminal.setTitle(`${APP_TITLE} - ${cwdBasename}`);
+        }
+    }
+    /**
+     * Run the interactive mode. This is the main entry point.
+     * Initializes the UI, shows warnings, processes initial messages, and starts the interactive loop.
+     */
+    async run() {
+        await this.init();
+        if (!process.env.AGENT_FORGE_OFFLINE) {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 15_000);
+            void refreshModelCatalogs(this.facade.getModelCatalog(), controller.signal)
+                .then(() => this.updateAvailableProviderCount())
+                .catch(() => { })
+                .finally(() => clearTimeout(timeout));
+        }
+        // Start version check asynchronously
+        checkForNewVersion(this.version).then((newRelease) => {
+            if (newRelease) {
+                this.showNewVersionNotification(newRelease);
+            }
+        });
+        // Start package update check asynchronously
+        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 the product title after the startup check.
+            if (process.platform === "win32" && this.isInitialized) {
+                this.updateTerminalTitle();
+            }
+        });
+        // Check tmux keyboard setup asynchronously
+        this.checkTmuxKeyboardSetup().then((warning) => {
+            if (warning) {
+                this.showWarning(warning);
+            }
+        });
+        // Show startup warnings
+        const { migratedProviders, startupDiagnostics, modelFallbackMessage, initialMessage, initialImages, initialMessages, } = this.options;
+        for (const diagnostic of startupDiagnostics ?? []) {
+            if (diagnostic.type === "error") {
+                this.showError(diagnostic.message);
+            }
+            else if (diagnostic.type === "warning") {
+                this.showWarning(diagnostic.message);
+            }
+            else {
+                this.showStatus(diagnostic.message);
+            }
+        }
+        if (migratedProviders && migratedProviders.length > 0) {
+            this.showWarning(`Migrated credentials to auth.json: ${migratedProviders.join(", ")}`);
+        }
+        const modelsJsonError = this.facade.getModelsError();
+        if (modelsJsonError) {
+            this.showError(`models.json error: ${modelsJsonError}`);
+        }
+        if (modelFallbackMessage) {
+            this.showWarning(modelFallbackMessage);
+        }
+        void this.maybeWarnAboutAnthropicSubscriptionAuth();
+        // Process initial messages
+        if (initialMessage) {
+            try {
+                await this.facade.prompt(initialMessage, { images: initialImages });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+                this.showError(errorMessage);
+            }
+        }
+        if (initialMessages) {
+            for (const message of initialMessages) {
+                try {
+                    await this.facade.prompt(message);
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+                    this.showError(errorMessage);
+                }
+            }
+        }
+        // Main interactive loop
+        while (true) {
+            const userInput = await this.getUserInput();
+            try {
+                await this.promptWithEmptyReplyRetry(userInput);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+                this.showError(errorMessage);
+            }
+        }
+    }
+    /**
+     * One-shot empty-reply auto-continuation (#5, print-mode parity): when a
+     * submitted turn finishes with an empty assistant text — and the model was
+     * neither aborted nor errored — nudge the model once to continue the task.
+     * The retry itself is never retried, so the budget is capped at one
+     * continuation per submission and this cannot loop.
+     */
+    async promptWithEmptyReplyRetry(text) {
+        const seen = this.facade.getState().messages.length;
+        await this.facade.prompt(text);
+        const lastAssistant = [...this.facade.getState().messages.slice(seen)]
+            .reverse()
+            .find((m) => m.role === "assistant");
+        if (lastAssistant === undefined)
+            return;
+        if (lastAssistant.stopReason === "error" || lastAssistant.stopReason === "aborted")
+            return;
+        if (contentText(lastAssistant.content).trim().length > 0)
+            return;
+        this.showStatus("Previous reply was empty, retrying...");
+        await this.facade.prompt(EMPTY_REPLY_RETRY_PROMPT);
+    }
+    async checkForPackageUpdates() {
+        if (process.env.AGENT_FORGE_OFFLINE) {
+            return [];
+        }
+        try {
+            const packageManager = new DefaultPackageManager({
+                cwd: this.facade.getCwd(),
+                agentDir: getAgentDir(),
+                settingsManager: this.settingsManager,
+            });
+            const updates = await packageManager.checkForAvailableUpdates();
+            return updates.map((update) => update.displayName);
+        }
+        catch {
+            return [];
+        }
+    }
+    async checkTmuxKeyboardSetup() {
+        if (!process.env.TMUX)
+            return undefined;
+        const runTmuxShow = (option) => {
+            return new Promise((resolve) => {
+                const proc = spawn("tmux", ["show", "-gv", option], {
+                    stdio: ["ignore", "pipe", "ignore"],
+                });
+                let stdout = "";
+                const timer = setTimeout(() => {
+                    proc.kill();
+                    resolve(undefined);
+                }, 2000);
+                proc.stdout?.on("data", (data) => {
+                    stdout += data.toString();
+                });
+                proc.on("error", () => {
+                    clearTimeout(timer);
+                    resolve(undefined);
+                });
+                proc.on("close", (code) => {
+                    clearTimeout(timer);
+                    resolve(code === 0 ? stdout.trim() : undefined);
+                });
+            });
+        };
+        const [extendedKeys, extendedKeysFormat] = await Promise.all([
+            runTmuxShow("extended-keys"),
+            runTmuxShow("extended-keys-format"),
+        ]);
+        // If we couldn't query tmux (timeout, sandbox, etc.), don't warn
+        if (extendedKeys === undefined)
+            return undefined;
+        if (extendedKeys !== "on" && extendedKeys !== "always") {
+            return "tmux extended-keys is off. Modified Enter keys may not work. Add `set -g extended-keys on` to ~/.tmux.conf and restart tmux.";
+        }
+        if (extendedKeysFormat === "xterm") {
+            return "tmux extended-keys-format is xterm. Agent Forge works best with csi-u. Add `set -g extended-keys-format csi-u` to ~/.tmux.conf and restart tmux.";
+        }
+        return undefined;
+    }
+    /**
+     * Get changelog entries to display on startup.
+     * Only shows new entries since last seen version, skips for resumed sessions.
+     */
+    getChangelogForDisplay() {
+        // Skip changelog for resumed/continued sessions (already have messages)
+        if (this.facade.getState().messages.length > 0) {
+            return undefined;
+        }
+        const lastVersion = this.settingsManager.getLastChangelogVersion();
+        const changelogPath = getChangelogPath();
+        const entries = parseChangelog(changelogPath);
+        if (!lastVersion) {
+            // Fresh install - record the version, don't show changelog
+            this.settingsManager.setLastChangelogVersion(VERSION);
+            return undefined;
+        }
+        const newEntries = getNewEntries(entries, lastVersion);
+        if (newEntries.length > 0) {
+            this.settingsManager.setLastChangelogVersion(VERSION);
+            return newEntries.map((e) => normalizeChangelogLinks(e.content, e)).join("\n\n");
+        }
+        return undefined;
+    }
+    getMarkdownThemeWithSettings() {
+        return {
+            ...getMarkdownTheme(),
+            codeBlockIndent: this.settingsManager.getCodeBlockIndent(),
+        };
+    }
+    // =========================================================================
+    // Extension System
+    // =========================================================================
+    formatDisplayPath(p) {
+        return formatDisplayPath(p);
+    }
+    formatContextPath(p) {
+        return formatContextPath(p, this.facade.getCwd());
+    }
+    getStartupExpansionState() {
+        return this.options.verbose || this.toolOutputExpanded;
+    }
+    /**
+     * Get a short path relative to the package root for display.
+     */
+    getShortPath(fullPath, sourceInfo) {
+        return getShortPath(fullPath, sourceInfo);
+    }
+    getCompactPathLabel(resourcePath, sourceInfo) {
+        return getCompactPathLabel(resourcePath, sourceInfo);
+    }
+    // The following formatting delegates have no in-class call sites (their
+    // implementations moved to interactive-format.ts) but remain part of the
+    // prototype contract, so they stay public instead of private.
+    getCompactPackageSourceLabel(sourceInfo) {
+        return getCompactPackageSourceLabel(sourceInfo);
+    }
+    getDisplaySourceInfo(sourceInfo) {
+        return getDisplaySourceInfo(sourceInfo);
+    }
+    getScopeGroup(sourceInfo) {
+        return getScopeGroup(sourceInfo);
+    }
+    isPackageSource(sourceInfo) {
+        return isPackageSource(sourceInfo);
+    }
+    buildScopeGroups(items) {
+        return buildScopeGroups(items);
+    }
+    formatScopeGroups(groups, options) {
+        return formatScopeGroups(groups, options);
+    }
+    findSourceInfoForPath(p, sourceInfos) {
+        return findSourceInfoForPath(p, sourceInfos);
+    }
+    formatPathWithSource(p, sourceInfo) {
+        return formatPathWithSource(p, sourceInfo);
+    }
+    formatDiagnostics(diagnostics, sourceInfos) {
+        return formatDiagnostics(diagnostics, sourceInfos);
+    }
+    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) {
+            return;
+        }
+        const sectionHeader = (name, color = "mdHeading") => theme.fg(color, `[${name}]`);
+        const formatCompactList = (items, options) => {
+            const labels = items.map((item) => item.trim()).filter((item) => item.length > 0);
+            if (options?.sort !== false) {
+                labels.sort((a, b) => a.localeCompare(b));
+            }
+            return theme.fg("dim", `  ${labels.join(", ")}`);
+        };
+        const addLoadedSection = (name, collapsedBody, expandedBody = collapsedBody, color = "mdHeading") => {
+            const section = new ExpandableText(() => `${sectionHeader(name, color)}\n${collapsedBody}`, () => `${sectionHeader(name, color)}\n${expandedBody}`, this.getStartupExpansionState(), 0, 0);
+            this.loadedResourcesContainer.addChild(section);
+            this.loadedResourcesContainer.addChild(new Spacer(1));
+        };
+        const skillsResult = this.facade.getSkills();
+        const promptsResult = this.facade.getPrompts();
+        const themesResult = this.facade.getThemes();
+        const sourceInfos = new Map();
+        for (const skill of skillsResult.skills) {
+            if (skill.sourceInfo) {
+                sourceInfos.set(skill.filePath, skill.sourceInfo);
+            }
+        }
+        for (const prompt of promptsResult.prompts) {
+            if (prompt.sourceInfo) {
+                sourceInfos.set(prompt.filePath, prompt.sourceInfo);
+            }
+        }
+        for (const loadedTheme of themesResult.themes) {
+            if (loadedTheme.sourcePath && loadedTheme.sourceInfo) {
+                sourceInfos.set(loadedTheme.sourcePath, loadedTheme.sourceInfo);
+            }
+        }
+        if (showListing) {
+            const systemPromptSource = this.facade.getSystemPromptSource();
+            const contextFiles = [
+                ...(systemPromptSource ? [systemPromptSource] : []),
+                ...this.facade.getAppendSystemPromptSources(),
+                ...this.facade.getAgentsFiles().agentsFiles,
+            ];
+            if (contextFiles.length > 0) {
+                this.loadedResourcesContainer.addChild(new Spacer(1));
+                const contextList = contextFiles
+                    .map((f) => theme.fg("dim", `  ${this.formatDisplayPath(f.path)}`))
+                    .join("\n");
+                const contextCompactList = formatCompactList(contextFiles.map((contextFile) => this.formatContextPath(contextFile.path)), { sort: false });
+                addLoadedSection("Context", contextCompactList, contextList);
+            }
+            const skills = skillsResult.skills;
+            if (skills.length > 0) {
+                const groups = this.buildScopeGroups(skills.map((skill) => ({ path: skill.filePath, sourceInfo: skill.sourceInfo })));
+                const skillList = this.formatScopeGroups(groups, {
+                    formatPath: (item) => this.formatDisplayPath(item.path),
+                    formatPackagePath: (item) => this.getShortPath(item.path, item.sourceInfo),
+                });
+                const skillCompactList = formatCompactList(skills.map((skill) => skill.name));
+                addLoadedSection("Skills", skillCompactList, skillList);
+            }
+            const templates = this.facade.getPromptTemplates();
+            if (templates.length > 0) {
+                const groups = this.buildScopeGroups(templates.map((template) => ({ path: template.filePath, sourceInfo: template.sourceInfo })));
+                const templateByPath = new Map(templates.map((t) => [t.filePath, t]));
+                const templateList = this.formatScopeGroups(groups, {
+                    formatPath: (item) => {
+                        const template = templateByPath.get(item.path);
+                        // v8 ignore next -- templateByPath is built from the same templates as the groups
+                        return template ? `/${template.name}` : this.formatDisplayPath(item.path);
+                    },
+                    formatPackagePath: (item) => {
+                        const template = templateByPath.get(item.path);
+                        // v8 ignore next -- templateByPath is built from the same templates as the groups
+                        return template ? `/${template.name}` : this.formatDisplayPath(item.path);
+                    },
+                });
+                const promptCompactList = formatCompactList(templates.map((template) => `/${template.name}`));
+                addLoadedSection("Prompts", promptCompactList, templateList);
+            }
+            // Show loaded themes (excluding built-in)
+            const loadedThemes = themesResult.themes;
+            const customThemes = loadedThemes.filter((t) => t.sourcePath);
+            if (customThemes.length > 0) {
+                const groups = this.buildScopeGroups(customThemes.map((loadedTheme) => ({
+                    path: loadedTheme.sourcePath,
+                    sourceInfo: loadedTheme.sourceInfo,
+                })));
+                const themeList = this.formatScopeGroups(groups, {
+                    formatPath: (item) => this.formatDisplayPath(item.path),
+                    formatPackagePath: (item) => this.getShortPath(item.path, item.sourceInfo),
+                });
+                const themeCompactList = formatCompactList(customThemes.map((loadedTheme) => loadedTheme.name ?? this.getCompactPathLabel(loadedTheme.sourcePath, loadedTheme.sourceInfo)));
+                addLoadedSection("Themes", themeCompactList, themeList);
+            }
+        }
+        // v8 ignore next -- showDiagnostics 为假时上方已提前返回，此处恒为真
+        if (showDiagnostics) {
+            const skillDiagnostics = skillsResult.diagnostics;
+            if (skillDiagnostics.length > 0) {
+                const warningLines = this.formatDiagnostics(skillDiagnostics, sourceInfos);
+                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.loadedResourcesContainer.addChild(new Text(`${theme.fg("warning", "[Prompt conflicts]")}\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.loadedResourcesContainer.addChild(new Text(`${theme.fg("warning", "[Theme conflicts]")}\n${warningLines}`, 0, 0));
+                this.loadedResourcesContainer.addChild(new Spacer(1));
+            }
+        }
+    }
+    /**
+     * Run the session-start boundary for the current session (capability
+     * session.start@1 dispatch + resource discovery pass) and refresh the
+     * startup surfaces that read session resources.
+     */
+    async bindCurrentSessionExtensions() {
+        await this.session.startSession();
+        setRegisteredThemes(buildRegisteredThemes(this.facade.getThemes().themes));
+        this.setupAutocompleteProvider();
+        this.showLoadedResources({ force: false, showDiagnosticsWhenQuiet: true });
+        this.showStartupNoticesIfNeeded();
+    }
+    applyFullscreenScrollbarSetting() {
+        this.transcriptScrollView?.setScrollbar(this.settingsManager.getFullscreenScrollbar());
+    }
+    applyRuntimeSettings() {
+        setCapabilityOverrides(this.settingsManager.getTerminalCapabilityOverrides());
+        configureHttpDispatcher(this.settingsManager.getHttpIdleTimeoutMs());
+        this.applyFullscreenScrollbarSetting();
+        if (this.renderer instanceof TuiAltScreen) {
+            this.renderer.setCopyOnSelect(this.settingsManager.getFullscreenCopyOnSelect());
+        }
+        this.footer.setSession(this.session);
+        this.footer.setAutoCompactEnabled(this.facade.isAutoCompactionEnabled());
+        this.footerDataProvider.setCwd(this.facade.getCwd());
+        this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
+        this.outputPad = this.settingsManager.getOutputPad();
+        this.ui.setShowHardwareCursor(this.settingsManager.getShowHardwareCursor());
+        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);
+        this.defaultEditor.setAutocompleteMaxVisible(autocompleteMaxVisible);
+        if (this.editor !== this.defaultEditor) {
+            this.editor.setPaddingX?.(editorPaddingX);
+            this.editor.setAutocompleteMaxVisible?.(autocompleteMaxVisible);
+        }
+    }
+    async rebindCurrentSession(options = {}) {
+        const session = this.session;
+        this.unsubscribe?.();
+        this.unsubscribe = undefined;
+        this.applyRuntimeSettings();
+        if (options.renderBeforeBind) {
+            this.renderCurrentSessionState();
+            this.subscribeToAgent();
+        }
+        await this.bindCurrentSessionExtensions();
+        if (this.session !== session) {
+            return;
+        }
+        if (!options.renderBeforeBind) {
+            this.subscribeToAgent();
+        }
+        await this.updateAvailableProviderCount();
+        this.updateEditorBorderColor();
+        this.updateTerminalTitle();
+    }
+    async handleFatalRuntimeError(prefix, error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.showError(`${prefix}: ${message}`);
+        stopThemeWatcher();
+        this.stop("transcript");
+        process.exit(1);
+    }
+    renderCurrentSessionState() {
+        this.loadedResourcesContainer.clear();
+        this.chatContainer.clear();
+        this.pendingMessagesContainer.clear();
+        this.compactionQueuedMessages = [];
+        this.streamingComponent = undefined;
+        this.streamingMessage = undefined;
+        this.pendingTools.clear();
+        this.renderInitialMessages();
+    }
+    /**
+     * Get a registered tool definition by name (for custom rendering).
+     */
+    getRegisteredToolDefinition(toolName) {
+        return this.facade.getToolDefinition(toolName);
+    }
+    getMarkdownTransformers() {
+        return [this.mermaidMarkdownTransformer];
+    }
+    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);
+        }
+    }
+    showWorkingStatusIndicator() {
+        this.showStatusIndicator(new WorkingStatusIndicator(this.ui, this.workingMessage ?? this.defaultWorkingMessage, this.workingIndicatorOptions));
+    }
+    setWorkingVisible(visible) {
+        this.workingVisible = visible;
+        if (!visible) {
+            this.clearStatusIndicator("working");
+            this.ui.requestRender();
+            return;
+        }
+        if (this.facade.isStreaming() && this.activeStatusIndicator?.kind !== "working") {
+            this.showWorkingStatusIndicator();
+        }
+        this.ui.requestRender();
+    }
+    setWorkingIndicator(options) {
+        this.workingIndicatorOptions = options;
+        if (this.activeStatusIndicator?.kind === "working") {
+            this.activeStatusIndicator.setIndicator(options);
+        }
+        this.ui.requestRender();
+    }
+    setHiddenThinkingLabel(label) {
+        this.hiddenThinkingLabel = label ?? this.defaultHiddenThinkingLabel;
+        for (const child of this.chatContainer.children) {
+            if (child instanceof AssistantMessageComponent) {
+                child.setHiddenThinkingLabel(this.hiddenThinkingLabel);
+            }
+        }
+        if (this.streamingComponent) {
+            this.streamingComponent.setHiddenThinkingLabel(this.hiddenThinkingLabel);
+        }
+        this.ui.requestRender();
+    }
+    /**
+     * Set the working/loading message shown during streaming. Host entry wired
+     * through ./interactive-dialog-ui.ts; restores the default when undefined.
+     */
+    setWorkingMessage(message) {
+        this.workingMessage = message;
+        if (this.activeStatusIndicator?.kind === "working") {
+            this.activeStatusIndicator.setMessage(message ?? this.defaultWorkingMessage);
+        }
+    }
+    resetDialogUI() {
+        if (this.dialogSelector) {
+            this.hideDialogSelector();
+        }
+        if (this.dialogInput) {
+            this.hideDialogInput();
+        }
+        if (this.dialogEditor) {
+            this.hideDialogEditor();
+        }
+        this.ui.hideOverlay();
+        this.footer.invalidate();
+        this.setupAutocompleteProvider();
+        this.updateTerminalTitle();
+        this.workingMessage = undefined;
+        this.workingVisible = true;
+        this.setWorkingIndicator();
+        if (this.activeStatusIndicator?.kind === "working") {
+            this.activeStatusIndicator.setMessage(`${this.defaultWorkingMessage} (${keyText("app.interrupt")} to interrupt)`);
+        }
+        this.setHiddenThinkingLabel();
+    }
+    /**
+     * Apply a theme request from the extension UI host (implemented by
+     * ./interactive-dialog-ui.ts), keeping the theme controller and settings
+     * persistence on the mode.
+     */
+    applyExtensionTheme(themeOrName) {
+        if (themeOrName instanceof Theme) {
+            return this.themeController.setThemeInstance(themeOrName);
+        }
+        const result = this.themeController.setThemeName(themeOrName);
+        if (result.success) {
+            if (this.settingsManager.getTheme() !== themeOrName) {
+                this.settingsManager.setTheme(themeOrName);
+            }
+        }
+        return result;
+    }
+    /**
+     * Interaction host for the versioned capability surface (1A.8): maps the
+     * frozen InteractionHostV1 contract onto the legacy TUI dialogs. Cancellation
+     * rides the existing dialog signal support; notify reuses the notify channel.
+     */
+    createInteractionHostV1() {
+        return createInteractionHostV1(this);
+    }
+    /**
+     * Show a selector for extensions.
+     */
+    showDialogSelector(title, options, opts) {
+        return showDialogSelector(this, title, options, opts);
+    }
+    /**
+     * Hide the extension selector.
+     */
+    hideDialogSelector() {
+        hideDialogSelector(this);
+    }
+    /**
+     * Show a confirmation dialog for extensions.
+     */
+    async showDialogConfirm(title, message, opts) {
+        return showDialogConfirm(this, title, message, opts);
+    }
+    async promptForMissingSessionCwd(error) {
+        const confirmed = await this.showDialogConfirm("Session cwd not found", formatMissingSessionCwdPrompt(error.issue));
+        return confirmed ? error.issue.fallbackCwd : undefined;
+    }
+    /**
+     * Show a text input for extensions.
+     */
+    showDialogInput(title, placeholder, opts) {
+        return showDialogInput(this, title, placeholder, opts);
+    }
+    /**
+     * Hide the extension input.
+     */
+    hideDialogInput() {
+        hideDialogInput(this);
+    }
+    /**
+     * Show a multi-line editor for extensions (with Ctrl+G support).
+     */
+    showDialogEditor(title, prefill) {
+        return showDialogEditor(this, title, prefill);
+    }
+    /**
+     * External editor command for extension editors. Host entry for
+     * ./interactive-dialog-ui.ts, keeping settings access on the mode.
+     */
+    getExternalEditorCommand() {
+        return this.settingsManager.getExternalEditorCommand();
+    }
+    /**
+     * Hide the extension editor.
+     */
+    hideDialogEditor() {
+        hideDialogEditor(this);
+    }
+    /**
+     * Show a notification for extensions.
+     */
+    showDialogNotify(message, type) {
+        showDialogNotify(this, message, type);
+    }
+    // =========================================================================
+    // Key Handlers
+    // =========================================================================
+    setupKeyHandlers() {
+        // Set up handlers on defaultEditor - they use this.editor for text access
+        // so they work correctly regardless of which editor is active
+        this.defaultEditor.onEscape = () => {
+            if (this.facade.isStreaming()) {
+                this.restoreQueuedMessagesToEditor({ abort: true });
+            }
+            else if (this.facade.isBashRunning()) {
+                this.facade.abortBash();
+            }
+            else if (this.isBashMode) {
+                this.editor.setText("");
+                this.isBashMode = false;
+                this.updateEditorBorderColor();
+            }
+            else if (!this.editor.getText().trim()) {
+                // Double-escape with empty editor triggers /tree, /fork, or nothing based on setting
+                const action = this.settingsManager.getDoubleEscapeAction();
+                if (action !== "none") {
+                    const now = Date.now();
+                    if (now - this.lastEscapeTime < 500) {
+                        if (action === "tree") {
+                            this.showTreeSelector();
+                        }
+                        else {
+                            this.showUserMessageSelector();
+                        }
+                        this.lastEscapeTime = 0;
+                    }
+                    else {
+                        this.lastEscapeTime = now;
+                    }
+                }
+            }
+        };
+        // Register app action handlers
+        this.defaultEditor.onAction("app.clear", () => this.handleCtrlC());
+        this.defaultEditor.onCtrlD = () => this.handleCtrlD();
+        this.defaultEditor.onAction("app.suspend", () => this.handleCtrlZ());
+        this.defaultEditor.onAction("app.thinking.cycle", () => this.cycleThinkingLevel());
+        this.defaultEditor.onAction("app.model.cycleForward", () => this.cycleModel("forward"));
+        this.defaultEditor.onAction("app.model.cycleBackward", () => this.cycleModel("backward"));
+        // Global debug handler on TUI (works regardless of focus)
+        this.ui.onDebug = () => this.handleDebugCommand();
+        this.defaultEditor.onAction("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", () => void this.handleOpenExternalEditor());
+        this.defaultEditor.onAction("app.message.copy", () => void this.handleCopyCommand({ flashConfirmation: true, preferSelection: 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());
+        this.defaultEditor.onAction("app.session.tree", () => this.showTreeSelector());
+        this.defaultEditor.onAction("app.session.fork", () => this.showUserMessageSelector());
+        this.defaultEditor.onAction("app.session.resume", () => this.showSessionSelector());
+        this.defaultEditor.onChange = (text) => {
+            const wasBashMode = this.isBashMode;
+            this.isBashMode = text.trimStart().startsWith("!");
+            if (wasBashMode !== this.isBashMode) {
+                this.updateEditorBorderColor();
+            }
+        };
+        // Handle clipboard paste (triggered on Ctrl+V). Images are attached by path;
+        // otherwise, paste plain text from the system clipboard.
+        this.defaultEditor.onPasteImage = () => {
+            void this.handleClipboardPaste();
+        };
+    }
+    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) {
+                const tmpDir = os.tmpdir();
+                const ext = extensionForImageMimeType(image.mimeType) ?? "png";
+                const fileName = `agent-forge-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;
+            }
+            const text = await readClipboardText();
+            if (text) {
+                this.editor.insertTextAtCursor?.(text);
+                this.ui.requestRender();
+            }
+        }
+        catch {
+            // Silently ignore clipboard errors (may not have permission, etc.)
+        }
+    }
+    // Startup-time submissions of plain prompts are queued; the main loop
+    // dequeues and submits them automatically once startup completes.
+    // Commands ("/", "!") and empty input keep the pre-existing behavior:
+    // commands need the post-startup dispatch context, so they are restored
+    // into the editor for the user to submit again after startup.
+    handleStartupSubmit(text) {
+        if (!text.trim())
+            return;
+        if (text.startsWith("/") || text.startsWith("!")) {
+            this.editor.setText(text);
+            this.showStatus("Startup in progress — command restored to the editor, submit again once startup completes");
+            return;
+        }
+        this.pendingUserInputs.push(text);
+        this.showStatus("Startup in progress — input queued and will run when startup completes");
+    }
+    setupEditorSubmitHandler() {
+        this.defaultEditor.onSubmit = async (text) => {
+            text = text.trim();
+            if (!text)
+                return;
+            // Handle /commands through the dispatch table (interactive-commands.ts)
+            const dispatched = this.dispatchEditorCommand(text);
+            if (dispatched) {
+                if (dispatched.pending)
+                    await dispatched.pending;
+                return;
+            }
+            // Handle bash command (! for normal, !! for excluded from context)
+            if (text.startsWith("!")) {
+                const isExcluded = text.startsWith("!!");
+                const command = isExcluded ? text.slice(2).trim() : text.slice(1).trim();
+                if (command) {
+                    if (this.facade.isBashRunning()) {
+                        this.showWarning("A bash command is already running. Press Esc to cancel it first.");
+                        this.editor.setText(text);
+                        return;
+                    }
+                    this.editor.addToHistory?.(text);
+                    await this.handleBashCommand(command, isExcluded);
+                    this.isBashMode = false;
+                    this.updateEditorBorderColor();
+                    return;
+                }
+            }
+            // Queue input during compaction
+            if (this.facade.isCompacting()) {
+                this.queueCompactionMessage(text, "steer");
+                return;
+            }
+            // If streaming, use prompt() with steer behavior
+            // This handles extension commands (execute immediately), prompt template expansion, and queueing
+            if (this.facade.isStreaming()) {
+                this.editor.addToHistory?.(text);
+                this.editor.setText("");
+                await this.facade.prompt(text, { streamingBehavior: "steer" });
+                this.updatePendingMessagesDisplay();
+                this.ui.requestRender();
+                return;
+            }
+            // Normal message submission
+            // First, move any pending bash components to chat
+            this.flushPendingBashComponents();
+            if (this.onInputCallback) {
+                this.onInputCallback(text);
+            }
+            else {
+                this.pendingUserInputs.push(text);
+            }
+            this.editor.addToHistory?.(text);
+        };
+    }
+    /**
+     * Run a /command through COMMAND_DISPATCH_ENTRIES. Returns undefined when
+     * text is not a registered command; otherwise the command has been fully
+     * dispatched (handler invoked, editor cleared in the original order) and
+     * pending carries the async completion, if any.
+     */
+    dispatchEditorCommand(text) {
+        const match = matchCommandDispatchEntry(COMMAND_DISPATCH_ENTRIES, text);
+        if (!match)
+            return undefined;
+        const { entry, arg } = match;
+        if (entry.clearEditorBeforeRun)
+            this.setEditorText("");
+        const result = entry.run(this, text, arg);
+        if (!(result instanceof Promise)) {
+            if (!entry.clearEditorBeforeRun)
+                this.setEditorText("");
+            return { pending: undefined };
+        }
+        return {
+            pending: entry.clearEditorBeforeRun ? result : result.then(() => this.setEditorText("")),
+        };
+    }
+    setEditorText(text) {
+        this.editor.setText(text);
+    }
+    subscribeToAgent() {
+        this.unsubscribe = this.facade.subscribe(async (event) => {
+            await this.handleEvent(event);
+        });
+    }
+    async handleEvent(event) {
+        if (!this.isInitialized) {
+            await this.init();
+        }
+        this.footer.invalidate();
+        switch (event.type) {
+            case "agent_start":
+                this.pendingTools.clear();
+                // Restore main escape handler if retry handler is still active
+                // (retry success event fires later, but we need main handler now)
+                if (this.retryEscapeHandler) {
+                    this.defaultEditor.onEscape = this.retryEscapeHandler;
+                    this.retryEscapeHandler = undefined;
+                }
+                break;
+            case "turn_start":
+                if (this.settingsManager.getShowTerminalProgress()) {
+                    this.ui.terminal.setProgress(true);
+                }
+                if (this.workingVisible) {
+                    if (this.activeStatusIndicator?.kind !== "working") {
+                        this.showWorkingStatusIndicator();
+                    }
+                }
+                else {
+                    this.clearStatusIndicator();
+                }
+                this.ui.requestRender();
+                break;
+            case "queue_update":
+                this.updatePendingMessagesDisplay();
+                this.ui.requestRender();
+                break;
+            case "entry_appended":
+                // Custom entries have no renderer source since the legacy extension
+                // surface was removed; nothing to append to the chat.
+                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);
+                    this.ui.requestRender();
+                }
+                else if (event.message.role === "user") {
+                    this.addMessageToChat(event.message);
+                    this.updatePendingMessagesDisplay();
+                    this.ui.requestRender();
+                }
+                else if (event.message.role === "assistant") {
+                    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, true);
+                    this.ui.requestRender();
+                }
+                break;
+            case "message_update":
+                if (this.streamingComponent && event.message.role === "assistant") {
+                    this.streamingMessage = event.message;
+                    this.streamingComponent.updateContent(this.streamingMessage, true);
+                    for (const content of this.streamingMessage.content) {
+                        if (content.type === "toolCall") {
+                            if (!this.pendingTools.has(content.id)) {
+                                const component = new ToolExecutionComponent(content.name, content.id, content.arguments, {
+                                    showImages: this.settingsManager.getShowImages(),
+                                    imageWidthCells: this.settingsManager.getImageWidthCells(),
+                                }, this.getRegisteredToolDefinition(content.name), this.ui, this.facade.getCwd());
+                                component.setExpanded(this.toolOutputExpanded);
+                                this.chatContainer.addChild(component);
+                                this.pendingTools.set(content.id, component);
+                            }
+                            else {
+                                const component = this.pendingTools.get(content.id);
+                                // v8 ignore next -- has() 已确认键存在，get() 恒返回组件
+                                if (component) {
+                                    component.updateArgs(content.arguments);
+                                }
+                            }
+                        }
+                    }
+                    this.ui.requestRender();
+                }
+                break;
+            case "message_end":
+                if (event.message.role === "user")
+                    break;
+                if (this.streamingComponent && event.message.role === "assistant") {
+                    this.streamingMessage = event.message;
+                    let errorMessage;
+                    if (this.streamingMessage.stopReason === "aborted") {
+                        const retryAttempt = this.facade.getRetryAttempt();
+                        errorMessage =
+                            retryAttempt > 0
+                                ? `Aborted after ${retryAttempt} retry attempt${retryAttempt > 1 ? "s" : ""}`
+                                : "Operation aborted";
+                        this.streamingMessage.errorMessage = errorMessage;
+                    }
+                    this.streamingComponent.updateContent(this.streamingMessage, false);
+                    if (this.streamingMessage.stopReason === "aborted" || this.streamingMessage.stopReason === "error") {
+                        if (!errorMessage) {
+                            errorMessage = this.streamingMessage.errorMessage || "Error";
+                        }
+                        for (const [, component] of this.pendingTools.entries()) {
+                            component.updateResult({
+                                content: [{ type: "text", text: errorMessage }],
+                                isError: true,
+                            });
+                        }
+                        this.pendingTools.clear();
+                    }
+                    else {
+                        // Args are now complete - trigger diff computation for edit tools
+                        for (const [, component] of this.pendingTools.entries()) {
+                            component.setArgsComplete();
+                        }
+                        this.maybeShowAssistantDiagnostics(this.streamingMessage);
+                        this.maybeShowCacheMissNotice(this.streamingMessage);
+                    }
+                    this.streamingComponent = undefined;
+                    this.streamingMessage = undefined;
+                    this.footer.invalidate();
+                }
+                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) {
+                    component = new ToolExecutionComponent(event.toolName, event.toolCallId, event.args, {
+                        showImages: this.settingsManager.getShowImages(),
+                        imageWidthCells: this.settingsManager.getImageWidthCells(),
+                    }, this.getRegisteredToolDefinition(event.toolName), this.ui, this.facade.getCwd());
+                    component.setExpanded(this.toolOutputExpanded);
+                    this.chatContainer.addChild(component);
+                    this.pendingTools.set(event.toolCallId, component);
+                }
+                component.markExecutionStarted();
+                this.ui.requestRender();
+                break;
+            }
+            case "tool_execution_update": {
+                const component = this.pendingTools.get(event.toolCallId);
+                if (component) {
+                    component.updateResult({ ...event.partialResult, isError: false }, true);
+                    this.ui.requestRender();
+                }
+                break;
+            }
+            case "tool_execution_end": {
+                const component = this.pendingTools.get(event.toolCallId);
+                if (component) {
+                    component.updateResult({ ...event.result, isError: event.isError });
+                    this.pendingTools.delete(event.toolCallId);
+                    this.ui.requestRender();
+                }
+                break;
+            }
+            case "capability_command_result": {
+                const links = event.result.links?.map((link) => `${link.label}: ${link.url}`) ?? [];
+                const message = [event.result.message, ...links].filter(Boolean).join("\n");
+                if (event.result.status === "error")
+                    this.showError(message);
+                else
+                    this.showStatus(message);
+                this.ui.requestRender();
+                break;
+            }
+            case "agent_end":
+                if (this.settingsManager.getShowTerminalProgress()) {
+                    this.ui.terminal.setProgress(false);
+                }
+                this.clearStatusIndicator("working");
+                if (this.streamingComponent) {
+                    this.chatContainer.removeChild(this.streamingComponent);
+                    this.streamingComponent = undefined;
+                    this.streamingMessage = undefined;
+                }
+                this.pendingTools.clear();
+                this.ui.requestRender();
+                break;
+            case "agent_settled":
+                await this.checkShutdownRequested();
+                break;
+            case "compaction_start": {
+                if (this.settingsManager.getShowTerminalProgress()) {
+                    this.ui.terminal.setProgress(true);
+                }
+                // Keep editor active; submissions are queued during compaction.
+                this.autoCompactionEscapeHandler = this.defaultEditor.onEscape;
+                this.defaultEditor.onEscape = () => {
+                    this.facade.abortCompaction();
+                };
+                this.showStatusIndicator(new CompactionStatusIndicator(this.ui, event.reason));
+                this.ui.requestRender();
+                break;
+            }
+            case "compaction_end": {
+                if (this.settingsManager.getShowTerminalProgress()) {
+                    this.ui.terminal.setProgress(false);
+                }
+                if (this.autoCompactionEscapeHandler) {
+                    this.defaultEditor.onEscape = this.autoCompactionEscapeHandler;
+                    this.autoCompactionEscapeHandler = undefined;
+                }
+                this.clearStatusIndicator("compaction");
+                if (event.aborted) {
+                    if (event.reason === "manual") {
+                        this.showError("Compaction cancelled");
+                    }
+                    else {
+                        this.showStatus("Auto-compaction cancelled");
+                    }
+                }
+                else if (event.result) {
+                    const entries = this.facade.getContextEntries();
+                    if (entries[0]?.type !== "compaction") {
+                        throw new Error("Completed compaction is missing from the session context");
+                    }
+                    this.chatContainer.clear();
+                    // The latest compaction is prepended for model context; append it below at its chronological position.
+                    this.renderSessionEntries(entries.slice(1));
+                    this.addMessageToChat(createCompactionSummaryMessage(event.result.summary, event.result.tokensBefore, new Date().toISOString()));
+                    if (event.result.usage) {
+                        this.addCompactionCostNotice({
+                            type: "compaction_cost",
+                            kind: "compaction",
+                            usage: event.result.usage,
+                        });
+                    }
+                    this.footer.invalidate();
+                }
+                else if (event.errorMessage) {
+                    if (event.reason === "manual") {
+                        this.showError(event.errorMessage);
+                    }
+                    else {
+                        this.chatContainer.addChild(new Spacer(1));
+                        this.chatContainer.addChild(new Text(theme.fg("error", event.errorMessage), 1, 0));
+                    }
+                }
+                void this.flushCompactionQueue({ willRetry: event.willRetry });
+                this.ui.requestRender();
+                break;
+            }
+            case "auto_retry_start": {
+                // Set up escape to abort retry
+                this.retryEscapeHandler = this.defaultEditor.onEscape;
+                this.defaultEditor.onEscape = () => {
+                    this.facade.abortRetry();
+                };
+                this.showStatusIndicator(new RetryStatusIndicator(this.ui, event.attempt, event.maxAttempts, event.delayMs));
+                this.ui.requestRender();
+                break;
+            }
+            case "auto_retry_end": {
+                // Restore escape handler
+                if (this.retryEscapeHandler) {
+                    this.defaultEditor.onEscape = this.retryEscapeHandler;
+                    this.retryEscapeHandler = undefined;
+                }
+                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"}`);
+                }
+                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 */
+    getUserMessageText(message) {
+        if (message.role !== "user")
+            return "";
+        const textBlocks = typeof message.content === "string"
+            ? [{ type: "text", text: message.content }]
+            : message.content.filter((c) => c.type === "text");
+        return textBlocks.map((c) => c.text).join("");
+    }
+    /** Show a 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.
+     *
+     * If multiple status messages are emitted back-to-back (without anything else being added to the chat),
+     * we update the previous status line instead of appending new ones to avoid log spam.
+     */
+    showStatus(message) {
+        const children = this.chatContainer.children;
+        const last = children.length > 0 ? children[children.length - 1] : undefined;
+        const secondLast = children.length > 1 ? children[children.length - 2] : undefined;
+        if (last && secondLast && last === this.lastStatusText && secondLast === this.lastStatusSpacer) {
+            this.lastStatusText.setText(theme.fg("dim", message));
+            this.ui.requestRender();
+            return;
+        }
+        const spacer = new Spacer(1);
+        const text = new Text(theme.fg("dim", message), 1, 0);
+        this.chatContainer.addChild(spacer);
+        this.chatContainer.addChild(text);
+        this.lastStatusSpacer = spacer;
+        this.lastStatusText = text;
+        this.ui.requestRender();
+    }
+    addMessageToChat(message, options) {
+        switch (message.role) {
+            case "bashExecution": {
+                const component = new BashExecutionComponent(message.command, this.ui, message.excludeFromContext);
+                if (message.output) {
+                    component.appendOutput(message.output);
+                }
+                component.setComplete(message.exitCode, message.cancelled, message.truncated ? { truncated: true } : undefined, message.fullOutputPath);
+                this.chatContainer.addChild(component);
+                break;
+            }
+            case "custom": {
+                if (message.display) {
+                    const renderer = undefined;
+                    const component = new CustomMessageComponent(message, renderer, this.getMarkdownThemeWithSettings(), this.outputPad);
+                    component.setExpanded(this.toolOutputExpanded);
+                    this.chatContainer.addChild(component);
+                }
+                break;
+            }
+            case "compactionSummary": {
+                this.chatContainer.addChild(new Spacer(1));
+                const component = new CompactionSummaryMessageComponent(message, this.getMarkdownThemeWithSettings());
+                component.setExpanded(this.toolOutputExpanded);
+                this.chatContainer.addChild(component);
+                break;
+            }
+            case "branchSummary": {
+                this.chatContainer.addChild(new Spacer(1));
+                const component = new BranchSummaryMessageComponent(message, this.getMarkdownThemeWithSettings());
+                component.setExpanded(this.toolOutputExpanded);
+                this.chatContainer.addChild(component);
+                break;
+            }
+            case "user": {
+                const textContent = this.getUserMessageText(message);
+                if (textContent) {
+                    if (this.chatContainer.children.length > 0) {
+                        this.chatContainer.addChild(new Spacer(1));
+                    }
+                    const skillBlock = parseSkillBlock(textContent);
+                    if (skillBlock) {
+                        // Render skill block (collapsible)
+                        const component = new SkillInvocationMessageComponent(skillBlock, this.getMarkdownThemeWithSettings());
+                        component.setExpanded(this.toolOutputExpanded);
+                        this.chatContainer.addChild(component);
+                        // Render user message separately if present
+                        if (skillBlock.userMessage) {
+                            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(), this.outputPad, this.getMarkdownTransformers());
+                        this.chatContainer.addChild(userComponent);
+                    }
+                    if (options?.populateHistory) {
+                        this.editor.addToHistory?.(textContent);
+                    }
+                }
+                break;
+            }
+            case "assistant": {
+                const assistantComponent = new AssistantMessageComponent(message, this.hideThinkingBlock, this.getMarkdownThemeWithSettings(), this.hiddenThinkingLabel, this.outputPad, this.getMarkdownTransformers());
+                this.chatContainer.addChild(assistantComponent);
+                break;
+            }
+            case "toolResult": {
+                // Tool results are rendered inline with tool calls, handled separately
+                break;
+            }
+            default: {
+                // v8 ignore next -- exhaustive over AgentMessage roles
+                const _exhaustive = message;
+            }
+        }
+    }
+    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.facade.getEntries(), this.facade.getModelPriceSource())
+            : new Map();
+        if (options.updateFooter) {
+            this.footer.invalidate();
+            this.updateEditorBorderColor();
+        }
+        for (const item of items) {
+            if (isCustomSessionEntry(item)) {
+                // No entry renderer source since the legacy extension surface was
+                // removed; previously renderer-less entries were skipped as well.
+                continue;
+            }
+            if (isCompactionCostNotice(item)) {
+                this.addCompactionCostNotice(item);
+                continue;
+            }
+            const message = item;
+            // Assistant messages need special handling for tool calls
+            if (message.role === "assistant") {
+                this.addMessageToChat(message);
+                // Render tool call components
+                for (const content of message.content) {
+                    if (content.type === "toolCall") {
+                        const component = new ToolExecutionComponent(content.name, content.id, content.arguments, {
+                            showImages: this.settingsManager.getShowImages(),
+                            imageWidthCells: this.settingsManager.getImageWidthCells(),
+                        }, this.getRegisteredToolDefinition(content.name), this.ui, this.facade.getCwd());
+                        component.setExpanded(this.toolOutputExpanded);
+                        this.chatContainer.addChild(component);
+                        if (message.stopReason === "aborted" || message.stopReason === "error") {
+                            let errorMessage;
+                            if (message.stopReason === "aborted") {
+                                const retryAttempt = this.facade.getRetryAttempt();
+                                errorMessage =
+                                    retryAttempt > 0
+                                        ? `Aborted after ${retryAttempt} retry attempt${retryAttempt > 1 ? "s" : ""}`
+                                        : "Operation aborted";
+                            }
+                            else {
+                                errorMessage = message.errorMessage || "Error";
+                            }
+                            component.updateResult({ content: [{ type: "text", text: errorMessage }], isError: true });
+                        }
+                        else {
+                            renderedPendingTools.set(content.id, component);
+                        }
+                    }
+                }
+                if (message.stopReason !== "aborted" && message.stopReason !== "error") {
+                    this.maybeShowAssistantDiagnostics(message);
+                    const miss = cacheMisses.get(message);
+                    if (miss)
+                        this.addCacheMissNotice(miss);
+                }
+            }
+            else if (message.role === "toolResult") {
+                // Match tool results to pending tool components
+                const component = renderedPendingTools.get(message.toolCallId);
+                if (component) {
+                    component.updateResult(message);
+                    renderedPendingTools.delete(message.toolCallId);
+                }
+            }
+            else {
+                // All other messages use standard rendering
+                this.addMessageToChat(message, options);
+            }
+        }
+        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];
+            }
+            const messages = sessionEntryToContextMessages(entry);
+            if ((entry.type === "compaction" || entry.type === "branch_summary") && entry.usage && messages.length > 0) {
+                return [...messages, { type: "compaction_cost", kind: entry.type, usage: entry.usage }];
+            }
+            return messages;
+        });
+        this.renderSessionItems(items, options);
+    }
+    /**
+     * Render billing usage for a compaction or branch summary. The notice is derived
+     * from persisted summary usage and is not stored as a separate session entry.
+     */
+    addCompactionCostNotice(notice) {
+        if (!this.settingsManager.getShowCacheMissNotices())
+            return;
+        const { usage } = notice;
+        const tokens = usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+        const cost = usage.cost.total >= 0.01 ? ` (~$${usage.cost.total.toFixed(2)})` : "";
+        const label = notice.kind === "compaction" ? "Compaction" : "Branch summary";
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new Text(theme.fg("warning", `${label}: ${formatTokens(tokens)} tokens billed${cost}`), 1, 0));
+    }
+    maybeShowAssistantDiagnostics(message) {
+        if (!this.settingsManager.getShowCacheMissNotices())
+            return;
+        for (const diagnostic of message.diagnostics ?? []) {
+            if (diagnostic.type !== "anthropic_input_transformations")
+                continue;
+            const transformations = diagnostic.details?.transformations;
+            if (!Array.isArray(transformations))
+                continue;
+            const dropped = transformations.flatMap((transformation) => {
+                if (typeof transformation !== "object" || transformation === null)
+                    return [];
+                const details = transformation;
+                if (details.type !== "thinking_dropped")
+                    return [];
+                const reason = typeof details.reason === "string" ? details.reason : "unknown reason";
+                const location = typeof details.path === "string" ? ` at ${details.path}` : "";
+                return [`${reason}${location}`];
+            });
+            if (dropped.length === 0)
+                continue;
+            const noun = dropped.length === 1 ? "thinking block" : `${dropped.length} thinking blocks`;
+            this.chatContainer.addChild(new Spacer(1));
+            this.chatContainer.addChild(new Text(theme.fg("warning", `Anthropic dropped ${noun}: ${dropped.join("; ")}`), 1, 0));
+        }
+    }
+    /**
+     * 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.facade.getEntries(), message, this.facade.getModelPriceSource());
+        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() {
+        const entries = this.facade.getContextEntries();
+        this.renderSessionEntries(entries, {
+            updateFooter: true,
+            populateHistory: true,
+        });
+        // Show compaction info if session was compacted
+        const allEntries = this.facade.getEntries();
+        const compactionCount = allEntries.filter((e) => e.type === "compaction").length;
+        if (compactionCount > 0) {
+            const times = compactionCount === 1 ? "1 time" : `${compactionCount} times`;
+            this.showStatus(`Session compacted ${times}`);
+        }
+    }
+    async getUserInput() {
+        const queuedInput = this.pendingUserInputs.shift();
+        if (queuedInput !== undefined) {
+            return queuedInput;
+        }
+        return new Promise((resolve) => {
+            this.onInputCallback = (text) => {
+                this.onInputCallback = undefined;
+                resolve(text);
+            };
+        });
+    }
+    rebuildChatFromMessages() {
+        this.chatContainer.clear();
+        this.renderSessionEntries(this.facade.getContextEntries());
+    }
+    // =========================================================================
+    // Key handlers
+    // =========================================================================
+    handleCtrlC() {
+        const now = Date.now();
+        if (now - this.lastSigintTime < 500) {
+            void this.shutdown();
+        }
+        else {
+            this.clearEditor();
+            this.lastSigintTime = now;
+        }
+    }
+    handleCtrlD() {
+        // Only called when editor is empty (enforced by CustomEditor)
+        void this.shutdown();
+    }
+    /**
+     * Gracefully shutdown the agent.
+     * Stops the TUI before emitting shutdown events so extension UI cleanup cannot
+     * repaint the final frame while the process is exiting.
+     */
+    isShuttingDown = false;
+    async shutdown(options) {
+        if (this.isShuttingDown)
+            return;
+        this.isShuttingDown = true;
+        // 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.runtimeFacade.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.runtimeFacade.dispose();
+        const resumeCommand = formatResumeCommand(this.runtimeFacade);
+        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);
+    }
+    /**
+     * 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)
+            return;
+        await this.shutdown();
+    }
+    registerSignalHandlers() {
+        this.unregisterSignalHandlers();
+        const signals = ["SIGTERM"];
+        if (process.platform !== "win32") {
+            signals.push("SIGHUP");
+        }
+        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({ fromSignal: true });
+            };
+            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 the application) 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) {
+            cleanup();
+        }
+        this.signalCleanupHandlers = [];
+    }
+    handleCtrlZ() {
+        if (process.platform === "win32") {
+            this.showStatus("Suspend to background is not supported on Windows");
+            return;
+        }
+        // Keep the event loop alive while suspended. Without this, stopping the TUI
+        // can leave Node with no ref'ed handles, causing the process to exit on fg
+        // before the SIGCONT handler gets a chance to restore the terminal.
+        const suspendKeepAlive = setInterval(() => { }, 2 ** 30);
+        // Ignore SIGINT while suspended so Ctrl+C in the terminal does not
+        // kill the backgrounded process. The handler is removed on resume.
+        const ignoreSigint = () => { };
+        process.on("SIGINT", ignoreSigint);
+        // Set up handler to restore TUI when resumed
+        process.once("SIGCONT", () => {
+            clearInterval(suspendKeepAlive);
+            process.removeListener("SIGINT", ignoreSigint);
+            this.ui.start();
+            this.ui.requestRender(true);
+        });
+        try {
+            // Stop the TUI (restore terminal to normal mode)
+            this.ui.stop();
+            // Send SIGTSTP to process group (pid=0 means all processes in group)
+            process.kill(0, "SIGTSTP");
+        }
+        catch (error) {
+            clearInterval(suspendKeepAlive);
+            process.removeListener("SIGINT", ignoreSigint);
+            throw error;
+        }
+    }
+    async handleFollowUp() {
+        const text = (this.editor.getExpandedText?.() ?? this.editor.getText()).trim();
+        if (!text)
+            return;
+        // Queue input during compaction (extension commands execute immediately)
+        if (this.facade.isCompacting()) {
+            this.queueCompactionMessage(text, "followUp");
+            return;
+        }
+        // Alt+Enter queues a follow-up message (waits until agent finishes)
+        // This handles extension commands (execute immediately), prompt template expansion, and queueing
+        if (this.facade.isStreaming()) {
+            this.editor.addToHistory?.(text);
+            this.editor.setText("");
+            await this.facade.prompt(text, { streamingBehavior: "followUp" });
+            this.updatePendingMessagesDisplay();
+            this.ui.requestRender();
+        }
+        // If not streaming, Alt+Enter acts like regular Enter (trigger onSubmit)
+        else if (this.editor.onSubmit) {
+            this.editor.setText("");
+            this.editor.onSubmit(text);
+        }
+    }
+    handleDequeue() {
+        const restored = this.restoreQueuedMessagesToEditor();
+        if (restored === 0) {
+            this.showStatus("No queued messages to restore");
+        }
+        else {
+            this.showStatus(`Restored ${restored} queued message${restored > 1 ? "s" : ""} to editor`);
+        }
+    }
+    /** Host-visible for ./interactive-auth.ts (S5 slice 3). */
+    updateEditorBorderColor() {
+        if (this.isBashMode) {
+            this.editor.borderColor = theme.getBashModeBorderColor();
+        }
+        else {
+            const level = this.facade.getState().thinkingLevel || "off";
+            this.editor.borderColor = theme.getThinkingBorderColor(level);
+        }
+        this.ui.requestRender();
+    }
+    cycleThinkingLevel() {
+        const newLevel = this.facade.cycleThinkingLevel();
+        if (newLevel === undefined) {
+            this.showStatus("Current model does not support thinking");
+        }
+        else {
+            this.footer.invalidate();
+            this.updateEditorBorderColor();
+            this.showStatus(`Thinking level: ${newLevel}`);
+        }
+    }
+    async cycleModel(direction) {
+        try {
+            const result = await this.facade.cycleModel(direction);
+            if (result === undefined) {
+                const msg = this.facade.getScopedModels().length > 0 ? "Only one model in scope" : "Only one model available";
+                this.showStatus(msg);
+            }
+            else {
+                this.footer.invalidate();
+                this.updateEditorBorderColor();
+                const thinkingStr = result.model.reasoning && result.thinkingLevel !== "off" ? ` (thinking: ${result.thinkingLevel})` : "";
+                this.showStatus(`Switched to ${result.model.name || result.model.id}${thinkingStr}`);
+                void this.maybeWarnAboutAnthropicSubscriptionAuth(result.model);
+            }
+        }
+        catch (error) {
+            this.showError(error instanceof Error ? error.message : String(error));
+        }
+    }
+    toggleToolOutputExpansion() {
+        this.setToolsExpanded(!this.toolOutputExpanded);
+    }
+    setToolsExpanded(expanded) {
+        if (expanded === this.toolOutputExpanded)
+            return;
+        this.toolOutputExpanded = expanded;
+        const activeHeader = this.builtInHeader;
+        if (isExpandable(activeHeader)) {
+            activeHeader.setExpanded(expanded);
+        }
+        for (const container of [this.loadedResourcesContainer, this.chatContainer]) {
+            for (const child of container.children) {
+                if (isExpandable(child)) {
+                    child.setExpanded(expanded);
+                }
+            }
+        }
+        this.showStatus(`Tool output: ${expanded ? "expanded" : "collapsed"}`);
+    }
+    /** Update rendered assistant messages without rebuilding live tool components. */
+    updateThinkingBlockVisibility() {
+        for (const child of this.chatContainer.children) {
+            if (child instanceof AssistantMessageComponent) {
+                child.setHideThinkingBlock(this.hideThinkingBlock);
+            }
+        }
+        this.ui.requestRender();
+    }
+    toggleThinkingBlockVisibility() {
+        this.hideThinkingBlock = !this.hideThinkingBlock;
+        this.settingsManager.setHideThinkingBlock(this.hideThinkingBlock);
+        this.updateThinkingBlockVisibility();
+        this.showStatus(`Thinking blocks: ${this.hideThinkingBlock ? "hidden" : "visible"}`);
+    }
+    async handleOpenExternalEditor() {
+        const editorCmd = this.settingsManager.getExternalEditorCommand();
+        const content = this.editor.getExpandedText?.() ?? this.editor.getText();
+        this.ui.stop();
+        try {
+            const result = await editInExternalEditor({
+                command: editorCmd,
+                content,
+            });
+            if (result.status === "complete") {
+                this.editor.setText(result.content);
+            }
+        }
+        finally {
+            this.ui.start();
+            this.ui.requestRender(true);
+        }
+    }
+    // =========================================================================
+    // UI helpers
+    // =========================================================================
+    clearEditor() {
+        this.editor.setText("");
+        this.ui.requestRender();
+    }
+    showError(errorMessage) {
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new Text(theme.fg("error", `Error: ${errorMessage}`), this.outputPad, 0));
+        this.ui.requestRender();
+    }
+    showWarning(warningMessage) {
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new Text(theme.fg("warning", `Warning: ${warningMessage}`), 1, 0));
+        this.ui.requestRender();
+    }
+    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 = process.env.AGENT_FORGE_CHANGELOG_URL;
+        const changelogLine = changelogUrl
+            ? theme.fg("muted", "Changelog: ") +
+                (getCapabilities().hyperlinks
+                    ? hyperlink(theme.fg("accent", changelogUrl), changelogUrl)
+                    : theme.fg("accent", changelogUrl))
+            : theme.fg("muted", "Changelog URL is not configured.");
+        const note = release.note?.trim();
+        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}`, 1, 0));
+        if (note) {
+            this.chatContainer.addChild(new Spacer(1));
+            this.chatContainer.addChild(new Markdown(note, 1, 0, this.getMarkdownThemeWithSettings(), {
+                color: (text) => theme.fg("muted", text),
+            }));
+            this.chatContainer.addChild(new Spacer(1));
+        }
+        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 --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));
+        this.chatContainer.addChild(new DynamicBorder((text) => theme.fg("warning", text)));
+        this.chatContainer.addChild(new Text(`${theme.bold(theme.fg("warning", "Package Updates Available"))}\n${updateInstruction}\n${theme.fg("muted", "Packages:")}\n${packageLines}`, 1, 0));
+        this.chatContainer.addChild(new DynamicBorder((text) => theme.fg("warning", text)));
+        this.ui.requestRender();
+    }
+    /**
+     * Get all queued messages (read-only).
+     * Combines session queue and compaction queue.
+     */
+    getAllQueuedMessages() {
+        return {
+            steering: [
+                ...this.facade.getSteeringMessages(),
+                ...this.compactionQueuedMessages.filter((msg) => msg.mode === "steer").map((msg) => msg.text),
+            ],
+            followUp: [
+                ...this.facade.getFollowUpMessages(),
+                ...this.compactionQueuedMessages.filter((msg) => msg.mode === "followUp").map((msg) => msg.text),
+            ],
+        };
+    }
+    /**
+     * Clear all queued messages and return their contents.
+     * Clears both session queue and compaction queue.
+     */
+    clearAllQueues() {
+        const { steering, followUp } = this.facade.clearQueue();
+        const compactionSteering = this.compactionQueuedMessages
+            .filter((msg) => msg.mode === "steer")
+            .map((msg) => msg.text);
+        const compactionFollowUp = this.compactionQueuedMessages
+            .filter((msg) => msg.mode === "followUp")
+            .map((msg) => msg.text);
+        this.compactionQueuedMessages = [];
+        return {
+            steering: [...steering, ...compactionSteering],
+            followUp: [...followUp, ...compactionFollowUp],
+        };
+    }
+    updatePendingMessagesDisplay() {
+        this.pendingMessagesContainer.clear();
+        const { steering: steeringMessages, followUp: followUpMessages } = this.getAllQueuedMessages();
+        if (steeringMessages.length > 0 || followUpMessages.length > 0) {
+            this.pendingMessagesContainer.addChild(new Spacer(1));
+            for (const message of steeringMessages) {
+                const text = theme.fg("dim", `Steering: ${message}`);
+                this.pendingMessagesContainer.addChild(new TruncatedText(text, 1, 0));
+            }
+            for (const message of followUpMessages) {
+                const text = theme.fg("dim", `Follow-up: ${message}`);
+                this.pendingMessagesContainer.addChild(new TruncatedText(text, 1, 0));
+            }
+            const dequeueHint = this.getAppKeyDisplay("app.message.dequeue");
+            const hintText = theme.fg("dim", `↳ ${dequeueHint} to edit all queued messages`);
+            this.pendingMessagesContainer.addChild(new TruncatedText(hintText, 1, 0));
+        }
+    }
+    restoreQueuedMessagesToEditor(options) {
+        const { steering, followUp } = this.clearAllQueues();
+        const allQueued = [...steering, ...followUp];
+        if (allQueued.length === 0) {
+            this.updatePendingMessagesDisplay();
+            if (options?.abort) {
+                this.agent.abort();
+            }
+            return 0;
+        }
+        const queuedText = allQueued.join("\n\n");
+        const currentText = options?.currentText ?? this.editor.getText();
+        const combinedText = [queuedText, currentText].filter((t) => t.trim()).join("\n\n");
+        this.editor.setText(combinedText);
+        this.updatePendingMessagesDisplay();
+        if (options?.abort) {
+            this.agent.abort();
+        }
+        return allQueued.length;
+    }
+    queueCompactionMessage(text, mode) {
+        this.compactionQueuedMessages.push({ text, mode });
+        this.editor.addToHistory?.(text);
+        this.editor.setText("");
+        this.updatePendingMessagesDisplay();
+        this.showStatus("Queued message for after compaction");
+    }
+    async flushCompactionQueue(options) {
+        if (this.compactionQueuedMessages.length === 0) {
+            return;
+        }
+        const queuedMessages = [...this.compactionQueuedMessages];
+        this.compactionQueuedMessages = [];
+        this.updatePendingMessagesDisplay();
+        const restoreQueue = (error) => {
+            this.facade.clearQueue();
+            this.compactionQueuedMessages = queuedMessages;
+            this.updatePendingMessagesDisplay();
+            this.showError(`Failed to send queued message${queuedMessages.length > 1 ? "s" : ""}: ${error instanceof Error ? error.message : String(error)}`);
+        };
+        try {
+            if (options?.willRetry) {
+                // When retry is pending, queue messages for the retry turn
+                for (const message of queuedMessages) {
+                    if (message.mode === "followUp") {
+                        await this.facade.followUp(message.text);
+                    }
+                    else {
+                        await this.facade.steer(message.text);
+                    }
+                }
+                this.updatePendingMessagesDisplay();
+                return;
+            }
+            const [firstPrompt, ...rest] = queuedMessages;
+            // Start a prompt when idle, or queue it into a run still finishing compaction.
+            const promptPromise = this.facade
+                .prompt(firstPrompt.text, { streamingBehavior: firstPrompt.mode })
+                .catch((error) => {
+                restoreQueue(error);
+            });
+            // Queue remaining messages
+            for (const message of rest) {
+                if (message.mode === "followUp") {
+                    await this.facade.followUp(message.text);
+                }
+                else {
+                    await this.facade.steer(message.text);
+                }
+            }
+            this.updatePendingMessagesDisplay();
+            void promptPromise;
+        }
+        catch (error) {
+            restoreQueue(error);
+        }
+    }
+    /** Move pending bash components from pending area to chat */
+    flushPendingBashComponents() {
+        for (const component of this.pendingBashComponents) {
+            this.pendingMessagesContainer.removeChild(component);
+            this.chatContainer.addChild(component);
+        }
+        this.pendingBashComponents = [];
+    }
+    // =========================================================================
+    // Selectors
+    // Suite/thinking/model/scoped-models/user-message-fork/clone selectors are
+    // implemented in ./interactive-selectors.ts (S5 slice 5) behind the
+    // SelectorsHost interface; same-name delegates below keep the command
+    // dispatch and prototype-level tests bound to these names. The selector
+    // infrastructure (showSelector/disposeActiveSelector), the settings/tree/
+    // session selectors, and resume stay on the mode: the settings and tree
+    // selectors assemble from broad private UI state, and the session/resume
+    // path is the documented session-boundary carve-out (SessionManager
+    // manager-level writes plus per-entry display reads).
+    // =========================================================================
+    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 created = create(done);
+        dispose = created.dispose;
+        this.disposeActiveSelector();
+        this.activeSelectorToken = token;
+        this.activeSelectorDispose = dispose;
+        this.editorContainer.clear();
+        this.editorContainer.addChild(created.component);
+        this.ui.setFocus(created.focus);
+        this.ui.requestRender();
+    }
+    showSettingsSelector() {
+        this.showSelector((done) => {
+            let selector;
+            const defaultProvider = this.settingsManager.getDefaultProvider();
+            const defaultModelId = this.settingsManager.getDefaultModel();
+            const defaultModel = defaultProvider && defaultModelId ? `${defaultProvider}/${defaultModelId}` : "not set";
+            selector = new SettingsSelectorComponent({
+                autoCompact: this.facade.isAutoCompactionEnabled(),
+                defaultModel,
+                currentModel: this.facade.getModel(),
+                availableDefaultModels: this.facade.getAvailableModels(),
+                showImages: this.settingsManager.getShowImages(),
+                imageWidthCells: this.settingsManager.getImageWidthCells(),
+                autoResizeImages: this.settingsManager.getImageAutoResize(),
+                blockImages: this.settingsManager.getBlockImages(),
+                enableSkillCommands: this.settingsManager.getEnableSkillCommands(),
+                steeringMode: this.facade.getSteeringMode(),
+                followUpMode: this.facade.getFollowUpMode(),
+                transport: this.settingsManager.getTransport(),
+                httpIdleTimeoutMs: this.settingsManager.getHttpIdleTimeoutMs(),
+                thinkingLevel: this.settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL,
+                availableThinkingLevels: [...THINKING_LEVEL_OPTIONS],
+                modelThinkingLevels: this.settingsManager.getAllModelThinkingLevels(),
+                currentTheme: this.themeController.getThemeSelection() || "dark",
+                terminalTheme: this.themeController.getTerminalTheme(),
+                availableThemes: getAvailableThemes(),
+                hideThinkingBlock: this.hideThinkingBlock,
+                mermaidRenderingMode: this.settingsManager.getMermaidRenderingMode(),
+                collapseChangelog: this.settingsManager.getCollapseChangelog(),
+                doubleEscapeAction: this.settingsManager.getDoubleEscapeAction(),
+                treeFilterMode: this.settingsManager.getTreeFilterMode(),
+                showHardwareCursor: this.settingsManager.getShowHardwareCursor(),
+                showCacheMissNotices: this.settingsManager.getShowCacheMissNotices(),
+                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(),
+                fullscreenCopyOnSelect: this.settingsManager.getFullscreenCopyOnSelect(),
+                warnings: this.settingsManager.getWarnings(),
+            }, {
+                onAutoCompactChange: (enabled) => {
+                    this.facade.setAutoCompactionEnabled(enabled);
+                    this.footer.setAutoCompactEnabled(enabled);
+                },
+                onShowImagesChange: (enabled) => {
+                    this.settingsManager.setShowImages(enabled);
+                    for (const child of this.chatContainer.children) {
+                        if (child instanceof ToolExecutionComponent) {
+                            child.setShowImages(enabled);
+                        }
+                    }
+                },
+                onImageWidthCellsChange: (width) => {
+                    this.settingsManager.setImageWidthCells(width);
+                    for (const child of this.chatContainer.children) {
+                        if (child instanceof ToolExecutionComponent) {
+                            child.setImageWidthCells(width);
+                        }
+                    }
+                },
+                onAutoResizeImagesChange: (enabled) => {
+                    this.settingsManager.setImageAutoResize(enabled);
+                },
+                onBlockImagesChange: (blocked) => {
+                    this.settingsManager.setBlockImages(blocked);
+                },
+                onEnableSkillCommandsChange: (enabled) => {
+                    this.settingsManager.setEnableSkillCommands(enabled);
+                    this.setupAutocompleteProvider();
+                },
+                onSteeringModeChange: (mode) => {
+                    this.facade.setSteeringMode(mode);
+                },
+                onFollowUpModeChange: (mode) => {
+                    this.facade.setFollowUpMode(mode);
+                },
+                onTransportChange: (transport) => {
+                    this.settingsManager.setTransport(transport);
+                    this.session.host.setTransport(transport);
+                },
+                onHttpIdleTimeoutMsChange: (timeoutMs) => {
+                    this.settingsManager.setHttpIdleTimeoutMs(timeoutMs);
+                    configureHttpDispatcher(timeoutMs);
+                    this.showStatus(`HTTP idle timeout: ${formatHttpIdleTimeoutMs(timeoutMs)}`);
+                },
+                onModelThinkingLevelChange: (provider, modelId, level) => {
+                    this.settingsManager.setModelThinkingLevel(provider, modelId, level);
+                    // If the override is for the current model, apply it to the session too
+                    const current = this.facade.getModel();
+                    if (current && current.provider === provider && current.id === modelId) {
+                        this.facade.setThinkingLevel(level);
+                        this.footer.invalidate();
+                        this.updateEditorBorderColor();
+                    }
+                },
+                onModelThinkingLevelRemove: (provider, modelId) => {
+                    this.settingsManager.removeModelThinkingLevel(provider, modelId);
+                    // If the override was for the current model, revert to global default
+                    const current = this.facade.getModel();
+                    if (current && current.provider === provider && current.id === modelId) {
+                        const globalDefault = this.settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL;
+                        this.facade.setThinkingLevel(globalDefault);
+                        this.footer.invalidate();
+                        this.updateEditorBorderColor();
+                    }
+                },
+                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);
+                    this.updateThinkingBlockVisibility();
+                },
+                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);
+                },
+                onQuietStartupChange: (enabled) => {
+                    this.settingsManager.setQuietStartup(enabled);
+                },
+                onDoubleEscapeActionChange: (action) => {
+                    this.settingsManager.setDoubleEscapeAction(action);
+                },
+                onTreeFilterModeChange: (mode) => {
+                    this.settingsManager.setTreeFilterMode(mode);
+                },
+                onShowHardwareCursorChange: (enabled) => {
+                    this.settingsManager.setShowHardwareCursor(enabled);
+                    this.ui.setShowHardwareCursor(enabled);
+                },
+                onEditorPaddingXChange: (padding) => {
+                    this.settingsManager.setEditorPaddingX(padding);
+                    this.defaultEditor.setPaddingX(padding);
+                    if (this.editor !== this.defaultEditor && this.editor.setPaddingX !== undefined) {
+                        this.editor.setPaddingX(padding);
+                    }
+                },
+                onOutputPadChange: (padding) => {
+                    this.settingsManager.setOutputPad(padding);
+                    this.outputPad = padding;
+                    if (this.streamingComponent || this.facade.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);
+                    if (this.editor !== this.defaultEditor && this.editor.setAutocompleteMaxVisible !== undefined) {
+                        this.editor.setAutocompleteMaxVisible(maxVisible);
+                    }
+                },
+                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();
+                },
+                onFullscreenCopyOnSelectChange: (enabled) => {
+                    this.settingsManager.setFullscreenCopyOnSelect(enabled);
+                    if (this.renderer instanceof TuiAltScreen)
+                        this.renderer.setCopyOnSelect(enabled);
+                },
+                onWarningsChange: (warnings) => {
+                    this.settingsManager.setWarnings(warnings);
+                },
+                onCancel: () => {
+                    done();
+                    this.ui.requestRender();
+                },
+            });
+            return { component: selector, focus: selector.getSettingsList() };
+        });
+    }
+    /** /thinking command entry; implementation in ./interactive-selectors.ts (S5 slice 5). */
+    handleThinkingCommand(searchTerm) {
+        selectorsFlow.handleThinkingCommand(this, searchTerm);
+    }
+    /** Thinking level apply; implementation in ./interactive-selectors.ts (S5 slice 5). */
+    selectThinkingLevel(level, persist) {
+        selectorsFlow.selectThinkingLevel(this, level, persist);
+    }
+    /** Thinking level picker; implementation in ./interactive-selectors.ts (S5 slice 5). */
+    showThinkingSelector() {
+        selectorsFlow.showThinkingSelector(this);
+    }
+    /**
+     * Current session's suite id, read from the session custom entry recorded at
+     * creation (设计 §10.1). Never inferred from settings or env; undefined when
+     * the session carries no suite entry (e.g. resumed legacy sessions).
+     * Internal collaboration surface; exposed for ./interactive-selectors.ts
+     * (S5 slice 5) while the read stays on the mode (session-boundary carve-out).
+     */
+    getCurrentSessionSuiteId() {
+        const entries = this.facade.getEntries();
+        for (let i = entries.length - 1; i >= 0; i--) {
+            const entry = entries[i];
+            if (entry.type !== "custom" || entry.customType !== SUITE_SESSION_ENTRY_TYPE)
+                continue;
+            const suiteId = entry.data?.suiteId;
+            if (typeof suiteId === "string" && suiteId.trim().length > 0)
+                return suiteId;
+        }
+        return undefined;
+    }
+    sessionSuiteIdCache;
+    /** Host-visible for ./interactive-selectors.ts (S5 slice 5): narrow session read. */
+    getAvailableThinkingLevels() {
+        return this.facade.getAvailableThinkingLevels();
+    }
+    /** Host-visible for ./interactive-selectors.ts (S5 slice 5): narrow session read. */
+    getUserMessagesForForking() {
+        return this.facade.getUserMessagesForForking();
+    }
+    /**
+     * Bound suite id of a listed session (设计 §10.1), read from the session
+     * file's binding entry and cached per path — the selector refilters the
+     * list on every keystroke.
+     */
+    readSessionSuiteId(sessionPath) {
+        this.sessionSuiteIdCache ??= new Map();
+        if (this.sessionSuiteIdCache.has(sessionPath))
+            return this.sessionSuiteIdCache.get(sessionPath);
+        const suiteId = readSessionSuiteIdFromFile(sessionPath);
+        this.sessionSuiteIdCache.set(sessionPath, suiteId);
+        return suiteId;
+    }
+    /** /suite command entry; implementation in ./interactive-selectors.ts (S5 slice 5). */
+    handleSuiteCommand(suiteId) {
+        selectorsFlow.handleSuiteCommand(this, suiteId);
+    }
+    /** Suite list overlay; implementation in ./interactive-selectors.ts (S5 slice 5). */
+    showSuiteSelector(availableSuites) {
+        selectorsFlow.showSuiteSelector(this, availableSuites);
+    }
+    /**
+     * Shared suite list overlay (设计 §9); implementation in
+     * ./interactive-selectors.ts (S5 slice 5).
+     */
+    openSuiteListSelector(callbacks) {
+        selectorsFlow.openSuiteListSelector(this, callbacks);
+    }
+    /**
+     * Interactive recovery for an unresolved startup suite id (设计 §9): pick a
+     * suite, persist it as the project setting, then rebuild the session with
+     * the selected suite via the same /new assembly path. Cancelling keeps the
+     * fallback assembly the runtime started with.
+     */
+    async showStartupSuiteSelector(pending) {
+        const selected = await new Promise((resolve) => {
+            this.openSuiteListSelector({
+                availableSuites: pending.available,
+                note: `Suite "${pending.requestedId}" was not found. The selected suite applies to the new session.`,
+                onSelect: (suiteId) => resolve(suiteId),
+                onCancel: () => resolve(undefined),
+            });
+        });
+        if (selected === undefined) {
+            this.showWarning(`Suite "${pending.requestedId}" was not found — continuing without a suite. Use /suite to choose one.`);
+            return;
+        }
+        this.settingsManager.setProjectSuite(selected);
+        try {
+            await this.runtimeFacade.newSession();
+            this.showStatus(`Suite set to ${selected} — new session started`);
+        }
+        catch (error) {
+            await this.handleFatalRuntimeError("Failed to create session", error);
+        }
+    }
+    /** /model command entry; implementation in ./interactive-selectors.ts (S5 slice 5). */
+    async handleModelCommand(searchTerm) {
+        await selectorsFlow.handleModelCommand(this, searchTerm);
+    }
+    /** Exact model lookup; implementation in ./interactive-selectors.ts (S5 slice 5). */
+    async findExactModelMatch(searchTerm) {
+        return selectorsFlow.findExactModelMatch(this, searchTerm);
+    }
+    /**
+     * Update the footer's available provider count from the current snapshot without
+     * refreshing catalogs. Host-visible for ./interactive-auth.ts (S5 slice 3).
+     */
+    updateAvailableProviderCount() {
+        const models = this.facade.getScopedModels().length > 0
+            ? this.facade.getScopedModels().map((scoped) => scoped.model)
+            : this.facade.getAvailableModels();
+        const uniqueProviders = new Set(models.map((model) => model.provider));
+        this.footerDataProvider.setAvailableProviderCount(uniqueProviders.size);
+    }
+    /** Host-visible for ./interactive-auth.ts (S5 slice 3). */
+    async maybeWarnAboutAnthropicSubscriptionAuth(model = this.facade.getModel()) {
+        if (this.settingsManager.getWarnings().anthropicExtraUsage === false) {
+            return;
+        }
+        if (this.anthropicSubscriptionWarningShown) {
+            return;
+        }
+        if (!model || model.provider !== "anthropic") {
+            return;
+        }
+        try {
+            if ((await this.facade.checkProviderAuth("anthropic"))?.type === "oauth") {
+                this.anthropicSubscriptionWarningShown = true;
+                this.showWarning(ANTHROPIC_SUBSCRIPTION_AUTH_WARNING);
+                return;
+            }
+            const apiKey = (await this.facade.getProviderAuth(model.provider))?.auth.apiKey;
+            if (!isAnthropicSubscriptionAuthKey(apiKey)) {
+                return;
+            }
+            this.anthropicSubscriptionWarningShown = true;
+            this.showWarning(ANTHROPIC_SUBSCRIPTION_AUTH_WARNING);
+        }
+        catch {
+            // Ignore auth lookup failures for warning-only checks.
+        }
+    }
+    /** Model picker; implementation in ./interactive-selectors.ts (S5 slice 5). */
+    showModelSelector(initialSearchInput) {
+        selectorsFlow.showModelSelector(this, initialSearchInput);
+    }
+    /** Scoped-models picker; implementation in ./interactive-selectors.ts (S5 slice 5). */
+    showModelsSelector() {
+        selectorsFlow.showModelsSelector(this);
+    }
+    /** Fork picker; implementation in ./interactive-selectors.ts (S5 slice 5). */
+    showUserMessageSelector() {
+        selectorsFlow.showUserMessageSelector(this);
+    }
+    /** /clone command entry; implementation in ./interactive-selectors.ts (S5 slice 5). */
+    async handleCloneCommand() {
+        await selectorsFlow.handleCloneCommand(this);
+    }
+    showTreeSelector(initialSelectedId) {
+        const tree = this.facade.getTree();
+        const realLeafId = this.facade.getLeafId();
+        const initialFilterMode = this.settingsManager.getTreeFilterMode();
+        if (tree.length === 0) {
+            this.showStatus("No entries in session");
+            return;
+        }
+        this.showSelector((done) => {
+            const selector = new TreeSelectorComponent(tree, realLeafId, this.ui.terminal.rows, async (entryId) => {
+                // Selecting the current leaf is a no-op (already there)
+                if (entryId === this.facade.getLeafId()) {
+                    done();
+                    this.showStatus("Already at this point");
+                    return;
+                }
+                // Ask about summarization
+                done(); // Close selector first
+                // Loop until user makes a complete choice or cancels to tree
+                let wantsSummary = false;
+                let customInstructions;
+                // Check if we should skip the prompt (user preference to always default to no summary)
+                if (!this.settingsManager.getBranchSummarySkipPrompt()) {
+                    while (true) {
+                        const summaryChoice = await this.showDialogSelector("Summarize branch?", [
+                            "No summary",
+                            "Summarize",
+                            "Summarize with custom prompt",
+                        ]);
+                        if (summaryChoice === undefined) {
+                            // User pressed escape - re-show tree selector with same selection
+                            this.showTreeSelector(entryId);
+                            return;
+                        }
+                        wantsSummary = summaryChoice !== "No summary";
+                        if (summaryChoice === "Summarize with custom prompt") {
+                            customInstructions = await this.showDialogEditor("Custom summarization instructions");
+                            if (customInstructions === undefined) {
+                                // User cancelled - loop back to summary selector
+                                continue;
+                            }
+                        }
+                        // User made a complete choice
+                        break;
+                    }
+                }
+                // The user committed to navigating: stop the active response first.
+                if (this.facade.isStreaming()) {
+                    this.restoreQueuedMessagesToEditor();
+                    await this.facade.abort();
+                }
+                // Set up escape handler and status indicator if summarizing
+                let showingSummaryIndicator = false;
+                const originalOnEscape = this.defaultEditor.onEscape;
+                if (wantsSummary) {
+                    this.defaultEditor.onEscape = () => {
+                        this.facade.abortBranchSummary();
+                    };
+                    this.chatContainer.addChild(new Spacer(1));
+                    this.showStatusIndicator(new BranchSummaryStatusIndicator(this.ui));
+                    showingSummaryIndicator = true;
+                    this.ui.requestRender();
+                }
+                try {
+                    const result = await this.facade.navigateTree(entryId, {
+                        summarize: wantsSummary,
+                        customInstructions,
+                    });
+                    if (result.aborted) {
+                        // Summarization aborted - re-show tree selector with same selection
+                        this.showStatus("Branch summarization cancelled");
+                        this.showTreeSelector(entryId);
+                        return;
+                    }
+                    if (result.cancelled) {
+                        this.showStatus("Navigation cancelled");
+                        return;
+                    }
+                    // Update UI
+                    this.chatContainer.clear();
+                    this.renderInitialMessages();
+                    if (result.editorText && !this.editor.getText().trim()) {
+                        this.editor.setText(result.editorText);
+                    }
+                    this.showStatus("Navigated to selected point");
+                    void this.flushCompactionQueue({ willRetry: false });
+                }
+                catch (error) {
+                    this.showError(error instanceof Error ? error.message : String(error));
+                }
+                finally {
+                    if (showingSummaryIndicator) {
+                        this.clearStatusIndicator("branchSummary");
+                    }
+                    this.defaultEditor.onEscape = originalOnEscape;
+                }
+            }, () => {
+                done();
+                this.ui.requestRender();
+            }, (entryId, label) => {
+                this.facade.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) => this.runtimeFacade.listSessions(onProgress), (onProgress) => this.runtimeFacade.listAllSessions(onProgress), async (sessionPath) => {
+                done();
+                await this.handleResumeSession(sessionPath);
+            }, () => {
+                done();
+                this.ui.requestRender();
+            }, () => {
+                void this.shutdown();
+            }, () => this.ui.requestRender(), {
+                renameSession: async (sessionFilePath, nextName) => {
+                    const next = (nextName ?? "").trim();
+                    if (!next)
+                        return;
+                    const mgr = SessionManager.open(sessionFilePath);
+                    mgr.appendSessionInfo(next);
+                },
+                showRenameHint: true,
+                keybindings: this.keybindings,
+                // 会话选择器默认只列当前方案的会话；跨方案会话仅在显式
+                // "show all" 后可见（设计 §10.1）。
+                suiteFilter: {
+                    currentSuiteId: this.getCurrentSessionSuiteId(),
+                    getSessionSuiteId: (session) => this.readSessionSuiteId(session.path),
+                },
+            }, this.runtimeFacade.getSessionFile());
+            return { component: selector, focus: selector };
+        });
+    }
+    async handleResumeSession(sessionPath, options) {
+        this.clearStatusIndicator();
+        try {
+            const result = await this.runtimeFacade.switchSession(sessionPath, {
+                withSession: options?.withSession,
+            });
+            if (result.cancelled) {
+                return result;
+            }
+            this.showStatus("Resumed session");
+            this.detectCrossSuiteResume();
+            return result;
+        }
+        catch (error) {
+            if (error instanceof MissingSessionCwdError) {
+                const selectedCwd = await this.promptForMissingSessionCwd(error);
+                if (!selectedCwd) {
+                    this.showStatus("Resume cancelled");
+                    return { cancelled: true };
+                }
+                const result = await this.runtimeFacade.switchSession(sessionPath, {
+                    cwdOverride: selectedCwd,
+                    withSession: options?.withSession,
+                });
+                if (result.cancelled) {
+                    return result;
+                }
+                this.showStatus("Resumed session in current cwd");
+                this.detectCrossSuiteResume();
+                return result;
+            }
+            return this.handleFatalRuntimeError("Failed to resume session", error);
+        }
+    }
+    /**
+     * Cross-suite resume detection (设计 §10.1 最小可用版): compare the loaded
+     * session's original suite binding with the suite resolved from the current
+     * settings/env — the id the resumed session was actually reassembled with
+     * (assembly happens at session creation, so reassembly is the existing
+     * behavior). On a mismatch, record the fact for later debugging: an info
+     * status line plus a `suite_mismatch` custom entry on the session. No
+     * context serialization or conversion is attempted.
+     */
+    detectCrossSuiteResume() {
+        const originalSuiteId = this.getCurrentSessionSuiteId();
+        // Pre-suite (legacy) sessions carry no binding; nothing to compare.
+        if (originalSuiteId === undefined)
+            return;
+        const currentSuiteId = resolveSuiteId({
+            envSuite: process.env[SUITE_ENV_VAR],
+            settings: this.settingsManager,
+            agentDir: getAgentDir(),
+        });
+        if (currentSuiteId === originalSuiteId)
+            return;
+        this.showStatus(`Cross-suite compatible mode: session created with "${originalSuiteId}", assembling with "${currentSuiteId}"`);
+        this.facade.recordSuiteMismatch(originalSuiteId, currentSuiteId);
+    }
+    // =========================================================================
+    // Login/authentication (implementation in ./interactive-auth.ts, S5 slice 3)
+    // Host-visible narrow accessors plus same-name delegates; prototype-level
+    // tests and the command dispatch bind to these names.
+    // =========================================================================
+    /**
+     * Host-visible for ./interactive-auth.ts (D-048): narrow credential/provider
+     * auth projection of the session's ModelRuntime through the stable facade.
+     * The full runtime never crosses the host boundary (D-047 裁决 3's
+     * credential-management semantics stay open).
+     */
+    getModelAuthRuntime() {
+        return this.facade.getModelAuthRuntime();
+    }
+    /** Host-visible for ./interactive-auth.ts (D-048): available model snapshot. */
+    getAvailableModels() {
+        return this.facade.getAvailableModels();
+    }
+    /** Host-visible for ./interactive-selectors.ts (D-048): narrow catalog-refresh projection. */
+    getModelCatalog() {
+        return this.facade.getModelCatalog();
+    }
+    /** Host-visible for ./interactive-auth.ts (S5 slice 3): opaque session identity. */
+    getSessionIdentity() {
+        return this.session;
+    }
+    /** Host-visible for ./interactive-auth.ts (S5 slice 3). */
+    isSameSessionIdentity(identity) {
+        return this.session === identity;
+    }
+    /** Host-visible for ./interactive-auth.ts (S5 slice 3): stable facade read. */
+    getSelectedModel() {
+        return this.facade.getModel();
+    }
+    /** Host-visible for ./interactive-auth.ts (S5 slice 3): stable facade write. */
+    async setSelectedModel(model) {
+        await this.facade.setModel(model, { persist: true });
+    }
+    /** Host-visible for ./interactive-auth.ts (S5 slice 3). */
+    invalidateFooter() {
+        this.footer.invalidate();
+    }
+    /** Host-visible for ./interactive-auth.ts (S5 slice 3); delegates to the selector area. */
+    showAuthSelector(create) {
+        this.showSelector(create);
+    }
+    /** Login provider options; implementation in ./interactive-auth.ts (S5 slice 3). */
+    getLoginProviderOptions(authType) {
+        return authFlow.getLoginProviderOptions(this, authType);
+    }
+    /** Logout provider options; implementation in ./interactive-auth.ts (S5 slice 3). */
+    async getLogoutProviderOptions() {
+        return authFlow.getLogoutProviderOptions(this);
+    }
+    /** Login provider lookup; implementation in ./interactive-auth.ts (S5 slice 3). */
+    findLoginProviderOptions(providerRef) {
+        return authFlow.findLoginProviderOptions(this, providerRef);
+    }
+    /** /login command entry; implementation in ./interactive-auth.ts (S5 slice 3). */
+    async handleLoginCommand(providerRef) {
+        await authFlow.handleLoginCommand(this, providerRef);
+    }
+    /** Login branch by auth type; implementation in ./interactive-auth.ts (S5 slice 3). */
+    async startProviderLogin(providerOption) {
+        await authFlow.startProviderLogin(this, providerOption);
+    }
+    /** Auth type selector; implementation in ./interactive-auth.ts (S5 slice 3). */
+    showLoginAuthTypeSelector(providerOptions) {
+        authFlow.showLoginAuthTypeSelector(this, providerOptions);
+    }
+    /** Login provider selector; implementation in ./interactive-auth.ts (S5 slice 3). */
+    showLoginProviderSelector(authType, initialSearchInput) {
+        authFlow.showLoginProviderSelector(this, authType, initialSearchInput);
+    }
+    /** Login/logout selector entry; implementation in ./interactive-auth.ts (S5 slice 3). */
+    async showOAuthSelector(mode) {
+        await authFlow.showOAuthSelector(this, mode);
+    }
+    /** Post-login completion; implementation in ./interactive-auth.ts (S5 slice 3). */
+    async completeProviderAuthentication(providerId, providerName, authType, previousModel) {
+        await authFlow.completeProviderAuthentication(this, providerId, providerName, authType, previousModel);
+    }
+    /** Ambient auth notice; implementation in ./interactive-auth.ts (S5 slice 3). */
+    showAmbientAuthDialog(providerOption) {
+        authFlow.showAmbientAuthDialog(this, providerOption);
+    }
+    /** API key login dialog; implementation in ./interactive-auth.ts (S5 slice 3). */
+    async showApiKeyLoginDialog(providerId, providerName) {
+        await authFlow.showApiKeyLoginDialog(this, providerId, providerName);
+    }
+    /** Auth select prompt; implementation in ./interactive-auth.ts (S5 slice 3). */
+    showAuthSelect(dialog, prompt) {
+        return authFlow.showAuthSelect(this, dialog, prompt);
+    }
+    /** Auth prompt plumbing; implementation in ./interactive-auth.ts (S5 slice 3). */
+    async showAuthPrompt(dialog, prompt) {
+        return authFlow.showAuthPrompt(this, dialog, prompt);
+    }
+    /** Auth event rendering; implementation in ./interactive-auth.ts (S5 slice 3). */
+    notifyAuthDialog(dialog, event) {
+        authFlow.notifyAuthDialog(this, dialog, event);
+    }
+    /** Provider login call; implementation in ./interactive-auth.ts (S5 slice 3). */
+    async loginProvider(dialog, providerId, method) {
+        await authFlow.loginProvider(this, dialog, providerId, method);
+    }
+    /** OAuth login dialog; implementation in ./interactive-auth.ts (S5 slice 3). */
+    async showLoginDialog(providerId, providerName) {
+        await authFlow.showLoginDialog(this, providerId, providerName);
+    }
+    // =========================================================================
+    // Command handlers
+    // =========================================================================
+    async handleReloadCommand() {
+        if (this.facade.isStreaming()) {
+            this.showWarning("Wait for the current response to finish before reloading.");
+            return;
+        }
+        if (this.facade.isCompacting()) {
+            this.showWarning("Wait for compaction to finish before reloading.");
+            return;
+        }
+        this.resetDialogUI();
+        const reloadBox = new Container();
+        const borderColor = (s) => theme.fg("border", s);
+        reloadBox.addChild(new DynamicBorder(borderColor));
+        reloadBox.addChild(new Spacer(1));
+        reloadBox.addChild(new Text(theme.fg("muted", "Reloading keybindings, skills, prompts, themes, and context files..."), 1, 0));
+        reloadBox.addChild(new Spacer(1));
+        reloadBox.addChild(new DynamicBorder(borderColor));
+        const previousEditor = this.editor;
+        this.editorContainer.clear();
+        this.editorContainer.addChild(reloadBox);
+        this.ui.setFocus(reloadBox);
+        this.ui.requestRender(true);
+        await new Promise((resolve) => process.nextTick(resolve));
+        const dismissReloadBox = (editor) => {
+            this.editorContainer.clear();
+            this.editorContainer.addChild(editor);
+            this.ui.setFocus(editor);
+            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.facade.reload({ beforeSessionStart: restoreChatBeforeSessionStart });
+            restoreChatBeforeSessionStart();
+            this.keybindings.reload();
+            const activeHeader = this.builtInHeader;
+            if (isExpandable(activeHeader)) {
+                activeHeader.setExpanded(this.toolOutputExpanded);
+            }
+            setRegisteredThemes(buildRegisteredThemes(this.facade.getThemes().themes));
+            this.applyRuntimeSettings();
+            await this.themeController.applyFromSettings();
+            this.setupAutocompleteProvider();
+            this.showLoadedResources({
+                force: false,
+                showDiagnosticsWhenQuiet: true,
+            });
+            const modelsJsonError = this.facade.getModelsError();
+            if (modelsJsonError) {
+                this.showError(`models.json error: ${modelsJsonError}`);
+            }
+            this.showStatus("Reloaded keybindings, skills, prompts, themes, and context files");
+            dismissReloadBox(this.editor);
+            reloadBoxDismissed = true;
+        }
+        catch (error) {
+            // v8 ignore next -- reloadBoxDismissed 置位后 catch 前无可抛出点，恒走 dismiss 分支
+            if (!reloadBoxDismissed) {
+                dismissReloadBox(previousEditor);
+            }
+            this.showError(`Reload failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async handleExportCommand(text) {
+        const outputPath = this.getPathCommandArgument(text, "/export");
+        try {
+            if (outputPath?.endsWith(".jsonl")) {
+                const filePath = this.facade.exportToJsonl(outputPath);
+                this.showStatus(`Session exported to: ${filePath}`);
+            }
+            else {
+                const filePath = await this.facade.exportToHtml(outputPath, {
+                    themeName: theme.name,
+                });
+                this.showStatus(`Session exported to: ${filePath}`);
+            }
+        }
+        catch (error) {
+            this.showError(`Failed to export session: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    getPathCommandArgument(text, command) {
+        if (text === command) {
+            return undefined;
+        }
+        if (!text.startsWith(`${command} `)) {
+            return undefined;
+        }
+        const argsString = text.slice(command.length + 1).trimStart();
+        if (!argsString) {
+            return undefined;
+        }
+        const firstChar = argsString[0];
+        if (firstChar === '"' || firstChar === "'") {
+            const closingQuoteIndex = argsString.indexOf(firstChar, 1);
+            if (closingQuoteIndex < 0) {
+                return undefined;
+            }
+            return argsString.slice(1, closingQuoteIndex);
+        }
+        const firstWhitespaceIndex = argsString.search(/\s/);
+        if (firstWhitespaceIndex < 0) {
+            return argsString;
+        }
+        return argsString.slice(0, firstWhitespaceIndex);
+    }
+    async handleImportCommand(text) {
+        const inputPath = this.getPathCommandArgument(text, "/import");
+        if (!inputPath) {
+            this.showError("Usage: /import <path.jsonl>");
+            return;
+        }
+        const confirmed = await this.showDialogConfirm("Import session", `Replace current session with ${inputPath}?`);
+        if (!confirmed) {
+            this.showStatus("Import cancelled");
+            return;
+        }
+        try {
+            this.clearStatusIndicator();
+            const result = await this.runtimeFacade.importFromJsonl(inputPath);
+            if (result.cancelled) {
+                this.showStatus("Import cancelled");
+                return;
+            }
+            this.showStatus(`Session imported from: ${inputPath}`);
+        }
+        catch (error) {
+            if (error instanceof MissingSessionCwdError) {
+                const selectedCwd = await this.promptForMissingSessionCwd(error);
+                if (!selectedCwd) {
+                    this.showStatus("Import cancelled");
+                    return;
+                }
+                const result = await this.runtimeFacade.importFromJsonl(inputPath, selectedCwd);
+                if (result.cancelled) {
+                    this.showStatus("Import cancelled");
+                    return;
+                }
+                this.showStatus(`Session imported from: ${inputPath}`);
+                return;
+            }
+            if (error instanceof SessionImportFileNotFoundError) {
+                this.showError(`Failed to import session: ${error.message}`);
+                return;
+            }
+            await this.handleFatalRuntimeError("Failed to import session", error);
+        }
+    }
+    async handleCopyCommand(options = {}) {
+        if (options.preferSelection &&
+            this.ui instanceof TuiAltScreen &&
+            !this.ui.getCopyOnSelect() &&
+            this.ui.hasActiveSelection()) {
+            await this.ui.copyActiveSelectionToClipboard();
+            return;
+        }
+        const text = this.facade.getLastAssistantText();
+        if (!text) {
+            this.showError("No agent messages to copy yet.");
+            return;
+        }
+        try {
+            await copyToClipboard(text);
+            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));
+        }
+    }
+    handleNameCommand(text) {
+        const name = text.replace(/^\/name\s*/, "").trim();
+        if (!name) {
+            const currentName = this.facade.getSessionName();
+            if (currentName) {
+                this.chatContainer.addChild(new Spacer(1));
+                this.chatContainer.addChild(new Text(theme.fg("dim", `Session name: ${currentName}`), 1, 0));
+            }
+            else {
+                this.showWarning("Usage: /name <name>");
+            }
+            this.ui.requestRender();
+            return;
+        }
+        this.facade.setSessionName(name);
+        const sessionName = this.facade.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: ${sessionName ?? name}`), 1, 0));
+        this.ui.requestRender();
+    }
+    handleSessionCommand() {
+        const stats = this.facade.getSessionStats();
+        const sessionName = this.facade.getSessionName();
+        const entries = this.facade.getEntries();
+        const cacheWaste = computeCacheWaste(entries, this.facade.getModelPriceSource());
+        // 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`;
+        }
+        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", "Tools:")} ${stats.toolCalls} calls, ${stats.toolResults} results\n\n`;
+        info += `${theme.bold("Tokens")}\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`;
+        // 双维度统计（用户裁决 2026-09-25）：总计之外按供应商/模型分桶——缓存读/写、
+        // 命中率、费用逐桶可见。此前该拆分门控在 cost>0 且多桶才渲染，单价为 0 的
+        // 自定义供应商（如自建代理）永远看不到。
+        if (usageBreakdown.length > 0) {
+            info += `\n${theme.bold("By Provider/Model")}\n`;
+            for (const entry of usageBreakdown) {
+                const bucket = entry.totals;
+                const promptBucket = bucket.input + bucket.cacheRead + bucket.cacheWrite;
+                let line = `  ${theme.bold(entry.key)}`;
+                if (promptBucket > 0) {
+                    line += `\n    ${theme.fg("dim", "Input:")} ${promptBucket.toLocaleString()}`;
+                    if (bucket.cacheRead > 0 || bucket.cacheWrite > 0) {
+                        const rate = promptBucket > 0 ? ((bucket.cacheRead / promptBucket) * 100).toFixed(1) : "0.0";
+                        line += ` ${theme.fg("dim", `(cache ${rate}%, W ${bucket.cacheWrite.toLocaleString()})`)}`;
+                    }
+                }
+                if (bucket.output > 0)
+                    line += `\n    ${theme.fg("dim", "Output:")} ${bucket.output.toLocaleString()}`;
+                if (entry.cost > 0)
+                    line += ` ${theme.fg("dim", `$${entry.cost.toFixed(3)}`)}`;
+                info += `${line}\n`;
+            }
+        }
+        if (stats.cost > 0 || cacheWaste.missedTokens > 0) {
+            info += `\n${theme.bold("Cost")}\n`;
+            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));
+        this.ui.requestRender();
+    }
+    handleMetricsCommand(turnsArg) {
+        const provider = this.options.getMetrics;
+        if (!provider) {
+            this.showWarning("Metrics are not available: the observability plugin is not mounted in this session");
+            return;
+        }
+        let windowTurns;
+        if (turnsArg !== undefined) {
+            const parsed = Number.parseInt(turnsArg, 10);
+            if (!Number.isSafeInteger(parsed) || parsed < 1) {
+                this.showWarning(`Invalid turns: ${turnsArg}. Usage: /metrics [turns]`);
+                return;
+            }
+            windowTurns = parsed;
+        }
+        let snapshot;
+        try {
+            const result = provider({ windowTurns });
+            if (result === undefined) {
+                this.showWarning("Metrics are not available: the observability plugin is not mounted in this session");
+                return;
+            }
+            snapshot = result;
+        }
+        catch (error) {
+            this.showError(error instanceof Error ? error.message : String(error));
+            return;
+        }
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new Text(formatMetricsSnapshot(snapshot), 1, 0));
+        this.ui.requestRender();
+    }
+    handleChangelogCommand() {
+        const changelogPath = getChangelogPath();
+        const allEntries = parseChangelog(changelogPath);
+        const changelogMarkdown = allEntries.length > 0
+            ? allEntries
+                .reverse()
+                .map((e) => normalizeChangelogLinks(e.content, e))
+                .join("\n\n")
+            : "No changelog entries found.";
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new DynamicBorder());
+        this.chatContainer.addChild(new Text(theme.bold(theme.fg("accent", "What's New")), 1, 0));
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new Markdown(changelogMarkdown, 1, 1, this.getMarkdownThemeWithSettings()));
+        this.chatContainer.addChild(new DynamicBorder());
+        this.ui.requestRender();
+    }
+    /**
+     * Get capitalized display string for an app keybinding action.
+     */
+    getAppKeyDisplay(action) {
+        return keyDisplayText(action);
+    }
+    /**
+     * Get capitalized display string for an editor keybinding action.
+     */
+    getEditorKeyDisplay(action) {
+        return keyDisplayText(action);
+    }
+    handleHelpCommand() {
+        const section = (title, rows) => {
+            if (rows.length === 0)
+                return "";
+            let table = `\n**${title}**\n| Command | Description |\n|---------|-------------|\n`;
+            for (const row of rows) {
+                const command = row.hint ? `\`/${row.name} ${row.hint}\`` : `\`/${row.name}\``;
+                table += `| ${command} | ${row.description ?? ""} |\n`;
+            }
+            return table;
+        };
+        const builtinRows = BUILTIN_SLASH_COMMANDS.map((command) => ({
+            name: command.name,
+            hint: command.argumentHint,
+            description: command.description,
+        }));
+        const promptRows = this.facade.getPromptTemplates().map((template) => ({
+            name: template.name,
+            hint: template.argumentHint,
+            description: template.description,
+        }));
+        const skillRows = this.facade.getSkills().skills.map((skill) => ({
+            name: `skill:${skill.name}`,
+            description: skill.description,
+        }));
+        const help = section("Built-in commands", builtinRows) +
+            section("Prompt templates", promptRows) +
+            section("Skills", skillRows) +
+            "\nType `/` for autocomplete. Use `/hotkeys` for keyboard shortcuts.";
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new DynamicBorder());
+        this.chatContainer.addChild(new Text(theme.bold(theme.fg("accent", "Available Commands")), 1, 0));
+        this.chatContainer.addChild(new Markdown(help.trim(), 1, 1, this.getMarkdownThemeWithSettings()));
+        this.chatContainer.addChild(new DynamicBorder());
+        this.ui.requestRender();
+    }
+    handleHotkeysCommand() {
+        // Navigation keybindings
+        const cursorUp = this.getEditorKeyDisplay("tui.editor.cursorUp");
+        const cursorDown = this.getEditorKeyDisplay("tui.editor.cursorDown");
+        const cursorLeft = this.getEditorKeyDisplay("tui.editor.cursorLeft");
+        const cursorRight = this.getEditorKeyDisplay("tui.editor.cursorRight");
+        const cursorWordLeft = this.getEditorKeyDisplay("tui.editor.cursorWordLeft");
+        const cursorWordRight = this.getEditorKeyDisplay("tui.editor.cursorWordRight");
+        const cursorLineStart = this.getEditorKeyDisplay("tui.editor.cursorLineStart");
+        const cursorLineEnd = this.getEditorKeyDisplay("tui.editor.cursorLineEnd");
+        const jumpForward = this.getEditorKeyDisplay("tui.editor.jumpForward");
+        const jumpBackward = this.getEditorKeyDisplay("tui.editor.jumpBackward");
+        const pageUp = this.getEditorKeyDisplay("tui.editor.pageUp");
+        const pageDown = this.getEditorKeyDisplay("tui.editor.pageDown");
+        // Editing keybindings
+        const submit = this.getEditorKeyDisplay("tui.input.submit");
+        const newLine = this.getEditorKeyDisplay("tui.input.newLine");
+        const deleteWordBackward = this.getEditorKeyDisplay("tui.editor.deleteWordBackward");
+        const deleteWordForward = this.getEditorKeyDisplay("tui.editor.deleteWordForward");
+        const deleteToLineStart = this.getEditorKeyDisplay("tui.editor.deleteToLineStart");
+        const deleteToLineEnd = this.getEditorKeyDisplay("tui.editor.deleteToLineEnd");
+        const yank = this.getEditorKeyDisplay("tui.editor.yank");
+        const yankPop = this.getEditorKeyDisplay("tui.editor.yankPop");
+        const undo = this.getEditorKeyDisplay("tui.editor.undo");
+        const tab = this.getEditorKeyDisplay("tui.input.tab");
+        // App keybindings
+        const interrupt = this.getAppKeyDisplay("app.interrupt");
+        const clear = this.getAppKeyDisplay("app.clear");
+        const exit = this.getAppKeyDisplay("app.exit");
+        const suspend = this.getAppKeyDisplay("app.suspend");
+        const cycleThinkingLevel = this.getAppKeyDisplay("app.thinking.cycle");
+        const cycleModelForward = this.getAppKeyDisplay("app.model.cycleForward");
+        const selectModel = this.getAppKeyDisplay("app.model.select");
+        const expandTools = this.getAppKeyDisplay("app.tools.expand");
+        const toggleThinking = this.getAppKeyDisplay("app.thinking.toggle");
+        const externalEditor = this.getAppKeyDisplay("app.editor.external");
+        const cycleModelBackward = this.getAppKeyDisplay("app.model.cycleBackward");
+        const 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");
+        const hotkeys = `
+**Navigation**
+| Key | Action |
+|-----|--------|
+| \`${cursorUp}\` / \`${cursorDown}\` / \`${cursorLeft}\` / \`${cursorRight}\` | Move cursor / browse history |
+| \`${cursorWordLeft}\` / \`${cursorWordRight}\` | Move by word |
+| \`${cursorLineStart}\` | Start of line |
+| \`${cursorLineEnd}\` | End of line |
+| \`${jumpForward}\` | Jump forward to character |
+| \`${jumpBackward}\` | Jump backward to character |
+| \`${pageUp}\` / \`${pageDown}\` | Scroll by page |
+
+**Editing**
+| Key | Action |
+|-----|--------|
+| \`${submit}\` | Send message |
+| \`${newLine}\` | New line${process.platform === "win32" ? " (Ctrl+Enter on Windows Terminal)" : ""} |
+| \`${deleteWordBackward}\` | Delete word backwards |
+| \`${deleteWordForward}\` | Delete word forwards |
+| \`${deleteToLineStart}\` | Delete to start of line |
+| \`${deleteToLineEnd}\` | Delete to end of line |
+| \`${yank}\` | Paste the most-recently-deleted text |
+| \`${yankPop}\` | Cycle through the deleted text after pasting |
+| \`${undo}\` | Undo |
+
+**Other**
+| Key | Action |
+|-----|--------|
+| \`${tab}\` | Path completion / accept autocomplete |
+| \`${interrupt}\` | Cancel autocomplete / abort streaming |
+| \`${clear}\` | Clear editor (first) / exit (second) |
+| \`${exit}\` | Exit (when editor is empty) |
+| \`${suspend}\` | Suspend to background |
+| \`${cycleThinkingLevel}\` | Cycle thinking level |
+| \`${cycleModelForward}\` / \`${cycleModelBackward}\` | Cycle models |
+| \`${selectModel}\` | Open model selector |
+| \`${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 or text from clipboard |
+| \`/\` | Slash commands |
+| \`!\` | Run bash command |
+| \`!!\` | Run bash command (excluded from context) |
+`;
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new DynamicBorder());
+        this.chatContainer.addChild(new Text(theme.bold(theme.fg("accent", "Keyboard Shortcuts")), 1, 0));
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new Markdown(hotkeys.trim(), 1, 1, this.getMarkdownThemeWithSettings()));
+        this.chatContainer.addChild(new DynamicBorder());
+        this.ui.requestRender();
+    }
+    async handleClearCommand() {
+        this.clearStatusIndicator();
+        try {
+            const result = await this.runtimeFacade.newSession();
+            if (result.cancelled) {
+                return;
+            }
+            this.chatContainer.addChild(new Spacer(1));
+            this.chatContainer.addChild(new Text(`${theme.fg("accent", "✓ New session started")}`, 1, 1));
+            this.ui.requestRender();
+        }
+        catch (error) {
+            await this.handleFatalRuntimeError("Failed to create session", error);
+        }
+    }
+    handleDebugCommand() {
+        const width = this.ui.terminal.columns;
+        const height = this.ui.terminal.rows;
+        const allLines = this.ui.render(width);
+        const debugLogPath = getDebugLogPath();
+        const debugData = [
+            `Debug output at ${new Date().toISOString()}`,
+            `Terminal: ${width}x${height}`,
+            `Total lines: ${allLines.length}`,
+            "",
+            "=== All rendered lines with visible widths ===",
+            ...allLines.map((line, idx) => {
+                const vw = visibleWidth(line);
+                const escaped = JSON.stringify(line);
+                return `[${idx}] (w=${vw}) ${escaped}`;
+            }),
+            "",
+            "=== Agent messages (JSONL) ===",
+            ...this.facade
+                .getSessionAPI()
+                .getMessages()
+                .map((msg) => JSON.stringify(msg)),
+            "",
+        ].join("\n");
+        fs.mkdirSync(path.dirname(debugLogPath), { recursive: true });
+        fs.writeFileSync(debugLogPath, debugData);
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new Text(`${theme.fg("accent", "✓ Debug log written")}\n${theme.fg("muted", debugLogPath)}`, 1, 1));
+        this.ui.requestRender();
+    }
+    handleArminSaysHi() {
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new ArminComponent(this.ui));
+        this.ui.requestRender();
+    }
+    handleDaxnuts() {
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new DaxnutsComponent(this.ui));
+        this.ui.requestRender();
+    }
+    /** Host-visible for ./interactive-auth.ts (S5 slice 3). */
+    checkDaxnutsEasterEgg(model) {
+        if (model.provider === "opencode" && model.id.toLowerCase().includes("kimi-k2.5")) {
+            this.handleDaxnuts();
+        }
+    }
+    async handleBashCommand(command, excludeFromContext = false) {
+        // Dispatch the user.bash lifecycle facts, then execute locally.
+        this.facade.emitUserBash(excludeFromContext);
+        // Normal execution path
+        const isDeferred = this.facade.isStreaming();
+        this.bashComponent = new BashExecutionComponent(command, this.ui, excludeFromContext);
+        if (isDeferred) {
+            // Show in pending area when agent is streaming
+            this.pendingMessagesContainer.addChild(this.bashComponent);
+            this.pendingBashComponents.push(this.bashComponent);
+        }
+        else {
+            // Show in chat immediately when agent is idle
+            this.chatContainer.addChild(this.bashComponent);
+        }
+        this.ui.requestRender();
+        try {
+            const result = await this.facade.executeBash(command, (chunk) => {
+                if (this.bashComponent) {
+                    this.bashComponent.appendOutput(chunk);
+                    this.ui.requestRender();
+                }
+            }, { excludeFromContext });
+            if (this.bashComponent) {
+                this.bashComponent.setComplete(result.exitCode, result.cancelled, result.truncated ? { truncated: true, content: result.output } : undefined, result.fullOutputPath);
+            }
+        }
+        catch (error) {
+            if (this.bashComponent) {
+                this.bashComponent.setComplete(undefined, false);
+            }
+            this.showError(`Bash command failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+        this.bashComponent = undefined;
+        this.ui.requestRender();
+    }
+    async handleCompactCommand(customInstructions) {
+        this.clearStatusIndicator();
+        try {
+            await this.facade.compact(customInstructions);
+        }
+        catch {
+            // Ignore, will be emitted as an event
+        }
+    }
+    stop(fullscreenExitOutput = this.settingsManager.getFullscreenExitOutput()) {
+        this.disposeActiveSelector();
+        if (this.settingsManager.getShowTerminalProgress()) {
+            this.ui.terminal.setProgress(false);
+        }
+        this.clearStatusIndicator();
+        this.themeController.disableAutoSync();
+        this.footer.dispose();
+        this.footerDataProvider.dispose();
+        if (this.unsubscribe) {
+            this.unsubscribe();
+        }
+        if (this.isInitialized) {
+            this.stopInteractiveTui(fullscreenExitOutput);
+            this.isInitialized = false;
+        }
+        this.unregisterSignalHandlers();
+    }
+}
+//# sourceMappingURL=interactive-mode.js.map