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

package/dist/integrations/pi/session-presenters/presenters.js

@@ -0,0 +1,341 @@
+import { createPiShellModelSelector, createPiShellModelsDialog, createPiShellScopedModelsSelector, createPiShellSessionSelector, createPiShellSettingsSelector, } from "../components/shell-selectors-dialogs.js";
+const MODEL_REFRESH_TIMEOUT_MS = 15_000;
+const MODEL_REFRESH_TIMED_OUT = "Model refresh timed out; showing cached models.";
+/**
+ * Builds the selectors and transcript renderers whose inputs are Pi engine objects. This owner is the one place
+ * that sees both the engine adapter and the Pi components, so the shell only ever holds the neutral port.
+ */
+export function createPiSessionPresenters(adapter, options = {}) {
+    const source = () => adapter.presentationSource();
+    let lazySelectors = options.lazySelectors;
+    let lazySelectorsPromise;
+    // Performance: the tree selector module stays out of the startup graph and loads on first use.
+    const loadLazySelectors = () => {
+        if (lazySelectors !== undefined)
+            return Promise.resolve(lazySelectors);
+        return lazySelectorsPromise ??= import("../components/lazy-selectors.js").then(module => {
+            lazySelectors = module.piShellLazySelectors;
+            return module.piShellLazySelectors;
+        });
+    };
+    const renderers = {
+        getMessageRenderer: customType => opaqueRenderer(source().pinnedMessageRenderer(customType)),
+        getToolRenderers: toolName => opaqueRenderer(source().pinnedToolRenderers(toolName)),
+        // Compatibility: the component adapter passes Pi's own keybinding config through the neutral port.
+        getShortcuts: bindings => source().pinnedShortcutDescriptions(bindings),
+    };
+    return {
+        transcriptRenderers: () => renderers,
+        openModelSelector(host, initialSearchInput) {
+            const context = source().pinnedModelSelectorContext();
+            const close = closeSurface(host);
+            const component = createPiShellModelSelector({
+                ...context,
+                runtime: {
+                    getColumns: () => host.viewport().columns,
+                    getRows: () => host.viewport().rows,
+                    requestRender: () => host.requestRender(),
+                },
+                ...(initialSearchInput === undefined ? {} : { initialSearchInput }),
+                onSelect: model => {
+                    close();
+                    void host.runWorkflow({ command: "model", argument: "", selection: modelReference(model) });
+                },
+                onSelectAsDefault: model => {
+                    close();
+                    void host.runWorkflow({ command: "model", argument: "", selection: modelReference(model), persist: true });
+                },
+                onCancel: close,
+            });
+            host.setInputSurface(component);
+            host.requestRender();
+        },
+        async openSessionSelector(host, onExit) {
+            const context = source().pinnedSessionSelectorContext();
+            const close = closeSurface(host);
+            const component = await createPiShellSessionSelector({
+                currentSessionsLoader: context.loadCurrentSessions,
+                allSessionsLoader: context.loadAllSessions,
+                currentSessionFilePath: context.currentSessionFilePath,
+                renameSession: context.renameSession,
+                requestRender: () => host.requestRender(),
+                onSelect: sessionPath => {
+                    close();
+                    void host.runWorkflow({ command: "resume", argument: sessionPath });
+                },
+                onCancel: close,
+                onExit: () => {
+                    close();
+                    onExit();
+                },
+            });
+            host.setInputSurface(component);
+            host.requestRender();
+        },
+        async openTreeSelector(host, navigate, initialSelectedId) {
+            const context = source().pinnedTreeSelectorContext();
+            if (context.tree.length === 0) {
+                host.appendWorkflowStatus("No entries in session");
+                host.requestRender();
+                return;
+            }
+            const close = closeSurface(host);
+            const releasePresentation = host.beginPresentationHold?.();
+            try {
+                const selectors = await loadLazySelectors();
+                const component = await selectors.createTree({
+                    tree: context.tree,
+                    currentLeafId: context.currentLeafId,
+                    terminalHeight: host.viewport().rows,
+                    initialFilterMode: context.filterMode,
+                    ...(initialSelectedId === undefined ? {} : { initialSelectedId }),
+                    onLabelChange: context.appendLabelChange,
+                    onCopy: text => {
+                        if (!text) {
+                            host.appendWorkflowResult({ command: "tree", outcome: "failed", message: "Selected entry has no text to copy" });
+                            host.requestRender();
+                            return;
+                        }
+                        const generation = adapter.identity.sessionBindingGeneration;
+                        const stale = () => host.disposed || generation !== adapter.identity.sessionBindingGeneration;
+                        void adapter.workflows.copyWorkflowText(text).then(acknowledged => {
+                            if (stale())
+                                return;
+                            host.appendWorkflowStatus(acknowledged ? "Copied selected message to clipboard" : "Submitted selected message to clipboard");
+                            host.requestRender();
+                        }).catch(error => {
+                            if (stale())
+                                return;
+                            host.appendWorkflowResult({ command: "tree", outcome: "failed", message: error instanceof Error ? error.message : String(error) });
+                            host.requestRender();
+                        });
+                    },
+                    onCancel: close,
+                    onSelect: entryId => {
+                        if (entryId === context.currentLeafId) {
+                            close();
+                            host.appendWorkflowStatus("Already at this point");
+                            host.requestRender();
+                            return;
+                        }
+                        if (context.skipSummaryPrompt)
+                            close();
+                        navigate(entryId, context.skipSummaryPrompt);
+                    },
+                });
+                if (host.disposed)
+                    return;
+                host.setInputSurface(component);
+                host.requestRender();
+            }
+            finally {
+                releasePresentation?.();
+            }
+        },
+        openSettingsSelector(host) {
+            const snapshot = adapter.settings.snapshot();
+            const { currentModel, availableDefaultModels } = source().pinnedSettingsModels();
+            const close = closeSurface(host);
+            const component = createPiShellSettingsSelector({
+                config: {
+                    ...snapshot,
+                    availableThinkingLevels: [...snapshot.availableThinkingLevels],
+                    availableThemes: [...snapshot.availableThemes],
+                    warnings: { ...snapshot.warnings },
+                    modelThinkingLevels: { ...snapshot.modelThinkingLevels },
+                    ...(currentModel === undefined ? {} : { currentModel: currentModel }),
+                    availableDefaultModels: availableDefaultModels,
+                },
+                onChange: (callback, value) => {
+                    if (callback === "onCancel") {
+                        close();
+                        return;
+                    }
+                    if (callback === "onTuiModeChange") {
+                        // Invariant: a surface that cannot change TUI mode (bare A1 is permanently fullscreen) ignores this callback.
+                        if (host.switchTuiMode === undefined)
+                            return;
+                        if (value !== "regular" && value !== "fullscreen")
+                            return;
+                        if (!host.switchTuiMode(value)) {
+                            host.appendWorkflowStatus("Close active overlays before changing TUI mode");
+                            host.requestRender();
+                            return;
+                        }
+                    }
+                    void source().applyPinnedSettingValue(callback, value).then(result => {
+                        if (result.outcome === "failed")
+                            host.appendWorkflowResult(result);
+                        else if (callback === "onTuiModeChange")
+                            host.appendWorkflowStatus(`TUI mode: ${value}`);
+                        host.requestRender();
+                    });
+                },
+                onCancel: close,
+            });
+            host.setInputSurface(component);
+            host.requestRender();
+        },
+        /** The bare-A1 unified Models dialog: switch on Enter, scope on Space, persist on Ctrl+S, all through the engine. */
+        openModelsDialog(host, initialQuery) {
+            const catalog = adapter.catalog;
+            const context = catalog.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;
+            const refresh = new ModelCatalogRefresh();
+            const close = () => {
+                refresh.stop();
+                host.setInputSurface(null);
+                host.requestRender();
+            };
+            const dialog = createPiShellModelsDialog({
+                models: context.models,
+                activeModelId: context.activeModelId,
+                scopeIds,
+                savedScopeIds,
+                ...(initialQuery === undefined ? {} : { initialQuery }),
+                refreshStatus: "Refreshing model catalogs…",
+                requestRender: () => host.requestRender(),
+                onSelect: modelId => {
+                    void host.runWorkflow({ command: "models", argument: "", selection: modelId }).then(result => {
+                        if (!refresh.stopped && result.outcome === "completed")
+                            close();
+                    });
+                },
+                onScopeChange: ids => {
+                    catalog.setSessionModelScope(ids);
+                    host.requestRender();
+                },
+                onSave: ids => {
+                    try {
+                        catalog.persistModelScope(ids);
+                    }
+                    catch (error) {
+                        host.appendWorkflowResult({ command: "models", outcome: "failed", message: error instanceof Error ? error.message : String(error) });
+                        host.requestRender();
+                        throw error;
+                    }
+                    host.appendWorkflowStatus("Model selection saved to settings");
+                    host.requestRender();
+                },
+                onCancel: close,
+            });
+            const component = {
+                ...dialog,
+                dispose: () => {
+                    refresh.stop();
+                    dialog.dispose?.();
+                },
+            };
+            host.setInputSurface(component);
+            host.requestRender();
+            refresh.run(host, component, signal => catalog.refreshModels(signal), refreshed => component.updateModels(refreshed.models));
+        },
+        openScopedModelsSelector(host) {
+            const catalog = adapter.catalog;
+            const initial = catalog.pinnedScopedModelsContext();
+            let currentEnabledIds = initial.enabledModelIds === null ? null : [...initial.enabledModelIds];
+            let selectionChanged = false;
+            const refresh = new ModelCatalogRefresh();
+            const close = () => {
+                refresh.stop();
+                host.setInputSurface(null);
+                host.requestRender();
+            };
+            const selector = createPiShellScopedModelsSelector({
+                models: initial.models,
+                enabledModelIds: currentEnabledIds,
+                refreshStatus: "Refreshing model catalogs…",
+                onChange: enabledIds => {
+                    selectionChanged = true;
+                    currentEnabledIds = enabledIds === null ? null : [...enabledIds];
+                    catalog.updateScopedModels(currentEnabledIds);
+                    host.requestRender();
+                },
+                onPersist: enabledIds => {
+                    currentEnabledIds = enabledIds === null ? null : [...enabledIds];
+                    catalog.persistScopedModels(currentEnabledIds);
+                    host.appendWorkflowStatus("Model selection saved to settings");
+                    host.requestRender();
+                },
+                onCancel: close,
+            });
+            const component = {
+                ...selector,
+                dispose: () => {
+                    refresh.stop();
+                    selector.dispose?.();
+                },
+            };
+            host.setInputSurface(component);
+            host.requestRender();
+            refresh.run(host, component, signal => catalog.refreshScopedModels(signal), refreshed => {
+                if (!selectionChanged) {
+                    currentEnabledIds = refreshed.enabledModelIds === null ? null : [...refreshed.enabledModelIds];
+                    component.updateModels(refreshed.models, currentEnabledIds);
+                }
+                else {
+                    component.updateModels(refreshed.models);
+                    catalog.updateScopedModels(currentEnabledIds);
+                }
+            });
+        },
+    };
+}
+/**
+ * One model-catalog refresh owned by an open dialog: it aborts after fifteen seconds or when the dialog
+ * closes, and a result that arrives after the dialog closed is dropped.
+ */
+class ModelCatalogRefresh {
+    #controller = new AbortController();
+    #timeout;
+    #stopped = false;
+    #timedOut = false;
+    constructor() {
+        this.#timeout = setTimeout(() => {
+            this.#timedOut = true;
+            this.#controller.abort();
+        }, MODEL_REFRESH_TIMEOUT_MS);
+    }
+    get stopped() { return this.#stopped; }
+    stop() {
+        this.#stopped = true;
+        clearTimeout(this.#timeout);
+        this.#controller.abort();
+    }
+    run(host, dialog, refresh, apply) {
+        void refresh(this.#controller.signal).then(refreshed => {
+            if (this.#stopped)
+                return;
+            apply(refreshed);
+            dialog.setRefreshStatus(this.#timedOut ? MODEL_REFRESH_TIMED_OUT : refreshed.status, this.#timedOut ? "warning" : refreshed.statusKind);
+            host.requestRender();
+        }).catch(error => {
+            if (this.#stopped)
+                return;
+            dialog.setRefreshStatus(this.#timedOut
+                ? MODEL_REFRESH_TIMED_OUT
+                : `Could not refresh model catalogs: ${error instanceof Error ? error.message : String(error)}`, "warning");
+            host.requestRender();
+        }).finally(() => clearTimeout(this.#timeout));
+    }
+}
+function closeSurface(host) {
+    return () => {
+        host.setInputSurface(null);
+        host.requestRender();
+    };
+}
+function opaqueRenderer(value) {
+    return (typeof value === "object" && value !== null) || typeof value === "function" ? value : undefined;
+}
+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}` : "";
+}

package/dist/integrations/pi/tui-runtime/adapter.js

@@ -95,7 +95,6 @@ export class PiTuiRuntimeAdapter {
     #terminal;
     #tuiTerminal;
     #tui;
-    #root;
     #layoutRoot;
     #tuiOptions;
     #logDirectory;
@@ -120,7 +119,6 @@ export class PiTuiRuntimeAdapter {
     #presentationFrozen = false;
     #presentationHolds = new Set();
     constructor(options) {
-        this.#root = options.root;
         this.#overlayGeometry = options.onOverlayGeometry === undefined ? undefined : new OverlayGeometryTracker(options.onOverlayGeometry);
         this.#terminal = options.terminal ?? new ProcessTerminal();
         this.#consumeUnhandledMouse = options.consumeUnhandledMouse ?? false;

package/dist/integrations/pi/tui-runtime/damage-aware-terminal.d.ts

@@ -1,6 +1,11 @@
 import type { PiTuiTerminalPort } from "./contracts.js";
 export declare const PINNED_PI_TUI_DAMAGE_GRAMMAR = "@earendil-works/pi-tui@1.1.0:tui-alt-screen-one-write-v1";
 export interface PiTuiDamageFrameDescriptor {
+    /**
+     * Frame ids are compared only within one presentation epoch; absent means the current epoch. A
+     * presenter switch starts a new epoch, because each presenter numbers its own frames.
+     */
+    readonly epoch?: number;
     readonly frameId: number;
     readonly width: number;
     readonly height: number;
@@ -63,6 +68,15 @@ export declare class DamageAwareTerminalAdapter implements PiTuiTerminalPort {
     get kittyProtocolActive(): boolean;
     get lastDecision(): PiTuiDamageDecision;
     get hyperlinkCleanupPending(): boolean;
+    get canvasBackgroundAnsi(): string | null;
+    get presentationEpoch(): number;
+    /**
+     * Starts a new presentation epoch: the remembered cells and the armed frame are discarded and frame ids
+     * restart, so the next frame is painted in full rather than reconciled against another presenter's.
+     */
+    invalidatePresentation(): void;
+    /** Invalidates remembered terminal cells before the shell forces one complete canvas repaint. */
+    setCanvasBackground(ansi: string | null): boolean;
     /**
      * The rows as last forwarded to the terminal, top to bottom, with styling
      * intact. A row the adapter has not seen since its last invalidation is empty.
@@ -86,3 +100,7 @@ export declare class DamageAwareTerminalAdapter implements PiTuiTerminalPort {
     setTitle(title: string): void;
     setProgress(active: boolean): void;
 }
+/** Makes SGR background resets return to A1's canvas while preserving explicit backgrounds. */
+export declare function rebaseTerminalDefaultBackground(content: string, backgroundAnsi: string): string;
+/** Paints only synchronized fullscreen rows; clipboard/title/progress controls remain byte-identical. */
+export declare function paintTerminalCanvasFrame(data: string, backgroundAnsi: string): string;

package/dist/integrations/pi/tui-runtime/damage-aware-terminal.js

@@ -8,6 +8,7 @@ const ROW_MARKER = /\u001b\[(\d+);1H\u001b\[2K/gu;
 const ROW_CONTENT_CURSOR = /\u001b\[\d+;1H/u;
 const CURSOR_SUFFIX = /(?:\u001b\[(\d+);(\d+)H)?\u001b\[\?25[hl]\u001b\[\?2026l$/u;
 const OUT_OF_BAND = /^(?:\u001b\](?:0|2|9|52);[^\u0007\u001b]*(?:\u0007|\u001b\\)|\u001b\[\?25[hl])+$/u;
+const SGR_SEQUENCE = /\u001b\[([0-9:;]*)m/gu;
 /**
  * A fail-closed adapter for one pinned Pi fullscreen write grammar. Semantic
  * viewport metadata authorizes a shift; bytes are inspected only to validate
@@ -22,10 +23,12 @@ export class DamageAwareTerminalAdapter {
     #cleanedRevision = 0;
     #recoveryRevision = 0;
     #epoch = 0;
+    #presentationEpoch = 0;
     #armed;
     #lastConsumedFrameId = 0;
     #cacheWidth = 0;
     #cacheHeight = 0;
+    #canvasBackgroundAnsi = null;
     #decision = {
         frameId: null,
         transformed: false,
@@ -41,6 +44,26 @@ export class DamageAwareTerminalAdapter {
     get kittyProtocolActive() { return this.inner.kittyProtocolActive; }
     get lastDecision() { return this.#decision; }
     get hyperlinkCleanupPending() { return this.#cleanupRevision > this.#cleanedRevision; }
+    get canvasBackgroundAnsi() { return this.#canvasBackgroundAnsi; }
+    get presentationEpoch() { return this.#presentationEpoch; }
+    /**
+     * Starts a new presentation epoch: the remembered cells and the armed frame are discarded and frame ids
+     * restart, so the next frame is painted in full rather than reconciled against another presenter's.
+     */
+    invalidatePresentation() {
+        this.#presentationEpoch += 1;
+        this.#armed = undefined;
+        this.#lastConsumedFrameId = 0;
+        this.#invalidatePresentation();
+    }
+    /** Invalidates remembered terminal cells before the shell forces one complete canvas repaint. */
+    setCanvasBackground(ansi) {
+        if (this.#canvasBackgroundAnsi === ansi)
+            return false;
+        this.#canvasBackgroundAnsi = ansi;
+        this.#invalidatePresentation();
+        return true;
+    }
     /**
      * The rows as last forwarded to the terminal, top to bottom, with styling
      * intact. A row the adapter has not seen since its last invalidation is empty.
@@ -97,7 +120,7 @@ export class DamageAwareTerminalAdapter {
         const armed = this.#armed;
         this.#armed = undefined;
         const parsed = parsePinnedFullscreenWrite(data);
-        if (armed !== undefined && armed.descriptor.frameId <= this.#lastConsumedFrameId) {
+        if (armed !== undefined && this.#isStale(armed.descriptor)) {
             // Concurrency: a recognized obsolete frame must never repaint newer cells,
             // acknowledge cleanup, or become the reference for a subsequent differential.
             this.#decision = this.#decide(armed, parsed);
@@ -140,7 +163,10 @@ export class DamageAwareTerminalAdapter {
                 output = buildDamageWrite(parsed, armed.descriptor, new Set(decision.paintedRows), this.#rows);
             }
         }
-        this.inner.write(output);
+        const forwarded = this.#canvasBackgroundAnsi === null
+            ? output
+            : paintTerminalCanvasFrame(output, this.#canvasBackgroundAnsi);
+        this.inner.write(forwarded);
         if (epoch !== this.#epoch
             || (armed !== undefined && this.#lastConsumedFrameId !== armed.descriptor.frameId))
             return;
@@ -175,7 +201,7 @@ export class DamageAwareTerminalAdapter {
             shiftRows: descriptor.verticalShiftRows,
             paintedRows: [],
         };
-        if (descriptor.frameId <= this.#lastConsumedFrameId)
+        if (this.#isStale(descriptor))
             return { ...base, reason: "stale-frame" };
         this.#lastConsumedFrameId = descriptor.frameId;
         if (this.hyperlinkCleanupPending)
@@ -251,6 +277,10 @@ export class DamageAwareTerminalAdapter {
             paintedRows: [...painted].sort((left, right) => left - right),
         };
     }
+    #isStale(descriptor) {
+        return (descriptor.epoch ?? this.#presentationEpoch) !== this.#presentationEpoch
+            || descriptor.frameId <= this.#lastConsumedFrameId;
+    }
     #rememberFrame(descriptor, parsed, raw) {
         if (raw.includes("\u001b[2J") || raw.includes("\u001b[?1049") || raw.includes("\u001b_G") || raw.includes("\u001bPq")) {
             this.#invalidateRows();
@@ -363,6 +393,57 @@ export class DamageAwareTerminalAdapter {
         this.#cacheHeight = 0;
     }
 }
+/** Makes SGR background resets return to A1's canvas while preserving explicit backgrounds. */
+export function rebaseTerminalDefaultBackground(content, backgroundAnsi) {
+    return content.replace(SGR_SEQUENCE, (sequence, parameters) => (sgrLeavesDefaultBackground(parameters) ? `${sequence}${backgroundAnsi}` : sequence));
+}
+/** Paints only synchronized fullscreen rows; clipboard/title/progress controls remain byte-identical. */
+export function paintTerminalCanvasFrame(data, backgroundAnsi) {
+    if (!data.startsWith(BEGIN_SYNCHRONIZED_OUTPUT) || !data.endsWith(END_SYNCHRONIZED_OUTPUT)
+        || !ROW_MARKER.test(data)) {
+        ROW_MARKER.lastIndex = 0;
+        return data;
+    }
+    ROW_MARKER.lastIndex = 0;
+    const rows = data.replace(ROW_MARKER, (_marker, row) => (`\u001b[${row};1H${backgroundAnsi}\u001b[2K${backgroundAnsi}`));
+    ROW_MARKER.lastIndex = 0;
+    const rebased = rebaseTerminalDefaultBackground(rows, backgroundAnsi);
+    return `${rebased.slice(0, -END_SYNCHRONIZED_OUTPUT.length)}\u001b[49m${END_SYNCHRONIZED_OUTPUT}`;
+}
+function sgrLeavesDefaultBackground(parameters) {
+    if (parameters.length === 0)
+        return true;
+    const values = parameters.split(";");
+    let defaultBackground;
+    for (let index = 0; index < values.length; index += 1) {
+        const token = values[index];
+        const code = Number.parseInt(token.split(":", 1)[0] || "0", 10);
+        if (!Number.isFinite(code))
+            continue;
+        if (code === 0 || code === 49) {
+            defaultBackground = true;
+            continue;
+        }
+        if (code >= 40 && code <= 47 || code >= 100 && code <= 107) {
+            defaultBackground = false;
+            continue;
+        }
+        if (code !== 38 && code !== 48 && code !== 58)
+            continue;
+        if (code === 48)
+            defaultBackground = false;
+        if (token.includes(":"))
+            continue;
+        const mode = Number.parseInt(values[index + 1] ?? "", 10);
+        if (mode === 5)
+            index += 2;
+        else if (mode === 2)
+            index += 4;
+        else
+            index += 1;
+    }
+    return defaultBackground === true;
+}
 function parsePinnedFullscreenWrite(data) {
     if (!data.startsWith(BEGIN_SYNCHRONIZED_OUTPUT) || !data.endsWith(END_SYNCHRONIZED_OUTPUT))
         return null;

package/dist/integrations/pi/tui-runtime/index.d.ts

@@ -1,6 +1,6 @@
 export type { PiTuiComponentPort, PiTuiInputDiagnosticsEvent, PiTuiInputDiagnosticsPhase, PiTuiInputListener, PiTuiInputListenerResult, PiTuiLayoutEntry, PiTuiLayoutNode, PiTuiOverlayAnchor, PiTuiOverlayHandle, PiTuiOverlayMargin, PiTuiOverlayOptions, PiTuiOverlayUnfocusOptions, PiTuiPointerSurface, PiTuiPreInputListener, PiTuiRuntimeAdapterOptions, PiTuiRuntimeState, PiTuiScrollState, PiTuiSizeValue, PiTuiStopOptions, PiTuiTerminalPort, PiTuiViewport, } from "./contracts.js";
 export { samePointerSurfaces } from "./overlay-geometry.js";
-export { DamageAwareTerminalAdapter, PINNED_PI_TUI_DAMAGE_GRAMMAR } from "./damage-aware-terminal.js";
+export { DamageAwareTerminalAdapter, PINNED_PI_TUI_DAMAGE_GRAMMAR, paintTerminalCanvasFrame, rebaseTerminalDefaultBackground, } from "./damage-aware-terminal.js";
 export type { DamageAwareTerminalOptions, PiTuiDamageDecision, PiTuiDamageDecisionReason, PiTuiDamageFrameDescriptor, PiTuiDamageFrameSafety, } from "./damage-aware-terminal.js";
 export { InputPresentationCoordinator, classifyPiTuiInput } from "./input-presentation-coordinator.js";
 export type { InputPresentationCoordinatorOptions, PiTuiInputCoordinationDecision, PiTuiInputCoordinationScheduler, PiTuiInputCoordinationTrace, PiTuiInputSurfaceKind, } from "./input-presentation-coordinator.js";

package/dist/integrations/pi/tui-runtime/index.js

@@ -1,5 +1,5 @@
 export { samePointerSurfaces } from "./overlay-geometry.js";
-export { DamageAwareTerminalAdapter, PINNED_PI_TUI_DAMAGE_GRAMMAR } from "./damage-aware-terminal.js";
+export { DamageAwareTerminalAdapter, PINNED_PI_TUI_DAMAGE_GRAMMAR, paintTerminalCanvasFrame, rebaseTerminalDefaultBackground, } from "./damage-aware-terminal.js";
 export { InputPresentationCoordinator, classifyPiTuiInput } from "./input-presentation-coordinator.js";
 export { PiTuiRuntimeAdapter, PiTuiRuntimeError } from "./adapter.js";
 export { createPiPresentationRuntime, createPiTerminalBridge } from "./presentation-adapter.js";

package/dist/native/darwin-arm64/manifest.json

@@ -5,7 +5,7 @@
   "platform": "darwin",
   "architecture": "arm64",
   "capability": "supported",
-  "builtAt": "2026-10-09T06:37:13.333Z",
+  "builtAt": "2026-10-10T09:15:37.918Z",
   "artifact": {
     "filename": "process-guardian",
     "sha256": "51b0b2dc1c9ae577f2586c4217066929278726c2c15308d9144eb6f538e118ff",

package/dist/native/linux-x64/manifest.json

@@ -5,7 +5,7 @@
   "platform": "linux",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-10-09T06:37:02.979Z",
+  "builtAt": "2026-10-10T09:15:10.349Z",
   "artifact": {
     "filename": "process-guardian",
     "sha256": "ef62679e83bc1fad3d38f9f21675d9256f08d20e67fd4791571032115ca1b0e9",

package/dist/native/win32-x64/manifest.json

@@ -5,10 +5,10 @@
   "platform": "win32",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-10-09T06:37:43.630Z",
+  "builtAt": "2026-10-10T09:16:06.991Z",
   "artifact": {
     "filename": "process-guardian.exe",
-    "sha256": "63c2b95f4d07de25f9b25da06e7386f681474967118bf034ef4b02f0259cc9a3",
+    "sha256": "c6e2cb23d012d779478fd1bff750f17687a4c5466bad7621b1b3c200a0557101",
     "size": 288256
   },
   "provenance": {

package/dist/ui/settings/declarations.d.ts

@@ -1,4 +1,4 @@
-export declare const OWNED_UI_SETTINGS_VERSION = 12;
+export declare const OWNED_UI_SETTINGS_VERSION = 13;
 export type OwnedUiSettingValue = string | number | boolean;
 export type OwnedUiSettingApplication = "live" | "restart";
 export interface OwnedUiSettingDeclaration {
@@ -44,6 +44,18 @@ export declare const OWNED_SETTING_DECLARATIONS: Readonly<{
         defaultValue: "purple";
         allowedValues: readonly ["purple", "blue", "cyan", "green", "orange", "pink"];
     }>;
+    readonly backgroundStyle: Readonly<{
+        id: "backgroundStyle";
+        label: "Background";
+        section: Readonly<{
+            id: "appearance";
+            title: "Appearance";
+        }>;
+        description: "Fullscreen canvas background: terminal transparency, a dark accent tint, or fixed neutral dark.";
+        application: "live";
+        defaultValue: "transparent";
+        allowedValues: readonly ["transparent", "accent", "dark"];
+    }>;
     readonly quitAnimation: Readonly<{
         id: "quitAnimation";
         label: "Quit animation";

package/dist/ui/settings/declarations.js

@@ -1,4 +1,4 @@
-export const OWNED_UI_SETTINGS_VERSION = 12;
+export const OWNED_UI_SETTINGS_VERSION = 13;
 const UI_ACCENT_COLOR_CHOICES = Object.freeze([
     "purple", "blue", "cyan", "green", "orange", "pink",
 ]);
@@ -32,6 +32,17 @@ export const OWNED_SETTING_DECLARATIONS = Object.freeze({
         defaultValue: "purple",
         allowedValues: UI_ACCENT_COLOR_CHOICES,
     }),
+    backgroundStyle: Object.freeze({
+        id: "backgroundStyle",
+        label: "Background",
+        section: APPEARANCE_SECTION,
+        description: "Fullscreen canvas background: terminal transparency, a dark accent tint, or fixed neutral dark.",
+        application: "live",
+        defaultValue: "transparent",
+        allowedValues: Object.freeze([
+            "transparent", "accent", "dark",
+        ]),
+    }),
     quitAnimation: Object.freeze({
         id: "quitAnimation",
         label: "Quit animation",

package/dist/ui/settings/migrations.js

@@ -97,6 +97,13 @@ export const OWNED_UI_SETTINGS_MIGRATIONS = Object.freeze([
                 : { ...values };
         },
     }),
+    Object.freeze({
+        to: 13,
+        description: "Introduce the transparent fullscreen background default.",
+        migrate(values) {
+            return { ...values };
+        },
+    }),
 ]);
 export function assertOwnedUiSettingsMigrations(migrations, currentVersion = OWNED_UI_SETTINGS_VERSION) {
     const firstProduced = currentVersion - migrations.length + 1;