@timurproko/a1 0.2.7-dev.1252 → 0.2.7-dev.1255

package/dist/app/session-shell/session-viewport-controller.d.ts

@@ -1,12 +1,12 @@
-import type { PiTuiPointerSurface } from "../../integrations/pi/tui-runtime/contracts.js";
+import type { OwnedUiShellEditorPort } from "../../contracts/owned-ui/index.js";
+import type { TerminalPointerSurface } from "../../contracts/presentation/index.js";
 import type { OwnedUiViewportSettings } from "../../contracts/owned-ui/index.js";
 import { type TranscriptViewportFrame, type TranscriptViewportFrameInput } from "../../ui/components/transcript-viewport.js";
 import type { SelectionCopySnapshot } from "../../ui/components/selection-copy.js";
-import type { PiShellEditorPort } from "../../integrations/pi/components/shell-shared-facade.js";
 import type { PasteEvent } from "./paste-protocol.js";
-export interface SessionViewportControllerOptions {
+interface SessionViewportControllerOptions {
     readonly enabled: boolean;
-    readonly editor: PiShellEditorPort;
+    readonly editor: OwnedUiShellEditorPort;
     readonly requestRender: (force?: boolean) => void;
     readonly requestHyperlinkCleanup?: (rows?: readonly number[]) => void;
     /** Whether mutable editor URL chips need targeted link-cell cleanup on deletion. */
@@ -61,8 +61,8 @@ export declare class SessionViewportController {
     tailControlHovered(target: TailControlRegion | undefined): boolean;
     /** Replacement input changed before its new bounds have been painted. */
     invalidateInputSurface(): void;
-    setInputSurfaceFrame(surface: PiTuiPointerSurface | undefined): void;
-    setOverlaySurfaces(surfaces: readonly PiTuiPointerSurface[] | null): void;
+    setInputSurfaceFrame(surface: TerminalPointerSurface | undefined): void;
+    setOverlaySurfaces(surfaces: readonly TerminalPointerSurface[] | null): void;
     get inputGeometryReady(): boolean;
     compose(input: Omit<TranscriptViewportFrameInput, "pointerPosition">): TranscriptViewportFrame;
     composeDockOnly(dockRows: readonly string[], width: number, height: number, copyableDockRows?: TranscriptViewportFrameInput["copyableDockRows"]): TranscriptViewportFrame | null;
@@ -74,3 +74,4 @@ export declare class SessionViewportController {
     clearPointerState(): void;
     handlePreInput(data: string, allowWheel?: boolean, now?: number, editorActive?: boolean): SessionViewportInputResult;
 }
+export {};

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

@@ -1,4 +1,4 @@
-import { samePointerSurfaces } from "../../integrations/pi/tui-runtime/overlay-geometry.js";
+import { samePointerSurfaces } from "../../contracts/presentation/index.js";
 import { TranscriptViewport } from "../../ui/components/transcript-viewport.js";
 import { readVisibleHyperlinks } from "../../ui/components/visible-hyperlinks.js";
 import { routeMouseInput } from "../../ui/components/mouse.js";
@@ -657,6 +657,6 @@ export class SessionViewportController {
 const SELECTION_AUTO_SCROLL_INTERVAL_MS = 30;
 const EDITOR_LINK_DELETION_INPUTS = new Set(["\b", "\u007f", "\u001b[3~"]);
 // Platform: Windows Terminal may consume Shift+Arrow for native selection. Ctrl+Arrow matches
-// solo A1's Windows binding while retaining Shift+Arrow whenever the terminal delivers it.
+// A1's Windows binding while retaining Shift+Arrow whenever the terminal delivers it.
 const PROMPT_UP_INPUTS = new Set(["\u001b[1;2A", "\u001b[1;5A"]);
 const PROMPT_DOWN_INPUTS = new Set(["\u001b[1;2B", "\u001b[1;5B"]);

package/dist/app/session-shell/settings-bindings.d.ts

@@ -1,8 +1,8 @@
-import type { OwnedUiSessionSettingsPort, OwnedUiSessionSettingsSnapshot } from "../../contracts/owned-ui/index.js";
+import type { OwnedUiSessionSettingsPort, OwnedUiSessionSettingsSnapshot, OwnedUiViewportSettingsPort } from "../../contracts/owned-ui/index.js";
 import type { OwnedUiPresenterTerminal } from "./shell-host.js";
 import type { OwnedUiSessionShellRoot } from "./session-shell-root.js";
 /** What the session's live setting effects reach: terminal modes, root presentation, and the presenter's progress flag. */
-export interface SessionSettingsTargets {
+interface SessionSettingsTargets {
     readonly terminal: Pick<OwnedUiPresenterTerminal, "setHardwareCursor" | "setClearOnShrink" | "setWheelScrollLines">;
     readonly root: Pick<OwnedUiSessionShellRoot, "setEditorPaddingX" | "setAutocompleteMaxVisible" | "setOutputPad" | "setHideThinkingBlock" | "setMermaidRenderingMode" | "setImagePresentation" | "setFullscreenCopyOnSelect">;
     setTerminalProgress(enabled: boolean): void;
@@ -15,3 +15,25 @@ export interface SessionSettingsTargets {
 export declare function bindSessionSettings(settings: Pick<OwnedUiSessionSettingsPort, "bindOwner" | "productMode">, snapshot: OwnedUiSessionSettingsSnapshot, targets: SessionSettingsTargets, options: {
     readonly customViewport: boolean;
 }): () => void;
+/** The shell's own live setting sources besides the session settings; absent sources bind nothing. */
+export interface ShellSettingSources {
+    readonly customViewport: boolean;
+    readonly promptImages: {
+        onChange(listener: () => void): () => void;
+    } | null;
+    readonly skills: {
+        onChange(listener: () => void): () => void;
+    } | null;
+    readonly viewport: OwnedUiViewportSettingsPort | undefined;
+    readonly historyScope: ((listener: (scope: "unique" | "shared") => void) => () => void) | undefined;
+}
+/** What those sources change: the prompt-image notice, the command menu, the viewport, and the transcript binding. */
+export interface ShellSettingEffects {
+    readonly root: Pick<OwnedUiSessionShellRoot, "setViewportConfig">;
+    promptImageLimitChanged(): void;
+    skillsChanged(): void;
+    historyScopeChanged(scope: "unique" | "shared"): void;
+}
+/** Seeds the viewport and subscribes every shell setting source; the returned release undoes all of them. */
+export declare function bindShellSettings(sources: ShellSettingSources, effects: ShellSettingEffects): () => void;
+export {};

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

@@ -89,3 +89,27 @@ export function bindSessionSettings(settings, snapshot, targets, options) {
     }
     return release;
 }
+/** Seeds the viewport and subscribes every shell setting source; the returned release undoes all of them. */
+export function bindShellSettings(sources, effects) {
+    const releases = [];
+    const release = () => { for (const unbind of releases.splice(0).reverse())
+        unbind(); };
+    try {
+        if (sources.promptImages !== null)
+            releases.push(sources.promptImages.onChange(() => effects.promptImageLimitChanged()));
+        // 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.
+        if (sources.skills !== null)
+            releases.push(sources.skills.onChange(() => effects.skillsChanged()));
+        effects.root.setViewportConfig(sources.viewport?.snapshot() ?? { scrollbarAppearance: "auto", scrollbarStyle: "thin", scrollbarSpeed: "normal" });
+        if (sources.customViewport && sources.viewport !== undefined)
+            releases.push(sources.viewport.onChange(settings => effects.root.setViewportConfig(settings)));
+        if (sources.customViewport && sources.historyScope !== undefined)
+            releases.push(sources.historyScope(scope => effects.historyScopeChanged(scope)));
+    }
+    catch (error) {
+        release();
+        throw error;
+    }
+    return release;
+}

package/dist/app/session-shell/share-operation.d.ts

@@ -1,3 +1,3 @@
-import { createPiShellOperationLoader, createPiShellShareOperationDialog } from "../../integrations/pi/components/index.js";
-export { createPiShellOperationLoader, createPiShellShareOperationDialog };
-export declare function renderPiShellShareResult(message: string, gistUrl: string): string;
+import type { UiTheme } from "../../contracts/presentation/index.js";
+/** The completed share result in bare A1: dim labels with the share and gist URLs made clickable. */
+export declare function renderShellShareResult(message: string, gistUrl: string, theme: UiTheme, hyperlink: (url: string) => string): string;

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

@@ -1,11 +1,9 @@
-import { createPiShellOperationLoader, createPiShellShareOperationDialog, piShellHyperlink, piTheme, } from "../../integrations/pi/components/index.js";
 import { nativeHyperlinkStyle } from "../../ui/components/index.js";
-export { createPiShellOperationLoader, createPiShellShareOperationDialog };
-export function renderPiShellShareResult(message, gistUrl) {
-    const theme = piTheme();
+/** The completed share result in bare A1: dim labels with the share and gist URLs made clickable. */
+export function renderShellShareResult(message, gistUrl, theme, hyperlink) {
     const match = /^Share URL: (\S+)$/u.exec(message);
     const linked = match === null
         ? theme.fg("dim", message)
-        : `${theme.fg("dim", "Share URL: ")}${piShellHyperlink(match[1])}`;
-    return nativeHyperlinkStyle(`${linked}\n${theme.fg("dim", "Gist: ")}${piShellHyperlink(gistUrl)}`, text => theme.fg("mdLink", text));
+        : `${theme.fg("dim", "Share URL: ")}${hyperlink(match[1])}`;
+    return nativeHyperlinkStyle(`${linked}\n${theme.fg("dim", "Gist: ")}${hyperlink(gistUrl)}`, text => theme.fg("mdLink", text));
 }

package/dist/app/session-shell/shell-clipboard.d.ts

@@ -0,0 +1,59 @@
+import { type OwnedUiShellClipboardContent } from "../../contracts/owned-ui/index.js";
+import type { OwnedUiClipboardServices } from "./clipboard-services.js";
+import type { PastePreparationClientOptions } from "./paste-preparation-client.js";
+import type { PasteSource } from "./paste-protocol.js";
+import { ResponseCopyCoordinator } from "./response-copy-coordinator.js";
+import type { SelectionCopySnapshot } from "../../ui/components/index.js";
+import { type CopyResult, type ResponseCopyEvent } from "./response-copy-protocol.js";
+import { type ResponseCopyExecutor } from "./response-copy-transport.js";
+/** A platform clipboard seam; production reads and writes through A1's system clipboard adapter. */
+export interface OwnedUiClipboardPort {
+    readText(signal?: AbortSignal): Promise<string | null>;
+    readImage?(signal?: AbortSignal): Promise<{
+        readonly data: string;
+        readonly mimeType: string;
+    } | null>;
+    writeText?(text: string, signal?: AbortSignal): Promise<void>;
+}
+/** What one shell's clipboard needs: the borrowed process-wide helpers, its terminal, and optional test seams. */
+export interface ShellClipboardOptions {
+    /** Bare A1 owns response copy; comparison profiles keep the terminal-control write. */
+    readonly ownedCopy: boolean;
+    readonly shared?: OwnedUiClipboardServices;
+    readonly clipboard?: OwnedUiClipboardPort;
+    readonly responseCopy?: {
+        readonly execute?: ResponseCopyExecutor;
+        readonly onEvent?: (event: ResponseCopyEvent) => void;
+    };
+    readonly pastePreparation?: Omit<PastePreparationClientOptions, "onEvent" | "spareIdleMs">;
+    /** True when a test terminal stands in for the process terminal. */
+    readonly substituteTerminal: boolean;
+    readonly disposed: () => boolean;
+    /** Whether the shell's terminal is running and attached. */
+    readonly terminalAttached: () => boolean;
+    readonly writeControl: (control: string) => void;
+}
+/**
+ * One shell's clipboard: response copy, the comparison write path, clipboard reads, and paste capture. It
+ * borrows the process-wide helper pools from composition and never disposes them.
+ */
+export declare class ShellClipboard {
+    #private;
+    /** Null in comparison profiles, which keep the pinned terminal-control write. */
+    readonly responseCopy: ResponseCopyCoordinator | null;
+    constructor(options: ShellClipboardOptions);
+    /** Paste-preparation options carrying the shared paste pool, or undefined when neither is supplied. */
+    pastePreparation(): Omit<PastePreparationClientOptions, "onEvent" | "spareIdleMs"> | undefined;
+    /** Copies text: through owned response copy when present, otherwise the comparison terminal-control write. */
+    copyText(text: string): Promise<CopyResult> | undefined;
+    /** Copies a selection after any pending comparison write has settled. */
+    copySelection(snapshot: SelectionCopySnapshot): Promise<CopyResult> | undefined;
+    /** Reads the clipboard once any write this shell started has settled. */
+    readContent(signal?: AbortSignal): Promise<OwnedUiShellClipboardContent | null>;
+    capturePaste(): PasteSource;
+    /** The extension clipboard writer: true once delivered, false when submitted without confirmation. */
+    writeForExtension(text: string): Promise<boolean>;
+    warm(): void;
+    reset(): void;
+    dispose(): void;
+}

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

@@ -0,0 +1,119 @@
+import { ImageAttachmentError } from "../../contracts/owned-ui/index.js";
+import { runImageWorker } from "./image-preparation-client.js";
+import { ResponseCopyCoordinator } from "./response-copy-coordinator.js";
+import { MAX_COPY_CONTROL_BYTES } from "./response-copy-protocol.js";
+import { createResponseCopyExecutor, responseCopyDestination } from "./response-copy-transport.js";
+import { writeSystemClipboardText } from "./system-clipboard.js";
+/**
+ * One shell's clipboard: response copy, the comparison write path, clipboard reads, and paste capture. It
+ * borrows the process-wide helper pools from composition and never disposes them.
+ */
+export class ShellClipboard {
+    /** Null in comparison profiles, which keep the pinned terminal-control write. */
+    responseCopy;
+    #options;
+    #executor;
+    #pendingWrite = Promise.resolve();
+    constructor(options) {
+        this.#options = options;
+        const { clipboard, shared, responseCopy } = options;
+        this.#executor = !options.ownedCopy || responseCopy?.execute !== undefined ? undefined : createResponseCopyExecutor({
+            ...(shared === undefined ? {} : { pool: shared.copy }),
+            ...(!options.substituteTerminal && clipboard === undefined ? {} : { destination: "terminal" }),
+            ...(clipboard?.writeText === undefined ? {} : { writeText: (text, signal) => clipboard.writeText(text, signal) }),
+            // Invariant: the owned host is the route contract. Pseudoterminal children must not infer
+            // clipboard reachability from Node's view of stdout, and inactive shells are fenced here.
+            terminal: { submit: async (control, signal) => {
+                    if (signal.aborted || options.disposed() || !options.terminalAttached())
+                        throw new Error("Copy canceled");
+                    // Performance: never grow the real terminal's pending buffer with another clipboard payload.
+                    if (!options.substituteTerminal && process.stdout.writableLength + control.length > MAX_COPY_CONTROL_BYTES) {
+                        throw new Error("Clipboard terminal is busy");
+                    }
+                    options.writeControl(control);
+                } },
+        });
+        this.responseCopy = !options.ownedCopy ? null : new ResponseCopyCoordinator({
+            execute: responseCopy?.execute ?? this.#executor,
+            ...(responseCopy?.onEvent === undefined ? {} : { onEvent: responseCopy.onEvent }),
+        });
+    }
+    /** Paste-preparation options carrying the shared paste pool, or undefined when neither is supplied. */
+    pastePreparation() {
+        const { pastePreparation, shared } = this.#options;
+        if (pastePreparation === undefined && shared === undefined)
+            return undefined;
+        return { ...pastePreparation, ...(shared === undefined ? {} : { pool: shared.paste }) };
+    }
+    /** Copies text: through owned response copy when present, otherwise the comparison terminal-control write. */
+    copyText(text) {
+        if (this.responseCopy !== null)
+            return this.responseCopy.submitText(text);
+        const { clipboard } = this.#options;
+        const write = () => {
+            if (this.#options.disposed())
+                return Promise.resolve();
+            this.#options.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.
+        this.#pendingWrite = write().catch(() => { });
+        return undefined;
+    }
+    /** Copies a selection after any pending comparison write has settled. */
+    copySelection(snapshot) {
+        return this.responseCopy?.submit(snapshot, this.#pendingWrite);
+    }
+    /** Reads the clipboard once any write this shell started has settled. */
+    async readContent(signal = new AbortController().signal) {
+        await this.#pendingWrite;
+        return this.#read(signal);
+    }
+    capturePaste() {
+        const before = this.responseCopy?.capturePasteBarrier() ?? (async () => true);
+        if (this.#options.clipboard !== undefined)
+            return { kind: "provided", read: signal => this.#read(signal), before };
+        if (responseCopyDestination(process.env) === "terminal")
+            return {
+                kind: "provided", before, read: async () => { throw new ImageAttachmentError("paste-unavailable"); },
+            };
+        return { kind: "native", before };
+    }
+    /** The extension clipboard writer: true once delivered, false when submitted without confirmation. */
+    async writeForExtension(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");
+    }
+    warm() { this.#executor?.warm(); }
+    reset() { this.responseCopy?.reset(); }
+    dispose() {
+        this.responseCopy?.dispose();
+        this.#executor?.dispose();
+    }
+    async #read(signal) {
+        if (signal.aborted)
+            throw new ImageAttachmentError("image-canceled");
+        const { clipboard } = this.#options;
+        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 };
+    }
+}

package/dist/app/session-shell/shell-editor-factory.d.ts

@@ -1,14 +1,17 @@
-import { type PiShellEditorOptions, type PiShellEditorPort } from "../../integrations/pi/components/shell-shared-facade.js";
+import type { OwnedUiShellComponents, OwnedUiShellEditorOptions, OwnedUiShellEditorPort } from "../../contracts/owned-ui/index.js";
+import type { ThemeSource } from "../../contracts/presentation/index.js";
 import type { PasteEvent, PasteSource } from "./paste-protocol.js";
 import type { PromptChipStore } from "./prompt-chips.js";
 /** The shell callbacks the editor is wired to; the editor receives the whole object as its own options. */
-export type ShellEditorHandlers = Omit<PiShellEditorOptions, "onChange" | "onToolsExpand" | "keybindingProfile"> & {
+type ShellEditorHandlers = Omit<OwnedUiShellEditorOptions, "onChange" | "onToolsExpand" | "keybindingProfile"> & {
     readonly requestRender: (force?: boolean) => void;
     readonly onEditorChange?: (text: string) => void;
     readonly captureClipboardPaste?: () => PasteSource;
     readonly pasteDiagnostics?: (event: PasteEvent) => void;
 };
-export interface ShellEditorPorts {
+interface ShellEditorPorts {
+    readonly theme: ThemeSource;
+    readonly components: Pick<OwnedUiShellComponents, "editor" | "text">;
     readonly handlers: ShellEditorHandlers;
     readonly customViewport: boolean;
     readonly cwd: string;
@@ -24,4 +27,5 @@ export interface ShellEditorPorts {
  * Builds the session's prompt editor: chip-aware paste, selection, and hyperlink decoration over
  * the Pi editor, plus bare A1's prompt presentation and terminal paste diagnostics.
  */
-export declare function createShellEditor(ports: ShellEditorPorts): PiShellEditorPort;
+export declare function createShellEditor(ports: ShellEditorPorts): OwnedUiShellEditorPort;
+export {};

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

@@ -3,9 +3,6 @@ import { PromptInput } from "../../ui/components/prompt-input.js";
 import { backgroundSgrSpan, hyperlinkSgrSpan } from "../../ui/components/spans.js";
 import { faint, stripAnsi } from "../../ui/components/text.js";
 import { paintTextSelection } from "../../ui/components/text-selection.js";
-import { createPiShellEditor } from "../../integrations/pi/components/shell-editor-autocomplete.js";
-import { piTheme } from "../../integrations/pi/components/upstream/theme/theme.js";
-import { piShellTruncateToWidth, piShellVisibleWidth, } from "../../integrations/pi/components/shell-shared-facade.js";
 import { EditorHyperlinkBudget } from "./editor-hyperlink-budget.js";
 import { canPreparePasteInline } from "./paste-text-preparation.js";
 /**
@@ -15,13 +12,14 @@ import { canPreparePasteInline } from "./paste-text-preparation.js";
 export function createShellEditor(ports) {
     const { handlers, customViewport, promptChips } = ports;
     let terminalPasteDiagnosticRequest;
-    const editor = createPiShellEditor({
+    const { visibleWidth, truncateToWidth } = ports.components.text;
+    const editor = ports.components.editor.create({
         ...handlers,
         keybindingProfile: customViewport ? "a1" : "pi",
         ...(handlers.keybindings === undefined ? {} : { keybindings: handlers.keybindings }),
         paintEditorSelection: (line, from, to, atomic) => atomic
-            ? backgroundSgrSpan(line, from, to, "\u001b[7m", "\u001b[27m", piShellVisibleWidth)
-            : paintTextSelection(line, from, to, piShellVisibleWidth, true),
+            ? backgroundSgrSpan(line, from, to, "\u001b[7m", "\u001b[27m", visibleWidth)
+            : paintTextSelection(line, from, to, visibleWidth, true),
         transformPastedContent: content => {
             try {
                 return promptChips.transformPastedContent(content, editor.getText());
@@ -50,16 +48,16 @@ export function createShellEditor(ports) {
         } : {}),
         editorAtomicRanges: line => promptChips.atomicRanges(line),
         editorHiddenRanges: line => promptChips.hiddenRanges(line),
-        decorateEditorRow: editorRowDecorator(promptChips, ports.editorPointerSelecting),
+        decorateEditorRow: editorRowDecorator(promptChips, ports.editorPointerSelecting, visibleWidth),
         expandCopiedEditorText: text => promptChips.expandCopiedText(text),
         cwd: ports.cwd,
         ...(ports.agentDir === undefined ? {} : { agentDir: ports.agentDir }),
         onToolsExpand: () => ports.toggleToolsExpanded(),
         ...(customViewport ? {
             promptPresentation: {
-                input: new PromptInput({ fg: (token, text) => piTheme().fg(token, text) }, {
-                    measure: piShellVisibleWidth,
-                    truncate: piShellTruncateToWidth,
+                input: new PromptInput({ fg: (token, text) => ports.theme.current().fg(token, text) }, {
+                    measure: visibleWidth,
+                    truncate: truncateToWidth,
                 }),
                 styleSuggestion: faint,
                 styleSuggestionCaret: caretCell,
@@ -78,17 +76,17 @@ export function createShellEditor(ports) {
  * Dims unsent chips and turns the draft's URLs into terminal hyperlinks, each target once per
  * decoration pass; while a pointer drag selects, links paint as plain underlines instead.
  */
-function editorRowDecorator(promptChips, editorPointerSelecting) {
+function editorRowDecorator(promptChips, editorPointerSelecting, visibleWidth) {
     const editorHyperlinks = new EditorHyperlinkBudget();
     return (row, width, rowIndex) => {
         if (rowIndex === 0)
             editorHyperlinks.reset();
         const plain = stripAnsi(row);
-        const dimmed = promptChips.unsentRanges(plain).reduce((result, range) => backgroundSgrSpan(result, piShellVisibleWidth(plain.slice(0, range.start)), piShellVisibleWidth(plain.slice(0, range.end)), "\u001b[2m", "\u001b[22m", piShellVisibleWidth), row);
+        const dimmed = promptChips.unsentRanges(plain).reduce((result, range) => backgroundSgrSpan(result, visibleWidth(plain.slice(0, range.start)), visibleWidth(plain.slice(0, range.end)), "\u001b[2m", "\u001b[22m", visibleWidth), row);
         const ranges = promptChips.hyperlinkRanges(plain);
         if (ranges.length === 0 || !editorHyperlinks.takeCleanup())
             return dimmed;
-        const linkResetAndTail = `\u001b]8;;\u001b\\\u001b[24m${" ".repeat(Math.max(0, width - piShellVisibleWidth(dimmed)))}`;
+        const linkResetAndTail = `\u001b]8;;\u001b\\\u001b[24m${" ".repeat(Math.max(0, width - visibleWidth(dimmed)))}`;
         // Platform: VS15 is zero-column and default-ignorable. It breaks Windows Terminal's
         // plain-text URL detector only in the held-button paint; semantic text stays exact.
         const selecting = editorPointerSelecting();
@@ -96,8 +94,8 @@ function editorRowDecorator(promptChips, editorPointerSelecting) {
             ? dimmed.replaceAll("https://", "https:︎//").replaceAll("http://", "http:︎//")
             : dimmed;
         const decorated = selecting
-            ? ranges.reduce((result, range) => backgroundSgrSpan(result, piShellVisibleWidth(plain.slice(0, range.start)), piShellVisibleWidth(plain.slice(0, range.end)), "\u001b[4:4m", "\u001b[24m", piShellVisibleWidth), paintRow)
-            : ranges.filter(range => editorHyperlinks.take(range.target)).reduce((result, range) => hyperlinkSgrSpan(result, piShellVisibleWidth(plain.slice(0, range.start)), piShellVisibleWidth(plain.slice(0, range.end)), range.target, piShellVisibleWidth), dimmed);
+            ? ranges.reduce((result, range) => backgroundSgrSpan(result, visibleWidth(plain.slice(0, range.start)), visibleWidth(plain.slice(0, range.end)), "\u001b[4:4m", "\u001b[24m", visibleWidth), paintRow)
+            : ranges.filter(range => editorHyperlinks.take(range.target)).reduce((result, range) => hyperlinkSgrSpan(result, visibleWidth(plain.slice(0, range.start)), visibleWidth(plain.slice(0, range.end)), range.target, visibleWidth), dimmed);
         // Platform: Windows Terminal can retain stale native dotted-link cells when a mutable
         // prompt replaces a longer URL. Explicit non-link spaces overwrite that tail.
         return `${decorated}${linkResetAndTail}`;

package/dist/app/session-shell/shell-host.d.ts

@@ -1,20 +1,18 @@
+import type { TerminalComponentPort, TerminalInputListener, TerminalInputListenerResult, TerminalInputSurfaceKind, TerminalOverlayHandle, TerminalOverlayOptions, TerminalPointerSurface, TerminalPort } from "../../contracts/presentation/index.js";
 import type { OwnedUiBackgroundSettingsPort, OwnedUiPresenterHost, OwnedUiSessionPresenter, OwnedUiTerminalHost as OwnedUiTerminalHostContract } from "../../contracts/owned-ui/index.js";
 import type { UiRouteSurface } from "../../ui/apps/contracts.js";
-import { type PiTuiDamageDecision, type PiTuiDamageFrameDescriptor, type PiTuiDamageFrameSafety } from "../../integrations/pi/tui-runtime/damage-aware-terminal.js";
-import { PiTuiRuntimeAdapter } from "../../integrations/pi/tui-runtime/adapter.js";
-import type { PiTuiInputSurfaceKind } from "../../integrations/pi/tui-runtime/input-presentation-coordinator.js";
-import type { PiTuiComponentPort, PiTuiInputListener, PiTuiInputListenerResult, PiTuiOverlayHandle, PiTuiOverlayOptions, PiTuiPointerSurface, PiTuiTerminalPort } from "../../integrations/pi/tui-runtime/contracts.js";
+import type { ShellPresentationPorts, TerminalDamageDecision, TerminalDamageFrameDescriptor, TerminalDamageFrameSafety, TerminalProgramStatus, TerminalRuntimePort, TerminalWheelScrollLines } from "../../contracts/presentation/index.js";
 import { type OwnedUiSessionShellOptions, type OwnedUiShellPresentationOptions, type PinnedLayoutPart } from "./session-shell-root.js";
-type ProgramStatus = Parameters<PiTuiRuntimeAdapter["setProgramStatus"]>[0];
-type WheelScrollLines = Parameters<PiTuiRuntimeAdapter["setWheelScrollLines"]>[0];
+type ProgramStatus = TerminalProgramStatus;
+type WheelScrollLines = TerminalWheelScrollLines;
 /** What the terminal host needs from a presenter beyond the neutral contract: the Pi runtime's per-session seams. */
 export interface OwnedUiHostedPresenter extends OwnedUiSessionPresenter {
-    inputCoordinationSurface(): PiTuiInputSurfaceKind;
-    setOverlaySurfaces(surfaces: readonly PiTuiPointerSurface[] | null): void;
+    inputCoordinationSurface(): TerminalInputSurfaceKind;
+    setOverlaySurfaces(surfaces: readonly TerminalPointerSurface[] | null): void;
     noteImmediatePresentation(): void;
     /** The bare-A1 viewport's pre-input routing; returns what the runtime's pre-input listener returns. */
-    handleViewportInput(data: string): PiTuiInputListenerResult | undefined;
-    layoutPart(part: PinnedLayoutPart): PiTuiComponentPort;
+    handleViewportInput(data: string): TerminalInputListenerResult | undefined;
+    layoutPart(part: PinnedLayoutPart): TerminalComponentPort;
     /** Called after the host makes this presenter active, to republish its terminal-wide state. */
     activated(): void;
     /**
@@ -45,9 +43,9 @@ export interface OwnedUiPresenterTerminal extends OwnedUiPresenterHost {
     writeControl(data: string): void;
     hasOverlay(): boolean;
     hasFocusedOverlay(): boolean;
-    showOverlay(component: PiTuiComponentPort, options?: PiTuiOverlayOptions): PiTuiOverlayHandle;
-    addInputListener(listener: PiTuiInputListener): () => void;
-    armFrame(descriptor: PiTuiDamageFrameDescriptor, safety: PiTuiDamageFrameSafety): void;
+    showOverlay(component: TerminalComponentPort, options?: TerminalOverlayOptions): TerminalOverlayHandle;
+    addInputListener(listener: TerminalInputListener): () => void;
+    armFrame(descriptor: TerminalDamageFrameDescriptor, safety: TerminalDamageFrameSafety): void;
     requestHyperlinkCleanup(rows?: readonly number[]): void;
     openRoute(surface: UiRouteSurface, callbacks: OwnedUiRouteCallbacks): {
         hide(): void;
@@ -61,19 +59,20 @@ export interface OwnedUiPresenterTerminal extends OwnedUiPresenterHost {
     setClearOnShrink(enabled: boolean): void;
     setWheelScrollLines(lines: WheelScrollLines): void;
 }
-export interface OwnedUiRouteCallbacks {
+interface OwnedUiRouteCallbacks {
     /** The route, or the interrupt chord over it, asked to leave A1. */
     exit(): void;
     /** The route closed itself; `rendered` is true when it was ever painted. */
     closed(rendered: boolean): void;
 }
 export interface OwnedUiTerminalHostOptions {
+    readonly presentation: ShellPresentationPorts;
     /** Bare A1 owns a bounded custom viewport; comparison profiles keep the pinned layout. */
     readonly layout: "pinned" | "custom-viewport";
     readonly mode: "regular" | "fullscreen";
     readonly hardwareCursor: boolean;
     readonly wheelScrollLines?: WheelScrollLines;
-    readonly terminal?: PiTuiTerminalPort;
+    readonly terminal?: TerminalPort;
     readonly input?: OwnedUiShellPresentationOptions["input"];
     readonly backgroundSettings?: OwnedUiBackgroundSettingsPort;
     readonly quitOutro?: OwnedUiShellPresentationOptions["quitOutro"];
@@ -93,9 +92,9 @@ export declare function sessionTerminalHostOptions(options: OwnedUiSessionShellO
  */
 export declare class OwnedUiTerminalHost implements OwnedUiTerminalHostContract<OwnedUiHostedPresenter> {
     #private;
-    readonly runtime: PiTuiRuntimeAdapter;
+    readonly runtime: TerminalRuntimePort;
     constructor(options: OwnedUiTerminalHostOptions);
-    get damagePresentationDecision(): PiTuiDamageDecision | null;
+    get damagePresentationDecision(): TerminalDamageDecision | null;
     /** Registers a presenter and returns its terminal handle. The presenter paints only once attached. */
     connect(presenter: OwnedUiHostedPresenter): OwnedUiPresenterTerminal;
     /** Forgets a presenter whose construction failed before it could be attached or released. */

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

@@ -1,9 +1,5 @@
 import { MOUSE_TRACKING_OFF, MOUSE_TRACKING_ON, parseMouseInput } from "../../ui/components/mouse.js";
 import { readVisibleHyperlinks } from "../../ui/components/visible-hyperlinks.js";
-import { piCanvasBackgroundAnsi } from "../../integrations/pi/components/theme.js";
-import { DamageAwareTerminalAdapter, } from "../../integrations/pi/tui-runtime/damage-aware-terminal.js";
-import { PiTuiRuntimeAdapter, legacyKeyInput } from "../../integrations/pi/tui-runtime/adapter.js";
-import { classifyPiTuiInput } from "../../integrations/pi/tui-runtime/input-presentation-coordinator.js";
 import { pinnedLayoutRoot, } from "./session-shell-root.js";
 /** The size and render request a Pi component reads from the terminal it is shown on, read on every call. */
 export function componentRuntime(terminal) {
@@ -20,6 +16,7 @@ export function sessionTerminalHostOptions(options) {
     const customViewport = sessionLayout === "custom-viewport";
     const settings = backend.settings.snapshot();
     return {
+        presentation: options.presenters,
         layout: customViewport ? "custom-viewport" : "pinned",
         // 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.
@@ -40,12 +37,13 @@ export function sessionTerminalHostOptions(options) {
 export class OwnedUiTerminalHost {
     runtime;
     #customViewport;
+    #runtimeFactory;
     #damageTerminal;
     #quitOutro;
     #presenters = new Set();
     #overlays = new Map();
-    #removeViewportPreInput;
-    #unsubscribeBackground;
+    // Invariant: one release removes both the viewport pre-input listener and the background subscription.
+    #release;
     #active = null;
     #focused = false;
     #pointerReporting = false;
@@ -53,6 +51,7 @@ export class OwnedUiTerminalHost {
     #ending;
     constructor(options) {
         this.#customViewport = options.layout === "custom-viewport";
+        this.#runtimeFactory = options.presentation.terminalRuntime;
         this.#quitOutro = options.quitOutro;
         const input = options.input;
         let damageTerminal;
@@ -75,7 +74,7 @@ export class OwnedUiTerminalHost {
                 consumeUnhandledMouse: true,
                 onOverlayGeometry: surfaces => this.#active?.setOverlaySurfaces(surfaces),
                 decorateTerminal: (terminal) => {
-                    damageTerminal = new DamageAwareTerminalAdapter(terminal, {
+                    damageTerminal = this.#runtimeFactory.createDamageTerminal(terminal, {
                         regionalScroll: process.env.TERM !== "dumb",
                         inspectHyperlinks: readVisibleHyperlinks,
                         onResize: () => this.#active?.noteImmediatePresentation(),
@@ -85,12 +84,12 @@ export class OwnedUiTerminalHost {
                 },
                 ...(input?.coordination === false ? {} : {
                     inputCoordination: {
-                        classify: (data, focusedOverlay) => classifyPiTuiInput(data, focusedOverlay ?? this.#active?.inputCoordinationSurface() ?? "opaque"),
+                        classify: (data, focusedOverlay) => this.#runtimeFactory.classifyInput(data, focusedOverlay ?? this.#active?.inputCoordinationSurface() ?? "opaque"),
                         onReceipt: () => this.#active?.noteImmediatePresentation(),
                         ...(input?.scheduler === undefined ? {} : { scheduler: input.scheduler }),
                     },
                 }),
-            } : { layoutRoot: pinnedLayoutRoot(this.#delegatingLayoutParts()) }),
+            } : { layoutRoot: pinnedLayoutRoot(this.#delegatingLayoutParts(), options.presentation.theme) }),
             ...(input?.onEvent === undefined ? {} : {
                 inputDiagnostics: {
                     onEvent: input.onEvent,
@@ -101,18 +100,19 @@ export class OwnedUiTerminalHost {
             hardwareCursor: options.hardwareCursor,
             ...(options.wheelScrollLines === undefined ? {} : { wheelScrollLines: options.wheelScrollLines }),
         };
-        this.runtime = new PiTuiRuntimeAdapter(runtimeOptions);
+        this.runtime = this.#runtimeFactory.createRuntime(runtimeOptions);
         this.#damageTerminal = damageTerminal ?? null;
         const background = this.#customViewport ? options.backgroundSettings : undefined;
         if (background !== undefined)
-            this.#damageTerminal?.setCanvasBackground(piCanvasBackgroundAnsi(background.snapshot()));
-        this.#unsubscribeBackground = background === undefined || this.#damageTerminal === null ? () => { } : background.onChange(style => {
-            if (this.#damageTerminal?.setCanvasBackground(piCanvasBackgroundAnsi(style)))
+            this.#damageTerminal?.setCanvasBackground(options.presentation.canvasBackground(background.snapshot()));
+        const unsubscribeBackground = background === undefined || this.#damageTerminal === null ? () => { } : background.onChange(style => {
+            if (this.#damageTerminal?.setCanvasBackground(options.presentation.canvasBackground(style)))
                 this.runtime.requestRender(true);
         });
-        this.#removeViewportPreInput = this.#customViewport
+        const removeViewportPreInput = this.#customViewport
             ? this.runtime.addPreInputListener(data => this.#active?.handleViewportInput(data))
             : () => { };
+        this.#release = () => { removeViewportPreInput(); unsubscribeBackground(); };
     }
     get damagePresentationDecision() {
         return this.#damageTerminal?.lastDecision ?? null;
@@ -199,8 +199,7 @@ export class OwnedUiTerminalHost {
         // Invariant: the outro frame is what the terminal shows now, before any cleanup writes.
         const outroFrame = this.#captureQuitOutroFrame();
         attempt(() => this.#setPointerReporting(false, true));
-        attempt(() => this.#removeViewportPreInput());
-        attempt(() => this.#unsubscribeBackground());
+        attempt(() => this.#release());
         const terminal = { mode: this.runtime.mode, columns: this.runtime.viewport().columns };
         const active = this.#active;
         const releases = [];
@@ -344,7 +343,7 @@ export class OwnedUiTerminalHost {
         };
         removeInterruptWatch = runtime.addInputListener(data => {
             // Compatibility: a kitty-keyboard child reports Ctrl+C as a CSI-u sequence rather than the byte.
-            if (!attached() || !data.includes(INTERRUPT) && legacyKeyInput(data) !== INTERRUPT)
+            if (!attached() || !data.includes(INTERRUPT) && this.#runtimeFactory.legacyKeyInput(data) !== 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.
@@ -403,7 +402,7 @@ export class OwnedUiTerminalHost {
                 for (const event of events)
                     surface.handleMouse(event);
                 // Invariant: owned screens see legacy key bytes whether the terminal reports legacy or kitty keys.
-                const key = rest.length > 0 ? legacyKeyInput(rest) : "";
+                const key = rest.length > 0 ? this.#runtimeFactory.legacyKeyInput(rest) : "";
                 if (key.length > 0)
                     surface.handleInput(key);
                 if (surface.isClosed()) {
@@ -471,7 +470,7 @@ export class OwnedUiTerminalHost {
                 write: data => this.runtime.writeControl(data),
                 ...(capture.settings.canvasBackgroundAnsi === null
                     ? {}
-                    : { canvasBackgroundAnsi: capture.settings.canvasBackgroundAnsi }),
+                    : { canvas: { ansi: capture.settings.canvasBackgroundAnsi, rebase: this.#runtimeFactory.rebaseDefaultBackground } }),
                 ...(outro.now === undefined ? {} : { now: outro.now }),
                 ...(outro.sleep === undefined ? {} : { sleep: outro.sleep }),
                 ...(outro.seed === undefined ? {} : { seed: outro.seed }),