@leanandmean/coding-agent 0.74.1-scramjet.6 → 0.74.1-scramjet.60

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

@@ -6,8 +6,9 @@ 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 { stripVTControlCharacters } from "node:util";
 import { getProviders, } from "@leanandmean/ai";
-import { CombinedAutocompleteProvider, Container, fuzzyFilter, Loader, Markdown, matchesKey, ProcessTerminal, Spacer, setKeybindings, Text, TruncatedText, TUI, visibleWidth, } from "@leanandmean/tui";
+import { CombinedAutocompleteProvider, Container, fuzzyFilter, isKeyRelease, Loader, Markdown, matchesKey, ProcessTerminal, Spacer, setKeybindings, Text, TruncatedText, TUI, TUI_KEYBINDINGS, visibleWidth, } from "@leanandmean/tui";
 import { spawn, spawnSync } from "child_process";
 import { APP_NAME, APP_TITLE, getAgentDir, getAuthPath, getDebugLogPath, getDocsPath, VERSION } from "../../config.js";
 import { parseSkillBlock } from "../../core/agent-session.js";
@@ -18,12 +19,13 @@ import { createCompactionSummaryMessage } from "../../core/messages.js";
 import { defaultModelPerProvider, findExactModelReferenceMatch, resolveModelScope } from "../../core/model-resolver.js";
 import { DefaultPackageManager } from "../../core/package-manager.js";
 import { BUILT_IN_PROVIDER_DISPLAY_NAMES } from "../../core/provider-display-names.js";
-import { parseScramjetCommandBlock } from "../../core/scramjet-command-parser.js"; // SCRAMJET-DIVERGENCE: scramjet-command block parsing (issue 82)
+import { describeRuntimeError } from "../../core/resource-loader.js";
+import { indexScramjetCommandStarts, parseScramjetCommandBlock, restoreScramjetCommandInvocation, } from "../../core/scramjet-command-parser.js"; // SCRAMJET-DIVERGENCE: scramjet-command restoration (issues 82, 414)
 import { formatMissingSessionCwdPrompt, MissingSessionCwdError } from "../../core/session-cwd.js";
 import { SessionManager } from "../../core/session-manager.js";
 import { BUILTIN_SLASH_COMMANDS } from "../../core/slash-commands.js";
 import { getChangelogPath, getNewEntries, parseChangelog } from "../../utils/changelog.js";
-import { copyToClipboard } from "../../utils/clipboard.js";
+import { copyToClipboard, createWslClipboardReader, readClipboardText } from "../../utils/clipboard.js";
 import { extensionForImageMimeType, readClipboardImage } from "../../utils/clipboard-image.js";
 import { parseGitUrl } from "../../utils/git.js";
 import { getCwdRelativePath } from "../../utils/paths.js";
@@ -57,7 +59,8 @@ import { ToolExecutionComponent } from "./components/tool-execution.js";
 import { TreeSelectorComponent } from "./components/tree-selector.js";
 import { UserMessageComponent } from "./components/user-message.js";
 import { UserMessageSelectorComponent } from "./components/user-message-selector.js";
-import { getAvailableThemes, getAvailableThemesWithPaths, getEditorTheme, getMarkdownTheme, getThemeByName, initTheme, onThemeChange, setRegisteredThemes, setTheme, setThemeInstance, stopThemeWatcher, Theme, theme, } from "./theme/theme.js";
+import { NspellProvider } from "./spellcheck.js";
+import { classifyBackgroundColor, detectThemeFromEnvironment, getAvailableThemes, getAvailableThemesWithPaths, getCurrentThemeName, getEditorTheme, getMarkdownTheme, getThemeByName, initTheme, onThemeChange, resolveThemeName, setRegisteredThemes, setTheme, setThemeInstance, stopThemeWatcher, Theme, theme, } from "./theme/theme.js";
 function isExpandable(obj) {
     return typeof obj === "object" && obj !== null && "setExpanded" in obj && typeof obj.setExpanded === "function";
 }
@@ -106,11 +109,15 @@ export class InteractiveMode {
     options;
     runtimeHost;
     ui;
+    tuiMode;
+    committedChatContainer;
     chatContainer;
+    mutableChatComponents = new Set();
     pendingMessagesContainer;
     statusContainer;
     defaultEditor;
     editor;
+    editorAvailableRows;
     editorComponentFactory;
     autocompleteProvider;
     autocompleteProviderWrappers = [];
@@ -126,6 +133,11 @@ export class InteractiveMode {
     loadingAnimation = undefined;
     workingMessage = undefined;
     workingVisible = true;
+    // SCRAMJET-DIVERGENCE: title provider for extension-owned terminal titles.
+    titleProvider = undefined;
+    // SCRAMJET-DIVERGENCE: captured terminal classification (env-seeded in the constructor, updated
+    // by the OSC 11 query) used to re-resolve the default theme once extension themes register.
+    detectedClassification = undefined;
     workingIndicatorOptions = undefined;
     defaultWorkingMessage = "Working...";
     defaultHiddenThinkingLabel = "Thinking...";
@@ -143,6 +155,11 @@ export class InteractiveMode {
     streamingMessage = undefined;
     // Tool execution tracking: toolCallId -> component
     pendingTools = new Map();
+    pendingToolFinalizations = new Set();
+    agentRunGeneration = 0;
+    selectorOpenGeneration = 0;
+    pendingSelectorOpenGeneration;
+    layoutSettingsSettlementGeneration = 0;
     // Tool output expansion state
     toolOutputExpanded = false;
     // Thinking block visibility state
@@ -173,6 +190,7 @@ export class InteractiveMode {
     extensionSelector = undefined;
     extensionInput = undefined;
     extensionEditor = undefined;
+    customHeightAllocation;
     extensionTerminalInputUnsubscribers = new Set();
     // Extension widgets (components rendered above/below the editor)
     extensionWidgetsAbove = new Map();
@@ -210,9 +228,30 @@ export class InteractiveMode {
             await this.rebindCurrentSession();
         });
         this.version = VERSION;
-        this.ui = new TUI(new ProcessTerminal(), this.settingsManager.getShowHardwareCursor());
-        this.ui.setClearOnShrink(this.settingsManager.getClearOnShrink());
+        this.tuiMode = this.settingsManager.getTuiMode();
+        // SCRAMJET-DIVERGENCE: retained interactive rendering and injectable terminals.
+        this.ui = new TUI(options.terminal ?? new ProcessTerminal(), this.settingsManager.getShowHardwareCursor());
+        this.clipboardReader = this.tuiMode === "retained" ? createWslClipboardReader() : undefined;
+        this.ui.addLifecycleListener((event) => {
+            if (event === "start")
+                void this.clipboardReader?.start().catch(() => { });
+            else {
+                this.clipboardPasteGeneration++;
+                this.clipboardPastePending = undefined;
+                this.clipboardReader?.close();
+            }
+        });
+        this.ui.addInputListener((data) => {
+            if (!isKeyRelease(data) &&
+                data !== "\x1b[I" &&
+                !/^\x1b\[<34;\d{1,5};\d{1,5}M$/.test(data) &&
+                !/^\x1b\[6;\d+;\d+t$/.test(data) &&
+                !/^\x1b\[<\d+;\d+;\d+m$/.test(data))
+                this.clipboardPasteGeneration++;
+            return undefined;
+        });
         this.headerContainer = new Container();
+        this.committedChatContainer = new Container();
         this.chatContainer = new Container();
         this.pendingMessagesContainer = new Container();
         this.statusContainer = new Container();
@@ -227,6 +266,8 @@ export class InteractiveMode {
             autocompleteMaxVisible,
         });
         this.editor = this.defaultEditor;
+        this.configureEditorHeight(this.editor);
+        this.defaultEditor.setSpellcheckProvider(new NspellProvider());
         this.editorContainer = new Container();
         this.editorContainer.addChild(this.editor);
         this.footerDataProvider = new FooterDataProvider(this.sessionManager.getCwd());
@@ -236,8 +277,287 @@ export class InteractiveMode {
         this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
         // Register themes from resource loader and initialize
         setRegisteredThemes(this.session.resourceLoader.getThemes().themes);
+        // SCRAMJET-DIVERGENCE: capture the env classification so the post-extension-bind reapplication
+        // can honor COLORFGBG/Apple-Terminal-detected (never-OSC) terminals. Without this seed, those
+        // terminals would resolve the dark branch and clobber light terminals to scramjet-dark.
+        this.detectedClassification = detectThemeFromEnvironment()?.theme;
         initTheme(this.settingsManager.getTheme(), true);
     }
+    configureEditorHeight(editor) {
+        editor.setHeightLimit?.(() => ({
+            rows: Math.max(1, this.editorAvailableRows ?? this.ui.terminal.rows - 3),
+            text: Math.max(1, Math.floor((this.ui.terminal.rows * this.settingsManager.getEditorMaxHeightPercent()) / 100)),
+        }));
+    }
+    renderSessionGap(width, below) {
+        if (below === 0)
+            return "";
+        const forms = [
+            `Session: ${below} lines below · Ctrl+End: latest`,
+            `Session: ${below} lines below`,
+            `Session: ${below} below`,
+            `Session↓${below}`,
+            "Session ↓…",
+        ];
+        return theme.fg("muted", forms.find((text) => visibleWidth(text) <= width) ?? "");
+    }
+    // SCRAMJET-DIVERGENCE: preserve production ownership while making mutable overflow browseable.
+    clipboardReader;
+    clipboardPastePending;
+    clipboardPasteGeneration = 0;
+    clipboardPasteOwner;
+    async pasteFromClipboard() {
+        const editor = this.editor;
+        const session = this.session;
+        const draft = editor.getText();
+        const generation = this.clipboardPasteGeneration;
+        const current = () => generation === this.clipboardPasteGeneration &&
+            this.editor === editor &&
+            this.session === session &&
+            editor.getText() === draft &&
+            this.editorContainer.children.length === 1 &&
+            this.editorContainer.children[0] === editor &&
+            this.ui.isComponentFocused(editor) &&
+            this.ui.isComponentVisible(this.editorContainer) &&
+            this.ui.isComponentRenderComplete(this.editorContainer);
+        if (!current())
+            return;
+        let pending;
+        try {
+            while (current() && !this.ui.isViewportFrameFlushed()) {
+                await this.ui.renderNow({ requireFlush: true });
+            }
+            if (!current())
+                return;
+            if (this.clipboardReader) {
+                await this.clipboardReader.start();
+                if (!current())
+                    return;
+            }
+            this.clipboardPastePending ??= this.clipboardReader ? this.clipboardReader.read() : readClipboardText();
+            pending = this.clipboardPastePending;
+            const text = await pending;
+            if (!current())
+                return;
+            const safeText = stripVTControlCharacters(text).replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/g, "");
+            editor.handleInput(`\x1b[200~${safeText}\x1b[201~`);
+            this.ui.requestRender();
+        }
+        catch (error) {
+            if (current())
+                this.showError(`Paste failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            if (pending && this.clipboardPastePending === pending)
+                this.clipboardPastePending = undefined;
+        }
+    }
+    configureRetainedViewport() {
+        this.ui.configureViewport({
+            getBlocks: () => this.ui.children.flatMap((component) => {
+                if (component === this.editorContainer &&
+                    this.clipboardPasteOwner !== this.editorContainer.children[0]) {
+                    this.clipboardPasteOwner = this.editorContainer.children[0];
+                    this.clipboardPasteGeneration++;
+                }
+                if (component instanceof Container &&
+                    (component === this.committedChatContainer || component === this.chatContainer)) {
+                    return component.children.map((child) => ({
+                        component: child,
+                        finalized: component === this.committedChatContainer,
+                    }));
+                }
+                const dock = this.settingsManager.getDockEditor() &&
+                    this.editorContainer.children.length > 0 &&
+                    [
+                        this.widgetContainerAbove,
+                        this.editorContainer,
+                        this.widgetContainerBelow,
+                        this.customFooter ?? this.footer,
+                    ].includes(component);
+                return [
+                    {
+                        component,
+                        finalized: false,
+                        dock,
+                        renderDockGap: component === this.widgetContainerAbove
+                            ? (width, below) => this.renderSessionGap(width, below)
+                            : undefined,
+                        fitHeight: component === this.editorContainer
+                            ? (rows) => {
+                                this.editorAvailableRows = rows;
+                                const allocation = this.customHeightAllocation;
+                                if (allocation) {
+                                    if (this.editorContainer.children.length === 1 &&
+                                        this.editorContainer.children[0] === allocation.component) {
+                                        try {
+                                            allocation.notify(rows);
+                                        }
+                                        catch (error) {
+                                            allocation.fail(error);
+                                        }
+                                    }
+                                    else
+                                        this.releaseCustomHeight();
+                                }
+                            }
+                            : undefined,
+                    },
+                ];
+            }),
+            keybindings: this.keybindings,
+            copy: copyToClipboard,
+            requestPaste: () => void this.pasteFromClipboard(),
+            minimumSize: { columns: 12, rows: 3 },
+            handleBlockedInput: (data) => {
+                const selector = this.editorContainer.children[0];
+                if (selector instanceof SettingsSelectorComponent &&
+                    this.ui.isComponentFocused(selector.getSettingsList()) &&
+                    this.keybindings.matches(data, "tui.select.cancel")) {
+                    selector.cancel();
+                }
+                else if (this.keybindings.matches(data, "app.interrupt")) {
+                    this.restoreQueuedMessagesToEditor();
+                    this.session.abortBash();
+                    this.session.abortCompaction();
+                    this.session.abortBranchSummary();
+                    void this.session.abort();
+                }
+                else if (this.keybindings.matches(data, "app.exit") && this.editor.getText().length === 0) {
+                    this.handleCtrlD();
+                }
+            },
+            getScrollWheelStep: () => this.settingsManager.getScrollWheelStep(),
+            allowViewportKeys: (data) => this.ui.isComponentFocused(this.editor) ||
+                (!matchesKey(data, "space") &&
+                    !Object.keys(TUI_KEYBINDINGS).some((action) => !action.startsWith("tui.viewport.") && this.keybindings.matches(data, action))),
+            keepReadingOnInput: () => {
+                const ownsFocus = (component) => this.ui.isComponentFocused(component) ||
+                    (component instanceof Container && component.children.some(ownsFocus));
+                return this.editorContainer.children.some(ownsFocus);
+            },
+            handlePresentationInput: (data) => {
+                if (!this.ui.isComponentFocused(this.editor))
+                    return false;
+                if (!this.keybindings.matches(data, "app.tools.expand") &&
+                    !this.keybindings.matches(data, "app.thinking.toggle"))
+                    return false;
+                this.editor.handleInput(data);
+                return true;
+            },
+        });
+        // SCRAMJET-DIVERGENCE: completion needs a painted slot even when its hardware cursor is hidden.
+        this.ui.addInputListener((data) => {
+            if (!this.ui.isComponentFocused(this.editor) ||
+                !this.editor.isShowingAutocomplete?.() ||
+                isKeyRelease(data) ||
+                /^\x1b\[\d+;\d+;\d+t$/.test(data) ||
+                this.keybindings.matches(data, "app.tools.expand") ||
+                this.keybindings.matches(data, "app.thinking.toggle"))
+                return undefined;
+            const visible = this.ui.isComponentVisible(this.editorContainer);
+            if (!visible && !this.ui.hasOverlay())
+                this.ui.revealComponent(this.editorContainer);
+            if ((this.keybindings.matches(data, "tui.input.tab") || this.keybindings.matches(data, "tui.select.confirm")) &&
+                (!visible || !this.ui.isViewportFrameFlushed()))
+                return { consume: true };
+            return undefined;
+        });
+    }
+    // SCRAMJET-DIVERGENCE: finalized transcript components are promoted atomically into append-only history (#389).
+    promoteFinalizedChatPrefix() {
+        let promoted = false;
+        while (this.chatContainer.children.length > 0) {
+            const child = this.chatContainer.children[0];
+            if (this.mutableChatComponents.has(child))
+                break;
+            this.chatContainer.removeChild(child);
+            if (child instanceof ToolExecutionComponent)
+                child.markCommitted();
+            this.committedChatContainer.addChild(child);
+            promoted = true;
+        }
+        if (promoted) {
+            if (this.ui.getViewportState())
+                this.ui.requestRender();
+            else
+                this.ui.commit();
+        }
+    }
+    setChatComponentMutable(component, mutable) {
+        if (mutable)
+            this.mutableChatComponents.add(component);
+        else
+            this.mutableChatComponents.delete(component);
+    }
+    sealStatus() {
+        if (this.lastStatusSpacer)
+            this.mutableChatComponents.delete(this.lastStatusSpacer);
+        if (this.lastStatusText)
+            this.mutableChatComponents.delete(this.lastStatusText);
+        this.lastStatusSpacer = undefined;
+        this.lastStatusText = undefined;
+        this.promoteFinalizedChatPrefix();
+    }
+    clearTranscript() {
+        this.clipboardPasteGeneration++;
+        if (this.ui.getViewportState())
+            this.ui.resetViewport();
+        this.pendingToolFinalizations = new Set();
+        const tools = new Set([
+            ...this.pendingTools.values(),
+            ...this.committedChatContainer.children.filter((component) => component instanceof ToolExecutionComponent),
+            ...this.chatContainer.children.filter((component) => component instanceof ToolExecutionComponent),
+        ]);
+        for (const tool of tools)
+            tool.detach();
+        this.committedChatContainer.clear();
+        this.chatContainer.clear();
+        this.mutableChatComponents.clear();
+        this.lastStatusSpacer = undefined;
+        this.lastStatusText = undefined;
+        this.ui.rebuild();
+    }
+    updateToolImagePresentation(update) {
+        for (const container of [this.committedChatContainer, this.chatContainer]) {
+            for (const child of container.children) {
+                if (child instanceof ToolExecutionComponent)
+                    update(child);
+            }
+        }
+        this.ui.rebuild();
+    }
+    commitFinalizedChatOutput() {
+        this.sealStatus();
+        this.ui.requestRender();
+    }
+    bindThemeChangeHandler() {
+        onThemeChange(() => {
+            this.ui.invalidate();
+            this.updateEditorBorderColor();
+            this.ui.rebuild();
+        });
+    }
+    // SCRAMJET-DIVERGENCE: re-resolve the theme after extension themes register (or after a reload),
+    // so scramjet-dark can take effect once it becomes available. An explicit user setting still wins
+    // via the resolver; the captured classification (env-seeded + OSC-updated) drives auto-detection.
+    // Skips the apply when the resolved name already matches the active theme, unless `force` is set:
+    // the reload path forces a re-read from disk (registered extension themes have no file watcher, so
+    // /reload is their only refresh path even when the active theme's name is unchanged).
+    reapplyResolvedTheme(force = false) {
+        const name = resolveThemeName({
+            explicitSetting: this.settingsManager.getTheme(),
+            detectedClassification: this.detectedClassification,
+            hasScramjetDark: getAvailableThemes().includes("scramjet-dark"),
+        });
+        if (!force && name === getCurrentThemeName()) {
+            return;
+        }
+        const result = setTheme(name, true);
+        if (!result.success) {
+            this.showError(`Failed to load theme "${name}": ${result.error}\nFell back to pi-dark theme.`);
+        }
+    }
     getAutocompleteSourceTag(sourceInfo) {
         if (!sourceInfo) {
             return undefined;
@@ -376,6 +696,7 @@ export class InteractiveMode {
             this.chatContainer.addChild(new Spacer(1));
         }
         this.chatContainer.addChild(new DynamicBorder());
+        this.promoteFinalizedChatPrefix();
     }
     async init() {
         if (this.isInitialized)
@@ -385,27 +706,58 @@ export class InteractiveMode {
         this.changelogMarkdown = this.getChangelogForDisplay();
         // Ensure fd and rg are available (downloads if missing, adds to PATH via getBinDir)
         // Both are needed: fd for autocomplete, rg for grep tool and bash commands
-        const [fdPath] = await Promise.all([ensureTool("fd"), ensureTool("rg")]);
+        const startupDiagnostics = [];
+        const report = (message) => {
+            startupDiagnostics.push(message);
+        };
+        const [fdPath] = await Promise.all([ensureTool("fd", false, report), ensureTool("rg", false, report)]);
         this.fdPath = fdPath;
-        if (this.session.scopedModels.length > 0 && (this.options.verbose || !this.settingsManager.getQuietStartup())) {
-            const modelList = this.session.scopedModels
-                .map((sm) => {
-                const thinkingStr = sm.thinkingLevel ? `:${sm.thinkingLevel}` : "";
-                return `${sm.model.id}${thinkingStr}`;
-            })
-                .join(", ");
-            const cycleKeys = this.keybindings.getKeys("app.model.cycleForward");
-            const cycleHint = cycleKeys.length > 0
-                ? theme.fg("muted", ` (${formatKeyText(cycleKeys.join("/"), { capitalize: true })} to cycle)`)
-                : "";
-            console.log(theme.fg("dim", `Model scope: ${modelList}${cycleHint}`));
-        }
-        // Add header container as first child
+        // Add header container as first child (content built after theme detection below)
         this.ui.addChild(this.headerContainer);
-        // Add header with keybindings from config (unless silenced)
+        this.ui.addChild(this.committedChatContainer);
+        this.ui.addChild(this.chatContainer);
+        if (this.tuiMode === "retained")
+            this.configureRetainedViewport();
+        else
+            this.ui.setLiveRegionStart(this.chatContainer);
+        this.ui.addChild(this.pendingMessagesContainer);
+        this.ui.addChild(this.statusContainer);
+        this.renderWidgets(); // Initialize with default spacer
+        this.ui.addChild(this.widgetContainerAbove);
+        this.ui.addChild(this.editorContainer);
+        this.ui.addChild(this.widgetContainerBelow);
+        this.ui.addChild(this.footer);
+        this.ui.setFocus(this.editor);
+        this.setupKeyHandlers();
+        this.setupEditorSubmitHandler();
+        // Start the UI before initializing extensions so session_start handlers can use interactive dialogs
+        this.ui.start();
+        this.isInitialized = true;
+        // Detect terminal background via OSC 11 if no stronger signal resolved synchronously.
+        // The constructor already initialized theme from explicit setting, COLORFGBG, or Apple Terminal
+        // heuristic (via getDefaultTheme). This step only fires when no explicit theme is set and
+        // detectThemeFromEnvironment() returned undefined (no env signal available).
+        if (!this.settingsManager.getTheme() && !detectThemeFromEnvironment()) {
+            const rgb = await this.ui.queryTerminalBackgroundColor({ timeoutMs: 100 });
+            if (rgb) {
+                // SCRAMJET-DIVERGENCE: capture the OSC 11 classification and resolve through the shared
+                // resolver so a dark terminal maps to scramjet-dark (when available) and a light one to
+                // pi-light. Skips the apply when the resolved name is already active.
+                this.detectedClassification = classifyBackgroundColor(rgb);
+                this.reapplyResolvedTheme();
+            }
+        }
+        // Build themed header content (after theme detection so colors are correct)
         if (this.options.verbose || !this.settingsManager.getQuietStartup()) {
+            if (this.session.scopedModels.length > 0) {
+                const modelList = this.session.scopedModels
+                    .map(({ model, thinkingLevel }) => `${model.id}${thinkingLevel ? `:${thinkingLevel}` : ""}`)
+                    .join(", ");
+                const cycleKeys = this.keybindings.getKeys("app.model.cycleForward");
+                const cycleHint = cycleKeys.length > 0 ? ` (${formatKeyText(cycleKeys.join("/"), { capitalize: true })} to cycle)` : "";
+                this.headerContainer.addChild(new Text(theme.fg("dim", `Model scope: ${modelList}${cycleHint}`), 1, 0));
+            }
             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"),
@@ -440,40 +792,22 @@ export class InteractiveMode {
             // SCRAMJET-DIVERGENCE: rebrand Pi → APP_NAME.
             `${APP_NAME} can explain its own features and look up its docs. Ask it how to use or extend ${APP_NAME}.`);
             this.builtInHeader = new ExpandableText(() => `${logo}\n${compactInstructions}\n${compactOnboarding}\n\n${onboarding}`, () => `${logo}\n${expandedInstructions}\n\n${onboarding}`, this.getStartupExpansionState(), 1, 0);
-            // Setup UI layout
             this.headerContainer.addChild(new Spacer(1));
             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.addChild(this.chatContainer);
-        this.ui.addChild(this.pendingMessagesContainer);
-        this.ui.addChild(this.statusContainer);
-        this.renderWidgets(); // Initialize with default spacer
-        this.ui.addChild(this.widgetContainerAbove);
-        this.ui.addChild(this.editorContainer);
-        this.ui.addChild(this.widgetContainerBelow);
-        this.ui.addChild(this.footer);
-        this.ui.setFocus(this.editor);
-        this.setupKeyHandlers();
-        this.setupEditorSubmitHandler();
-        // Start the UI before initializing extensions so session_start handlers can use interactive dialogs
-        this.ui.start();
-        this.isInitialized = true;
+        for (const diagnostic of startupDiagnostics)
+            this.headerContainer.addChild(new Text(diagnostic, 1, 0));
         // Initialize extensions first so resources are shown before messages
         await this.rebindCurrentSession();
         // Render initial messages AFTER showing loaded resources
         this.renderInitialMessages();
         // Set up theme file watcher
-        onThemeChange(() => {
-            this.ui.invalidate();
-            this.updateEditorBorderColor();
-            this.ui.requestRender();
-        });
+        this.bindThemeChangeHandler();
         // Set up git branch watcher (uses provider instead of footer)
         this.footerDataProvider.onBranchChange(() => {
             this.ui.requestRender();
@@ -485,6 +819,20 @@ export class InteractiveMode {
      * Update terminal title with session name and cwd.
      */
     updateTerminalTitle() {
+        // SCRAMJET-DIVERGENCE: delegate to title provider when set.
+        if (this.titleProvider) {
+            let title;
+            try {
+                title = this.titleProvider();
+            }
+            catch {
+                // Provider failed; fall through to default title
+            }
+            if (title !== undefined) {
+                this.ui.terminal.setTitle(title);
+                return;
+            }
+        }
         const cwdBasename = path.basename(this.sessionManager.getCwd());
         const sessionName = this.sessionManager.getSessionName();
         if (sessionName) {
@@ -1112,7 +1460,7 @@ export class InteractiveMode {
                     if (result.cancelled) {
                         return { cancelled: true };
                     }
-                    this.chatContainer.clear();
+                    this.clearTranscript();
                     this.renderInitialMessages();
                     if (result.editorText && !this.editor.getText().trim()) {
                         this.editor.setText(result.editorText);
@@ -1139,11 +1487,15 @@ export class InteractiveMode {
             },
         });
         setRegisteredThemes(this.session.resourceLoader.getThemes().themes);
+        // SCRAMJET-DIVERGENCE: extension themes (e.g. scramjet-dark) register after the constructor's
+        // initTheme, so re-resolve now that they are available.
+        this.reapplyResolvedTheme();
         this.setupAutocompleteProvider();
         const extensionRunner = this.session.extensionRunner;
         this.setupExtensionShortcuts(extensionRunner);
         this.showLoadedResources({ force: false, showDiagnosticsWhenQuiet: true });
         this.showStartupNoticesIfNeeded();
+        this.promoteFinalizedChatPrefix();
     }
     applyRuntimeSettings() {
         this.footer.setSession(this.session);
@@ -1151,7 +1503,6 @@ export class InteractiveMode {
         this.footerDataProvider.setCwd(this.sessionManager.getCwd());
         this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
         this.ui.setShowHardwareCursor(this.settingsManager.getShowHardwareCursor());
-        this.ui.setClearOnShrink(this.settingsManager.getClearOnShrink());
         const editorPaddingX = this.settingsManager.getEditorPaddingX();
         const autocompleteMaxVisible = this.settingsManager.getAutocompleteMaxVisible();
         this.defaultEditor.setPaddingX(editorPaddingX);
@@ -1196,14 +1547,13 @@ export class InteractiveMode {
         }
     }
     async handleFatalRuntimeError(prefix, error) {
-        const message = error instanceof Error ? error.message : String(error);
-        this.showError(`${prefix}: ${message}`);
+        this.showError(`${prefix}: ${describeRuntimeError(error)}`);
         stopThemeWatcher();
         this.stop();
         process.exit(1);
     }
     renderCurrentSessionState() {
-        this.chatContainer.clear();
+        this.clearTranscript();
         this.pendingMessagesContainer.clear();
         this.compactionQueuedMessages = [];
         this.streamingComponent = undefined;
@@ -1232,6 +1582,7 @@ export class InteractiveMode {
             sessionManager: this.sessionManager,
             modelRegistry: this.session.modelRegistry,
             model: this.session.model,
+            scopedModels: this.session.scopedModels,
             isIdle: () => !this.session.isStreaming,
             signal: this.session.agent.signal,
             abort: () => this.session.abort(),
@@ -1312,7 +1663,7 @@ export class InteractiveMode {
     }
     setHiddenThinkingLabel(label) {
         this.hiddenThinkingLabel = label ?? this.defaultHiddenThinkingLabel;
-        for (const child of this.chatContainer.children) {
+        for (const child of [...this.committedChatContainer.children, ...this.chatContainer.children]) {
             if (child instanceof AssistantMessageComponent) {
                 child.setHiddenThinkingLabel(this.hiddenThinkingLabel);
             }
@@ -1320,7 +1671,7 @@ export class InteractiveMode {
         if (this.streamingComponent) {
             this.streamingComponent.setHiddenThinkingLabel(this.hiddenThinkingLabel);
         }
-        this.ui.requestRender();
+        this.ui.rebuild();
     }
     /**
      * Set an extension widget (string array or custom component).
@@ -1370,7 +1721,19 @@ export class InteractiveMode {
         this.extensionWidgetsBelow.clear();
         this.renderWidgets();
     }
+    // SCRAMJET-DIVERGENCE: height delivery belongs to one opted-in custom invocation, never an inferred component capability.
+    releaseCustomHeight() {
+        const allocation = this.customHeightAllocation;
+        this.customHeightAllocation = undefined;
+        try {
+            allocation?.notify(undefined);
+        }
+        catch (error) {
+            this.showError(`Custom input height release failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     resetExtensionUI() {
+        this.releaseCustomHeight();
         if (this.extensionSelector) {
             this.hideExtensionSelector();
         }
@@ -1391,6 +1754,7 @@ export class InteractiveMode {
         this.setCustomEditorComponent(undefined);
         this.setupAutocompleteProvider();
         this.defaultEditor.onExtensionShortcut = undefined;
+        this.titleProvider = undefined;
         this.updateTerminalTitle();
         this.workingMessage = undefined;
         this.workingVisible = true;
@@ -1493,7 +1857,7 @@ export class InteractiveMode {
                 this.headerContainer.children[index] = this.builtInHeader;
             }
         }
-        this.ui.requestRender();
+        this.ui.rebuild();
     }
     addExtensionTerminalInputListener(handler) {
         const unsubscribe = this.ui.addInputListener(handler);
@@ -1533,6 +1897,10 @@ export class InteractiveMode {
             setFooter: (factory) => this.setExtensionFooter(factory),
             setHeader: (factory) => this.setExtensionHeader(factory),
             setTitle: (title) => this.ui.terminal.setTitle(title),
+            setTitleProvider: (provider) => {
+                this.titleProvider = provider;
+                this.updateTerminalTitle();
+            },
             custom: (factory, options) => this.showExtensionCustom(factory, options),
             pasteToEditor: (text) => this.editor.handleInput(`\x1b[200~${text}\x1b[201~`),
             setEditorText: (text) => this.editor.setText(text),
@@ -1737,6 +2105,7 @@ export class InteractiveMode {
                 }
             }
             this.editor = newEditor;
+            this.configureEditorHeight(this.editor);
         }
         else {
             // Restore default editor with text from custom editor
@@ -1763,26 +2132,77 @@ export class InteractiveMode {
     }
     /** Show a custom component with keyboard focus. Overlay mode renders on top of existing content. */
     async showExtensionCustom(factory, options) {
+        if (options?.onAvailableHeight && (options.overlay || options.toolAttachedContext))
+            throw new Error("Available height is supported only for ordinary custom input controls");
         const savedText = this.editor.getText();
         const isOverlay = options?.overlay ?? false;
-        const restoreEditor = () => {
+        const restoreEditor = (restoreFocus = true) => {
             this.editorContainer.clear();
             this.editorContainer.addChild(this.editor);
             this.editor.setText(savedText);
-            this.ui.setFocus(this.editor);
+            if (restoreFocus)
+                this.ui.setFocus(this.editor);
             this.ui.requestRender();
         };
         return new Promise((resolve, reject) => {
             let component;
+            let attachedTool;
+            let committedContext;
+            let removeInputGuard;
+            let releaseHeight = () => { };
+            let revealingControls = false;
+            let needsReveal = false;
+            const retained = this.ui.getViewportState() !== undefined;
+            const pendingFocus = { render: () => [], invalidate() { } };
+            const restoreAttachedFocus = (current) => {
+                if (!retained)
+                    return;
+                this.ui.replaceFocus(pendingFocus, current ? this.editor : null);
+                if (attachedTool)
+                    this.ui.replaceFocus(attachedTool, current ? this.editor : null);
+            };
             let closed = false;
+            const attachmentCurrent = () => attachedTool &&
+                committedContext &&
+                this.pendingTools.get(options.toolAttachedContext.toolCallId) === attachedTool &&
+                this.chatContainer.children.includes(attachedTool) &&
+                this.committedChatContainer.children.includes(committedContext);
+            const fail = (error) => {
+                if (closed)
+                    return;
+                closed = true;
+                removeInputGuard?.();
+                releaseHeight();
+                const current = !attachedTool || this.chatContainer.children.includes(attachedTool);
+                attachedTool?.cancelCommittedContext();
+                if (committedContext) {
+                    this.committedChatContainer.removeChild(committedContext);
+                    this.ui.rebuild();
+                }
+                try {
+                    component?.dispose?.();
+                }
+                catch { }
+                if (attachedTool)
+                    restoreAttachedFocus(current);
+                if (!isOverlay && current)
+                    restoreEditor(!attachedTool || !retained);
+                reject(error);
+            };
             const close = (result) => {
                 if (closed)
                     return;
                 closed = true;
+                removeInputGuard?.();
+                releaseHeight();
+                attachedTool?.detachCommittedContext();
+                const current = !attachedTool || this.chatContainer.children.includes(attachedTool);
+                if (attachedTool)
+                    restoreAttachedFocus(current);
                 if (isOverlay)
                     this.ui.hideOverlay();
-                else
-                    restoreEditor();
+                else if (current)
+                    restoreEditor(!attachedTool || !retained);
                 // Note: both branches above already call requestRender
                 resolve(result);
                 try {
@@ -1793,10 +2213,90 @@ export class InteractiveMode {
                 }
             };
             Promise.resolve(factory(this.ui, theme, this.keybindings, close))
-                .then((c) => {
+                .then(async (c) => {
                 if (closed)
                     return;
                 component = c;
+                const attachment = options?.toolAttachedContext;
+                if (attachment) {
+                    if (isOverlay)
+                        throw new Error("Tool-attached context cannot be shown as an overlay");
+                    const tool = this.pendingTools.get(attachment.toolCallId);
+                    const orderingBarrier = this.chatContainer.children.find((child) => this.mutableChatComponents.has(child));
+                    if (!tool || !this.chatContainer.children.includes(tool) || orderingBarrier !== tool) {
+                        throw new Error("Tool-attached context requires the current pending tool row");
+                    }
+                    attachedTool = tool;
+                    committedContext = attachment.render(this.ui, theme);
+                    this.committedChatContainer.addChild(committedContext);
+                    tool.attachCommittedContext(component);
+                    if (retained)
+                        this.ui.replaceFocus(this.editor, pendingFocus);
+                    else
+                        this.ui.setFocus(null);
+                    this.editorContainer.clear();
+                    const reveal = async () => {
+                        revealingControls = true;
+                        this.ui.replaceFocus(tool, pendingFocus);
+                        if (retained) {
+                            this.ui.revealComponent(tool);
+                            await this.ui.renderNow({ requireFlush: true });
+                        }
+                        else
+                            await this.ui.commitNow({ requireFlush: true });
+                        if (closed)
+                            return;
+                        if (!attachmentCurrent())
+                            throw new Error("Tool-attached context was replaced before flush settled");
+                        if (retained && !this.ui.isViewportFrameFlushed()) {
+                            needsReveal = true;
+                            revealingControls = false;
+                            return;
+                        }
+                        if (retained &&
+                            (!this.ui.isComponentRenderComplete(committedContext) ||
+                                !this.ui.isComponentRenderComplete(tool)))
+                            throw new Error("Approval context or controls could not be rendered completely");
+                        const visibility = retained ? this.ui.getComponentVisibility(tool) : "visible";
+                        if (visibility === "outside")
+                            throw new Error("Approval controls do not fit in the visible viewport");
+                        needsReveal = visibility === "occluded";
+                        revealingControls = false;
+                        if (retained)
+                            this.ui.replaceFocus(pendingFocus, tool);
+                        else
+                            this.ui.setFocus(tool);
+                    };
+                    if (retained) {
+                        // SCRAMJET-DIVERGENCE: occluded controls require a fresh reveal/flush, never overlay focus theft.
+                        removeInputGuard = this.ui.addInputListener((data) => {
+                            if (isKeyRelease(data) || /^\x1b\[\d+;\d+;\d+t$/.test(data))
+                                return undefined;
+                            if (!this.ui.isComponentFocused(tool) && !this.ui.isComponentFocused(pendingFocus))
+                                return undefined;
+                            if (!attachmentCurrent()) {
+                                fail(new Error("Tool-attached context is no longer current"));
+                                return { consume: true };
+                            }
+                            if (revealingControls)
+                                return { consume: true };
+                            if (!needsReveal &&
+                                this.ui.isViewportFrameFlushed() &&
+                                this.ui.isComponentVisible(tool) &&
+                                this.ui.isComponentRenderComplete(committedContext) &&
+                                this.ui.isComponentRenderComplete(tool))
+                                return undefined;
+                            if (!this.ui.hasOverlay())
+                                void reveal().catch(fail);
+                            return { consume: true };
+                        });
+                    }
+                    await reveal();
+                    if (closed)
+                        return;
+                    this.ui.requestRender();
+                    return;
+                }
                 if (isOverlay) {
                     // Resolve overlay options - can be static or dynamic function
                     const resolveOptions = () => {
@@ -1815,19 +2315,23 @@ export class InteractiveMode {
                     options?.onHandle?.(handle);
                 }
                 else {
+                    this.releaseCustomHeight();
+                    if (options?.onAvailableHeight) {
+                        const allocation = { component, notify: options.onAvailableHeight, fail };
+                        this.customHeightAllocation = allocation;
+                        releaseHeight = () => {
+                            if (this.customHeightAllocation === allocation)
+                                this.releaseCustomHeight();
+                        };
+                        allocation.notify(undefined);
+                    }
                     this.editorContainer.clear();
                     this.editorContainer.addChild(component);
                     this.ui.setFocus(component);
                     this.ui.requestRender();
                 }
             })
-                .catch((err) => {
-                if (closed)
-                    return;
-                if (!isOverlay)
-                    restoreEditor();
-                reject(err);
-            });
+                .catch(fail);
         });
     }
     /**
@@ -1848,7 +2352,7 @@ export class InteractiveMode {
                 this.chatContainer.addChild(new Text(stackLines, 1, 0));
             }
         }
-        this.ui.requestRender();
+        this.commitFinalizedChatOutput();
     }
     // =========================================================================
     // Key Handlers
@@ -1857,6 +2361,11 @@ export class InteractiveMode {
         // Set up handlers on defaultEditor - they use this.editor for text access
         // so they work correctly regardless of which editor is active
         this.defaultEditor.onEscape = () => {
+            if (this.pendingSelectorOpenGeneration !== undefined) {
+                this.selectorOpenGeneration++;
+                this.pendingSelectorOpenGeneration = undefined;
+                return;
+            }
             if (this.session.isStreaming) {
                 this.restoreQueuedMessagesToEditor({ abort: true });
             }
@@ -1908,6 +2417,7 @@ export class InteractiveMode {
         this.defaultEditor.onAction("app.session.fork", () => this.showUserMessageSelector());
         this.defaultEditor.onAction("app.session.resume", () => this.showSessionSelector());
         this.defaultEditor.onChange = (text) => {
+            this.clipboardPasteGeneration++;
             const wasBashMode = this.isBashMode;
             this.isBashMode = text.trimStart().startsWith("!");
             if (wasBashMode !== this.isBashMode) {
@@ -1944,6 +2454,8 @@ export class InteractiveMode {
             text = text.trim();
             if (!text)
                 return;
+            // SCRAMJET-DIVERGENCE: submission intent precedes command routing and queued-message delivery.
+            this.ui.followViewport();
             // Handle commands
             if (text === "/settings") {
                 this.showSettingsSelector();
@@ -2122,7 +2634,9 @@ export class InteractiveMode {
         this.footer.invalidate();
         switch (event.type) {
             case "agent_start":
+                this.agentRunGeneration += 1;
                 this.pendingTools.clear();
+                this.pendingToolFinalizations = new Set();
                 if (this.settingsManager.getShowTerminalProgress()) {
                     this.ui.terminal.setProgress(true);
                 }
@@ -2161,19 +2675,22 @@ export class InteractiveMode {
                 this.updateEditorBorderColor();
                 break;
             case "message_start":
+                this.sealStatus();
                 if (event.message.role === "custom") {
                     this.addMessageToChat(event.message);
                     this.ui.requestRender();
                 }
                 else if (event.message.role === "user") {
                     this.addMessageToChat(event.message);
+                    this.ui.followViewport();
                     this.updatePendingMessagesDisplay();
                     this.ui.requestRender();
                 }
                 else if (event.message.role === "assistant") {
-                    this.streamingComponent = new AssistantMessageComponent(undefined, this.hideThinkingBlock, this.getMarkdownThemeWithSettings(), this.hiddenThinkingLabel);
+                    this.streamingComponent = new AssistantMessageComponent(undefined, this.hideThinkingBlock, this.getMarkdownThemeWithSettings(), this.hiddenThinkingLabel, false);
                     this.streamingMessage = event.message;
                     this.chatContainer.addChild(this.streamingComponent);
+                    this.setChatComponentMutable(this.streamingComponent, true);
                     this.streamingComponent.updateContent(this.streamingMessage);
                     this.ui.requestRender();
                 }
@@ -2191,6 +2708,7 @@ export class InteractiveMode {
                                 }, this.getRegisteredToolDefinition(content.name), this.ui, this.sessionManager.getCwd());
                                 component.setExpanded(this.toolOutputExpanded);
                                 this.chatContainer.addChild(component);
+                                this.setChatComponentMutable(component, true);
                                 this.pendingTools.set(content.id, component);
                             }
                             else {
@@ -2219,6 +2737,8 @@ export class InteractiveMode {
                         this.streamingMessage.errorMessage = errorMessage;
                     }
                     this.streamingComponent.updateContent(this.streamingMessage);
+                    this.streamingComponent.setFinalized(true);
+                    this.setChatComponentMutable(this.streamingComponent, false);
                     if (this.streamingMessage.stopReason === "aborted" || this.streamingMessage.stopReason === "error") {
                         if (!errorMessage) {
                             errorMessage = this.streamingMessage.errorMessage || "Error";
@@ -2228,6 +2748,8 @@ export class InteractiveMode {
                                 content: [{ type: "text", text: errorMessage }],
                                 isError: true,
                             });
+                            component.seal();
+                            this.setChatComponentMutable(component, false);
                         }
                         this.pendingTools.clear();
                     }
@@ -2237,6 +2759,7 @@ export class InteractiveMode {
                             component.setArgsComplete();
                         }
                     }
+                    this.promoteFinalizedChatPrefix();
                     this.streamingComponent = undefined;
                     this.streamingMessage = undefined;
                     this.footer.invalidate();
@@ -2244,6 +2767,7 @@ export class InteractiveMode {
                 this.ui.requestRender();
                 break;
             case "tool_execution_start": {
+                this.sealStatus();
                 let component = this.pendingTools.get(event.toolCallId);
                 if (!component) {
                     component = new ToolExecutionComponent(event.toolName, event.toolCallId, event.args, {
@@ -2252,6 +2776,7 @@ export class InteractiveMode {
                     }, this.getRegisteredToolDefinition(event.toolName), this.ui, this.sessionManager.getCwd());
                     component.setExpanded(this.toolOutputExpanded);
                     this.chatContainer.addChild(component);
+                    this.setChatComponentMutable(component, true);
                     this.pendingTools.set(event.toolCallId, component);
                 }
                 component.markExecutionStarted();
@@ -2270,12 +2795,34 @@ export class InteractiveMode {
                 const component = this.pendingTools.get(event.toolCallId);
                 if (component) {
                     component.updateResult({ ...event.result, isError: event.isError });
-                    this.pendingTools.delete(event.toolCallId);
-                    this.ui.requestRender();
+                    const pendingToolFinalizations = this.pendingToolFinalizations;
+                    const finalization = component.waitForImageConversions().then(() => {
+                        component.seal();
+                        if (this.pendingTools.get(event.toolCallId) === component) {
+                            this.pendingTools.delete(event.toolCallId);
+                        }
+                        if (this.mutableChatComponents.has(component) && this.chatContainer.children.includes(component)) {
+                            this.setChatComponentMutable(component, false);
+                            this.promoteFinalizedChatPrefix();
+                            this.ui.requestRender();
+                        }
+                    });
+                    pendingToolFinalizations.add(finalization);
+                    try {
+                        await finalization;
+                    }
+                    finally {
+                        pendingToolFinalizations.delete(finalization);
+                    }
                 }
                 break;
             }
-            case "agent_end":
+            case "agent_end": {
+                const runGeneration = this.agentRunGeneration;
+                const pendingToolFinalizations = this.pendingToolFinalizations;
+                await Promise.all(pendingToolFinalizations);
+                if (runGeneration !== this.agentRunGeneration || pendingToolFinalizations !== this.pendingToolFinalizations)
+                    break;
                 if (this.settingsManager.getShowTerminalProgress()) {
                     this.ui.terminal.setProgress(false);
                 }
@@ -2286,13 +2833,20 @@ export class InteractiveMode {
                 }
                 if (this.streamingComponent) {
                     this.chatContainer.removeChild(this.streamingComponent);
+                    this.setChatComponentMutable(this.streamingComponent, false);
                     this.streamingComponent = undefined;
                     this.streamingMessage = undefined;
                 }
+                for (const component of this.pendingTools.values()) {
+                    component.seal();
+                    this.setChatComponentMutable(component, false);
+                }
                 this.pendingTools.clear();
+                this.promoteFinalizedChatPrefix();
                 await this.checkShutdownRequested();
                 this.ui.requestRender();
                 break;
+            }
             case "compaction_start": {
                 if (this.settingsManager.getShowTerminalProgress()) {
                     this.ui.terminal.setProgress(true);
@@ -2334,7 +2888,6 @@ export class InteractiveMode {
                     }
                 }
                 else if (event.result) {
-                    this.chatContainer.clear();
                     this.rebuildChatFromMessages();
                     this.addMessageToChat(createCompactionSummaryMessage(event.result.summary, event.result.tokensBefore, new Date().toISOString()));
                     this.footer.invalidate();
@@ -2346,6 +2899,7 @@ export class InteractiveMode {
                     else {
                         this.chatContainer.addChild(new Spacer(1));
                         this.chatContainer.addChild(new Text(theme.fg("error", event.errorMessage), 1, 0));
+                        this.commitFinalizedChatOutput();
                     }
                 }
                 void this.flushCompactionQueue({ willRetry: event.willRetry });
@@ -2361,7 +2915,13 @@ export class InteractiveMode {
                 // Show retry indicator
                 this.statusContainer.clear();
                 this.retryCountdown?.dispose();
-                const retryMessage = (seconds) => `Retrying (${event.attempt}/${event.maxAttempts}) in ${seconds}s... (${keyText("app.interrupt")} to cancel)`;
+                const retryMessage = (seconds) => {
+                    const base = `Retrying (${event.attempt}/${event.maxAttempts}) in ${seconds}s...`;
+                    const cumulative = event.cumulativeErrors && event.cumulativeErrors > 1
+                        ? ` [${event.cumulativeErrors} total failures this prompt]`
+                        : "";
+                    return `${base}${cumulative} (${keyText("app.interrupt")} to cancel)`;
+                };
                 this.retryLoader = new Loader(this.ui, (spinner) => theme.fg("warning", spinner), (text) => theme.fg("muted", text), retryMessage(Math.ceil(event.delayMs / 1000)));
                 this.retryCountdown = new CountdownTimer(event.delayMs, this.ui, (seconds) => {
                     this.retryLoader?.setMessage(retryMessage(seconds));
@@ -2425,11 +2985,14 @@ export class InteractiveMode {
         const text = new Text(theme.fg("dim", message), 1, 0);
         this.chatContainer.addChild(spacer);
         this.chatContainer.addChild(text);
+        this.setChatComponentMutable(spacer, true);
+        this.setChatComponentMutable(text, true);
         this.lastStatusSpacer = spacer;
         this.lastStatusText = text;
         this.ui.requestRender();
     }
     addMessageToChat(message, options) {
+        this.sealStatus();
         switch (message.role) {
             case "bashExecution": {
                 const component = new BashExecutionComponent(message.command, this.ui, message.excludeFromContext);
@@ -2480,9 +3043,10 @@ export class InteractiveMode {
                             this.chatContainer.addChild(userComponent);
                         }
                         if (options?.populateHistory) {
-                            const compactForm = scramjetBlock.userContext
-                                ? `/${scramjetBlock.name} ${scramjetBlock.userContext}`
-                                : `/${scramjetBlock.name}`;
+                            const compactForm = options.historyText ??
+                                (scramjetBlock.userContext
+                                    ? `/${scramjetBlock.name} ${scramjetBlock.userContext}`
+                                    : `/${scramjetBlock.name}`);
                             this.editor.addToHistory?.(compactForm);
                         }
                     }
@@ -2521,6 +3085,7 @@ export class InteractiveMode {
                 const _exhaustive = message;
             }
         }
+        this.promoteFinalizedChatPrefix();
     }
     /**
      * Render session context to chat. Used for initial load and rebuild after compaction.
@@ -2531,6 +3096,11 @@ export class InteractiveMode {
     renderSessionContext(sessionContext, options = {}) {
         this.pendingTools.clear();
         const renderedPendingTools = new Map();
+        const entries = options.populateHistory ? this.sessionManager.getEntries() : [];
+        const commandStarts = indexScramjetCommandStarts(entries);
+        const entriesByMessage = new Map(entries
+            .filter((entry) => entry.type === "message")
+            .map((entry) => [entry.message, entry]));
         if (options.updateFooter) {
             this.footer.invalidate();
             this.updateEditorBorderColor();
@@ -2548,6 +3118,7 @@ export class InteractiveMode {
                         }, this.getRegisteredToolDefinition(content.name), this.ui, this.sessionManager.getCwd());
                         component.setExpanded(this.toolOutputExpanded);
                         this.chatContainer.addChild(component);
+                        this.setChatComponentMutable(component, true);
                         if (message.stopReason === "aborted" || message.stopReason === "error") {
                             let errorMessage;
                             if (message.stopReason === "aborted") {
@@ -2561,6 +3132,8 @@ export class InteractiveMode {
                                 errorMessage = message.errorMessage || "Error";
                             }
                             component.updateResult({ content: [{ type: "text", text: errorMessage }], isError: true });
+                            component.seal();
+                            this.setChatComponentMutable(component, false);
                         }
                         else {
                             renderedPendingTools.set(content.id, component);
@@ -2572,18 +3145,45 @@ export class InteractiveMode {
                 // Match tool results to pending tool components
                 const component = renderedPendingTools.get(message.toolCallId);
                 if (component) {
+                    component.markExecutionStarted();
+                    component.setArgsComplete();
                     component.updateResult(message);
                     renderedPendingTools.delete(message.toolCallId);
+                    if (component.hasPendingImageConversions()) {
+                        const pendingToolFinalizations = this.pendingToolFinalizations;
+                        const finalization = component.waitForImageConversions().then(() => {
+                            if (!this.mutableChatComponents.has(component) ||
+                                !this.chatContainer.children.includes(component)) {
+                                component.seal();
+                                return;
+                            }
+                            component.seal();
+                            this.setChatComponentMutable(component, false);
+                            this.promoteFinalizedChatPrefix();
+                            this.ui.requestRender();
+                        });
+                        pendingToolFinalizations.add(finalization);
+                        void finalization.finally(() => pendingToolFinalizations.delete(finalization));
+                    }
+                    else {
+                        component.seal();
+                        this.setChatComponentMutable(component, false);
+                    }
                 }
             }
             else {
                 // All other messages use standard rendering
-                this.addMessageToChat(message, options);
+                const entry = entriesByMessage.get(message);
+                this.addMessageToChat(message, {
+                    ...options,
+                    historyText: entry ? restoreScramjetCommandInvocation(entry, commandStarts) : undefined,
+                });
             }
         }
         for (const [toolCallId, component] of renderedPendingTools) {
             this.pendingTools.set(toolCallId, component);
         }
+        this.promoteFinalizedChatPrefix();
         this.ui.requestRender();
     }
     renderInitialMessages() {
@@ -2610,7 +3210,7 @@ export class InteractiveMode {
         });
     }
     rebuildChatFromMessages() {
-        this.chatContainer.clear();
+        this.clearTranscript();
         const context = this.sessionManager.buildSessionContext();
         this.renderSessionContext(context);
     }
@@ -2645,9 +3245,18 @@ export class InteractiveMode {
         // Drain any in-flight Kitty key release events before stopping.
         // This prevents escape sequences from leaking to the parent shell over slow SSH.
         await this.ui.terminal.drainInput(1000);
-        this.stop();
+        await this.settingsManager.flush();
+        let exitCode = 0;
+        try {
+            this.stop({ retainContent: this.settingsManager.getRetainTranscriptOnExit() });
+        }
+        catch (error) {
+            exitCode = 1;
+            console.error(`Could not retain terminal history: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        await this.ui.terminal.flush?.();
         await this.runtimeHost.dispose();
-        process.exit(0);
+        process.exit(exitCode);
     }
     emergencyTerminalExit() {
         this.isShuttingDown = true;
@@ -2737,7 +3346,7 @@ export class InteractiveMode {
         }
         this.signalCleanupHandlers = [];
     }
-    handleCtrlZ() {
+    async handleCtrlZ() {
         if (process.platform === "win32") {
             this.showStatus("Suspend to background is not supported on Windows");
             return;
@@ -2755,10 +3364,11 @@ export class InteractiveMode {
             clearInterval(suspendKeepAlive);
             process.removeListener("SIGINT", ignoreSigint);
             this.ui.start();
-            this.ui.requestRender(true);
+            this.ui.rebuild();
         });
         try {
-            // Stop the TUI (restore terminal to normal mode)
+            // SCRAMJET-DIVERGENCE: drain releases before handing keyboard ownership back to the shell.
+            await this.ui.terminal.drainInput();
             this.ui.stop();
             // Send SIGTSTP to process group (pid=0 means all processes in group)
             process.kill(0, "SIGTSTP");
@@ -2773,6 +3383,7 @@ export class InteractiveMode {
         const text = (this.editor.getExpandedText?.() ?? this.editor.getText()).trim();
         if (!text)
             return;
+        this.ui.followViewport();
         // Queue input during compaction (extension commands execute immediately)
         if (this.session.isCompacting) {
             if (this.isExtensionCommand(text)) {
@@ -2858,28 +3469,28 @@ export class InteractiveMode {
         if (isExpandable(activeHeader)) {
             activeHeader.setExpanded(expanded);
         }
-        for (const child of this.chatContainer.children) {
+        for (const child of [...this.committedChatContainer.children, ...this.chatContainer.children]) {
             if (isExpandable(child)) {
                 child.setExpanded(expanded);
             }
         }
-        this.ui.requestRender();
+        this.ui.rebuild();
     }
     toggleThinkingBlockVisibility() {
-        this.hideThinkingBlock = !this.hideThinkingBlock;
-        this.settingsManager.setHideThinkingBlock(this.hideThinkingBlock);
-        // Rebuild chat from session messages
-        this.chatContainer.clear();
-        this.rebuildChatFromMessages();
-        // If streaming, re-add the streaming component with updated visibility and re-render
-        if (this.streamingComponent && this.streamingMessage) {
-            this.streamingComponent.setHideThinkingBlock(this.hideThinkingBlock);
-            this.streamingComponent.updateContent(this.streamingMessage);
-            this.chatContainer.addChild(this.streamingComponent);
-        }
+        this.setThinkingBlockVisibility(!this.hideThinkingBlock);
         this.showStatus(`Thinking blocks: ${this.hideThinkingBlock ? "hidden" : "visible"}`);
     }
-    openExternalEditor() {
+    // SCRAMJET-DIVERGENCE: presentation changes retain live tools and browsing identities.
+    setThinkingBlockVisibility(hidden) {
+        this.hideThinkingBlock = hidden;
+        this.settingsManager.setHideThinkingBlock(hidden);
+        for (const child of [...this.committedChatContainer.children, ...this.chatContainer.children]) {
+            if (child instanceof AssistantMessageComponent)
+                child.setHideThinkingBlock(hidden);
+        }
+        this.ui.rebuild();
+    }
+    async openExternalEditor() {
         // Determine editor (respect $VISUAL, then $EDITOR)
         const editorCmd = process.env.VISUAL || process.env.EDITOR;
         if (!editorCmd) {
@@ -2891,7 +3502,8 @@ export class InteractiveMode {
         try {
             // Write current content to temp file
             fs.writeFileSync(tmpFile, currentText, "utf-8");
-            // Stop TUI to release terminal
+            // SCRAMJET-DIVERGENCE: the editor must not inherit the key release that opened it.
+            await this.ui.terminal.drainInput();
             this.ui.stop();
             // Split by space to support editor arguments (e.g., "code --wait")
             const [editor, ...editorArgs] = editorCmd.split(" ");
@@ -2917,8 +3529,7 @@ export class InteractiveMode {
             }
             // Restart TUI
             this.ui.start();
-            // Force full re-render since external editor uses alternate screen
-            this.ui.requestRender(true);
+            this.ui.rebuild();
         }
     }
     // =========================================================================
@@ -2929,14 +3540,18 @@ export class InteractiveMode {
         this.ui.requestRender();
     }
     showError(errorMessage) {
+        this.sealStatus();
         this.chatContainer.addChild(new Spacer(1));
         this.chatContainer.addChild(new Text(theme.fg("error", `Error: ${errorMessage}`), 1, 0));
         this.chatContainer.addChild(new Spacer(1));
+        this.promoteFinalizedChatPrefix();
         this.ui.requestRender();
     }
     showWarning(warningMessage) {
+        this.sealStatus();
         this.chatContainer.addChild(new Spacer(1));
         this.chatContainer.addChild(new Text(theme.fg("warning", `Warning: ${warningMessage}`), 1, 0));
+        this.promoteFinalizedChatPrefix();
         this.ui.requestRender();
     }
     // SCRAMJET-DIVERGENCE: showNewVersionNotification removed (version check gutted).
@@ -2948,7 +3563,7 @@ export class InteractiveMode {
         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();
+        this.commitFinalizedChatOutput();
     }
     /**
      * Get all queued messages (read-only).
@@ -3108,11 +3723,14 @@ export class InteractiveMode {
     }
     /** Move pending bash components from pending area to chat */
     flushPendingBashComponents() {
+        if (this.pendingBashComponents.length > 0)
+            this.sealStatus();
         for (const component of this.pendingBashComponents) {
             this.pendingMessagesContainer.removeChild(component);
             this.chatContainer.addChild(component);
         }
         this.pendingBashComponents = [];
+        this.promoteFinalizedChatPrefix();
     }
     // =========================================================================
     // Selectors
@@ -3122,7 +3740,10 @@ export class InteractiveMode {
      * @param create Factory that receives a `done` callback and returns the component and focus target
      */
     showSelector(create) {
+        this.selectorOpenGeneration++;
+        this.pendingSelectorOpenGeneration = undefined;
         const done = () => {
+            this.selectorOpenGeneration++;
             this.editorContainer.clear();
             this.editorContainer.addChild(this.editor);
             this.ui.setFocus(this.editor);
@@ -3133,6 +3754,23 @@ export class InteractiveMode {
         this.ui.setFocus(focus);
         this.ui.requestRender();
     }
+    async settleLayoutSettings(selector) {
+        const generation = ++this.layoutSettingsSettlementGeneration;
+        const settings = this.settingsManager;
+        await settings.flush();
+        // SCRAMJET-DIVERGENCE: only the latest settlement may drain a shared batch of save errors.
+        if (generation !== this.layoutSettingsSettlementGeneration)
+            return;
+        const errors = settings.drainErrors();
+        selector.setSaveError(errors.length ? "Changes not saved; see warning" : undefined);
+        if (errors.length) {
+            const details = stripVTControlCharacters(errors.map(({ scope, error }) => `${scope}: ${error.message}`).join("; "))
+                .replace(/[\r\n\t]/g, " ")
+                .slice(0, 200);
+            this.showWarning(`Display settings not saved (${details}). Changes may be lost on restart; project overrides still apply.`);
+        }
+        this.ui.requestRender();
+    }
     showSettingsSelector() {
         this.showSelector((done) => {
             const selector = new SettingsSelectorComponent({
@@ -3147,7 +3785,8 @@ export class InteractiveMode {
                 transport: this.settingsManager.getTransport(),
                 thinkingLevel: this.session.thinkingLevel,
                 availableThinkingLevels: this.session.getAvailableThinkingLevels(),
-                currentTheme: this.settingsManager.getTheme() || "dark",
+                // SCRAMJET-DIVERGENCE: display fallback routed to the renamed builtin.
+                currentTheme: this.settingsManager.getTheme() || "pi-dark",
                 availableThemes: getAvailableThemes(),
                 hideThinkingBlock: this.hideThinkingBlock,
                 collapseChangelog: this.settingsManager.getCollapseChangelog(),
@@ -3158,9 +3797,14 @@ export class InteractiveMode {
                 editorPaddingX: this.settingsManager.getEditorPaddingX(),
                 autocompleteMaxVisible: this.settingsManager.getAutocompleteMaxVisible(),
                 quietStartup: this.settingsManager.getQuietStartup(),
-                clearOnShrink: this.settingsManager.getClearOnShrink(),
                 showTerminalProgress: this.settingsManager.getShowTerminalProgress(),
                 warnings: this.settingsManager.getWarnings(),
+                tuiMode: this.tuiMode,
+                dockEditor: this.settingsManager.getDockEditor(),
+                retainTranscriptOnExit: this.settingsManager.getRetainTranscriptOnExit(),
+                editorMaxHeightPercent: this.settingsManager.getEditorMaxHeightPercent(),
+                scrollWheelStep: this.settingsManager.getScrollWheelStep(),
+                viewportProjectOverrides: Object.keys(this.settingsManager.getProjectSettings()),
             }, {
                 onAutoCompactChange: (enabled) => {
                     this.session.setAutoCompactionEnabled(enabled);
@@ -3168,19 +3812,11 @@ export class InteractiveMode {
                 },
                 onShowImagesChange: (enabled) => {
                     this.settingsManager.setShowImages(enabled);
-                    for (const child of this.chatContainer.children) {
-                        if (child instanceof ToolExecutionComponent) {
-                            child.setShowImages(enabled);
-                        }
-                    }
+                    this.updateToolImagePresentation((component) => component.setShowImages(enabled));
                 },
                 onImageWidthCellsChange: (width) => {
                     this.settingsManager.setImageWidthCells(width);
-                    for (const child of this.chatContainer.children) {
-                        if (child instanceof ToolExecutionComponent) {
-                            child.setImageWidthCells(width);
-                        }
-                    }
+                    this.updateToolImagePresentation((component) => component.setImageWidthCells(width));
                 },
                 onAutoResizeImagesChange: (enabled) => {
                     this.settingsManager.setImageAutoResize(enabled);
@@ -3212,7 +3848,8 @@ export class InteractiveMode {
                     this.settingsManager.setTheme(themeName);
                     this.ui.invalidate();
                     if (!result.success) {
-                        this.showError(`Failed to load theme "${themeName}": ${result.error}\nFell back to dark theme.`);
+                        // SCRAMJET-DIVERGENCE: fallback message names the renamed builtin.
+                        this.showError(`Failed to load theme "${themeName}": ${result.error}\nFell back to pi-dark theme.`);
                     }
                 },
                 onThemePreview: (themeName) => {
@@ -3222,17 +3859,7 @@ export class InteractiveMode {
                         this.ui.requestRender();
                     }
                 },
-                onHideThinkingBlockChange: (hidden) => {
-                    this.hideThinkingBlock = hidden;
-                    this.settingsManager.setHideThinkingBlock(hidden);
-                    for (const child of this.chatContainer.children) {
-                        if (child instanceof AssistantMessageComponent) {
-                            child.setHideThinkingBlock(hidden);
-                        }
-                    }
-                    this.chatContainer.clear();
-                    this.rebuildChatFromMessages();
-                },
+                onHideThinkingBlockChange: (hidden) => this.setThinkingBlockVisibility(hidden),
                 onCollapseChangelogChange: (collapsed) => {
                     this.settingsManager.setCollapseChangelog(collapsed);
                 },
@@ -3266,21 +3893,42 @@ export class InteractiveMode {
                         this.editor.setAutocompleteMaxVisible(maxVisible);
                     }
                 },
-                onClearOnShrinkChange: (enabled) => {
-                    this.settingsManager.setClearOnShrink(enabled);
-                    this.ui.setClearOnShrink(enabled);
-                },
                 onShowTerminalProgressChange: (enabled) => {
                     this.settingsManager.setShowTerminalProgress(enabled);
                 },
                 onWarningsChange: (warnings) => {
                     this.settingsManager.setWarnings(warnings);
                 },
+                onRetainTranscriptOnExitChange: (enabled) => {
+                    this.settingsManager.setRetainTranscriptOnExit(enabled);
+                    void this.settleLayoutSettings(selector);
+                    return this.settingsManager.getRetainTranscriptOnExit();
+                },
+                onDockEditorChange: (enabled) => {
+                    this.settingsManager.setDockEditor(enabled);
+                    void this.settleLayoutSettings(selector);
+                    this.ui.refreshViewportLayout();
+                    if (!this.settingsManager.getDockEditor())
+                        this.ui.revealComponent(this.editorContainer);
+                    return this.settingsManager.getDockEditor();
+                },
+                onEditorMaxHeightPercentChange: (percent) => {
+                    this.settingsManager.setEditorMaxHeightPercent(percent);
+                    void this.settleLayoutSettings(selector);
+                    this.ui.refreshViewportLayout();
+                    return this.settingsManager.getEditorMaxHeightPercent();
+                },
+                onScrollWheelStepChange: (step) => {
+                    this.settingsManager.setScrollWheelStep(step);
+                    void this.settleLayoutSettings(selector);
+                    this.ui.requestRender();
+                    return this.settingsManager.getScrollWheelStep();
+                },
                 onCancel: () => {
                     done();
                     this.ui.requestRender();
                 },
-            });
+            }, () => Math.max(1, Math.min(this.editorAvailableRows ?? Infinity, this.ui.terminal.rows - 4)));
             return { component: selector, focus: selector.getSettingsList() };
         });
     }
@@ -3356,7 +4004,22 @@ export class InteractiveMode {
             // Ignore auth lookup failures for warning-only checks.
         }
     }
-    showModelSelector(initialSearchInput) {
+    selectorPreparationIsCurrent(session, generation) {
+        const current = this.isInitialized && this.session === session && this.selectorOpenGeneration === generation;
+        if (!current && this.pendingSelectorOpenGeneration === generation)
+            this.pendingSelectorOpenGeneration = undefined;
+        return current;
+    }
+    // SCRAMJET-DIVERGENCE: Refresh profile-scoped output-rate history before opening model selectors (issue 476).
+    async showModelSelector(initialSearchInput) {
+        const session = this.session;
+        const generation = ++this.selectorOpenGeneration;
+        this.pendingSelectorOpenGeneration = generation;
+        await session.refreshOutputThroughputHistory().catch(() => undefined);
+        if (!this.selectorPreparationIsCurrent(session, generation))
+            return;
+        this.pendingSelectorOpenGeneration = undefined;
+        const outputThroughputHistory = session.outputThroughputHistory;
         this.showSelector((done) => {
             const selector = new ModelSelectorComponent(this.ui, this.session.model, this.settingsManager, this.session.modelRegistry, this.session.scopedModels, async (model) => {
                 try {
@@ -3375,20 +4038,28 @@ export class InteractiveMode {
             }, () => {
                 done();
                 this.ui.requestRender();
-            }, initialSearchInput);
+            }, initialSearchInput, outputThroughputHistory);
             return { component: selector, focus: selector };
         });
     }
     async showModelsSelector() {
+        const session = this.session;
+        const generation = ++this.selectorOpenGeneration;
+        this.pendingSelectorOpenGeneration = generation;
+        await session.refreshOutputThroughputHistory().catch(() => undefined);
+        if (!this.selectorPreparationIsCurrent(session, generation))
+            return;
+        const outputThroughputHistory = session.outputThroughputHistory;
         // Get all available models
-        this.session.modelRegistry.refresh();
-        const allModels = this.session.modelRegistry.getAvailable();
+        session.modelRegistry.refresh();
+        const allModels = session.modelRegistry.getAvailable();
         if (allModels.length === 0) {
+            this.pendingSelectorOpenGeneration = undefined;
             this.showStatus("No models available");
             return;
         }
         // Check if session has scoped models (from previous session-only changes or CLI --models)
-        const sessionScopedModels = this.session.scopedModels;
+        const sessionScopedModels = session.scopedModels;
         const hasSessionScope = sessionScopedModels.length > 0;
         // Build enabled model IDs from session state or settings
         let currentEnabledIds = null;
@@ -3400,10 +4071,13 @@ export class InteractiveMode {
             // Fall back to settings
             const patterns = this.settingsManager.getEnabledModels();
             if (patterns !== undefined && patterns.length > 0) {
-                const scopedModels = await resolveModelScope(patterns, this.session.modelRegistry);
+                const scopedModels = await resolveModelScope(patterns, session.modelRegistry);
                 currentEnabledIds = scopedModels.map((scoped) => `${scoped.model.provider}/${scoped.model.id}`);
             }
         }
+        if (!this.selectorPreparationIsCurrent(session, generation))
+            return;
+        this.pendingSelectorOpenGeneration = undefined;
         // Helper to update session's scoped models (session-only, no persist)
         const updateSessionModels = async (enabledIds) => {
             currentEnabledIds = enabledIds === null ? null : [...enabledIds];
@@ -3441,7 +4115,7 @@ export class InteractiveMode {
                     done();
                     this.ui.requestRender();
                 },
-            });
+            }, outputThroughputHistory);
             return { component: selector, focus: selector };
         });
     }
@@ -3468,7 +4142,7 @@ export class InteractiveMode {
                 }
                 catch (error) {
                     done();
-                    this.showError(error instanceof Error ? error.message : String(error));
+                    this.showError(describeRuntimeError(error));
                 }
             }, () => {
                 done();
@@ -3494,7 +4168,7 @@ export class InteractiveMode {
             this.showStatus("Cloned to new session");
         }
         catch (error) {
-            this.showError(error instanceof Error ? error.message : String(error));
+            this.showError(describeRuntimeError(error));
         }
     }
     showTreeSelector(initialSelectedId) {
@@ -3571,7 +4245,7 @@ export class InteractiveMode {
                         return;
                     }
                     // Update UI
-                    this.chatContainer.clear();
+                    this.clearTranscript();
                     this.renderInitialMessages();
                     if (result.editorText && !this.editor.getText().trim()) {
                         this.editor.setText(result.editorText);
@@ -4006,7 +4680,7 @@ export class InteractiveMode {
         this.editorContainer.clear();
         this.editorContainer.addChild(reloadBox);
         this.ui.setFocus(reloadBox);
-        this.ui.requestRender(true);
+        this.ui.rebuild();
         await new Promise((resolve) => process.nextTick(resolve));
         const dismissReloadBox = (editor) => {
             this.editorContainer.clear();
@@ -4023,11 +4697,10 @@ export class InteractiveMode {
             }
             setRegisteredThemes(this.session.resourceLoader.getThemes().themes);
             this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
-            const themeName = this.settingsManager.getTheme();
-            const themeResult = themeName ? setTheme(themeName, true) : { success: true };
-            if (!themeResult.success) {
-                this.showError(`Failed to load theme "${themeName}": ${themeResult.error}\nFell back to dark theme.`);
-            }
+            // SCRAMJET-DIVERGENCE: re-resolve through the resolver after reload so newly registered
+            // themes (and the captured classification) are honored; force a re-read since reload's purpose
+            // is to pick up on-disk theme edits even when the active theme's name is unchanged.
+            this.reapplyResolvedTheme(true);
             const editorPaddingX = this.settingsManager.getEditorPaddingX();
             const autocompleteMaxVisible = this.settingsManager.getAutocompleteMaxVisible();
             this.defaultEditor.setPaddingX(editorPaddingX);
@@ -4037,7 +4710,6 @@ export class InteractiveMode {
                 this.editor.setAutocompleteMaxVisible?.(autocompleteMaxVisible);
             }
             this.ui.setShowHardwareCursor(this.settingsManager.getShowHardwareCursor());
-            this.ui.setClearOnShrink(this.settingsManager.getClearOnShrink());
             this.setupAutocompleteProvider();
             const runner = this.session.extensionRunner;
             this.setupExtensionShortcuts(runner);
@@ -4055,7 +4727,7 @@ export class InteractiveMode {
         }
         catch (error) {
             dismissReloadBox(previousEditor);
-            this.showError(`Reload failed: ${error instanceof Error ? error.message : String(error)}`);
+            this.showError(`Reload failed: ${describeRuntimeError(error)}`);
         }
     }
     async handleExportCommand(text) {
@@ -4173,13 +4845,13 @@ export class InteractiveMode {
             else {
                 this.showWarning("Usage: /name <name>");
             }
-            this.ui.requestRender();
+            this.commitFinalizedChatOutput();
             return;
         }
         this.session.setSessionName(name);
         this.chatContainer.addChild(new Spacer(1));
         this.chatContainer.addChild(new Text(theme.fg("dim", `Session name set: ${name}`), 1, 0));
-        this.ui.requestRender();
+        this.commitFinalizedChatOutput();
     }
     handleSessionCommand() {
         const stats = this.session.getSessionStats();
@@ -4212,7 +4884,7 @@ export class InteractiveMode {
         }
         this.chatContainer.addChild(new Spacer(1));
         this.chatContainer.addChild(new Text(info, 1, 0));
-        this.ui.requestRender();
+        this.commitFinalizedChatOutput();
     }
     handleChangelogCommand() {
         const changelogPath = getChangelogPath();
@@ -4229,7 +4901,7 @@ export class InteractiveMode {
         this.chatContainer.addChild(new Spacer(1));
         this.chatContainer.addChild(new Markdown(changelogMarkdown, 1, 1, this.getMarkdownThemeWithSettings()));
         this.chatContainer.addChild(new DynamicBorder());
-        this.ui.requestRender();
+        this.commitFinalizedChatOutput();
     }
     /**
      * Get capitalized display string for an app keybinding action.
@@ -4350,7 +5022,7 @@ export class InteractiveMode {
         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();
+        this.commitFinalizedChatOutput();
     }
     async handleClearCommand() {
         if (this.loadingAnimation) {
@@ -4366,7 +5038,7 @@ export class InteractiveMode {
             this.renderCurrentSessionState();
             this.chatContainer.addChild(new Spacer(1));
             this.chatContainer.addChild(new Text(`${theme.fg("accent", "✓ New session started")}`, 1, 1));
-            this.ui.requestRender();
+            this.commitFinalizedChatOutput();
         }
         catch (error) {
             await this.handleFatalRuntimeError("Failed to create session", error);
@@ -4397,22 +5069,38 @@ export class InteractiveMode {
         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();
+        this.commitFinalizedChatOutput();
     }
     handleArminSaysHi() {
+        const component = new ArminComponent(this.ui, () => {
+            if (!this.mutableChatComponents.has(component) || !this.chatContainer.children.includes(component))
+                return;
+            this.setChatComponentMutable(component, false);
+            this.promoteFinalizedChatPrefix();
+            this.ui.requestRender();
+        });
         this.chatContainer.addChild(new Spacer(1));
-        this.chatContainer.addChild(new ArminComponent(this.ui));
-        this.ui.requestRender();
+        this.chatContainer.addChild(component);
+        this.setChatComponentMutable(component, true);
+        this.commitFinalizedChatOutput();
     }
     handleDementedDelves() {
         this.chatContainer.addChild(new Spacer(1));
         this.chatContainer.addChild(new EarendilAnnouncementComponent());
-        this.ui.requestRender();
+        this.commitFinalizedChatOutput();
     }
     handleDaxnuts() {
+        const component = new DaxnutsComponent(this.ui, () => {
+            if (!this.mutableChatComponents.has(component) || !this.chatContainer.children.includes(component))
+                return;
+            this.setChatComponentMutable(component, false);
+            this.promoteFinalizedChatPrefix();
+            this.ui.requestRender();
+        });
         this.chatContainer.addChild(new Spacer(1));
-        this.chatContainer.addChild(new DaxnutsComponent(this.ui));
-        this.ui.requestRender();
+        this.chatContainer.addChild(component);
+        this.setChatComponentMutable(component, true);
+        this.commitFinalizedChatOutput();
     }
     checkDaxnutsEasterEgg(model) {
         if (model.provider === "opencode" && model.id.toLowerCase().includes("kimi-k2.5")) {
@@ -4438,6 +5126,7 @@ export class InteractiveMode {
                 this.pendingBashComponents.push(this.bashComponent);
             }
             else {
+                this.sealStatus();
                 this.chatContainer.addChild(this.bashComponent);
             }
             // Show output and complete
@@ -4447,6 +5136,7 @@ export class InteractiveMode {
             this.bashComponent.setComplete(result.exitCode, result.cancelled, result.truncated ? { truncated: true, content: result.output } : undefined, result.fullOutputPath);
             // Record the result in session
             this.session.recordBashResult(command, result, { excludeFromContext });
+            this.promoteFinalizedChatPrefix();
             this.bashComponent = undefined;
             this.ui.requestRender();
             return;
@@ -4454,6 +5144,7 @@ export class InteractiveMode {
         // Normal execution path (possibly with custom operations)
         const isDeferred = this.session.isStreaming;
         this.bashComponent = new BashExecutionComponent(command, this.ui, excludeFromContext);
+        this.setChatComponentMutable(this.bashComponent, true);
         if (isDeferred) {
             // Show in pending area when agent is streaming
             this.pendingMessagesContainer.addChild(this.bashComponent);
@@ -4461,6 +5152,7 @@ export class InteractiveMode {
         }
         else {
             // Show in chat immediately when agent is idle
+            this.sealStatus();
             this.chatContainer.addChild(this.bashComponent);
         }
         this.ui.requestRender();
@@ -4481,6 +5173,9 @@ export class InteractiveMode {
             }
             this.showError(`Bash command failed: ${error instanceof Error ? error.message : "Unknown error"}`);
         }
+        if (this.bashComponent)
+            this.setChatComponentMutable(this.bashComponent, false);
+        this.promoteFinalizedChatPrefix();
         this.bashComponent = undefined;
         this.ui.requestRender();
     }
@@ -4503,24 +5198,30 @@ export class InteractiveMode {
             // Ignore, will be emitted as an event
         }
     }
-    stop() {
-        this.unregisterSignalHandlers();
-        if (this.settingsManager.getShowTerminalProgress()) {
-            this.ui.terminal.setProgress(false);
-        }
-        if (this.loadingAnimation) {
-            this.loadingAnimation.stop();
-            this.loadingAnimation = undefined;
-        }
-        this.clearExtensionTerminalInputListeners();
-        this.footer.dispose();
-        this.footerDataProvider.dispose();
-        if (this.unsubscribe) {
-            this.unsubscribe();
+    stop(options) {
+        try {
+            if (this.isInitialized) {
+                this.isInitialized = false;
+                this.ui.stop(options);
+            }
         }
-        if (this.isInitialized) {
-            this.ui.stop();
-            this.isInitialized = false;
+        finally {
+            this.selectorOpenGeneration++;
+            this.pendingSelectorOpenGeneration = undefined;
+            this.unregisterSignalHandlers();
+            if (this.settingsManager.getShowTerminalProgress()) {
+                this.ui.terminal.setProgress(false);
+            }
+            if (this.loadingAnimation) {
+                this.loadingAnimation.stop();
+                this.loadingAnimation = undefined;
+            }
+            this.clearExtensionTerminalInputListeners();
+            this.footer.dispose();
+            this.footerDataProvider.dispose();
+            if (this.unsubscribe) {
+                this.unsubscribe();
+            }
         }
     }
 }