@timurproko/a1 0.2.6-dev.727 → 0.2.6-dev.736

package/dist/app/session-shell/session-shell.js

@@ -4,34 +4,35 @@ import { MAX_COPY_CONTROL_BYTES } from "./response-copy-protocol.js";
 import { PromptHistoryController } from "./prompt-history-controller.js";
 import { PRODUCT_TEXT } from "../../product-identity.js";
 import { boundedCleanup } from "../../foundation/terminal-cleanup/terminal-reset.js";
-import { assertOwnedUiCommand } from "../../contracts/owned-ui/index.js";
+import { assertOwnedUiCommand, OWNED_UI_HIDDEN_COMMAND_NAMES } from "../../contracts/owned-ui/index.js";
 import { assertPromptImages, ImageAttachmentError } from "../../contracts/owned-ui/index.js";
 import { ContextualPromptSuggestionController } from "./prompt-suggestion-controller.js";
-import { MOUSE_TRACKING_OFF, MOUSE_TRACKING_ON, parseMouseInput } from "../../ui/components/mouse.js";
-import { readVisibleHyperlinks } from "../../ui/components/visible-hyperlinks.js";
-import { PINNED_PI_HIDDEN_COMMAND_NAMES, workflowCommandNames } from "../../integrations/pi/engine/workflows.js";
+import { workflowCommandNames } from "../../integrations/pi/engine/workflows.js";
 import { createPiExtensionUiBridge } from "../../integrations/pi/components/shell-extension-ui.js";
 import { ProgramStatusReporter } from "../../integrations/pi/components/upstream/program-status-reporter.js";
-import { createPiShellEditor } from "../../integrations/pi/components/shell-editor-autocomplete.js";
 import { SKILLS_COMMAND_NAME, findSkillByArgument, rewriteSkillsTunnelSubmission, skillPrompt, skillsFromCommands, } from "../../integrations/pi/components/skills-command.js";
-import { createPiQueuedInputStatus, createPiShellFooter, createPiShellHeader, createPiShellLoadedResources, createPiShellStatus, } from "../../integrations/pi/components/shell-footer-status.js";
-import { createPiShellArmin, createPiShellAuthProviderSelector, createPiShellDialog, createPiShellEarendilAnnouncement, createPiShellExtensionSelector, createPiShellLoginDialog, createPiShellModelSelector, createPiShellModelsDialog, createPiShellReloadBox, createPiShellScopedModelsSelector, createPiShellSelector, createPiShellSessionSelector, createPiShellSettingsSelector, createPiShellSkillsSelector, createPiShellTrustSelector, createPiShellUserMessageSelector, } from "../../integrations/pi/components/shell-selectors-dialogs.js";
-import { createPiShellChangelog, createPiShellHotkeys, createPiShellSessionInfo, renderPiShellPackageUpdateNotice, renderPiShellStatusText, } from "../../integrations/pi/components/shell-presenters-info.js";
-import { createPiShellTranscriptComponent, renderPiShellStartupDiagnostic, renderPiShellTranscriptBlock, } from "../../integrations/pi/components/shell-presenters-transcript.js";
-import { onPiThemeChange, piTheme } from "../../integrations/pi/components/upstream/theme/theme.js";
-import { DamageAwareTerminalAdapter } from "../../integrations/pi/tui-runtime/damage-aware-terminal.js";
-import { PiTuiRuntimeAdapter } from "../../integrations/pi/tui-runtime/adapter.js";
-import { classifyPiTuiInput } from "../../integrations/pi/tui-runtime/input-presentation-coordinator.js";
+import { createPiShellAuthProviderSelector, createPiShellDialog, createPiShellExtensionSelector, createPiShellLoginDialog, createPiShellReloadBox, createPiShellSelector, createPiShellSkillsSelector, createPiShellTrustSelector, createPiShellUserMessageSelector, } from "../../integrations/pi/components/shell-selectors-dialogs.js";
+import { renderPiShellStatusText, } from "../../integrations/pi/components/shell-presenters-info.js";
+import { OwnedUiTerminalHost, sessionTerminalHostOptions, } from "./shell-host.js";
 import { runImageWorker } from "./image-preparation-client.js";
 import { STREAM_PRESENTATION_INTERVAL_MS, StreamPresentationCoalescer, } from "./stream-presentation-coalescer.js";
 import { writeSystemClipboardText, } from "./system-clipboard.js";
 import { OwnedUiSessionShellRoot, shellResourceEntries, } from "./session-shell-root.js";
+// Invariant: a disposed shell leaves the engine a host that holds no reference back to it.
+const DETACHED_WORKFLOW_INTERACTION = { prompt: async () => null, notify() { } };
 export { OwnedUiSessionShellRoot, } from "./session-shell-root.js";
-/** Coordinates backend, owned presentation, and Pi TUI lifecycles for one interactive session. */
-export class OwnedUiSessionShell {
+export { OwnedUiTerminalHost, sessionTerminalHostOptions } from "./shell-host.js";
+/**
+ * Presents one engine session: its transcript root, editor, controllers, submission, workflows, and dialogs.
+ * It reaches the terminal only through its terminal host's handle, and paints only while it is attached.
+ */
+export class OwnedUiSessionPresenter {
     backend;
+    #presenters;
+    #dialogHost;
     root;
-    runtime;
+    #host;
+    #terminal;
     #cwd;
     #listeners = new Set();
     #unsubscribe;
@@ -57,9 +58,11 @@ export class OwnedUiSessionShell {
     #editorRevision = 0;
     #started = false;
     #disposed = false;
+    #released;
     #shutdownPromise;
     #disposePromise;
-    #pointerReporting = false;
+    #layoutParts;
+    #pendingClipboardWrite = Promise.resolve();
     // Invariant: translated startup diagnostics create at most one dock notice per kind per shell.
     #startupTrustHandled = false;
     #customViewport;
@@ -70,11 +73,9 @@ export class OwnedUiSessionShell {
     #copyExecutor;
     #copyIntentSequence = 0;
     #unbindClipboardWriter;
-    #damageTerminal;
-    #quitOutro;
     #reloadPresentation;
     #streamPresentation;
-    #removeViewportPreInput;
+    #inputCoordination;
     #unsubscribeSettings;
     #unbindPiSettings;
     #unbindTerminalSettings;
@@ -91,556 +92,572 @@ export class OwnedUiSessionShell {
     #sessionGeneration;
     #sessionBindingGeneration;
     #suggestionModelKey;
-    constructor(options) {
+    constructor(host, options) {
         const { backend, cwd, routeHost, sessionLayout } = options.engine;
-        const { terminal, startup, viewportSettings, quitOutro, reload: reloadPresentation, stream: streamPresentationOptions, input: inputPresentation } = options.presentation ?? {};
+        const { terminal, startup, viewportSettings, reload: reloadPresentation, stream: streamPresentationOptions, input: inputPresentation, } = options.presentation ?? {};
         const { clipboard, responseCopy, paste: pasteDiagnostics, pastePreparation } = options.diagnostics ?? {};
         const promptHistory = options.history;
+        const { clipboard: sharedClipboard, keybindings: sharedKeybindings } = options.shared ?? {};
         this.backend = backend;
-        this.#sessionGeneration = this.backend.sessionGeneration;
-        this.#sessionBindingGeneration = this.backend.sessionBindingGeneration;
-        this.#suggestionModelKey = modelKey(this.backend.view());
+        this.#presenters = options.presenters;
+        this.#sessionGeneration = this.backend.identity.sessionGeneration;
+        this.#sessionBindingGeneration = this.backend.identity.sessionBindingGeneration;
+        this.#suggestionModelKey = modelKey(this.backend.session.view());
         this.#cwd = cwd;
         this.#routeHost = routeHost ?? null;
         this.#startupRoute = options.engine.startupRoute;
         this.#customViewport = sessionLayout === "custom-viewport";
+        this.#inputCoordination = inputPresentation?.coordination !== false;
+        this.#host = host;
+        this.#terminal = host.connect(this);
+        // Invariant: the host's optional members follow the layout, so it is built only once the layout is known.
+        this.#dialogHost = this.#createDialogHost();
         this.#lazySelectors = options.diagnostics?.lazySelectors;
         this.#stopped = new Promise(resolve => {
             this.#resolveStopped = resolve;
         });
-        let runtime;
-        let damageTerminal;
-        let streamPresentation;
-        let pendingClipboardWrite = Promise.resolve();
         let promptSuggestionController = null;
         // Invariant: owned prompt limits and collapsed skills are bare-A1 replacements; comparison profiles keep pinned behavior.
         this.#promptImages = this.#customViewport ? options.promptImages ?? null : null;
         this.#skills = this.#customViewport ? options.skills ?? null : null;
-        const terminalCopy = terminal !== undefined || hasAsyncClipboardOutput();
-        this.#responseCopy = this.#customViewport ? new ResponseCopyCoordinator({
-            execute: responseCopy?.execute ?? (this.#copyExecutor = createResponseCopyExecutor({
-                ...(terminal === undefined && clipboard === undefined ? {} : { destination: "terminal" }),
-                ...(clipboard?.writeText === undefined ? {} : { writeText: (text, signal) => clipboard.writeText(text, signal) }),
-                ...(terminalCopy ? { terminal: { submit: async (control, signal) => {
-                            if (signal.aborted || this.#disposed || !runtime?.active)
-                                throw new Error("Copy canceled");
-                            // Performance: never grow the real terminal's pending buffer with another clipboard payload.
-                            if (terminal === undefined && process.stdout.writableLength + control.length > MAX_COPY_CONTROL_BYTES) {
-                                throw new Error("Clipboard terminal is busy");
-                            }
-                            runtime.writeControl(control);
-                        } } } : {}),
-            })),
-            ...(responseCopy?.onEvent === undefined ? {} : { onEvent: responseCopy.onEvent }),
-            onFailure: result => {
-                if (this.#disposed || !runtime?.active)
-                    return;
-                this.root.appendWorkflowStatus(result.outcome === "timed-out" ? "Copy timed out; the clipboard did not respond."
-                    : result.failure === "size" ? "Selection exceeds this clipboard route's size limit."
-                        : "Could not copy the selection; the clipboard is unavailable.");
-                runtime.requestRender();
-            },
-        }) : null;
-        const readClipboard = async (signal) => {
-            if (signal.aborted)
-                throw new ImageAttachmentError("image-canceled");
-            if (clipboard === undefined)
-                return runImageWorker({ kind: "clipboard" }, signal);
-            try {
-                const image = await clipboard.readImage?.(signal);
-                if (image !== null && image !== undefined) {
-                    const canonical = await runImageWorker({ kind: "canonicalize", source: image }, signal);
-                    if (canonical !== null)
-                        return { kind: "image", ...canonical };
-                }
-            }
-            catch (error) {
-                if (error instanceof ImageAttachmentError)
-                    throw error;
-                // Compatibility: an unavailable image reader can still provide text.
-            }
-            const text = await clipboard.readText(signal);
-            return text === null ? null : { kind: "text", text };
-        };
-        this.root = new OwnedUiSessionShellRoot(this.backend.view(), cwd, {
-            getColumns: () => runtime?.viewport().columns ?? terminal?.columns ?? 80,
-            getRows: () => runtime?.viewport().rows ?? terminal?.rows ?? 24,
-            requestRender: force => runtime?.requestRender(force),
-            requestHyperlinkCleanup: rows => damageTerminal?.requestHyperlinkCleanup(rows),
-            onViewportFrame: frame => damageTerminal?.arm(frame.descriptor, {
-                overlayActive: runtime?.hasOverlay() ?? false,
-                selectionActive: this.root.hasActiveSelection(),
-                replacementSurfaceActive: !this.root.usesDefaultInputSurface(),
-            }),
-            enableDockInputReuse: inputPresentation?.viewportReuse !== false,
-            persistentHistory: this.#customViewport && promptHistory !== undefined,
-            ...(promptHistory === undefined ? {} : { historyEditor: promptHistory.editor }),
-            onSubmit: text => { void this.submit(text).catch(() => this.#reportSubmissionError()); },
-            onPasteRejected: error => this.#reportSubmissionError(error),
-            onInterrupt: () => { void this.interrupt(); },
-            onClear: () => { void this.clearOrExit(); },
-            onExit: () => { void this.shutdown(); },
-            onModelSelect: () => this.#customViewport ? this.showModelsDialog() : this.showModelSelector(),
-            onModelCycle: direction => { void this.cycleModel(direction); },
-            onThinkingCycle: () => { void this.cycleThinkingLevel(); },
-            onThinkingToggle: () => {
-                this.root.toggleThinkingVisibility();
-                this.runtime.requestRender();
-            },
-            onMessageCopy: () => { void this.runWorkflow({ command: "copy", argument: "" }); },
-            onFollowUp: () => { void this.queueFollowUp().catch(() => this.#reportSubmissionError()); },
-            onDequeue: () => this.restoreQueuedInput(),
-            onEditorChange: text => {
-                this.#editorRevision++;
-                promptSuggestionController?.abortPending();
-                if (text.length === 0) {
-                    // Concurrency: the editor synchronizes deletion-owned autocomplete after onChange.
-                    // Reassert retained ghost text in the microtask before Pi emits its scheduled frame.
-                    queueMicrotask(() => promptSuggestionController?.restoreAvailable());
+        // Invariant: construction is transactional. Each binding registers its release as it is made, and a
+        // throw releases them in reverse, so a shell that never finished constructing holds nothing.
+        const constructed = [() => host.disconnect(this)];
+        try {
+            const terminalCopy = terminal !== undefined || hasAsyncClipboardOutput();
+            this.#responseCopy = this.#customViewport ? new ResponseCopyCoordinator({
+                execute: responseCopy?.execute ?? (this.#copyExecutor = createResponseCopyExecutor({
+                    ...(sharedClipboard === undefined ? {} : { pool: sharedClipboard.copy }),
+                    ...(terminal === undefined && clipboard === undefined ? {} : { destination: "terminal" }),
+                    ...(clipboard?.writeText === undefined ? {} : { writeText: (text, signal) => clipboard.writeText(text, signal) }),
+                    ...(terminalCopy ? { terminal: { submit: async (control, signal) => {
+                                if (signal.aborted || this.#disposed || !this.#terminal.running)
+                                    throw new Error("Copy canceled");
+                                // Performance: never grow the real terminal's pending buffer with another clipboard payload.
+                                if (terminal === undefined && process.stdout.writableLength + control.length > MAX_COPY_CONTROL_BYTES) {
+                                    throw new Error("Clipboard terminal is busy");
+                                }
+                                this.#terminal.writeControl(control);
+                            } } } : {}),
+                })),
+                ...(responseCopy?.onEvent === undefined ? {} : { onEvent: responseCopy.onEvent }),
+                onFailure: result => {
+                    if (this.#disposed || !this.#terminal.running)
+                        return;
+                    this.root.appendWorkflowStatus(result.outcome === "timed-out" ? "Copy timed out; the clipboard did not respond."
+                        : result.failure === "size" ? "Selection exceeds this clipboard route's size limit."
+                            : "Could not copy the selection; the clipboard is unavailable.");
+                    this.#terminal.requestRender();
+                },
+            }) : null;
+            constructed.push(() => { this.#responseCopy?.dispose(); this.#copyExecutor?.dispose(); });
+            const readClipboard = async (signal) => {
+                if (signal.aborted)
+                    throw new ImageAttachmentError("image-canceled");
+                if (clipboard === undefined)
+                    return runImageWorker({ kind: "clipboard" }, signal);
+                try {
+                    const image = await clipboard.readImage?.(signal);
+                    if (image !== null && image !== undefined) {
+                        const canonical = await runImageWorker({ kind: "canonicalize", source: image }, signal);
+                        if (canonical !== null)
+                            return { kind: "image", ...canonical };
+                    }
                 }
-                this.root.reconcilePromptImageLimitNotice(text);
-            },
-            onPromptSuggestionAccepted: () => promptSuggestionController?.accept(),
-            onPromptSuggestionEligibilityChanged: () => {
-                queueMicrotask(() => promptSuggestionController?.restoreAvailable());
-            },
-            onInputSurfaceChanged: () => {
-                promptSuggestionController?.invalidate();
-                this.#promptHistory?.synchronize();
-            },
-            onCopyText: text => {
-                if (this.#responseCopy !== null) {
-                    void this.#responseCopy.submitText(text);
-                    return;
+                catch (error) {
+                    if (error instanceof ImageAttachmentError)
+                        throw error;
+                    // Compatibility: an unavailable image reader can still provide text.
                 }
-                const write = () => {
-                    if (this.#disposed)
-                        return Promise.resolve();
-                    runtime?.writeControl(`\u001b]52;c;${Buffer.from(text, "utf8").toString("base64")}\u0007`);
-                    return clipboard === undefined ? writeSystemClipboardText(text)
-                        : clipboard.writeText?.(text) ?? Promise.resolve();
-                };
-                // Compatibility: comparison profiles retain their existing clipboard path.
-                pendingClipboardWrite = write().catch(() => { });
-            },
-            readClipboardContent: async (signal = new AbortController().signal) => {
-                await pendingClipboardWrite;
-                return readClipboard(signal);
-            },
-            captureClipboardPaste: () => {
-                const before = this.#responseCopy?.capturePasteBarrier() ?? (async () => true);
-                if (clipboard !== undefined)
-                    return { kind: "provided", read: readClipboard, before };
-                if (responseCopyDestination(process.env) === "terminal")
-                    return {
-                        kind: "provided", before, read: async () => { throw new ImageAttachmentError("paste-unavailable"); },
+                const text = await clipboard.readText(signal);
+                return text === null ? null : { kind: "text", text };
+            };
+            this.root = new OwnedUiSessionShellRoot(this.backend.session.view(), cwd, {
+                getColumns: () => this.#terminal.viewport().columns,
+                getRows: () => this.#terminal.viewport().rows,
+                requestRender: force => this.#terminal.requestRender(force),
+                requestHyperlinkCleanup: rows => this.#terminal.requestHyperlinkCleanup(rows),
+                onViewportFrame: frame => this.#terminal.armFrame(frame.descriptor, {
+                    overlayActive: this.#terminal.hasOverlay(),
+                    selectionActive: this.root.hasActiveSelection(),
+                    replacementSurfaceActive: !this.root.usesDefaultInputSurface(),
+                }),
+                enableDockInputReuse: inputPresentation?.viewportReuse !== false,
+                persistentHistory: this.#customViewport && promptHistory !== undefined,
+                ...(promptHistory === undefined ? {} : { historyEditor: promptHistory.editor }),
+                onSubmit: text => { void this.submit(text).catch(() => this.#reportSubmissionError()); },
+                onPasteRejected: error => this.#reportSubmissionError(error),
+                onInterrupt: () => { void this.interrupt(); },
+                onClear: () => { void this.clearOrExit(); },
+                onExit: () => { void this.shutdown(); },
+                onModelSelect: () => this.#customViewport ? this.showModelsDialog() : this.showModelSelector(),
+                onModelCycle: direction => { void this.cycleModel(direction); },
+                onThinkingCycle: () => { void this.cycleThinkingLevel(); },
+                onThinkingToggle: () => {
+                    this.root.toggleThinkingVisibility();
+                    this.#terminal.requestRender();
+                },
+                onMessageCopy: () => { void this.runWorkflow({ command: "copy", argument: "" }); },
+                onFollowUp: () => { void this.queueFollowUp().catch(() => this.#reportSubmissionError()); },
+                onDequeue: () => this.restoreQueuedInput(),
+                onEditorChange: text => {
+                    this.#editorRevision++;
+                    promptSuggestionController?.abortPending();
+                    if (text.length === 0) {
+                        // Concurrency: the editor synchronizes deletion-owned autocomplete after onChange.
+                        // Reassert retained ghost text in the microtask before Pi emits its scheduled frame.
+                        queueMicrotask(() => promptSuggestionController?.restoreAvailable());
+                    }
+                    this.root.reconcilePromptImageLimitNotice(text);
+                },
+                onPromptSuggestionAccepted: () => promptSuggestionController?.accept(),
+                onPromptSuggestionEligibilityChanged: () => {
+                    queueMicrotask(() => promptSuggestionController?.restoreAvailable());
+                },
+                onInputSurfaceChanged: () => {
+                    promptSuggestionController?.invalidate();
+                    this.#promptHistory?.synchronize();
+                },
+                onCopyText: text => {
+                    if (this.#responseCopy !== null) {
+                        void this.#responseCopy.submitText(text);
+                        return;
+                    }
+                    const write = () => {
+                        if (this.#disposed)
+                            return Promise.resolve();
+                        this.#terminal.writeControl(`\u001b]52;c;${Buffer.from(text, "utf8").toString("base64")}\u0007`);
+                        return clipboard === undefined ? writeSystemClipboardText(text)
+                            : clipboard.writeText?.(text) ?? Promise.resolve();
                     };
-                return { kind: "native", before };
-            },
-            ...(pasteDiagnostics === undefined ? {} : { pasteDiagnostics: pasteDiagnostics }),
-            ...(pastePreparation === undefined ? {} : { pastePreparation }),
-            ...(this.#promptImages === null ? {} : { promptImageLimit: this.#promptImages.limit }),
-            skillsPresentation: () => this.#skills?.presentation() ?? "expand",
-        }, {
-            ...startup,
-            resources: startup?.resources ?? shellResourceEntries(this.backend),
-        }, this.backend.agentDir, {
-            getMessageRenderer: customType => this.backend.pinnedMessageRenderer(customType),
-            getToolRenderers: toolName => this.backend.pinnedToolRenderers(toolName),
-            getShortcuts: bindings => this.backend.pinnedShortcutDescriptions(bindings),
-        }, sessionLayout, {
-            resolve: assetId => this.backend.resolveTranscriptImage(assetId),
-        });
-        const initialPiSettings = this.backend.pinnedSettingsSnapshot();
-        // Invariant: bare A1 owns a bounded viewport and therefore always runs on the alternate
-        // fullscreen surface. The pinned comparison profiles still honor Pi's mode.
-        const tuiMode = this.#customViewport
-            ? "fullscreen"
-            : this.backend.disposed ? "regular" : initialPiSettings.tuiMode;
-        const runtimeOptions = {
-            root: this.root,
-            mode: tuiMode,
-            ...(this.#customViewport ? {
-                // Invariant: the owned shell enables and routes mouse reports itself. Pi's
-                // enclosing fullscreen renderer must never establish a competing white selection.
-                mouse: false,
-                consumeUnhandledMouse: true,
-                onOverlayGeometry: surfaces => this.root.setViewportOverlaySurfaces(surfaces),
-                decorateTerminal: (terminal) => {
-                    damageTerminal = new DamageAwareTerminalAdapter(terminal, {
-                        regionalScroll: process.env.TERM !== "dumb",
-                        inspectHyperlinks: readVisibleHyperlinks,
-                        onResize: () => streamPresentation?.noteImmediatePresentation(),
-                        onHyperlinkCleanupRequired: () => runtime?.requestRender(true),
-                    });
-                    return damageTerminal;
+                    // Compatibility: comparison profiles retain their existing clipboard path.
+                    this.#pendingClipboardWrite = write().catch(() => { });
+                },
+                readClipboardContent: async (signal = new AbortController().signal) => {
+                    await this.#pendingClipboardWrite;
+                    return readClipboard(signal);
                 },
-                ...(inputPresentation?.coordination === false ? {} : {
-                    inputCoordination: {
-                        classify: (data, focusedOverlay) => classifyPiTuiInput(data, focusedOverlay ?? this.root.inputCoordinationSurface()),
-                        onReceipt: () => streamPresentation?.noteImmediatePresentation(),
-                        ...(inputPresentation?.scheduler === undefined
-                            ? {}
-                            : { scheduler: inputPresentation.scheduler }),
+                captureClipboardPaste: () => {
+                    const before = this.#responseCopy?.capturePasteBarrier() ?? (async () => true);
+                    if (clipboard !== undefined)
+                        return { kind: "provided", read: readClipboard, before };
+                    if (responseCopyDestination(process.env) === "terminal")
+                        return {
+                            kind: "provided", before, read: async () => { throw new ImageAttachmentError("paste-unavailable"); },
+                        };
+                    return { kind: "native", before };
+                },
+                ...(pasteDiagnostics === undefined ? {} : { pasteDiagnostics: pasteDiagnostics }),
+                ...(pastePreparation === undefined && sharedClipboard === undefined ? {} : {
+                    pastePreparation: { ...pastePreparation, ...(sharedClipboard === undefined ? {} : { pool: sharedClipboard.paste }) },
+                }),
+                ...(sharedKeybindings === undefined ? {} : { keybindings: sharedKeybindings }),
+                ...(this.#promptImages === null ? {} : { promptImageLimit: this.#promptImages.limit }),
+                skillsPresentation: () => this.#skills?.presentation() ?? "expand",
+            }, {
+                ...startup,
+                resources: startup?.resources ?? shellResourceEntries(this.backend),
+            }, this.backend.identity.agentDir, this.#presenters.transcriptRenderers(), sessionLayout, {
+                resolve: assetId => this.backend.extensions.resolveTranscriptImage(assetId),
+            });
+            // Invariant: the presenter owns its root (theme subscription and helper clients) and disposes it once the
+            // terminal no longer renders it.
+            constructed.push(() => this.root.dispose());
+            const initialPiSettings = this.backend.settings.snapshot();
+            this.#programStatus = new ProgramStatusReporter(status => this.#terminal.setProgramStatus(status), () => this.view().status.footer?.sessionName ?? undefined);
+            this.#reloadPresentation = reloadPresentation;
+            const presentationInterval = streamPresentationOptions?.intervalMs ?? STREAM_PRESENTATION_INTERVAL_MS;
+            this.#streamPresentation = streamPresentationOptions?.scheduler === undefined
+                ? new StreamPresentationCoalescer(() => this.#terminal.requestRender(), presentationInterval)
+                : new StreamPresentationCoalescer(() => this.#terminal.requestRender(), presentationInterval, streamPresentationOptions.scheduler);
+            constructed.push(() => this.#streamPresentation.dispose());
+            const promptSuggestionOptions = this.#customViewport ? options.suggestions : undefined;
+            promptSuggestionController = promptSuggestionOptions === undefined ? null : new ContextualPromptSuggestionController({
+                generator: promptSuggestionOptions.generator,
+                enabled: promptSuggestionOptions.enabled(),
+                ...(promptSuggestionOptions.diagnostics === undefined ? {} : { diagnostics: promptSuggestionOptions.diagnostics }),
+                surface: {
+                    canPresent: identity => this.#promptSuggestionPresentationBlockReason(identity) === null,
+                    presentationBlockReason: identity => this.#promptSuggestionPresentationBlockReason(identity),
+                    present: text => {
+                        if (!this.root.canPresentPromptSuggestion())
+                            return false;
+                        this.root.setPromptSuggestion(text);
+                        return true;
                     },
+                    clear: () => this.root.setPromptSuggestion(null),
+                    requestRender: () => this.#terminal.requestRender(),
+                },
+            });
+            this.#promptSuggestions = promptSuggestionController;
+            constructed.push(() => this.#promptSuggestions?.dispose());
+            this.#unsubscribePromptSuggestions = promptSuggestionOptions === undefined
+                ? () => { }
+                : promptSuggestionOptions.onChange(enabled => this.#promptSuggestions?.setEnabled(enabled));
+            constructed.push(this.#unsubscribePromptSuggestions);
+            this.#unsubscribePromptImages = this.#promptImages === null ? () => { } : this.#promptImages.onChange(() => {
+                if (!this.#disposed && this.root.reconcilePromptImageLimitNotice())
+                    this.#terminal.requestRender();
+            });
+            constructed.push(this.#unsubscribePromptImages);
+            // Rationale: the same listener refreshes the menu for the A1 presentation choice and for the engine's
+            // skill-command registration, both of which the owned settings manager reports through one change.
+            this.#unsubscribeSkills = this.#skills === null ? () => { } : this.#skills.onChange(() => {
+                // Invariant: reinstalling drops extension provider wrappers, so an unrelated setting change leaves the list alone.
+                if (this.#disposed || this.#commandListSignature() === this.#installedCommandSignature)
+                    return;
+                this.#installAutocompleteCommands();
+                this.#terminal.requestRender();
+            });
+            constructed.push(this.#unsubscribeSkills);
+            this.#terminal.setHardwareCursor(initialPiSettings.showHardwareCursor);
+            this.#terminal.setClearOnShrink(initialPiSettings.clearOnShrink);
+            this.#terminalProgressEnabled = initialPiSettings.showTerminalProgress;
+            this.#fullscreenExitOutput = initialPiSettings.fullscreenExitOutput;
+            // Invariant: bare A1 prints only the resume hint at exit, so the pinned exit-output
+            // choice is hidden there and cannot be bound; the comparison profile binds and honors it.
+            this.#unbindShutdownSettings = this.backend.settings.productMode === "bare" ? () => { } : this.backend.settings.bindOwner("shutdown", {
+                fullscreenExitOutput: { apply() { } },
+            });
+            constructed.push(this.#unbindShutdownSettings);
+            this.#unbindTerminalSettings = this.backend.settings.bindOwner("terminal", {
+                showHardwareCursor: { apply: value => {
+                        if (typeof value !== "boolean")
+                            throw new TypeError("Hardware cursor setting is invalid");
+                        this.#terminal.setHardwareCursor(value);
+                    } },
+                clearOnShrink: { apply: value => {
+                        if (typeof value !== "boolean")
+                            throw new TypeError("Clear-on-shrink setting is invalid");
+                        this.#terminal.setClearOnShrink(value);
+                    } },
+                showTerminalProgress: { apply: value => {
+                        if (typeof value !== "boolean")
+                            throw new TypeError("Terminal progress setting is invalid");
+                        this.#terminalProgressEnabled = value;
+                        this.#syncTerminalProgress(this.view());
+                    } },
+            });
+            constructed.push(this.#unbindTerminalSettings);
+            const applyViewportSettings = () => {
+                const snapshot = viewportSettings?.snapshot();
+                this.root.setViewportConfig(snapshot ?? {
+                    scrollbarAppearance: "auto",
+                    scrollbarStyle: "thin",
+                    scrollbarSpeed: "normal",
+                });
+            };
+            applyViewportSettings();
+            this.#unsubscribeSettings = this.#customViewport && viewportSettings
+                ? viewportSettings.onChange(settings => this.root.setViewportConfig(settings))
+                : () => { };
+            constructed.push(this.#unsubscribeSettings);
+            this.root.setEditorPaddingX(initialPiSettings.editorPaddingX);
+            this.root.setAutocompleteMaxVisible(initialPiSettings.autocompleteMaxVisible);
+            this.root.setOutputPad(initialPiSettings.outputPad);
+            this.root.setFullscreenCopyOnSelect(initialPiSettings.fullscreenCopyOnSelect);
+            this.root.setHideThinkingBlock(initialPiSettings.hideThinkingBlock);
+            this.root.setMermaidRenderingMode(initialPiSettings.mermaidRenderingMode);
+            this.#showImages = initialPiSettings.showImages;
+            this.#imageWidthCells = initialPiSettings.imageWidthCells;
+            this.root.setImagePresentation(this.#showImages, this.#imageWidthCells);
+            this.#unbindPiSettings = this.backend.settings.bindOwner("shell", {
+                editorPaddingX: { apply: value => {
+                        if (typeof value !== "number")
+                            throw new TypeError("Editor padding is invalid");
+                        this.root.setEditorPaddingX(value);
+                    } },
+                autocompleteMaxVisible: { apply: value => {
+                        if (typeof value !== "number")
+                            throw new TypeError("Autocomplete maximum is invalid");
+                        this.root.setAutocompleteMaxVisible(value);
+                    } },
+                outputPad: { apply: value => {
+                        if (value !== 0 && value !== 1)
+                            throw new TypeError("Output padding is invalid");
+                        this.root.setOutputPad(value);
+                    } },
+                hideThinkingBlock: { apply: value => {
+                        if (typeof value !== "boolean")
+                            throw new TypeError("Thinking-block visibility is invalid");
+                        this.root.setHideThinkingBlock(value);
+                    } },
+                mermaidRenderingMode: { apply: value => {
+                        if (value !== "off" && value !== "final" && value !== "streaming")
+                            throw new TypeError("Mermaid mode is invalid");
+                        this.root.setMermaidRenderingMode(value);
+                    } },
+                showImages: { apply: value => {
+                        if (typeof value !== "boolean")
+                            throw new TypeError("Image visibility is invalid");
+                        this.#showImages = value;
+                        this.root.setImagePresentation(this.#showImages, this.#imageWidthCells);
+                    } },
+                imageWidthCells: { apply: value => {
+                        if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1)
+                            throw new TypeError("Image width is invalid");
+                        this.#imageWidthCells = value;
+                        this.root.setImagePresentation(this.#showImages, this.#imageWidthCells);
+                    } },
+                ...(this.#customViewport ? { fullscreenCopyOnSelect: { apply: (value) => {
+                            if (typeof value !== "boolean")
+                                throw new TypeError("Fullscreen copy-on-select setting is invalid");
+                            this.root.setFullscreenCopyOnSelect(value);
+                        } } } : {
+                    fullscreenWheelScrollLines: { apply: (value) => {
+                            if (value !== "auto" && (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1 || value > 100)) {
+                                throw new TypeError("Fullscreen wheel-scroll distance is invalid");
+                            }
+                            this.#terminal.setWheelScrollLines(value);
+                        } },
                 }),
-            } : { layoutRoot: this.root.layoutRoot() }),
-            ...(inputPresentation?.onEvent === undefined ? {} : {
-                inputDiagnostics: {
-                    onEvent: inputPresentation.onEvent,
-                    ...(inputPresentation.now === undefined ? {} : { now: inputPresentation.now }),
+            });
+            constructed.push(this.#unbindPiSettings);
+            if (this.#customViewport && promptHistory !== undefined) {
+                this.#promptHistoryImageSidecar = promptHistory.imageSidecar;
+                const sidecar = this.#promptHistoryImageSidecar;
+                this.#promptHistory = new PromptHistoryController({
+                    editor: this.root.editor,
+                    store: promptHistory.store,
+                    limit: promptHistory.limit,
+                    fallback: this.view().transcript.flatMap(block => block.kind === "user" ? [block.text] : []),
+                    active: () => this.root.usesDefaultInputSurface(),
+                    render: () => this.#terminal.requestRender(),
+                    rehydrate: value => this.root.rehydrateHistoryText(value, id => sidecar?.readAttachment(id) ?? null),
+                });
+                constructed.push(() => { void this.#promptHistory?.close().catch(() => false); });
+            }
+            this.#extensionBridge = createPiExtensionUiBridge({
+                runtime: {
+                    getColumns: () => this.#terminal.viewport().columns,
+                    getRows: () => this.#terminal.viewport().rows,
+                    requestRender: () => this.#terminal.requestRender(),
                 },
-            }),
-            ...(terminal === undefined ? {} : { terminal: terminal }),
-            hardwareCursor: this.backend.view().terminal.hardwareCursor,
-            ...(this.#customViewport ? {} : { wheelScrollLines: initialPiSettings.fullscreenWheelScrollLines }),
-        };
-        runtime = new PiTuiRuntimeAdapter(runtimeOptions);
-        this.runtime = runtime;
-        this.#programStatus = new ProgramStatusReporter(status => { if (this.runtime.active)
-            this.runtime.setProgramStatus(status); }, () => this.view().status.footer?.sessionName ?? undefined);
-        this.#damageTerminal = damageTerminal ?? null;
-        this.#quitOutro = quitOutro;
-        this.#reloadPresentation = reloadPresentation;
-        const presentationInterval = streamPresentationOptions?.intervalMs ?? STREAM_PRESENTATION_INTERVAL_MS;
-        streamPresentation = streamPresentationOptions?.scheduler === undefined
-            ? new StreamPresentationCoalescer(() => this.runtime.requestRender(), presentationInterval)
-            : new StreamPresentationCoalescer(() => this.runtime.requestRender(), presentationInterval, streamPresentationOptions.scheduler);
-        this.#streamPresentation = streamPresentation;
-        const promptSuggestionOptions = this.#customViewport ? options.suggestions : undefined;
-        promptSuggestionController = promptSuggestionOptions === undefined ? null : new ContextualPromptSuggestionController({
-            generator: promptSuggestionOptions.generator,
-            enabled: promptSuggestionOptions.enabled(),
-            ...(promptSuggestionOptions.diagnostics === undefined ? {} : { diagnostics: promptSuggestionOptions.diagnostics }),
-            surface: {
-                canPresent: identity => this.#promptSuggestionPresentationBlockReason(identity) === null,
-                presentationBlockReason: identity => this.#promptSuggestionPresentationBlockReason(identity),
-                present: text => {
-                    if (!this.root.canPresentPromptSuggestion())
-                        return false;
-                    this.root.setPromptSuggestion(text);
-                    return true;
+                agentDir: this.backend.identity.agentDir,
+                setInputSurface: component => this.root.setInputSurface(component, true, "opaque"),
+                setProgramStatusBlocked: status => this.#programStatus.setBlocked("extension-dialog", status),
+                showOverlay: (component, overlayOptions) => this.#terminal.showOverlay(component, overlayOptions),
+                listenInput: handler => this.#terminal.addInputListener(handler),
+                replaceWidget: (key, component, placement) => this.root.setExtensionWidget(key, component, placement),
+                replaceHeader: component => this.root.setExtensionHeader(component),
+                replaceFooter: component => this.root.setExtensionFooter(component),
+                setStatus: (key, text) => this.root.setExtensionStatus(key, text),
+                setWorking: (message, visible) => this.root.setExtensionWorking(message, visible),
+                notify: (message, type) => this.root.addExtensionNotification(message, type),
+                setTitle: title => this.#terminal.setTitle(title),
+                getEditorText: () => this.root.editor.getText(),
+                setEditorText: text => this.root.editor.setText(text),
+                pasteToEditor: text => this.root.editor.insertText(text),
+                addAutocompleteProvider: factory => this.root.editor.addAutocompleteProvider(factory),
+                setCustomEditor: component => this.root.setInputSurface(component, true, "opaque"),
+                getFooterData: () => this.root.extensionFooterData(),
+                getToolsExpanded: () => this.root.toolsExpanded,
+                setToolsExpanded: expanded => this.root.setToolsExpanded(expanded),
+            });
+            constructed.push(() => this.#extensionBridge.dispose());
+            constructed.push(() => this.backend.workflows.setWorkflowInteractionHost(DETACHED_WORKFLOW_INTERACTION));
+            this.backend.workflows.setWorkflowInteractionHost({
+                startLogin: request => this.#startWorkflowLogin(request),
+                prompt: request => this.#requestWorkflowInput(request),
+                notify: event => this.#notifyWorkflowLogin(event),
+                publish: message => {
+                    this.root.appendWorkflowMessage(message);
+                    this.#terminal.requestRender();
                 },
-                clear: () => this.root.setPromptSuggestion(null),
-                requestRender: () => this.runtime.requestRender(),
-            },
-        });
-        this.#promptSuggestions = promptSuggestionController;
-        this.#unsubscribePromptSuggestions = promptSuggestionOptions === undefined
-            ? () => { }
-            : promptSuggestionOptions.onChange(enabled => this.#promptSuggestions?.setEnabled(enabled));
-        this.#unsubscribePromptImages = this.#promptImages === null ? () => { } : this.#promptImages.onChange(() => {
-            if (!this.#disposed && this.root.reconcilePromptImageLimitNotice())
-                this.runtime.requestRender();
-        });
-        // Rationale: the same listener refreshes the menu for the A1 presentation choice and for the engine's
-        // skill-command registration, both of which the owned settings manager reports through one change.
-        this.#unsubscribeSkills = this.#skills === null ? () => { } : this.#skills.onChange(() => {
-            // Invariant: reinstalling drops extension provider wrappers, so an unrelated setting change leaves the list alone.
-            if (this.#disposed || this.#commandListSignature() === this.#installedCommandSignature)
-                return;
+                finishLogin: () => this.#finishWorkflowLogin(),
+            });
             this.#installAutocompleteCommands();
-            this.runtime.requestRender();
-        });
-        this.runtime.setHardwareCursor(initialPiSettings.showHardwareCursor);
-        this.runtime.setClearOnShrink(initialPiSettings.clearOnShrink);
-        this.#terminalProgressEnabled = initialPiSettings.showTerminalProgress;
-        this.#fullscreenExitOutput = initialPiSettings.fullscreenExitOutput;
-        // Invariant: bare A1 prints only the resume hint at exit, so the pinned exit-output
-        // choice is hidden there and cannot be bound; the comparison profile binds and honors it.
-        this.#unbindShutdownSettings = this.backend.settingsProductMode === "bare" ? () => { } : this.backend.bindSettingsOwner("shutdown", {
-            fullscreenExitOutput: { apply() { } },
-        });
-        this.#unbindTerminalSettings = this.backend.bindSettingsOwner("terminal", {
-            showHardwareCursor: { apply: value => {
-                    if (typeof value !== "boolean")
-                        throw new TypeError("Hardware cursor setting is invalid");
-                    this.runtime.setHardwareCursor(value);
-                } },
-            clearOnShrink: { apply: value => {
-                    if (typeof value !== "boolean")
-                        throw new TypeError("Clear-on-shrink setting is invalid");
-                    this.runtime.setClearOnShrink(value);
-                } },
-            showTerminalProgress: { apply: value => {
-                    if (typeof value !== "boolean")
-                        throw new TypeError("Terminal progress setting is invalid");
-                    this.#terminalProgressEnabled = value;
-                    this.#syncTerminalProgress(this.view());
-                } },
-        });
-        this.#removeViewportPreInput = this.#customViewport
-            ? this.runtime.addPreInputListener(data => {
-                if (inputPresentation?.coordination === false)
-                    this.#streamPresentation.noteImmediatePresentation();
-                // Compatibility: route modal paging and boundary keys before Pi's fullscreen handlers.
-                const isDefault = this.root.usesDefaultInputSurface();
-                if (!this.runtime.hasOverlay() && !isDefault
-                    && (this.root.editor.matchesTerminalKey(data, "pageUp")
-                        || this.root.editor.matchesTerminalKey(data, "pageDown"))) {
-                    this.root.handleInput(data);
-                    this.runtime.requestRender();
-                    return { consume: true };
+            this.#unsubscribe = this.backend.session.onEvent(event => {
+                // Invariant: once disposal begins no event touches the view; only the stop still settles the shell.
+                if (this.#disposed) {
+                    if (event.type === "session-lifecycle" && event.lifecycle === "stopped")
+                        this.#settleStoppedLifecycle();
+                    return;
+                }
+                // Performance: a streamed chunk names one block, and touching only that block is what keeps the
+                // cost of a chunk the same in a long session as in a new one. Everything else
+                // resynchronizes the view, which is cheap next to re-reading the transcript.
+                if (event.type === "agent-run-started") {
+                    this.#promptSuggestions?.invalidate();
+                    this.root.resumeViewportFollowing();
                 }
-                if (!this.runtime.hasOverlay() && (this.root.editor.matchesTerminalKey(data, "home")
-                    || this.root.editor.matchesTerminalKey(data, "end")
-                    || !isDefault && (this.root.editor.matchesTerminalKey(data, "ctrl+home")
-                        || this.root.editor.matchesTerminalKey(data, "ctrl+end")))) {
-                    if (isDefault)
-                        this.root.handleViewportPreInput(data, true);
-                    this.root.handleInput(data);
-                    this.runtime.requestRender();
-                    return { consume: true };
+                if (event.type === "assistant-message-completed" && !event.successful) {
+                    this.#programStatus.setErrorMessage(this.view().status.diagnostics.at(-1));
                 }
-                // Invariant: geometry must belong to the painted frame, including newly opened/nested
-                // surfaces. Steady pointer input does not trigger a synchronous composition.
-                const viewport = this.runtime.viewport();
-                if (data.includes("\u001b[<") && !this.root.viewportInputGeometryReady(viewport.columns, viewport.rows)) {
-                    this.runtime.renderNow();
+                if (event.type === "agent-run-started" || event.type === "assistant-message-completed" || event.type === "agent-run-settled") {
+                    this.#programStatus.handleEvent(event);
+                }
+                if (event.type === "assistant-message-completed") {
+                    this.root.noteCompletedAssistantMessage();
+                    const identity = {
+                        sessionId: event.sessionId,
+                        sessionGeneration: event.sessionGeneration,
+                        runSequence: event.runSequence,
+                        responseSequence: event.responseSequence,
+                        model: event.model,
+                    };
+                    if (event.model === null)
+                        this.#promptSuggestions?.skip(identity, "no-model");
+                    else
+                        this.#promptSuggestions?.consider({ ...identity, model: event.model }, !event.successful ? "failed-response"
+                            : event.toolContinuation || event.stopReason === "toolUse" ? "tool-continuation"
+                                : event.stopReason !== "stop" ? "incomplete-response"
+                                    : event.assistantMessageCount < 2 ? "early-conversation"
+                                        : this.root.promptSuggestionPrepareBlockReason());
                 }
-                const routed = this.root.handleViewportPreInput(data, true, Date.now(), this.root.usesDefaultInputSurface() && !this.runtime.hasFocusedOverlay());
-                if (routed.copySelection !== undefined) {
-                    const snapshot = routed.copySelection;
-                    const acknowledgement = copyAcknowledgement(snapshot);
-                    const intent = ++this.#copyIntentSequence;
-                    void this.#responseCopy?.submit(snapshot, pendingClipboardWrite).then(result => {
-                        if (this.#disposed || !runtime.active || intent !== this.#copyIntentSequence
-                            || result.outcome !== "delivered" && result.outcome !== "submitted-unverified")
-                            return;
-                        if (acknowledgement.hasNonWhitespace) {
-                            this.root.showCopyAcknowledgement(`copied ${acknowledgement.characters} chars to clipboard`);
-                        }
-                    });
+                const semanticOnly = event.type === "agent-run-started" || event.type === "assistant-message-completed";
+                const view = event.type === "transcript-block" && this.#sessionGeneration === this.backend.identity.sessionGeneration
+                    ? this.#syncBlock(event.block)
+                    : semanticOnly ? this.view() : this.#syncView();
+                this.#syncTerminalProgress(view);
+                const currentModelKey = modelKey(view);
+                if (this.backend.identity.sessionGeneration !== this.#sessionGeneration || currentModelKey !== this.#suggestionModelKey) {
+                    this.#promptSuggestions?.invalidate();
+                    this.#suggestionModelKey = currentModelKey;
                 }
-                if (!routed.consumed)
-                    return routed.data === data ? undefined : { data: routed.data };
-                return routed.data.length === 0 ? { consume: true } : { data: routed.data };
-            })
-            : () => { };
-        const applyViewportSettings = () => {
-            const snapshot = viewportSettings?.snapshot();
-            this.root.setViewportConfig(snapshot ?? {
-                scrollbarAppearance: "auto",
-                scrollbarStyle: "thin",
-                scrollbarSpeed: "normal",
+                if (event.type === "status" && /^(Retrying|Compacting)/.test(event.status.workingMessage ?? "")) {
+                    this.#promptSuggestions?.invalidate();
+                }
+                if (event.type === "agent-run-settled") {
+                    const identity = {
+                        sessionId: event.sessionId,
+                        sessionGeneration: event.sessionGeneration,
+                        runSequence: event.runSequence,
+                        responseSequence: event.responseSequence,
+                        model: event.model,
+                    };
+                    if (event.model === null)
+                        this.#promptSuggestions?.skip(identity, "no-model");
+                    else
+                        this.#promptSuggestions?.settle({ ...identity, model: event.model }, !event.successful ? "failed-response"
+                            : event.toolContinuation || event.stopReason === "toolUse" ? "tool-continuation"
+                                : event.stopReason !== "stop" ? "incomplete-response"
+                                    : event.assistantMessageCount < 2 ? "early-conversation"
+                                        : this.root.promptSuggestionPrepareBlockReason());
+                }
+                if (event.type === "session-lifecycle" && event.lifecycle === "stopped")
+                    this.#settleStoppedLifecycle();
             });
-        };
-        applyViewportSettings();
-        this.#unsubscribeSettings = this.#customViewport && viewportSettings
-            ? viewportSettings.onChange(settings => this.root.setViewportConfig(settings))
-            : () => { };
-        this.root.setEditorPaddingX(initialPiSettings.editorPaddingX);
-        this.root.setAutocompleteMaxVisible(initialPiSettings.autocompleteMaxVisible);
-        this.root.setOutputPad(initialPiSettings.outputPad);
-        this.root.setFullscreenCopyOnSelect(initialPiSettings.fullscreenCopyOnSelect);
-        this.root.setHideThinkingBlock(initialPiSettings.hideThinkingBlock);
-        this.root.setMermaidRenderingMode(initialPiSettings.mermaidRenderingMode);
-        this.#showImages = initialPiSettings.showImages;
-        this.#imageWidthCells = initialPiSettings.imageWidthCells;
-        this.root.setImagePresentation(this.#showImages, this.#imageWidthCells);
-        this.#unbindPiSettings = this.backend.bindSettingsOwner("shell", {
-            editorPaddingX: { apply: value => {
-                    if (typeof value !== "number")
-                        throw new TypeError("Editor padding is invalid");
-                    this.root.setEditorPaddingX(value);
-                } },
-            autocompleteMaxVisible: { apply: value => {
-                    if (typeof value !== "number")
-                        throw new TypeError("Autocomplete maximum is invalid");
-                    this.root.setAutocompleteMaxVisible(value);
-                } },
-            outputPad: { apply: value => {
-                    if (value !== 0 && value !== 1)
-                        throw new TypeError("Output padding is invalid");
-                    this.root.setOutputPad(value);
-                } },
-            hideThinkingBlock: { apply: value => {
-                    if (typeof value !== "boolean")
-                        throw new TypeError("Thinking-block visibility is invalid");
-                    this.root.setHideThinkingBlock(value);
-                } },
-            mermaidRenderingMode: { apply: value => {
-                    if (value !== "off" && value !== "final" && value !== "streaming")
-                        throw new TypeError("Mermaid mode is invalid");
-                    this.root.setMermaidRenderingMode(value);
-                } },
-            showImages: { apply: value => {
-                    if (typeof value !== "boolean")
-                        throw new TypeError("Image visibility is invalid");
-                    this.#showImages = value;
-                    this.root.setImagePresentation(this.#showImages, this.#imageWidthCells);
-                } },
-            imageWidthCells: { apply: value => {
-                    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1)
-                        throw new TypeError("Image width is invalid");
-                    this.#imageWidthCells = value;
-                    this.root.setImagePresentation(this.#showImages, this.#imageWidthCells);
-                } },
-            ...(this.#customViewport ? { fullscreenCopyOnSelect: { apply: (value) => {
-                        if (typeof value !== "boolean")
-                            throw new TypeError("Fullscreen copy-on-select setting is invalid");
-                        this.root.setFullscreenCopyOnSelect(value);
-                    } } } : {
-                fullscreenWheelScrollLines: { apply: (value) => {
-                        if (value !== "auto" && (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1 || value > 100)) {
-                            throw new TypeError("Fullscreen wheel-scroll distance is invalid");
-                        }
-                        this.runtime.setWheelScrollLines(value);
-                    } },
-            }),
-        });
-        if (this.#customViewport && promptHistory !== undefined) {
-            this.#promptHistoryImageSidecar = promptHistory.imageSidecar;
-            const sidecar = this.#promptHistoryImageSidecar;
-            this.#promptHistory = new PromptHistoryController({
-                editor: this.root.editor,
-                store: promptHistory.store,
-                limit: promptHistory.limit,
-                fallback: this.view().transcript.flatMap(block => block.kind === "user" ? [block.text] : []),
-                active: () => this.root.usesDefaultInputSurface(),
-                render: () => this.runtime.requestRender(),
-                rehydrate: value => this.root.rehydrateHistoryText(value, id => sidecar?.readAttachment(id) ?? null),
+            constructed.push(this.#unsubscribe);
+            this.#unbindClipboardWriter = this.#responseCopy === null ? () => { } : this.backend.extensions.bindClipboardWriter(async (text) => {
+                const result = await this.#responseCopy.submitText(text);
+                if (result.outcome === "delivered")
+                    return true;
+                if (result.outcome === "submitted-unverified")
+                    return false;
+                throw new Error(result.outcome === "timed-out" ? "Clipboard delivery timed out" : "Clipboard delivery could not be completed");
             });
+            constructed.push(this.#unbindClipboardWriter);
+            if (this.backend.session.view().lifecycle === "stopped")
+                this.#resolveStopped?.();
         }
-        this.#extensionBridge = createPiExtensionUiBridge({
-            runtime: {
-                getColumns: () => this.runtime.viewport().columns,
-                getRows: () => this.runtime.viewport().rows,
-                requestRender: () => this.runtime.requestRender(),
-            },
-            agentDir: this.backend.agentDir,
-            setInputSurface: component => this.root.setInputSurface(component, true, "opaque"),
-            setProgramStatusBlocked: status => this.#programStatus.setBlocked("extension-dialog", status),
-            showOverlay: (component, overlayOptions) => this.runtime.showOverlay(component, overlayOptions),
-            listenInput: handler => this.runtime.addInputListener(handler),
-            replaceWidget: (key, component, placement) => this.root.setExtensionWidget(key, component, placement),
-            replaceHeader: component => this.root.setExtensionHeader(component),
-            replaceFooter: component => this.root.setExtensionFooter(component),
-            setStatus: (key, text) => this.root.setExtensionStatus(key, text),
-            setWorking: (message, visible) => this.root.setExtensionWorking(message, visible),
-            notify: (message, type) => this.root.addExtensionNotification(message, type),
-            setTitle: title => this.runtime.setTitle(title),
-            getEditorText: () => this.root.editor.getText(),
-            setEditorText: text => this.root.editor.setText(text),
-            pasteToEditor: text => this.root.editor.insertText(text),
-            addAutocompleteProvider: factory => this.root.editor.addAutocompleteProvider(factory),
-            setCustomEditor: component => this.root.setInputSurface(component, true, "opaque"),
-            getFooterData: () => this.root.extensionFooterData(),
-            getToolsExpanded: () => this.root.toolsExpanded,
-            setToolsExpanded: expanded => this.root.setToolsExpanded(expanded),
-        });
-        this.backend.setWorkflowInteractionHost({
-            startLogin: request => this.#startWorkflowLogin(request),
-            prompt: request => this.#requestWorkflowInput(request),
-            notify: event => this.#notifyWorkflowLogin(event),
-            publish: message => {
-                this.root.appendWorkflowMessage(message);
-                this.runtime.requestRender();
-            },
-            finishLogin: () => this.#finishWorkflowLogin(),
-        });
-        this.#installAutocompleteCommands();
-        this.#unsubscribe = this.backend.onEvent(event => {
-            // Performance: a streamed chunk names one block, and touching only that block is what keeps the
-            // cost of a chunk the same in a long session as in a new one. Everything else
-            // resynchronizes the view, which is cheap next to re-reading the transcript.
-            if (event.type === "agent-run-started") {
-                this.#promptSuggestions?.invalidate();
-                this.root.resumeViewportFollowing();
-            }
-            if (event.type === "assistant-message-completed" && !event.successful) {
-                this.#programStatus.setErrorMessage(this.view().status.diagnostics.at(-1));
-            }
-            if (event.type === "agent-run-started" || event.type === "assistant-message-completed" || event.type === "agent-run-settled") {
-                this.#programStatus.handleEvent(event);
-            }
-            if (event.type === "assistant-message-completed") {
-                this.root.noteCompletedAssistantMessage();
-                const identity = {
-                    sessionId: event.sessionId,
-                    sessionGeneration: event.sessionGeneration,
-                    runSequence: event.runSequence,
-                    responseSequence: event.responseSequence,
-                    model: event.model,
-                };
-                if (event.model === null)
-                    this.#promptSuggestions?.skip(identity, "no-model");
-                else
-                    this.#promptSuggestions?.consider({ ...identity, model: event.model }, !event.successful ? "failed-response"
-                        : event.toolContinuation || event.stopReason === "toolUse" ? "tool-continuation"
-                            : event.stopReason !== "stop" ? "incomplete-response"
-                                : event.assistantMessageCount < 2 ? "early-conversation"
-                                    : this.root.promptSuggestionPrepareBlockReason());
-            }
-            const semanticOnly = event.type === "agent-run-started" || event.type === "assistant-message-completed";
-            const view = event.type === "transcript-block" && this.#sessionGeneration === this.backend.sessionGeneration
-                ? this.#syncBlock(event.block)
-                : semanticOnly ? this.view() : this.#syncView();
-            this.#syncTerminalProgress(view);
-            const currentModelKey = modelKey(view);
-            if (this.backend.sessionGeneration !== this.#sessionGeneration || currentModelKey !== this.#suggestionModelKey) {
-                this.#promptSuggestions?.invalidate();
-                this.#suggestionModelKey = currentModelKey;
-            }
-            if (event.type === "status" && /^(Retrying|Compacting)/.test(event.status.workingMessage ?? "")) {
-                this.#promptSuggestions?.invalidate();
-            }
-            if (event.type === "agent-run-settled") {
-                const identity = {
-                    sessionId: event.sessionId,
-                    sessionGeneration: event.sessionGeneration,
-                    runSequence: event.runSequence,
-                    responseSequence: event.responseSequence,
-                    model: event.model,
-                };
-                if (event.model === null)
-                    this.#promptSuggestions?.skip(identity, "no-model");
-                else
-                    this.#promptSuggestions?.settle({ ...identity, model: event.model }, !event.successful ? "failed-response"
-                        : event.toolContinuation || event.stopReason === "toolUse" ? "tool-continuation"
-                            : event.stopReason !== "stop" ? "incomplete-response"
-                                : event.assistantMessageCount < 2 ? "early-conversation"
-                                    : this.root.promptSuggestionPrepareBlockReason());
+        catch (error) {
+            for (const release of constructed.reverse()) {
+                try {
+                    release();
+                }
+                catch { /* Rationale: the construction failure is the error worth reporting. */ }
             }
-            if (event.type === "session-lifecycle" && event.lifecycle === "stopped")
-                this.#settleStoppedLifecycle();
-        });
-        this.#unbindClipboardWriter = this.#responseCopy === null ? () => { } : this.backend.bindClipboardWriter(async (text) => {
-            const result = await this.#responseCopy.submitText(text);
-            if (result.outcome === "delivered")
-                return true;
-            if (result.outcome === "submitted-unverified")
-                return false;
-            throw new Error(result.outcome === "timed-out" ? "Clipboard delivery timed out" : "Clipboard delivery could not be completed");
-        });
-        if (this.backend.view().lifecycle === "stopped")
-            this.#resolveStopped?.();
+            throw error;
+        }
     }
     view() {
-        return this.backend.view();
+        return this.backend.session.view();
+    }
+    get terminalHost() {
+        return this.#host;
+    }
+    render(width) {
+        return this.root.render(width);
+    }
+    handleInput(data) {
+        this.root.handleInput(data);
+    }
+    invalidate() {
+        this.root.invalidate();
+    }
+    setFocused(focused) {
+        this.root.setFocused(focused);
+    }
+    inputCoordinationSurface() {
+        return this.root.inputCoordinationSurface();
+    }
+    setOverlaySurfaces(surfaces) {
+        this.root.setViewportOverlaySurfaces(surfaces);
+    }
+    noteImmediatePresentation() {
+        this.#streamPresentation.noteImmediatePresentation();
+    }
+    layoutPart(part) {
+        this.#layoutParts ??= this.root.layoutParts();
+        return this.#layoutParts[part];
+    }
+    activated() {
+        this.#syncTerminalProgress(this.view());
+    }
+    handleViewportInput(data) {
+        if (!this.#inputCoordination)
+            this.#streamPresentation.noteImmediatePresentation();
+        // Compatibility: route modal paging and boundary keys before Pi's fullscreen handlers.
+        const isDefault = this.root.usesDefaultInputSurface();
+        if (!this.#terminal.hasOverlay() && !isDefault
+            && (this.root.editor.matchesTerminalKey(data, "pageUp")
+                || this.root.editor.matchesTerminalKey(data, "pageDown"))) {
+            this.root.handleInput(data);
+            this.#terminal.requestRender();
+            return { consume: true };
+        }
+        if (!this.#terminal.hasOverlay() && (this.root.editor.matchesTerminalKey(data, "home")
+            || this.root.editor.matchesTerminalKey(data, "end")
+            || !isDefault && (this.root.editor.matchesTerminalKey(data, "ctrl+home")
+                || this.root.editor.matchesTerminalKey(data, "ctrl+end")))) {
+            if (isDefault)
+                this.root.handleViewportPreInput(data, true);
+            this.root.handleInput(data);
+            this.#terminal.requestRender();
+            return { consume: true };
+        }
+        // Invariant: geometry must belong to the painted frame, including newly opened/nested
+        // surfaces. Steady pointer input does not trigger a synchronous composition.
+        const viewport = this.#terminal.viewport();
+        if (data.includes("\u001b[<") && !this.root.viewportInputGeometryReady(viewport.columns, viewport.rows)) {
+            this.#terminal.renderNow();
+        }
+        const routed = this.root.handleViewportPreInput(data, true, Date.now(), this.root.usesDefaultInputSurface() && !this.#terminal.hasFocusedOverlay());
+        if (routed.copySelection !== undefined) {
+            const snapshot = routed.copySelection;
+            const acknowledgement = copyAcknowledgement(snapshot);
+            const intent = ++this.#copyIntentSequence;
+            void this.#responseCopy?.submit(snapshot, this.#pendingClipboardWrite).then(result => {
+                if (this.#disposed || !this.#terminal.running || intent !== this.#copyIntentSequence
+                    || result.outcome !== "delivered" && result.outcome !== "submitted-unverified")
+                    return;
+                if (acknowledgement.hasNonWhitespace) {
+                    this.root.showCopyAcknowledgement(`copied ${acknowledgement.characters} chars to clipboard`);
+                }
+            });
+        }
+        if (!routed.consumed)
+            return routed.data === data ? undefined : { data: routed.data };
+        return routed.data.length === 0 ? { consume: true } : { data: routed.data };
     }
     #promptSuggestionPresentationBlockReason(identity) {
         const view = this.view();
         if (this.#disposed)
             return "disposed";
-        if (identity.sessionId !== view.sessionId || identity.sessionGeneration !== this.backend.sessionGeneration
+        if (identity.sessionId !== view.sessionId || identity.sessionGeneration !== this.backend.identity.sessionGeneration
             || modelKey(view) !== `${identity.model.providerId}/${identity.model.modelId}`)
             return "stale-identity";
         return this.root.promptSuggestionPresentationBlockReason();
     }
-    damagePresentationDecision() {
-        return this.#damageTerminal?.lastDecision ?? null;
-    }
     start() {
         if (this.#started)
             return;
         this.#started = true;
-        this.runtime.start();
+        this.#terminal.start();
         this.#promptHistory?.start();
         this.#syncTerminalProgress(this.view());
-        if (this.#customViewport)
-            this.#setPointerReporting(true);
-        void this.backend.bindExtensionUi(this.#extensionBridge.context, () => { void this.shutdown(); });
+        void this.backend.extensions.bindExtensionUi(this.#extensionBridge.context, () => { void this.shutdown(); });
         this.#syncView();
         // Performance: the spare clipboard helpers fork after the first frame is out, so startup never waits on them.
         setImmediate(() => {
@@ -670,10 +687,10 @@ export class OwnedUiSessionShell {
         if (!this.root.hasPendingPastes(draft))
             return this.#guardSubmission(draft, action);
         const controller = new AbortController();
-        const generation = this.backend.sessionGeneration;
+        const generation = this.backend.identity.sessionGeneration;
         const result = this.#guardSubmission(draft, async () => {
             await this.root.waitForPromptPastes(draft, controller.signal);
-            if (controller.signal.aborted || this.#disposed || this.backend.sessionGeneration !== generation)
+            if (controller.signal.aborted || this.#disposed || this.backend.identity.sessionGeneration !== generation)
                 return rejected("image submission canceled");
             return action();
         }).finally(() => {
@@ -693,7 +710,7 @@ export class OwnedUiSessionShell {
             render: width => [...renderPiShellStatusText(`Waiting for images (${count} submission${count === 1 ? "" : "s"}) — Esc cancels; dequeue restores`, width)],
             invalidate: () => { },
         }, "aboveEditor");
-        this.runtime.requestRender();
+        this.#terminal.requestRender();
     }
     #cancelWaitingImages() {
         for (const item of this.#waitingImages.values())
@@ -707,7 +724,7 @@ export class OwnedUiSessionShell {
                 this.#promptHistory.rememberRecovery(text);
             else {
                 this.#persistImageSidecars(text);
-                this.#promptHistory.capture(reusable, kind, this.#cwd, this.backend.sessionId);
+                this.#promptHistory.capture(reusable, kind, this.#cwd, this.backend.identity.sessionId);
             }
         }
     }
@@ -738,7 +755,7 @@ export class OwnedUiSessionShell {
             if (command) {
                 this.#rememberInput(displayInput, "bash");
                 try {
-                    const result = await this.backend.executeBashWorkflow(command, excludeFromContext);
+                    const result = await this.backend.workflows.executeBashWorkflow(command, excludeFromContext);
                     const workflow = {
                         command: "debug",
                         outcome: result.cancelled ? "cancelled" : result.exitCode === 0 || result.exitCode === undefined ? "completed" : "failed",
@@ -746,13 +763,13 @@ export class OwnedUiSessionShell {
                         ...(result.output ? { detail: result.output } : {}),
                     };
                     this.root.appendWorkflowResult(workflow);
-                    this.runtime.requestRender();
+                    this.#terminal.requestRender();
                     return workflow.outcome === "failed" ? rejected(workflow.message) : { outcome: "completed", diagnostic: null };
                 }
                 catch (error) {
                     const message = `Bash command failed: ${error instanceof Error ? error.message : String(error)}`;
                     this.root.appendWorkflowResult({ command: "debug", outcome: "failed", message });
-                    this.runtime.requestRender();
+                    this.#terminal.requestRender();
                     return rejected(message);
                 }
             }
@@ -767,7 +784,7 @@ export class OwnedUiSessionShell {
             return await this.#execute({
                 type,
                 correlationId: this.#correlation(type),
-                sessionId: this.backend.sessionId,
+                sessionId: this.backend.identity.sessionId,
                 text: input,
                 ...(prepared.images.length === 0 ? {} : { images: prepared.images }),
             }, displayInput);
@@ -782,7 +799,7 @@ export class OwnedUiSessionShell {
             return this.shutdown();
         this.root.editor.setText("");
         this.#lastClearTime = now;
-        this.runtime.requestRender();
+        this.#terminal.requestRender();
         return { outcome: "completed", diagnostic: null };
     }
     async interrupt(now = Date.now()) {
@@ -800,7 +817,7 @@ export class OwnedUiSessionShell {
         // Compatibility: match Pi: with an empty editor, two escapes inside 500 ms open the
         // configured session navigator. The first escape intentionally does not
         // interrupt or mutate the prompt.
-        const action = this.backend.pinnedSettingsSnapshot().doubleEscapeAction;
+        const action = this.backend.settings.snapshot().doubleEscapeAction;
         if (action === "none")
             return { outcome: "rejected", diagnostic: "nothing to interrupt" };
         if (now - this.#lastEscapeTime < 500) {
@@ -834,7 +851,7 @@ export class OwnedUiSessionShell {
         return this.#execute({
             type: "resume-session",
             correlationId: this.#correlation("resume"),
-            sessionId: this.backend.sessionId,
+            sessionId: this.backend.identity.sessionId,
             sessionPath,
         });
     }
@@ -843,7 +860,7 @@ export class OwnedUiSessionShell {
         return this.#execute({
             type: "set-model",
             correlationId: this.#correlation("model"),
-            sessionId: this.backend.sessionId,
+            sessionId: this.backend.identity.sessionId,
             model: { providerId, modelId, displayName: modelId },
         });
     }
@@ -851,7 +868,7 @@ export class OwnedUiSessionShell {
         return this.#execute({
             type: "set-thinking-level",
             correlationId: this.#correlation("thinking"),
-            sessionId: this.backend.sessionId,
+            sessionId: this.backend.identity.sessionId,
             thinkingLevel,
         });
     }
@@ -861,9 +878,9 @@ export class OwnedUiSessionShell {
         return this.setThinkingLevel(levels[(current + 1) % levels.length] ?? "off");
     }
     async cycleModel(direction) {
-        const result = await this.backend.cycleModelWorkflow(direction);
+        const result = await this.backend.workflows.cycleModelWorkflow(direction);
         this.root.appendWorkflowResult(result);
-        this.runtime.requestRender();
+        this.#terminal.requestRender();
         return workflowAdapterResult(result);
     }
     async queueFollowUp() {
@@ -884,18 +901,18 @@ export class OwnedUiSessionShell {
         return this.#execute({
             type: "follow-up",
             correlationId: this.#correlation("follow-up"),
-            sessionId: this.backend.sessionId,
+            sessionId: this.backend.identity.sessionId,
             text,
             ...(prepared.images.length === 0 ? {} : { images: prepared.images }),
         }, displayInput);
     }
     restoreQueuedInput() {
-        const queued = [...this.#waitingImages.keys(), ...this.backend.clearQueuedWorkflows()];
+        const queued = [...this.#waitingImages.keys(), ...this.backend.workflows.clearQueuedWorkflows()];
         this.#cancelWaitingImages();
         if (queued.length === 0)
             return;
         this.root.editor.setText(queued.join("\n"));
-        this.runtime.requestRender();
+        this.#terminal.requestRender();
     }
     showSelector(title, options, onSelect, onCancel) {
         this.#dialogHandle?.hide();
@@ -917,7 +934,7 @@ export class OwnedUiSessionShell {
                 onCancel?.();
             },
         });
-        const handle = this.runtime.showOverlay(component, {
+        const handle = this.#terminal.showOverlay(component, {
             width: "70%",
             maxHeight: "80%",
             anchor: "center",
@@ -926,6 +943,24 @@ export class OwnedUiSessionShell {
         this.#dialogHandle = handle;
         return handle;
     }
+    // Rationale: presenters see the shell only as a dialog host; selectors open in the input dock and run choices as workflows.
+    #createDialogHost() {
+        const isDisposed = () => this.#disposed;
+        return {
+            get disposed() { return isDisposed(); },
+            setInputSurface: surface => this.root.setInputSurface(surface),
+            requestRender: () => this.#terminal.requestRender(),
+            viewport: () => this.#terminal.viewport(),
+            appendWorkflowStatus: text => this.root.appendWorkflowStatus(text),
+            appendWorkflowResult: result => this.root.appendWorkflowResult(result),
+            runWorkflow: request => this.runWorkflow(request),
+            // Invariant: the custom bare-A1 surface holds frames while optional selectors load and is permanently
+            // fullscreen; the pinned comparison profiles render immediately and keep Pi's TUI mode switch.
+            ...(this.#customViewport
+                ? { beginPresentationHold: () => this.#terminal.beginPresentationHold() }
+                : { switchTuiMode: mode => this.#terminal.switchMode(mode) }),
+        };
+    }
     #loadLazySelectors() {
         if (this.#lazySelectors !== undefined)
             return Promise.resolve(this.#lazySelectors);
@@ -935,17 +970,17 @@ export class OwnedUiSessionShell {
         });
     }
     async showThinkingSelector() {
-        const snapshot = this.backend.pinnedSettingsSnapshot();
+        const snapshot = this.backend.settings.snapshot();
         const close = () => {
             this.root.setFooterLevel(true);
             this.root.setInputSurface(null);
-            this.runtime.requestRender();
+            this.#terminal.requestRender();
         };
         const select = (level) => {
             close();
             void this.runWorkflow({ command: "thinking", argument: "", selection: level });
         };
-        const releasePresentation = this.#customViewport ? this.runtime.beginPresentationHold() : undefined;
+        const releasePresentation = this.#customViewport ? this.#terminal.beginPresentationHold() : undefined;
         try {
             const selectors = await this.#loadLazySelectors();
             const component = await selectors.createThinking({
@@ -953,7 +988,7 @@ export class OwnedUiSessionShell {
                 availableLevels: snapshot.availableThinkingLevels,
                 onSelect: select,
                 onCancel: close,
-                onSelectAsDefault: level => this.backend.setDefaultThinkingLevel(level),
+                onSelectAsDefault: level => this.backend.settings.setDefaultThinkingLevel(level),
                 defaultLevel: snapshot.defaultThinkingLevel,
                 ...(this.#customViewport ? {
                     presentation: {
@@ -966,7 +1001,7 @@ export class OwnedUiSessionShell {
                 return;
             this.root.setFooterLevel(false);
             this.root.setInputSurface(component);
-            this.runtime.requestRender();
+            this.#terminal.requestRender();
         }
         finally {
             releasePresentation?.();
@@ -976,7 +1011,7 @@ export class OwnedUiSessionShell {
     showSkillsSelector(skills = this.#skillSummaries()) {
         const close = () => {
             this.root.setInputSurface(null);
-            this.runtime.requestRender();
+            this.#terminal.requestRender();
         };
         const component = createPiShellSkillsSelector({
             skills,
@@ -987,57 +1022,33 @@ export class OwnedUiSessionShell {
             onCancel: close,
         });
         this.root.setInputSurface(component);
-        this.runtime.requestRender();
+        this.#terminal.requestRender();
     }
     showModelSelector(initialSearchInput) {
-        const context = this.backend.pinnedModelSelectorContext();
-        const close = () => {
-            this.root.setInputSurface(null);
-            this.runtime.requestRender();
-        };
-        const component = createPiShellModelSelector({
-            ...context,
-            runtime: {
-                getColumns: () => this.runtime.viewport().columns,
-                getRows: () => this.runtime.viewport().rows,
-                requestRender: () => this.runtime.requestRender(),
-            },
-            ...(initialSearchInput === undefined ? {} : { initialSearchInput }),
-            onSelect: model => {
-                close();
-                void this.runWorkflow({ command: "model", argument: "", selection: modelReference(model) });
-            },
-            onSelectAsDefault: model => {
-                close();
-                void this.runWorkflow({ command: "model", argument: "", selection: modelReference(model), persist: true });
-            },
-            onCancel: close,
-        });
-        this.root.setInputSurface(component);
-        this.runtime.requestRender();
+        this.#presenters.openModelSelector(this.#dialogHost, initialSearchInput);
     }
     showForkSelector() {
-        const options = this.backend.pinnedForkOptions();
+        const options = this.backend.catalog.pinnedForkOptions();
         if (options.length === 0) {
             this.root.appendWorkflowResult({ command: "fork", outcome: "completed", message: "No messages to fork from", messageKind: "status" });
-            this.runtime.requestRender();
+            this.#terminal.requestRender();
             return;
         }
         const close = () => {
             this.root.setInputSurface(null);
-            this.runtime.requestRender();
+            this.#terminal.requestRender();
         };
         const component = createPiShellUserMessageSelector(options, selection => {
             close();
             void this.runWorkflow({ command: "fork", argument: "", selection });
         }, close);
         this.root.setInputSurface(component);
-        this.runtime.requestRender();
+        this.#terminal.requestRender();
     }
     async showLogoutSelector() {
         let options;
         try {
-            options = await this.backend.pinnedLogoutOptions();
+            options = await this.backend.catalog.pinnedLogoutOptions();
         }
         catch (error) {
             this.root.appendWorkflowResult({
@@ -1045,27 +1056,27 @@ export class OwnedUiSessionShell {
                 outcome: "failed",
                 message: `Could not read stored credentials: ${error instanceof Error ? error.message : String(error)}`,
             });
-            this.runtime.requestRender();
+            this.#terminal.requestRender();
             return;
         }
         if (options.length === 0) {
             this.root.appendWorkflowStatus("No stored credentials to remove. /logout only removes credentials saved by /login; environment variables and models.json config are unchanged.");
-            this.runtime.requestRender();
+            this.#terminal.requestRender();
             return;
         }
         const close = () => {
             this.root.setInputSurface(null);
-            this.runtime.requestRender();
+            this.#terminal.requestRender();
         };
         const component = createPiShellAuthProviderSelector("logout", options, selection => {
             close();
             void this.runWorkflow({ command: "logout", argument: "", selection });
         }, close);
         this.root.setInputSurface(component);
-        this.runtime.requestRender();
+        this.#terminal.requestRender();
     }
     showLoginMethodSelector(providerReference) {
-        const method = this.backend.pinnedLoginMethodOptions(providerReference);
+        const method = this.backend.catalog.pinnedLoginMethodOptions(providerReference);
         if (method.options.length === 0) {
             this.showLoginProviderSelector(undefined, providerReference);
             return;
@@ -1078,7 +1089,7 @@ export class OwnedUiSessionShell {
         }
         const close = () => {
             this.root.setInputSurface(null);
-            this.runtime.requestRender();
+            this.#terminal.requestRender();
         };
         const labels = method.options.map(option => option.label);
         const component = createPiShellExtensionSelector(method.title, labels, label => {
@@ -1089,74 +1100,17 @@ export class OwnedUiSessionShell {
             void this.runWorkflow({ command: "login", argument: "", selection });
         }, close);
         this.root.setInputSurface(component);
-        this.runtime.requestRender();
+        this.#terminal.requestRender();
     }
-    async showTreeSelector(initialSelectedId) {
-        const context = this.backend.pinnedTreeSelectorContext();
-        if (context.tree.length === 0) {
-            this.root.appendWorkflowStatus("No entries in session");
-            this.runtime.requestRender();
-            return;
-        }
-        const close = () => {
-            this.root.setInputSurface(null);
-            this.runtime.requestRender();
-        };
-        const releasePresentation = this.#customViewport ? this.runtime.beginPresentationHold() : undefined;
-        try {
-            const selectors = await this.#loadLazySelectors();
-            const component = await selectors.createTree({
-                tree: context.tree,
-                currentLeafId: context.currentLeafId,
-                terminalHeight: this.runtime.viewport().rows,
-                initialFilterMode: context.filterMode,
-                ...(initialSelectedId === undefined ? {} : { initialSelectedId }),
-                onLabelChange: context.appendLabelChange,
-                onCopy: text => {
-                    if (!text) {
-                        this.root.appendWorkflowResult({ command: "tree", outcome: "failed", message: "Selected entry has no text to copy" });
-                        this.runtime.requestRender();
-                        return;
-                    }
-                    const generation = this.backend.sessionBindingGeneration;
-                    void this.backend.copyWorkflowText(text).then(acknowledged => {
-                        if (this.#disposed || generation !== this.backend.sessionBindingGeneration)
-                            return;
-                        this.root.appendWorkflowStatus(acknowledged ? "Copied selected message to clipboard" : "Submitted selected message to clipboard");
-                        this.runtime.requestRender();
-                    }).catch(error => {
-                        if (this.#disposed || generation !== this.backend.sessionBindingGeneration)
-                            return;
-                        this.root.appendWorkflowResult({ command: "tree", outcome: "failed", message: error instanceof Error ? error.message : String(error) });
-                        this.runtime.requestRender();
-                    });
-                },
-                onCancel: close,
-                onSelect: entryId => {
-                    if (entryId === context.currentLeafId) {
-                        close();
-                        this.root.appendWorkflowStatus("Already at this point");
-                        this.runtime.requestRender();
-                        return;
-                    }
-                    if (context.skipSummaryPrompt)
-                        close();
-                    void this.#completeTreeSelection(entryId, context.skipSummaryPrompt);
-                },
-            });
-            if (this.#disposed)
-                return;
-            this.root.setInputSurface(component);
-            this.runtime.requestRender();
-        }
-        finally {
-            releasePresentation?.();
-        }
+    showTreeSelector(initialSelectedId) {
+        return this.#presenters.openTreeSelector(this.#dialogHost, (entryId, skipSummaryPrompt) => {
+            void this.#completeTreeSelection(entryId, skipSummaryPrompt);
+        }, initialSelectedId);
     }
     showLoginAuthTypeSelector() {
         const close = () => {
             this.root.setInputSurface(null);
-            this.runtime.requestRender();
+            this.#terminal.requestRender();
         };
         const labels = ["Sign in with an account", "Sign in with an API key"];
         const component = createPiShellExtensionSelector("Select authentication method:", labels, label => {
@@ -1164,18 +1118,18 @@ export class OwnedUiSessionShell {
             this.showLoginProviderSelector(label === labels[0] ? "oauth" : "api_key");
         }, close);
         this.root.setInputSurface(component);
-        this.runtime.requestRender();
+        this.#terminal.requestRender();
     }
     showLoginProviderSelector(authType, initialSearchInput) {
-        const options = this.backend.pinnedLoginOptions(authType);
+        const options = this.backend.catalog.pinnedLoginOptions(authType);
         if (options.length === 0) {
             this.root.appendWorkflowStatus(authType === "oauth" ? "No account providers available." : authType === "api_key" ? "No API key providers available." : "No login providers available.");
-            this.runtime.requestRender();
+            this.#terminal.requestRender();
             return;
         }
         const close = () => {
             this.root.setInputSurface(null);
-            this.runtime.requestRender();
+            this.#terminal.requestRender();
         };
         const component = createPiShellAuthProviderSelector("login", options, id => {
             close();
@@ -1186,84 +1140,13 @@ export class OwnedUiSessionShell {
                 this.showLoginAuthTypeSelector();
         }, initialSearchInput);
         this.root.setInputSurface(component);
-        this.runtime.requestRender();
+        this.#terminal.requestRender();
     }
-    async showSessionSelector() {
-        const context = this.backend.pinnedSessionSelectorContext();
-        const close = () => {
-            this.root.setInputSurface(null);
-            this.runtime.requestRender();
-        };
-        const component = await createPiShellSessionSelector({
-            currentSessionsLoader: context.loadCurrentSessions,
-            allSessionsLoader: context.loadAllSessions,
-            currentSessionFilePath: context.currentSessionFilePath,
-            renameSession: context.renameSession,
-            requestRender: () => this.runtime.requestRender(),
-            onSelect: sessionPath => {
-                close();
-                void this.runWorkflow({ command: "resume", argument: sessionPath });
-            },
-            onCancel: close,
-            onExit: () => {
-                close();
-                void this.shutdown();
-            },
-        });
-        this.root.setInputSurface(component);
-        this.runtime.requestRender();
+    showSessionSelector() {
+        return this.#presenters.openSessionSelector(this.#dialogHost, () => { void this.shutdown(); });
     }
     showSettingsSelector() {
-        const snapshot = this.backend.pinnedSettingsSnapshot();
-        const close = () => {
-            this.root.setInputSurface(null);
-            this.runtime.requestRender();
-        };
-        const { currentModel, ...settingsSnapshot } = snapshot;
-        const component = createPiShellSettingsSelector({
-            config: {
-                ...settingsSnapshot,
-                availableThinkingLevels: [...snapshot.availableThinkingLevels],
-                availableThemes: [...snapshot.availableThemes],
-                warnings: { ...snapshot.warnings },
-                modelThinkingLevels: { ...snapshot.modelThinkingLevels },
-                ...(currentModel === undefined ? {} : { currentModel: currentModel }),
-                availableDefaultModels: snapshot.availableDefaultModels,
-            },
-            onChange: (callback, value) => {
-                if (callback === "onCancel") {
-                    close();
-                    return;
-                }
-                if (callback === "onTuiModeChange") {
-                    // Invariant: the custom bare-A1 surface is permanently fullscreen; this callback
-                    // remains available only to pinned comparison profiles.
-                    if (this.#customViewport)
-                        return;
-                    if (value !== "regular" && value !== "fullscreen")
-                        return;
-                    if (!this.runtime.switchMode(value)) {
-                        this.root.appendWorkflowStatus("Close active overlays before changing TUI mode");
-                        this.runtime.requestRender();
-                        return;
-                    }
-                    if (this.#customViewport) {
-                        this.#pointerReporting = false;
-                        this.#setPointerReporting(true);
-                    }
-                }
-                void this.backend.applyPinnedSettingValue(callback, value).then(result => {
-                    if (result.outcome === "failed")
-                        this.root.appendWorkflowResult(result);
-                    else if (callback === "onTuiModeChange")
-                        this.root.appendWorkflowStatus(`TUI mode: ${value}`);
-                    this.runtime.requestRender();
-                });
-            },
-            onCancel: close,
-        });
-        this.root.setInputSurface(component);
-        this.runtime.requestRender();
+        this.#presenters.openSettingsSelector(this.#dialogHost);
     }
     shutdown() {
         this.#shutdownPromise ??= this.#shutdown();
@@ -1271,7 +1154,13 @@ export class OwnedUiSessionShell {
     }
     async #shutdown() {
         try {
-            const result = await this.backend.executeWorkflow({ command: "quit", argument: "" });
+            const quit = this.backend.workflows.executeWorkflow({ command: "quit", argument: "" });
+            // Invariant: a slow or hung engine quit never holds the terminal past the cleanup deadline. The
+            // shell restores it then, and the result still waits for the engine to finish quitting.
+            const timedOut = await boundedCleanup(() => quit.catch(() => { })).then(() => false, () => true);
+            if (timedOut)
+                await this.dispose();
+            const result = await quit;
             await this.dispose();
             return workflowAdapterResult(result);
         }
@@ -1291,26 +1180,26 @@ export class OwnedUiSessionShell {
                 if (this.#disposed)
                     return;
                 this.root.appendWorkflowResult({ command: "name", outcome: "failed", message: error instanceof Error ? error.message : String(error) });
-                this.runtime.requestRender();
+                this.#terminal.requestRender();
             });
             return { outcome: "completed", diagnostic: null };
         }
-        const copyGeneration = request.command === "copy" ? this.backend.sessionBindingGeneration : undefined;
+        const copyGeneration = request.command === "copy" ? this.backend.identity.sessionBindingGeneration : undefined;
         if (request.command === "login" && request.selection !== undefined) {
-            const setup = this.backend.pinnedAmbientAuthentication(request.selection);
+            const setup = this.backend.catalog.pinnedAmbientAuthentication(request.selection);
             if (setup) {
                 const close = () => {
                     this.root.setInputSurface(null);
-                    this.runtime.requestRender();
+                    this.#terminal.requestRender();
                 };
                 const dialog = createPiShellLoginDialog({
-                    getColumns: () => this.runtime.viewport().columns,
-                    getRows: () => this.runtime.viewport().rows,
-                    requestRender: () => this.runtime.requestRender(),
+                    getColumns: () => this.#terminal.viewport().columns,
+                    getRows: () => this.#terminal.viewport().rows,
+                    requestRender: () => this.#terminal.requestRender(),
                 }, setup.providerId, close, setup.providerName, setup.title);
                 dialog.showInfo(setup.message, [], true);
                 this.root.setInputSurface(dialog);
-                this.runtime.requestRender();
+                this.#terminal.requestRender();
                 return { outcome: "completed", diagnostic: null };
             }
         }
@@ -1362,10 +1251,10 @@ export class OwnedUiSessionShell {
             return { outcome: "completed", diagnostic: null };
         }
         if (request.command === "reload") {
-            const blocked = this.backend.reloadBlockedResult();
+            const blocked = this.backend.workflows.reloadBlockedResult();
             if (blocked) {
                 this.root.appendWorkflowResult(blocked);
-                this.runtime.requestRender();
+                this.#terminal.requestRender();
                 return workflowAdapterResult(blocked);
             }
             this.root.resetExtensionUi();
@@ -1375,20 +1264,20 @@ export class OwnedUiSessionShell {
             : undefined;
         const shareSurface = shareDialog === undefined ? undefined
             : (this.#customViewport ? shareDialog.createPiShellShareOperationDialog : shareDialog.createPiShellOperationLoader)({
-                getColumns: () => this.runtime.viewport().columns,
-                getRows: () => this.runtime.viewport().rows,
-                requestRender: () => this.runtime.requestRender(),
+                getColumns: () => this.#terminal.viewport().columns,
+                getRows: () => this.#terminal.viewport().rows,
+                requestRender: () => this.#terminal.requestRender(),
             }, "Creating gist…");
         const operationSurface = shareSurface ?? (request.command === "reload" ? createPiShellReloadBox() : undefined);
         const now = this.#reloadPresentation?.now ?? Date.now;
         const shownAt = now();
         if (operationSurface) {
             this.root.setInputSurface(operationSurface);
-            this.runtime.requestRender();
+            this.#terminal.requestRender();
         }
         let result;
         try {
-            result = await this.backend.executeWorkflow(shareSurface === undefined ? request : { ...request, signal: shareSurface.signal });
+            result = await this.backend.workflows.executeWorkflow(shareSurface === undefined ? request : { ...request, signal: shareSurface.signal });
         }
         finally {
             if (operationSurface) {
@@ -1397,10 +1286,10 @@ export class OwnedUiSessionShell {
                 if (request.command === "reload")
                     await this.#holdReloadSurface(now() - shownAt);
                 this.root.setInputSurface(null);
-                this.runtime.requestRender();
+                this.#terminal.requestRender();
             }
         }
-        if (copyGeneration !== undefined && (this.#disposed || copyGeneration !== this.backend.sessionBindingGeneration)) {
+        if (copyGeneration !== undefined && (this.#disposed || copyGeneration !== this.backend.identity.sessionBindingGeneration)) {
             return workflowAdapterResult({ command: "copy", outcome: "cancelled", message: "" });
         }
         if (result.outcome === "requires-selection" && request.command === "model") {
@@ -1426,7 +1315,7 @@ export class OwnedUiSessionShell {
         }
         if (result.outcome === "requires-selection" || result.outcome === "requires-confirmation") {
             this.root.appendWorkflowResult({ command: request.command, outcome: "failed", message: `Owned controller missing for ${request.command}` });
-            this.runtime.requestRender();
+            this.#terminal.requestRender();
             return { outcome: "failed", diagnostic: `Owned controller missing for ${request.command}` };
         }
         if (request.command === "reload" && result.outcome === "completed") {
@@ -1445,7 +1334,7 @@ export class OwnedUiSessionShell {
         else {
             this.root.appendWorkflowResult(result);
         }
-        this.runtime.requestRender();
+        this.#terminal.requestRender();
         return workflowAdapterResult(result);
     }
     async #holdReloadSurface(visibleMs) {
@@ -1457,16 +1346,16 @@ export class OwnedUiSessionShell {
         await sleep(remaining);
     }
     showTrustSelector() {
-        const context = this.backend.pinnedProjectTrustContext();
+        const context = this.backend.catalog.pinnedProjectTrustContext();
         const close = () => {
             this.root.setInputSurface(null);
-            this.runtime.requestRender();
+            this.#terminal.requestRender();
         };
         const component = createPiShellTrustSelector({
             ...context,
             onSelect: selection => {
                 try {
-                    this.backend.persistProjectTrust(selection.updates);
+                    this.backend.catalog.persistProjectTrust(selection.updates);
                     close();
                     this.root.appendWorkflowStatus(`Saved trust decision: ${selection.trusted ? "trusted" : "untrusted"}. Restart pi for this to take effect.`);
                 }
@@ -1474,196 +1363,45 @@ export class OwnedUiSessionShell {
                     close();
                     this.root.appendWorkflowResult({ command: "trust", outcome: "failed", message: error instanceof Error ? error.message : String(error) });
                 }
-                this.runtime.requestRender();
+                this.#terminal.requestRender();
             },
             onCancel: close,
         });
         this.root.setInputSurface(component);
-        this.runtime.requestRender();
+        this.#terminal.requestRender();
     }
     showScopedModelsSelector() {
-        const initial = this.backend.pinnedScopedModelsContext();
-        let currentEnabledIds = initial.enabledModelIds === null ? null : [...initial.enabledModelIds];
-        let selectionChanged = false;
-        let disposed = false;
-        let timedOut = false;
-        const controller = new AbortController();
-        const timeout = setTimeout(() => {
-            timedOut = true;
-            controller.abort();
-        }, 15_000);
-        const close = () => {
-            disposed = true;
-            clearTimeout(timeout);
-            controller.abort();
-            this.root.setInputSurface(null);
-            this.runtime.requestRender();
-        };
-        const selector = createPiShellScopedModelsSelector({
-            models: initial.models,
-            enabledModelIds: currentEnabledIds,
-            refreshStatus: "Refreshing model catalogs…",
-            onChange: enabledIds => {
-                selectionChanged = true;
-                currentEnabledIds = enabledIds === null ? null : [...enabledIds];
-                this.backend.updateScopedModels(currentEnabledIds);
-                this.runtime.requestRender();
-            },
-            onPersist: enabledIds => {
-                currentEnabledIds = enabledIds === null ? null : [...enabledIds];
-                this.backend.persistScopedModels(currentEnabledIds);
-                this.root.appendWorkflowStatus("Model selection saved to settings");
-                this.runtime.requestRender();
-            },
-            onCancel: close,
-        });
-        const component = {
-            ...selector,
-            dispose: () => {
-                disposed = true;
-                clearTimeout(timeout);
-                controller.abort();
-                selector.dispose?.();
-            },
-        };
-        this.root.setInputSurface(component);
-        this.runtime.requestRender();
-        void this.backend.refreshScopedModels(controller.signal).then(refreshed => {
-            if (disposed)
-                return;
-            if (!selectionChanged) {
-                currentEnabledIds = refreshed.enabledModelIds === null ? null : [...refreshed.enabledModelIds];
-                component.updateModels(refreshed.models, currentEnabledIds);
-            }
-            else {
-                component.updateModels(refreshed.models);
-                this.backend.updateScopedModels(currentEnabledIds);
-            }
-            component.setRefreshStatus(timedOut ? "Model refresh timed out; showing cached models." : refreshed.status, timedOut ? "warning" : refreshed.statusKind);
-            this.runtime.requestRender();
-        }).catch(error => {
-            if (disposed)
-                return;
-            component.setRefreshStatus(timedOut
-                ? "Model refresh timed out; showing cached models."
-                : `Could not refresh model catalogs: ${error instanceof Error ? error.message : String(error)}`, "warning");
-            this.runtime.requestRender();
-        }).finally(() => clearTimeout(timeout));
+        this.#presenters.openScopedModelsSelector(this.#dialogHost);
     }
     // Invariant: bare A1 routes `models`; the comparison profile keeps the pinned `model`/`scoped-models` pair. Hidden routes are shared.
     #isWorkflowRoute(value) {
         return workflowCommandNames(this.#customViewport ? "bare" : "comparison").includes(value)
-            || PINNED_PI_HIDDEN_COMMAND_NAMES.includes(value);
+            || OWNED_UI_HIDDEN_COMMAND_NAMES.includes(value);
     }
     /** The bare-A1 unified Models dialog: switch on Enter, scope on Space, persist on Ctrl+S, all through the engine. */
     showModelsDialog(initialQuery) {
-        const context = this.backend.modelsContext();
-        const available = new Set(context.models.map(model => `${model.provider}/${model.id}`));
-        const savedScopeIds = context.persistedScopeIds.filter(id => available.has(id));
-        // Invariant: an explicit session scope wins; otherwise the dialog starts from what is persisted, never from "all rows scoped".
-        const scopeIds = context.sessionScopeIds.length > 0 ? context.sessionScopeIds : savedScopeIds;
-        let disposed = false;
-        let timedOut = false;
-        const controller = new AbortController();
-        const timeout = setTimeout(() => {
-            timedOut = true;
-            controller.abort();
-        }, 15_000);
-        const close = () => {
-            disposed = true;
-            clearTimeout(timeout);
-            controller.abort();
-            this.root.setInputSurface(null);
-            this.runtime.requestRender();
-        };
-        const dialog = createPiShellModelsDialog({
-            models: context.models,
-            activeModelId: context.activeModelId,
-            scopeIds,
-            savedScopeIds,
-            ...(initialQuery === undefined ? {} : { initialQuery }),
-            refreshStatus: "Refreshing model catalogs…",
-            requestRender: () => this.runtime.requestRender(),
-            onSelect: modelId => {
-                void this.runWorkflow({ command: "models", argument: "", selection: modelId }).then(result => {
-                    if (!disposed && result.outcome === "completed")
-                        close();
-                });
-            },
-            onScopeChange: ids => {
-                this.backend.setSessionModelScope(ids);
-                this.runtime.requestRender();
-            },
-            onSave: ids => {
-                try {
-                    this.backend.persistModelScope(ids);
-                }
-                catch (error) {
-                    this.root.appendWorkflowResult({ command: "models", outcome: "failed", message: error instanceof Error ? error.message : String(error) });
-                    this.runtime.requestRender();
-                    throw error;
-                }
-                this.root.appendWorkflowStatus("Model selection saved to settings");
-                this.runtime.requestRender();
-            },
-            onCancel: close,
-        });
-        const component = {
-            ...dialog,
-            dispose: () => {
-                disposed = true;
-                clearTimeout(timeout);
-                controller.abort();
-                dialog.dispose?.();
-            },
-        };
-        this.root.setInputSurface(component);
-        this.runtime.requestRender();
-        void this.backend.refreshModels(controller.signal).then(refreshed => {
-            if (disposed)
-                return;
-            component.updateModels(refreshed.models);
-            component.setRefreshStatus(timedOut ? "Model refresh timed out; showing cached models." : refreshed.status, timedOut ? "warning" : refreshed.statusKind);
-            this.runtime.requestRender();
-        }).catch(error => {
-            if (disposed)
-                return;
-            component.setRefreshStatus(timedOut
-                ? "Model refresh timed out; showing cached models."
-                : `Could not refresh model catalogs: ${error instanceof Error ? error.message : String(error)}`, "warning");
-            this.runtime.requestRender();
-        }).finally(() => clearTimeout(timeout));
-    }
-    // Invariant: pointer reporting is disabled on every path that ends the owning screen.
-    #setPointerReporting(enabled, forceOff = false) {
-        const effective = forceOff ? false : this.#customViewport || enabled;
-        if (this.#pointerReporting === effective)
-            return;
-        this.#pointerReporting = effective;
-        if (!this.runtime.active)
-            return;
-        this.runtime.writeControl(effective ? MOUSE_TRACKING_ON : MOUSE_TRACKING_OFF);
+        this.#presenters.openModelsDialog(this.#dialogHost, initialQuery);
     }
+    // Invariant: one teardown per presenter, starting on a microtask so never inside the event listener that
+    // requested it. Callers during the teardown share its outcome; a later call finds it done. Closing the
+    // terminal host's last presenter ends the terminal.
     dispose() {
         if (this.#disposePromise !== undefined)
             return this.#disposePromise;
         if (this.#disposed)
             return Promise.resolve();
-        const pending = Promise.resolve().then(() => this.#dispose());
+        this.#disposed = true;
+        const pending = Promise.resolve().then(() => this.#host.close(this));
         this.#disposePromise = pending;
         const clear = () => { if (this.#disposePromise === pending)
             this.#disposePromise = undefined; };
         void pending.then(clear, clear);
         return pending;
     }
-    async #dispose() {
+    release(terminal) {
+        if (this.#released !== undefined)
+            return { exitText: "", failures: [], settle: async () => [] };
         this.#disposed = true;
-        this.#copyIntentSequence += 1;
-        // Invariant: the outro frame is what the terminal shows now, before any cleanup writes.
-        const outroFrame = this.#captureQuitOutroFrame();
-        this.#responseCopy?.dispose();
-        this.#copyExecutor?.dispose();
-        this.#cancelWaitingImages();
         const failures = [];
         const attempt = (action) => { try {
             action();
@@ -1671,13 +1409,17 @@ export class OwnedUiSessionShell {
         catch (error) {
             failures.push(error);
         } };
+        // Invariant: events stop first, so nothing re-enters the view during history close, outro, or restoration.
+        attempt(() => this.#unsubscribe());
+        this.#copyIntentSequence += 1;
+        this.#responseCopy?.dispose();
+        this.#copyExecutor?.dispose();
+        this.#cancelWaitingImages();
         let pasteCleanup = Promise.resolve();
         let historyCleanup = Promise.resolve(true);
         attempt(() => { historyCleanup = this.#promptHistory?.close() ?? Promise.resolve(true); });
         attempt(() => { pasteCleanup = this.root.disposePendingPastes(); });
         attempt(() => this.root.clearViewportPointerState());
-        attempt(() => this.#setPointerReporting(false, true));
-        attempt(() => this.#removeViewportPreInput());
         attempt(() => this.#streamPresentation.dispose());
         attempt(() => {
             if (this.#startupRouteTimer !== undefined)
@@ -1689,88 +1431,41 @@ export class OwnedUiSessionShell {
         attempt(() => this.#unsubscribePromptImages());
         attempt(() => this.#unsubscribeSkills());
         attempt(() => this.#unsubscribeSettings());
-        let fullscreenExitText = "";
+        let exitText = "";
         attempt(() => {
-            const exitMode = this.backend.disposed ? this.#fullscreenExitOutput : this.backend.pinnedSettingsSnapshot().fullscreenExitOutput;
-            const resume = this.backend.currentSessionResumeMetadata();
+            const exitMode = this.backend.identity.disposed ? this.#fullscreenExitOutput : this.backend.settings.snapshot().fullscreenExitOutput;
+            const resume = this.backend.identity.currentSessionResumeMetadata();
             const resumeHint = resume === null ? "" : `${dim("To resume this session:")} ${formatSessionResumeCommand(resume)}`;
             // Invariant: bare A1 leaves only the hint behind; the pinned comparison profile still
             // honors fullscreenExitOutput, including the styled transcript.
-            fullscreenExitText = this.runtime.mode !== "fullscreen" ? ""
+            exitText = terminal.mode !== "fullscreen" ? ""
                 : this.#customViewport || exitMode === "resume-hint" ? resumeHint
-                    : [this.root.exitTranscript(this.runtime.viewport().columns), resumeHint].filter(Boolean).join("\n\n");
+                    : [this.root.exitTranscript(terminal.columns), resumeHint].filter(Boolean).join("\n\n");
         });
         attempt(() => this.#unbindClipboardWriter());
         attempt(() => this.#unbindPiSettings());
         attempt(() => this.#unbindTerminalSettings());
         attempt(() => this.#unbindShutdownSettings());
-        attempt(() => this.#unsubscribe());
+        attempt(() => this.backend.workflows.setWorkflowInteractionHost(DETACHED_WORKFLOW_INTERACTION));
         attempt(() => this.#dialogHandle?.hide());
         attempt(() => this.#extensionBridge.dispose());
         attempt(() => this.#programStatus.clear());
-        // Invariant: from here to the leave nothing but the outro paints. A throttled frame the
-        // renderer still has queued would otherwise land during the stop-time input drain and
-        // flash the prompt and footer, whether or not an effect plays.
-        attempt(() => this.#freezeQuitPresentation());
-        await this.#playQuitOutro(outroFrame);
-        // Invariant: terminal restoration precedes any potentially stalled backend teardown. The
-        // fullscreen leave preserves the screen: the pinned runtime never dumps its final document
-        // into the parent terminal, so only the configured exit text follows the leave.
-        await this.runtime.dispose({ preserveScreen: this.runtime.mode === "fullscreen" }).catch(error => failures.push(error));
-        await historyCleanup.catch(() => false); // Security: background durability outcomes never enter terminal output.
-        await boundedCleanup(() => pasteCleanup).catch(error => failures.push(error));
-        await boundedCleanup(() => this.backend.unbindExtensionUi()).catch(error => failures.push(error));
-        if (failures.length > 0)
-            throw new AggregateError(failures, "Owned UI disposal failed");
-        if (fullscreenExitText.length > 0)
-            this.runtime.writeAfterStop(`${fullscreenExitText}\n`);
-    }
-    // Invariant: the snapshot is synchronous; the outro module itself loads only at quit.
-    #captureQuitOutroFrame() {
-        const outro = this.#quitOutro;
-        if (outro === undefined || !outro.interactive || !this.#customViewport || this.#damageTerminal === null)
-            return null;
-        if (!this.runtime.active || this.runtime.mode !== "fullscreen")
-            return null;
-        try {
-            if (!outro.snapshot().enabled)
-                return null;
-            const viewport = this.runtime.viewport();
-            return {
-                rows: this.#damageTerminal.presentedRows(), columns: viewport.columns, height: viewport.rows,
-                settings: { effect: QUIT_OUTRO_EFFECT, durationMs: QUIT_OUTRO_DURATION_MS },
-            };
-        }
-        catch {
-            return null;
-        }
-    }
-    #freezeQuitPresentation() {
-        if (!this.#customViewport || !this.runtime.active || this.runtime.mode !== "fullscreen")
-            return;
-        this.runtime.freezePresentation();
-    }
-    // Rationale: any failure here only skips the effect; restoration always follows.
-    async #playQuitOutro(capture) {
-        const outro = this.#quitOutro;
-        if (capture === null || outro === undefined || !this.runtime.active)
-            return;
-        try {
-            // Rationale: the effects stay off the startup graph; quit is the only time they load.
-            const { captureQuitOutroFrame, playQuitOutro } = await import("./quit-outro.js");
-            const frame = captureQuitOutroFrame(capture.rows, capture.columns, capture.height);
-            if (frame === null || !this.runtime.active)
-                return;
-            await playQuitOutro(frame, capture.settings.effect, capture.settings.durationMs, {
-                write: data => this.runtime.writeControl(data),
-                ...(outro.now === undefined ? {} : { now: outro.now }),
-                ...(outro.sleep === undefined ? {} : { sleep: outro.sleep }),
-                ...(outro.seed === undefined ? {} : { seed: outro.seed }),
-            });
-        }
-        catch {
-            // Rationale: a failed or interrupted effect must never hold the terminal; restoration follows.
-        }
+        // Invariant: the host settles a presenter only once the terminal is restored, so these never stall it.
+        const settle = async () => {
+            const settled = [];
+            try {
+                this.root.dispose();
+            }
+            catch (error) {
+                settled.push(error);
+            }
+            await historyCleanup.catch(() => false); // Security: background durability outcomes never enter terminal output.
+            await boundedCleanup(() => pasteCleanup).catch(error => settled.push(error));
+            await boundedCleanup(() => this.backend.extensions.unbindExtensionUi()).catch(error => settled.push(error));
+            return settled;
+        };
+        this.#released = { exitText, failures, settle };
+        return this.#released;
     }
     #settleStoppedLifecycle() {
         void this.dispose().then(() => this.#resolveStoppedLifecycle(), () => this.#resolveStoppedLifecycle());
@@ -1798,9 +1493,9 @@ export class OwnedUiSessionShell {
         return view;
     }
     #syncTerminalProgress(view) {
-        if (!this.runtime.active)
+        if (!this.#terminal.running)
             return;
-        this.runtime.setTerminalProgress(this.#terminalProgressEnabled && view.lifecycle === "busy");
+        this.#terminal.setTerminalProgress(this.#terminalProgressEnabled && view.lifecycle === "busy");
         if (view.lifecycle === "stopped" || view.lifecycle === "stopping") {
             this.#programStatus.clear();
             return;
@@ -1816,17 +1511,17 @@ export class OwnedUiSessionShell {
     #syncView() {
         this.#streamPresentation.noteImmediatePresentation();
         const view = this.view();
-        if (this.backend.sessionGeneration !== this.#sessionGeneration) {
+        if (this.backend.identity.sessionGeneration !== this.#sessionGeneration) {
             this.#copyIntentSequence += 1;
             this.#responseCopy?.reset();
             this.#cancelWaitingImages();
             this.root.resetPendingPastes();
             this.#promptSuggestions?.invalidate();
-            this.#sessionGeneration = this.backend.sessionGeneration;
+            this.#sessionGeneration = this.backend.identity.sessionGeneration;
             this.#programStatus.reset();
             // Invariant: delivery recovery invalidates callbacks, not same-session local recall or its draft.
-            if (this.#sessionBindingGeneration !== this.backend.sessionBindingGeneration) {
-                this.#sessionBindingGeneration = this.backend.sessionBindingGeneration;
+            if (this.#sessionBindingGeneration !== this.backend.identity.sessionBindingGeneration) {
+                this.#sessionBindingGeneration = this.backend.identity.sessionBindingGeneration;
                 this.root.resetTranscript();
                 this.#promptHistory?.reset(view.transcript.flatMap(block => block.kind === "user" ? [block.text] : []));
             }
@@ -1838,7 +1533,6 @@ export class OwnedUiSessionShell {
             this.#dialogHandle = undefined;
             this.#dialogId = undefined;
             this.#dialogSource = undefined;
-            this.#setPointerReporting(false);
             this.root.setInputSurface(null);
             this.root.resetExtensionUi();
             this.root.resetWorkflowPresentation();
@@ -1846,7 +1540,7 @@ export class OwnedUiSessionShell {
         this.root.update(view);
         this.#syncDialog(view.dialog);
         this.#presentStartupTrustWarning(view);
-        this.runtime.requestRender();
+        this.#terminal.requestRender();
         for (const listener of this.#listeners)
             listener(view);
         return view;
@@ -1857,16 +1551,16 @@ export class OwnedUiSessionShell {
         if (this.#startupTrustHandled || !this.#customViewport)
             return;
         const diagnostic = view.diagnostics.find(candidate => candidate.code === "project-trust");
-        if (diagnostic === undefined || !this.runtime.active)
+        if (diagnostic === undefined || !this.#terminal.running)
             return;
         this.#startupTrustHandled = true;
         this.root.appendWorkflowMessage({ kind: "warning", message: diagnostic.message });
     }
     #presentStartupRoute() {
         const pending = this.#startupRoute;
-        if (pending === undefined || this.#disposed || !this.runtime.active)
+        if (pending === undefined || this.#disposed || !this.#terminal.running)
             return;
-        if (this.runtime.hasOverlay() || !this.root.usesDefaultInputSurface()) {
+        if (this.#terminal.hasOverlay() || !this.root.usesDefaultInputSurface()) {
             this.#startupRouteTimer = setTimeout(() => {
                 this.#startupRouteTimer = undefined;
                 this.#presentStartupRoute();
@@ -1881,121 +1575,33 @@ export class OwnedUiSessionShell {
         const surface = this.#routeHost?.open(route, input) ?? null;
         if (surface === null)
             return { outcome: "failed", diagnostic: `route is unavailable: ${route}` };
-        if (!this.runtime.active)
+        if (!this.#terminal.running)
             return { outcome: "failed", diagnostic: "runtime is not active" };
         this.root.dismissNotice();
         this.#dialogHandle?.hide();
         this.#dialogSource = "route";
-        // Protocol: any-event reporting: hover and drag are what the screen is driven by, and
-        // it also stops the terminal treating a drag as a text selection.
-        this.#setPointerReporting(true);
-        // Protocol: the interrupt chord is global, so it is watched on raw input rather than
-        // through the overlay: the pinned shell handles that key before an overlay
-        // ever sees it, which is why an owned screen must not rely on being asked.
-        let armedAt = 0;
-        const removeInterruptWatch = this.runtime.addInputListener(data => {
-            if (!data.includes(INTERRUPT))
-                return undefined;
-            // Protocol: route hosts decide whether one interrupt closes their app. Raw-input forwarding
-            // is required because Pi handles Ctrl+C before the fullscreen overlay receives normal input.
-            const consumedBySurface = surface.handleInput(INTERRUPT);
-            if (surface.isClosed()) {
-                armedAt = 0;
-                closeSurface();
-                return { consume: true };
-            }
-            if (consumedBySurface) {
-                armedAt = 0;
-                this.runtime.requestRender();
-                return { consume: true };
-            }
-            const now = Date.now();
-            if (armedAt !== 0 && now - armedAt <= INTERRUPT_CHORD_MS) {
-                armedAt = 0;
-                closeSurface();
-                void this.shutdown();
-                return { consume: true };
-            }
-            armedAt = now;
-            this.runtime.requestRender();
-            // Invariant: the presented screen owns the chord, so the pinned shell never sees a
-            // stray interrupt while it is up.
-            return { consume: true };
-        });
-        let removeSurfacePreInput = () => { };
-        let rendered = false;
-        let closed = false;
-        const closeSurface = () => {
-            if (closed)
-                return;
-            closed = true;
-            removeSurfacePreInput();
-            removeInterruptWatch();
-            this.#setPointerReporting(false);
-            this.#dialogHandle?.hide();
-            this.#dialogHandle = undefined;
-            this.#dialogId = undefined;
-            this.#dialogSource = undefined;
-            if (rendered) {
-                try {
-                    void onClosed?.()?.catch(() => undefined);
+        const handle = this.#terminal.openRoute(surface, {
+            exit: () => { void this.shutdown(); },
+            closed: rendered => {
+                if (this.#dialogHandle === handle) {
+                    this.#dialogHandle = undefined;
+                    this.#dialogId = undefined;
+                    this.#dialogSource = undefined;
                 }
-                catch { /* Rationale: a failed acknowledgement stays pending. */ }
-            }
-        };
-        // Compatibility: fullscreen Pi owns a fallback text-selection layer before focused overlay
-        // components see pointer input. Route every mouse report to the owned screen
-        // at the pre-input boundary so dropdowns, value hover, and numeric +/- work,
-        // and consume even unhandled reports so settings content is never selected.
-        removeSurfacePreInput = this.runtime.addPreInputListener(data => {
-            const { events, rest } = parseMouseInput(data);
-            if (events.length === 0)
-                return undefined;
-            for (const event of events)
-                surface.handleMouse(event);
-            if (surface.isClosed())
-                closeSurface();
-            else
-                this.runtime.requestRender();
-            return rest.length === 0 ? { consume: true } : { data: rest };
-        });
-        const rows = () => Math.max(1, this.runtime.viewport().rows);
-        const component = {
-            render: (width) => {
-                const frame = [...surface.render(Math.max(1, width), rows())];
-                rendered = true;
-                return frame;
-            },
-            handleInput: (data) => {
-                const { events, rest } = parseMouseInput(data);
-                for (const event of events)
-                    surface.handleMouse(event);
-                if (rest.length > 0)
-                    surface.handleInput(rest);
-                if (surface.isClosed()) {
-                    closeSurface();
-                    return;
+                if (rendered) {
+                    try {
+                        void onClosed?.()?.catch(() => undefined);
+                    }
+                    catch { /* Rationale: a failed acknowledgement stays pending. */ }
                 }
-                this.runtime.requestRender();
             },
-            invalidate: () => this.runtime.requestRender(),
-        };
-        surface.onRenderRequested(() => this.runtime.requestRender());
-        surface.onExitRequested(() => {
-            closeSurface();
-            void this.shutdown();
-        });
-        this.#dialogHandle = this.runtime.showOverlay(component, {
-            width: "100%",
-            maxHeight: "100%",
-            anchor: "top-left",
-            inputCoordination: "owned",
         });
+        this.#dialogHandle = handle;
         this.#dialogId = surface.id;
         return { outcome: "completed", diagnostic: null };
     }
     #syncDialog(dialog) {
-        if (!this.runtime.active)
+        if (!this.#terminal.running)
             return;
         if (dialog === null) {
             // Invariant: locally owned routes (notably /settings) are independent of backend
@@ -2026,7 +1632,7 @@ export class OwnedUiSessionShell {
                 this.#dialogSource = undefined;
             },
         });
-        this.#dialogHandle = this.runtime.showOverlay(component, {
+        this.#dialogHandle = this.#terminal.showOverlay(component, {
             width: "70%",
             maxHeight: "80%",
             anchor: "center",
@@ -2059,24 +1665,24 @@ export class OwnedUiSessionShell {
         return this.#execute({
             type: this.view().lifecycle === "busy" ? "steer" : "prompt",
             correlationId: this.#correlation("prompt-command"),
-            sessionId: this.backend.sessionId,
+            sessionId: this.backend.identity.sessionId,
             text,
         });
     }
     #installAutocompleteCommands() {
-        this.root.editor.setAutocompleteCommands(this.backend.workflowAutocompleteCommands());
+        this.root.editor.setAutocompleteCommands(this.backend.workflows.workflowAutocompleteCommands());
         this.#installedCommandSignature = this.#commandListSignature();
     }
     #commandListSignature() {
-        return JSON.stringify([this.#skills?.presentation() ?? "expand", this.backend.disposed ? [] : this.backend.workflowAutocompleteCommands().map(command => command.name)]);
+        return JSON.stringify([this.#skills?.presentation() ?? "expand", this.backend.identity.disposed ? [] : this.backend.workflows.workflowAutocompleteCommands().map(command => command.name)]);
     }
     // Invariant: collapse applies only while the engine registers skill commands; otherwise there is nothing to collapse.
     #skillsCollapsed() {
         return this.#skills !== null && this.#skills.presentation() === "collapse"
-            && !this.backend.disposed && this.backend.pinnedSettingsSnapshot().enableSkillCommands;
+            && !this.backend.identity.disposed && this.backend.settings.snapshot().enableSkillCommands;
     }
     #skillSummaries() {
-        return skillsFromCommands(this.backend.workflowAutocompleteCommands());
+        return skillsFromCommands(this.backend.workflows.workflowAutocompleteCommands());
     }
     // Protocol: bare "/skills" opens the dialog, "/skills <name> [args]" applies directly, and an unknown name is a command outcome.
     async #runSkillsCommand(text, argument) {
@@ -2092,7 +1698,7 @@ export class OwnedUiSessionShell {
         if (skill === undefined) {
             const message = "Unknown skill: " + token;
             this.root.appendWorkflowMessage({ kind: "error", message });
-            this.runtime.requestRender();
+            this.#terminal.requestRender();
             return { outcome: "failed", diagnostic: message };
         }
         return this.#submitSkillPrompt(skillPrompt(skill.name, separator < 0 ? "" : trimmed.slice(separator + 1)), text);
@@ -2104,14 +1710,14 @@ export class OwnedUiSessionShell {
         return this.#execute({
             type: this.view().lifecycle === "busy" ? "steer" : "prompt",
             correlationId: this.#correlation("prompt-command"),
-            sessionId: this.backend.sessionId,
+            sessionId: this.backend.identity.sessionId,
             text: prompt,
         });
     }
     #treeSummary() {
         return new Promise(resolve => {
             this.root.setInputSurface(createPiShellExtensionSelector("Summarize Branch?", ["No summary", "Summarize", "Summarize with custom prompt"], resolve, () => resolve(undefined)), true, "opaque");
-            this.runtime.requestRender();
+            this.#terminal.requestRender();
         });
     }
     async #completeTreeSelection(entryId, skipSummaryPrompt) {
@@ -2134,7 +1740,7 @@ export class OwnedUiSessionShell {
             }
         }
         this.root.setInputSurface(null);
-        this.runtime.requestRender();
+        this.#terminal.requestRender();
         const result = await this.runWorkflow({
             command: "tree",
             argument: "",
@@ -2150,9 +1756,9 @@ export class OwnedUiSessionShell {
     #startWorkflowLogin(request) {
         this.#finishWorkflowLogin();
         const dialog = createPiShellLoginDialog({
-            getColumns: () => this.runtime.viewport().columns,
-            getRows: () => this.runtime.viewport().rows,
-            requestRender: () => this.runtime.requestRender(),
+            getColumns: () => this.#terminal.viewport().columns,
+            getRows: () => this.#terminal.viewport().rows,
+            requestRender: () => this.#terminal.requestRender(),
         }, request.providerId, success => {
             if (!success)
                 this.#finishWorkflowLogin();
@@ -2164,7 +1770,7 @@ export class OwnedUiSessionShell {
             message: `Log in to ${request.providerName}`,
         });
         this.#syncTerminalProgress(this.view());
-        this.runtime.requestRender();
+        this.#terminal.requestRender();
     }
     #requestWorkflowInput(request) {
         const dialog = this.#activeLoginDialog;
@@ -2177,7 +1783,7 @@ export class OwnedUiSessionShell {
                 const restoreDialog = () => {
                     if (this.#activeLoginDialog === dialog)
                         this.root.setInputSurface(dialog);
-                    this.runtime.requestRender();
+                    this.#terminal.requestRender();
                 };
                 const selector = createPiShellExtensionSelector(request.message, labels, label => {
                     const id = options.find(option => option.label === label)?.id;
@@ -2188,13 +1794,13 @@ export class OwnedUiSessionShell {
                     resolve(null);
                 });
                 this.root.setInputSurface(selector, false);
-                this.runtime.requestRender();
+                this.#terminal.requestRender();
             });
         }
         const response = request.type === "manual-code"
             ? dialog.showManualInput(request.message)
             : dialog.showPrompt(request.message, request.placeholder);
-        this.runtime.requestRender();
+        this.#terminal.requestRender();
         return response.then(value => value, () => null);
     }
     #notifyWorkflowLogin(event) {
@@ -2213,7 +1819,7 @@ export class OwnedUiSessionShell {
             dialog.showWaiting(event.message);
         else
             dialog.showProgress(event.message);
-        this.runtime.requestRender();
+        this.#terminal.requestRender();
     }
     #finishWorkflowLogin() {
         if (!this.#activeLoginDialog)
@@ -2222,11 +1828,11 @@ export class OwnedUiSessionShell {
         this.root.setInputSurface(null);
         this.#programStatus.setBlocked("authentication", undefined);
         this.#syncTerminalProgress(this.view());
-        this.runtime.requestRender();
+        this.#terminal.requestRender();
     }
     async #execute(command, draft) {
         if (draft === undefined)
-            return this.backend.execute(command);
+            return this.backend.session.execute(command);
         const revision = this.#editorRevision;
         try {
             assertOwnedUiCommand(command);
@@ -2235,7 +1841,7 @@ export class OwnedUiSessionShell {
             return this.#recoverSubmission(draft, revision, error);
         }
         try {
-            const result = await this.backend.execute(command);
+            const result = await this.backend.session.execute(command);
             if (result.outcome === "rejected")
                 return this.#recoverSubmission(draft, revision);
             return result;
@@ -2276,18 +1882,41 @@ export class OwnedUiSessionShell {
         try {
             this.root.appendWorkflowResult({ command: "debug", outcome: "failed", message: message
                     ?? (error instanceof ImageAttachmentError ? error.message : "Submission failed. Check the prompt and try again.") }, error instanceof ImageAttachmentError ? error.code : undefined);
-            this.runtime.requestRender();
+            this.#terminal.requestRender();
         }
         catch { /* Security: error presentation cannot create another rejected submission callback. */ }
     }
     #simple(type) {
-        return { type, correlationId: this.#correlation(type), sessionId: this.backend.sessionId };
+        return { type, correlationId: this.#correlation(type), sessionId: this.backend.identity.sessionId };
     }
     #correlation(prefix) {
         this.#sequence += 1;
         return `pi-shell-${prefix}-${this.#sequence}`;
     }
 }
+/**
+ * One session on a terminal of its own: a terminal host with this presenter attached. Disposing it ends the
+ * terminal, as quitting the single-session product does.
+ */
+export class OwnedUiSessionShell extends OwnedUiSessionPresenter {
+    constructor(options) {
+        const host = new OwnedUiTerminalHost(sessionTerminalHostOptions(options));
+        try {
+            super(host, options);
+        }
+        catch (error) {
+            void host.dispose().catch(() => { });
+            throw error;
+        }
+        host.attach(this);
+    }
+    get runtime() {
+        return this.terminalHost.runtime;
+    }
+    damagePresentationDecision() {
+        return this.terminalHost.damagePresentationDecision;
+    }
+}
 function isCoalescedStreamBlock(kind) {
     return kind === "assistant" || kind === "thinking" || kind === "tool-call" || kind === "tool-result";
 }
@@ -2317,14 +1946,6 @@ export function quoteCommandArgument(value) {
 function dim(value) {
     return `\u001b[2m${value}\u001b[22m`;
 }
-function modelReference(model) {
-    if (typeof model !== "object" || model === null)
-        return "";
-    const value = model;
-    const provider = typeof value.provider === "string" ? value.provider : "";
-    const id = typeof value.id === "string" ? value.id : typeof value.modelId === "string" ? value.modelId : "";
-    return provider && id ? `${provider}/${id}` : "";
-}
 function rejected(diagnostic) {
     return { outcome: "rejected", diagnostic };
 }
@@ -2338,9 +1959,4 @@ function workflowAdapterResult(result) {
         return { outcome: "failed", diagnostic: result.message };
     return { outcome: "rejected", diagnostic: result.message };
 }
-const INTERRUPT = "\u0003";
-const INTERRUPT_CHORD_MS = 1_500;
 const RELOAD_SURFACE_MIN_VISIBLE_MS = 400;
-// Rationale: the outro is not configurable; the switch only decides whether this plan plays.
-const QUIT_OUTRO_EFFECT = "fall";
-const QUIT_OUTRO_DURATION_MS = 800;