@leanandmean/coding-agent 0.74.1-scramjet.58 → 0.74.1-scramjet.59

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";
@@ -24,7 +25,7 @@ import { formatMissingSessionCwdPrompt, MissingSessionCwdError } from "../../cor
 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";
@@ -108,6 +109,7 @@ export class InteractiveMode {
     options;
     runtimeHost;
     ui;
+    tuiMode;
     committedChatContainer;
     chatContainer;
     mutableChatComponents = new Set();
@@ -115,6 +117,7 @@ export class InteractiveMode {
     statusContainer;
     defaultEditor;
     editor;
+    editorAvailableRows;
     editorComponentFactory;
     autocompleteProvider;
     autocompleteProviderWrappers = [];
@@ -156,6 +159,7 @@ export class InteractiveMode {
     agentRunGeneration = 0;
     selectorOpenGeneration = 0;
     pendingSelectorOpenGeneration;
+    layoutSettingsSettlementGeneration = 0;
     // Tool output expansion state
     toolOutputExpanded = false;
     // Thinking block visibility state
@@ -186,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();
@@ -223,8 +228,28 @@ export class InteractiveMode {
             await this.rebindCurrentSession();
         });
         this.version = VERSION;
-        // SCRAMJET-DIVERGENCE: mandatory committed/live rendering and injectable terminals (#389).
+        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();
@@ -241,6 +266,7 @@ 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);
@@ -257,6 +283,187 @@ export class InteractiveMode {
         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;
@@ -270,8 +477,12 @@ export class InteractiveMode {
             this.committedChatContainer.addChild(child);
             promoted = true;
         }
-        if (promoted)
-            this.ui.commit();
+        if (promoted) {
+            if (this.ui.getViewportState())
+                this.ui.requestRender();
+            else
+                this.ui.commit();
+        }
     }
     setChatComponentMutable(component, mutable) {
         if (mutable)
@@ -289,6 +500,9 @@ export class InteractiveMode {
         this.promoteFinalizedChatPrefix();
     }
     clearTranscript() {
+        this.clipboardPasteGeneration++;
+        if (this.ui.getViewportState())
+            this.ui.resetViewport();
         this.pendingToolFinalizations = new Set();
         const tools = new Set([
             ...this.pendingTools.values(),
@@ -492,26 +706,20 @@ 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 (content built after theme detection below)
         this.ui.addChild(this.headerContainer);
         this.ui.addChild(this.committedChatContainer);
         this.ui.addChild(this.chatContainer);
-        this.ui.setLiveRegionStart(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
@@ -541,6 +749,14 @@ export class InteractiveMode {
         }
         // 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}`);
             const hint = (keybinding, description) => keyHint(keybinding, description);
             const expandedInstructions = [
@@ -584,6 +800,8 @@ export class InteractiveMode {
             this.builtInHeader = new Text("", 0, 0);
             this.headerContainer.addChild(this.builtInHeader);
         }
+        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
@@ -1503,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();
         }
@@ -1875,6 +2105,7 @@ export class InteractiveMode {
                 }
             }
             this.editor = newEditor;
+            this.configureEditorHeight(this.editor);
         }
         else {
             // Restore default editor with text from custom editor
@@ -1901,29 +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 {
@@ -1951,21 +2230,70 @@ export class InteractiveMode {
                     committedContext = attachment.render(this.ui, theme);
                     this.committedChatContainer.addChild(committedContext);
                     tool.attachCommittedContext(component);
-                    this.ui.setFocus(null);
+                    if (retained)
+                        this.ui.replaceFocus(this.editor, pendingFocus);
+                    else
+                        this.ui.setFocus(null);
                     this.editorContainer.clear();
-                    try {
-                        await this.ui.commitNow({ requireFlush: true });
-                    }
-                    catch (error) {
-                        tool.cancelCommittedContext();
-                        this.committedChatContainer.removeChild(committedContext);
-                        committedContext = undefined;
-                        this.ui.rebuild();
-                        throw error;
+                    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.setFocus(tool);
                     this.ui.requestRender();
                     return;
                 }
@@ -1987,30 +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;
-                attachedTool?.cancelCommittedContext();
-                if (committedContext) {
-                    this.committedChatContainer.removeChild(committedContext);
-                    this.ui.rebuild();
-                }
-                try {
-                    component?.dispose?.();
-                }
-                catch {
-                    /* ignore dispose errors */
-                }
-                if (!isOverlay)
-                    restoreEditor();
-                reject(err);
-            });
+                .catch(fail);
         });
     }
     /**
@@ -2096,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) {
@@ -2132,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();
@@ -2358,6 +2682,7 @@ export class InteractiveMode {
                 }
                 else if (event.message.role === "user") {
                     this.addMessageToChat(event.message);
+                    this.ui.followViewport();
                     this.updatePendingMessagesDisplay();
                     this.ui.requestRender();
                 }
@@ -2920,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;
@@ -3012,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;
@@ -3033,7 +3367,8 @@ export class InteractiveMode {
             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");
@@ -3048,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)) {
@@ -3141,20 +3477,20 @@ export class InteractiveMode {
         this.ui.rebuild();
     }
     toggleThinkingBlockVisibility() {
-        this.hideThinkingBlock = !this.hideThinkingBlock;
-        this.settingsManager.setHideThinkingBlock(this.hideThinkingBlock);
-        // Rebuild chat from session messages
-        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.setChatComponentMutable(this.streamingComponent, true);
-        }
+        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) {
@@ -3166,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(" ");
@@ -3417,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({
@@ -3445,6 +3799,12 @@ export class InteractiveMode {
                 quietStartup: this.settingsManager.getQuietStartup(),
                 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);
@@ -3499,16 +3859,7 @@ export class InteractiveMode {
                         this.ui.requestRender();
                     }
                 },
-                onHideThinkingBlockChange: (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.rebuildChatFromMessages();
-                },
+                onHideThinkingBlockChange: (hidden) => this.setThinkingBlockVisibility(hidden),
                 onCollapseChangelogChange: (collapsed) => {
                     this.settingsManager.setCollapseChangelog(collapsed);
                 },
@@ -3548,11 +3899,36 @@ export class InteractiveMode {
                 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() };
         });
     }
@@ -4822,26 +5198,30 @@ export class InteractiveMode {
             // Ignore, will be emitted as an event
         }
     }
-    stop() {
-        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();
+    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();
+            }
         }
     }
 }