@timurproko/a1 0.2.7-dev.810 → 0.2.7-dev.828

package/dist/composition/settings-search-input.d.ts

@@ -0,0 +1,9 @@
+import type { SettingsSearchInputFactory } from "../features/owned-ui/settings-search-input.js";
+import { type PiKeybindingsHost } from "../integrations/pi/components/shell-shared-facade.js";
+export interface SettingsSearchInputFactoryOptions {
+    readonly keybindings?: PiKeybindingsHost;
+    readonly agentDir?: string;
+    readonly cwd?: string;
+}
+/** Builds Settings search from the same configurable owned editor used by the agent prompt. */
+export declare function createSettingsSearchInputFactory(options?: SettingsSearchInputFactoryOptions): SettingsSearchInputFactory;

package/dist/composition/settings-search-input.js

@@ -0,0 +1,58 @@
+import { editorInsertedText } from "../integrations/pi/components/owned-editor-ux.js";
+import { createPiShellEditor } from "../integrations/pi/components/shell-editor-autocomplete.js";
+import { piShellTruncateToWidth, piShellVisibleWidth, } from "../integrations/pi/components/shell-shared-facade.js";
+import { backgroundSgrSpan } from "../ui/components/spans.js";
+import { caretCell } from "../ui/components/line-input.js";
+import { PromptInput } from "../ui/components/prompt-input.js";
+/** Builds Settings search from the same configurable owned editor used by the agent prompt. */
+export function createSettingsSearchInputFactory(options = {}) {
+    return {
+        isTextInput: data => {
+            const text = editorInsertedText(data);
+            return text !== undefined && /[^\p{Cc}]/u.test(text);
+        },
+        create: surface => createSettingsSearchInput(surface, options),
+    };
+}
+function createSettingsSearchInput(surface, options) {
+    let columns = 80;
+    const editor = createPiShellEditor({
+        keybindingProfile: "a1",
+        inputCapabilities: {
+            singleLine: true,
+            paste: false,
+            autocomplete: false,
+            placeholder: "Search settings",
+        },
+        ...(options.keybindings === undefined ? {} : { keybindings: options.keybindings }),
+        ...(options.agentDir === undefined ? {} : { agentDir: options.agentDir }),
+        cwd: options.cwd ?? process.cwd(),
+        getColumns: () => columns,
+        getRows: surface.getRows,
+        requestRender: surface.requestRender,
+        onSubmit: () => { },
+        onCopyText: text => surface.copyText(text),
+        paintEditorSelection: (line, from, to, atomic) => backgroundSgrSpan(line, from, to, atomic ? "\u001b[7m" : "\u001b[27m\u001b[48;2;38;79;120m", atomic ? "\u001b[27m" : "\u001b[49m", piShellVisibleWidth),
+        promptPresentation: {
+            input: new PromptInput({ fg: (token, text) => surface.theme.fg(token, text) }, {
+                measure: piShellVisibleWidth,
+                truncate: piShellTruncateToWidth,
+            }),
+            styleSuggestion: text => surface.theme.fg("dim", text),
+            styleSuggestionCaret: caretCell,
+        },
+    });
+    editor.setFocused?.(true);
+    return {
+        render(width) {
+            columns = width;
+            return editor.render(width);
+        },
+        handleInput: (data) => editor.handleInput?.(data),
+        handlePointer: (event) => editor.handlePointer(event),
+        getText: () => editor.getText(),
+        hasSelection: () => editor.hasSelection(),
+        ownsPointer: () => editor.ownsPointer(),
+        setFocused: (focused) => editor.setFocused?.(focused),
+    };
+}

package/dist/composition/utility-tab.d.ts

@@ -0,0 +1,28 @@
+import type { OwnedUiApplicationPort, PresentationTerminalPort } from "../contracts/presentation/index.js";
+import type { TabBridgeClient } from "../foundation/resident-tabs/bridge-client.js";
+import type { ResidentTabRoute } from "../foundation/resident-tabs/routes.js";
+import type { ReleaseNoteCatalog } from "../features/owned-ui/release-notes.js";
+import type { UiRouteHost } from "../ui/apps/contracts.js";
+import type { OwnedSettingsManager } from "../ui/settings/manager.js";
+import { terminateOwnedUiProcess } from "../features/owned-ui/run.js";
+export { terminateOwnedUiProcess };
+export interface UtilityTabOptions {
+    readonly route: ResidentTabRoute;
+    readonly bridge: TabBridgeClient;
+    readonly cwd?: string;
+    readonly profileId?: string;
+    readonly terminal?: PresentationTerminalPort;
+    readonly agentDir?: string;
+    readonly settings?: OwnedSettingsManager;
+    readonly routeHost?: UiRouteHost;
+    readonly releaseNotes?: ReleaseNoteCatalog;
+    readonly onApplication?: (application: OwnedUiApplicationPort) => void;
+}
+export interface UtilityTabComposition {
+    readonly application: OwnedUiApplicationPort;
+    readonly settings: OwnedSettingsManager;
+}
+/** Runs one pinned Settings or Changelog screen without constructing an Agent engine or session. */
+export declare function runUtilityTab(options: UtilityTabOptions): Promise<number>;
+export declare function composeUtilityTab(options: UtilityTabOptions): Promise<UtilityTabComposition>;
+export declare function utilityAgentDir(environment?: NodeJS.ProcessEnv): string;

package/dist/composition/utility-tab.js

@@ -0,0 +1,242 @@
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import { MAX_CLIPBOARD_TEXT_BYTES } from "../contracts/owned-ui/index.js";
+import { writeSystemClipboardText } from "../app/session-shell/system-clipboard.js";
+import { OwnedUiTerminalHost, } from "../app/session-shell/shell-host.js";
+import { nativeHyperlinkStyle } from "../ui/components/spans.js";
+import { createPiKeybindingsHost } from "../integrations/pi/components/shell-shared-facade.js";
+import { applyConfiguredPiTheme, setPiAccentColor, setPiPackageBorderProjectionEnabled } from "../integrations/pi/components/upstream/theme/theme.js";
+import { createPiTerminalBridge } from "../integrations/pi/tui-runtime/presentation-adapter.js";
+import { resolveLaunchProfilePaths } from "../features/launch/profile-paths.js";
+import { createOwnedSettingsManager, watchSharedSettings } from "./owned-settings.js";
+import { residentRouteHostOptions, residentTabKeybindings } from "./resident-tab-bridge.js";
+import { createOwnedRouteHost } from "./settings-route-host.js";
+import { runOwnedUi, terminateOwnedUiProcess } from "../features/owned-ui/run.js";
+export { terminateOwnedUiProcess };
+/** Runs one pinned Settings or Changelog screen without constructing an Agent engine or session. */
+export async function runUtilityTab(options) {
+    const composition = await composeUtilityTab(options);
+    options.onApplication?.(composition.application);
+    return await runOwnedUi(composition);
+}
+export async function composeUtilityTab(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const agentDir = options.agentDir ?? utilityAgentDir();
+    const { settings, offline } = await prepareUtilitySettings(options, cwd, agentDir);
+    await options.bridge.start().catch(() => false);
+    options.bridge.status("starting");
+    applyUtilityTheme(settings, options.bridge);
+    const keybindings = residentTabKeybindings(options.bridge, agentDir, createPiKeybindingsHost({ profile: "a1", agentDir }));
+    const routeHost = options.routeHost ?? createUtilityRouteHost(options, settings, keybindings, cwd, agentDir);
+    return {
+        settings,
+        application: createUtilityApplication(options, settings, offline, routeHost),
+    };
+}
+async function prepareUtilitySettings(options, cwd, agentDir) {
+    const offline = options.settings === undefined && options.route === "settings"
+        ? await import("../integrations/pi/engine/offline-settings-port.js")
+            .then(module => module.createOfflinePiSettingsPort({ cwd, agentDir }))
+        : null;
+    return {
+        offline,
+        settings: options.settings ?? createOwnedSettingsManager({
+            profileId: options.profileId ?? "a1",
+            agent: offline?.port ?? null,
+        }),
+    };
+}
+function applyUtilityTheme(settings, bridge) {
+    setPiPackageBorderProjectionEnabled(true);
+    setPiAccentColor(settings.value("accentColor"));
+    applyConfiguredPiTheme("dark");
+    bridge.accent(settings.value("accentColor"));
+}
+function createUtilityRouteHost(options, settings, keybindings, cwd, agentDir) {
+    let catalog;
+    const releaseNoteCatalog = () => catalog ??= options.releaseNotes === undefined
+        ? import("../features/owned-ui/release-notes.js").then(module => module.readPackagedReleaseNotes())
+        : Promise.resolve(options.releaseNotes);
+    return pinnedRouteHost(options.route, createOwnedRouteHost(settings, {
+        changelog: async () => {
+            const [notes, { renderPiShellChangelogLines }] = await Promise.all([
+                releaseNoteCatalog(),
+                import("../integrations/pi/components/shell-presenters-info.js"),
+            ]);
+            return { rows: width => renderPiShellChangelogLines(notes.completeMarkdown, width).map(row => nativeHyperlinkStyle(row)) };
+        },
+        hotkeys: async () => { throw new Error("hotkeys are unavailable in a utility tab"); },
+        session: async () => { throw new Error("session information is unavailable in a utility tab"); },
+    }, {
+        ...residentRouteHostOptions(options.bridge),
+        keybindings,
+        agentDir,
+        cwd,
+        copyText: text => {
+            if (Buffer.byteLength(text) <= MAX_CLIPBOARD_TEXT_BYTES)
+                void writeSystemClipboardText(text).catch(() => { });
+        },
+    }));
+}
+function createUtilityApplication(options, settings, offline, routeHost) {
+    const backgroundSettings = {
+        snapshot: () => settings.value("backgroundStyle"),
+        onChange: listener => settings.onChange(current => listener(current.value("backgroundStyle"))),
+    };
+    const terminalHost = new OwnedUiTerminalHost({
+        layout: "custom-viewport", mode: "fullscreen", hardwareCursor: false,
+        ...(options.terminal === undefined ? {} : { terminal: createPiTerminalBridge(options.terminal) }),
+        backgroundSettings,
+    });
+    const presenter = new UtilityTabPresenter(terminalHost, routeHost, options.route, options.bridge);
+    const removeBoundaryInput = terminalHost.runtime.addPreInputListener(data => ({ data: options.bridge.consumeControllerBoundaryInput(data) }));
+    const unwatchSettings = watchSharedSettings(settings);
+    const unsubscribeAccent = settings.onChange(current => {
+        const accent = current.value("accentColor");
+        setPiAccentColor(accent);
+        options.bridge.accent(accent);
+    });
+    let disposed = false;
+    let started = false;
+    let stopResolve;
+    let unsubscribeBridge = () => { };
+    const stopped = new Promise(resolvePromise => { stopResolve = resolvePromise; });
+    return {
+        get disposed() { return disposed; },
+        start: () => {
+            if (started || disposed)
+                return;
+            started = true;
+            presenter.start();
+            terminalHost.attach(presenter);
+            unsubscribeBridge = options.bridge.onCommand(command => handleBridgeCommand(command, presenter, options.route, () => {
+                stopResolve();
+                void terminalHost.dispose().catch(() => undefined);
+            }));
+            options.bridge.status("idle");
+            void offline?.modelsReady.then(() => settings.load()).catch(() => undefined);
+        },
+        flush: async () => { },
+        waitUntilStopped: () => stopped,
+        dispose: async () => {
+            if (disposed)
+                return;
+            disposed = true;
+            stopResolve();
+            unsubscribeBridge();
+            unsubscribeAccent();
+            unwatchSettings();
+            removeBoundaryInput();
+            try {
+                await terminalHost.dispose();
+            }
+            finally {
+                options.bridge.close();
+            }
+        },
+    };
+}
+function pinnedRouteHost(route, host) {
+    return {
+        claims: candidate => candidate === route && host.claims(candidate),
+        open: (candidate, input) => candidate === route ? host.open(candidate, input) : null,
+    };
+}
+function handleBridgeCommand(command, presenter, route, stop) {
+    if (command.type === "stop")
+        stop();
+    else if (command.type === "route" && command.route === route)
+        presenter.presentRoute();
+}
+export function utilityAgentDir(environment = process.env) {
+    const configured = environment.PI_CODING_AGENT_DIR;
+    if (configured !== undefined && configured.trim().length > 0) {
+        return resolve(configured.startsWith("~/") || configured.startsWith("~\\")
+            ? `${homedir()}${configured.slice(1)}`
+            : configured);
+    }
+    return resolveLaunchProfilePaths().agentProfile;
+}
+class UtilityTabPresenter {
+    #host;
+    #terminal;
+    #routeHost;
+    #route;
+    #bridge;
+    #surface = null;
+    #routeHandle = null;
+    #released = false;
+    constructor(host, routeHost, route, bridge) {
+        this.#host = host;
+        this.#routeHost = routeHost;
+        this.#route = route;
+        this.#bridge = bridge;
+        this.#terminal = host.connect(this);
+    }
+    render(_width) { return []; }
+    handleInput(_data) { }
+    invalidate() { this.#terminal.requestRender(); }
+    setFocused(_focused) { }
+    inputCoordinationSurface() { return "owned"; }
+    setOverlaySurfaces(_surfaces) { }
+    noteImmediatePresentation() { }
+    handleViewportInput(_data) { return undefined; }
+    layoutPart(_part) { return EMPTY_COMPONENT; }
+    activated() { this.presentRoute(); }
+    start() { this.#terminal.start(); }
+    waitUntilStopped() { return new Promise(() => { }); }
+    dispose() { return this.#host.close(this); }
+    presentRoute() {
+        if (this.#released || this.#routeHandle !== null)
+            return;
+        if (!this.#terminal.running || !this.#terminal.attached)
+            return;
+        const surface = this.#routeHost.open(this.#route);
+        if (surface === null)
+            throw new Error(`utility route is unavailable: ${this.#route}`);
+        this.#surface = surface;
+        let exitRequested = false;
+        const handle = this.#terminal.openRoute(surface, {
+            closed: rendered => {
+                if (this.#routeHandle === handle)
+                    this.#routeHandle = null;
+                this.#surface = null;
+                queueMicrotask(() => {
+                    if (rendered && !exitRequested)
+                        void this.#bridge.requestClose();
+                });
+            },
+            exit: () => {
+                exitRequested = true;
+                void this.#bridge.requestDetach().then(() => this.presentRoute(), () => this.presentRoute());
+            },
+        });
+        this.#routeHandle = handle;
+    }
+    release() {
+        if (this.#released)
+            return { exitText: "", failures: [], settle: async () => [] };
+        this.#released = true;
+        const failures = [];
+        try {
+            this.#routeHandle?.hide();
+        }
+        catch (error) {
+            failures.push(error);
+        }
+        try {
+            this.#surface?.close();
+        }
+        catch (error) {
+            failures.push(error);
+        }
+        this.#routeHandle = null;
+        this.#surface = null;
+        return { exitText: "", failures, settle: async () => [] };
+    }
+}
+const EMPTY_COMPONENT = {
+    render: () => [],
+    handleInput: () => { },
+    invalidate: () => { },
+};

package/dist/contracts/owned-ui/session-backend.d.ts

@@ -37,6 +37,8 @@ export interface OwnedUiSessionIdentityPort {
     readonly sessionBindingGeneration: number;
     readonly disposed: boolean;
     currentSessionFile(): string | null;
+    /** The durable conversation identity; unlike sessionId it survives agent process restart. */
+    currentHistorySessionId(): string | null;
     currentSessionResumeMetadata(): OwnedUiSessionResumeMetadata | null;
 }
 /** The session lifecycle, its view, its event stream, and command admission. */

package/dist/contracts/owned-ui/session-workflows.d.ts

@@ -337,9 +337,13 @@ export interface OwnedUiVisualExtensionSupport {
     readonly renderCallbacks: typeof OWNED_UI_EXTENSION_RENDER_CALLBACKS;
     readonly diagnostic: string;
 }
-/** A newer release found by the startup check. */
-export interface OwnedUiReleaseUpdate {
+/** A newer release found by the startup check, or one installed for the next restart. */
+export type OwnedUiReleaseUpdate = {
+    readonly status?: "available";
     readonly version: string;
     readonly command: string;
     readonly changelogUrl: string | null;
-}
+} | {
+    readonly status: "installed";
+    readonly version: string;
+};

package/dist/contracts/presentation/index.d.ts

@@ -14,6 +14,17 @@ export declare const DIALOG_BACK_SHORTCUT_HINT: Readonly<{
     key: string;
     action: string;
 }>;
+/** Global inset inherited by every semantic row inside an A1-owned dialog frame. */
+export declare const DIALOG_CONTENT_PADDING_X = 1;
+export interface DialogFrameGeometry {
+    readonly frameWidth: number;
+    readonly contentPaddingX: number;
+    readonly contentWidth: number;
+}
+/** Shared full-width-rule/content-width geometry for string and component dialog renderers. */
+export declare function dialogFrameGeometry(width: number): DialogFrameGeometry;
+/** Injects a semantic row into the frame's global content inset. */
+export declare function insetDialogContent(row: string, geometry: DialogFrameGeometry): string;
 export interface ShortcutHintRoles {
     key(label: string): string;
     action(name: string): string;

package/dist/contracts/presentation/index.js

@@ -2,6 +2,18 @@
 export const DIALOG_CLOSE_SHORTCUT_HINT = Object.freeze({ key: "esc", action: "close" });
 /** Canonical return guidance for a nested step within a dialog surface. */
 export const DIALOG_BACK_SHORTCUT_HINT = Object.freeze({ key: "esc", action: "back" });
+/** Global inset inherited by every semantic row inside an A1-owned dialog frame. */
+export const DIALOG_CONTENT_PADDING_X = 1;
+/** Shared full-width-rule/content-width geometry for string and component dialog renderers. */
+export function dialogFrameGeometry(width) {
+    const frameWidth = Math.max(0, width);
+    const contentPaddingX = Math.min(DIALOG_CONTENT_PADDING_X, frameWidth);
+    return { frameWidth, contentPaddingX, contentWidth: frameWidth - contentPaddingX };
+}
+/** Injects a semantic row into the frame's global content inset. */
+export function insetDialogContent(row, geometry) {
+    return `${" ".repeat(geometry.contentPaddingX)}${row}`;
+}
 const SHORTCUT_KEY_NAMES = Object.freeze({
     alt: "Alt", backspace: "Backspace", cmd: "Cmd", ctrl: "Ctrl", delete: "Delete", down: "Down", end: "End",
     enter: "Enter", esc: "Esc", escape: "Escape", home: "Home", insert: "Insert", left: "Left", meta: "Meta",

package/dist/features/launch/development-launch.js

@@ -19,6 +19,11 @@ export function resolveDevelopmentLaunchEnvironment(canonicalPackageRoot, releas
         ? join(developmentRoot, "config")
         : join(checkoutRoot, "config");
     const dataDir = resolve(source[PRODUCT_IDENTITY.environment.dataDir] ?? join(developmentRoot, "data"));
+    // Rationale: solo processes keep isolated control state but must see the same history
+    // after selecting Shared; use a checkout-wide root across rebuilds unless overridden.
+    const historyDataDir = resolve(source[PRODUCT_IDENTITY.environment.developmentHistoryDataDir]
+        ?? source[PRODUCT_IDENTITY.environment.dataDir]
+        ?? (selectedDevelopmentRoot ? dataDir : join(checkoutRoot, "data")));
     return {
         checkoutId,
         releaseId,
@@ -27,6 +32,7 @@ export function resolveDevelopmentLaunchEnvironment(canonicalPackageRoot, releas
         environment: {
             ...source,
             [PRODUCT_IDENTITY.environment.developmentInstanceId]: instanceId,
+            [PRODUCT_IDENTITY.environment.developmentHistoryDataDir]: historyDataDir,
             [PRODUCT_IDENTITY.environment.configDir]: resolve(source[PRODUCT_IDENTITY.environment.configDir] ?? persistentConfigDir),
             [PRODUCT_IDENTITY.environment.dataDir]: dataDir,
             [PRODUCT_IDENTITY.environment.runtimeDir]: resolve(source[PRODUCT_IDENTITY.environment.runtimeDir] ?? join(developmentRoot, "runtime")),

package/dist/features/launch/profile-paths.js

@@ -18,6 +18,10 @@ export function resolveLaunchProfilePaths(options = {}) {
 export function resolvePromptHistoryDataDir(options = {}) {
     const environment = options.environment ?? process.env;
     const platform = options.platform ?? process.platform;
+    const developmentHistoryDataDir = environment[PRODUCT_IDENTITY.environment.developmentHistoryDataDir];
+    if (developmentHistoryDataDir !== undefined) {
+        return resolveProductPaths({ ...environment, [PRODUCT_IDENTITY.environment.dataDir]: developmentHistoryDataDir }, platform).dataDir;
+    }
     if (environment[PRODUCT_IDENTITY.environment.dataDir] !== undefined) {
         return resolveProductPaths(environment, platform).dataDir;
     }

package/dist/features/owned-ui/plus-menu-dialog.d.ts

@@ -0,0 +1,22 @@
+import type { UiTheme } from "../../ui/components/index.js";
+/** The A1 setting holding the tab kinds the strip's `+` offers. */
+export declare const PLUS_MENU_SETTING_ID = "tabBarPlusMenu";
+/** One tab kind the plus menu can offer. */
+export interface PlusMenuKind {
+    readonly key: string;
+    readonly label: string;
+}
+/**
+ * The plus-menu dialog: every tab kind with `●` when `+` offers it and `○` when not, filtered by typed
+ * text. It owns only its filter and the row in hand; the enabled record and its saving stay with the
+ * Settings screen that opened it.
+ */
+export declare class PlusMenuDialog {
+    #private;
+    constructor(kinds: readonly PlusMenuKind[]);
+    /** The kinds the filter keeps, in kind order. */
+    shown(): readonly PlusMenuKind[];
+    /** Handles one key by its resolved name; `toggle` flips a kind. Returns whether the dialog closed. */
+    handle(name: string, data: string, toggle: (key: string) => void): "close" | "handled";
+    lines(enabled: Readonly<Record<string, boolean | string>>, width: number, theme: UiTheme): readonly string[];
+}

package/dist/features/owned-ui/plus-menu-dialog.js

@@ -0,0 +1,76 @@
+import { LineInput, displayWidth, handleLineInputKey, renderInputRow, truncateToWidth, } from "../../ui/components/index.js";
+/** The A1 setting holding the tab kinds the strip's `+` offers. */
+export const PLUS_MENU_SETTING_ID = "tabBarPlusMenu";
+const TITLE = "Plus Menu";
+const DESCRIPTION = "Choose what the + button in the tab bar can add.";
+const HINT = "Type search · ↑↓ navigate · Space toggle · Esc close";
+/**
+ * The plus-menu dialog: every tab kind with `●` when `+` offers it and `○` when not, filtered by typed
+ * text. It owns only its filter and the row in hand; the enabled record and its saving stay with the
+ * Settings screen that opened it.
+ */
+export class PlusMenuDialog {
+    #kinds;
+    #filter = new LineInput("");
+    #index = 0;
+    constructor(kinds) {
+        this.#kinds = kinds;
+    }
+    /** The kinds the filter keeps, in kind order. */
+    shown() {
+        const needle = this.#filter.value.trim().toLowerCase();
+        return this.#kinds.filter(kind => needle.length === 0 || kind.label.toLowerCase().includes(needle));
+    }
+    /** Handles one key by its resolved name; `toggle` flips a kind. Returns whether the dialog closed. */
+    handle(name, data, toggle) {
+        const shown = this.shown();
+        if (name === "escape")
+            return "close";
+        if (name === "up" || name === "down") {
+            this.#index = Math.min(Math.max(0, shown.length - 1), Math.max(0, this.#index + (name === "down" ? 1 : -1)));
+            return "handled";
+        }
+        if (name === "space") {
+            const kind = shown[this.#index];
+            if (kind !== undefined)
+                toggle(kind.key);
+            return "handled";
+        }
+        handleLineInputKey(this.#filter, data);
+        this.#index = 0;
+        return "handled";
+    }
+    lines(enabled, width, theme) {
+        const rule = theme.fg("border", "─".repeat(Math.max(0, width)));
+        const inset = width > 0 ? " " : "";
+        const contentWidth = Math.max(0, width - inset.length);
+        const row = (painted, raw) => {
+            const clipped = truncateToWidth(painted, contentWidth);
+            return `${inset}${clipped}${" ".repeat(Math.max(0, contentWidth - displayWidth(raw)))}`;
+        };
+        const shown = this.shown();
+        const index = Math.min(this.#index, Math.max(0, shown.length - 1));
+        const rows = shown.length === 0
+            ? [row(theme.fg("dim", "No tabs match"), "No tabs match")]
+            : shown.map((kind, position) => {
+                const selected = position === index;
+                const cursor = selected ? "→ " : "  ";
+                const marker = enabled[kind.key] === true ? "●" : "○";
+                const raw = `${cursor}${marker} ${kind.label}`;
+                const content = `${selected ? theme.fg("accent", cursor) : cursor}${theme.fg("text", marker)} ${theme.fg("text", kind.label)}`;
+                return row(selected ? theme.highlight(content) : content, raw);
+            });
+        return [
+            rule,
+            row(theme.bold(theme.fg("accent", TITLE)), TITLE),
+            row(theme.fg("dim", DESCRIPTION), DESCRIPTION),
+            "",
+            ...renderInputRow(this.#filter, width, { ruled: false, promptGlyph: "> ", theme }).lines,
+            "",
+            ...rows,
+            "",
+            row(theme.fg("dim", HINT), HINT),
+            rule,
+        ];
+    }
+}

package/dist/features/owned-ui/project-trust-dialog.d.ts

@@ -1,2 +1,2 @@
 /** Fixed startup-safe rendering only; project-derived presentation is forbidden before trust resolves. */
-export declare function renderProjectTrustDialog(cwd: string, options: readonly string[], selected: number, terminalWidth: number, terminalRows: number): readonly string[];
+export declare function renderProjectTrustDialog(cwd: string, options: readonly string[], selected: number, terminalWidth: number, terminalRows: number, accent: string, border: string): readonly string[];

package/dist/features/owned-ui/project-trust-dialog.js

@@ -1,6 +1,4 @@
 import { DIALOG_CLOSE_SHORTCUT_HINT, displayShortcutKeyLabel } from "../../contracts/presentation/index.js";
-const ACCENT = "\u001b[38;2;167;152;215m";
-const BORDER = "\u001b[38;2;97;133;204m";
 const MUTED = "\u001b[38;2;157;165;169m";
 const DIM = "\u001b[38;2;126;136;142m";
 const RESET_FG = "\u001b[39m";
@@ -8,12 +6,12 @@ const BOLD = "\u001b[1m";
 const RESET_BOLD = "\u001b[22m";
 const EXPLANATION = "This allows to load project settings and resources, install missing project packages, and execute project extensions.";
 /** Fixed startup-safe rendering only; project-derived presentation is forbidden before trust resolves. */
-export function renderProjectTrustDialog(cwd, options, selected, terminalWidth, terminalRows) {
+export function renderProjectTrustDialog(cwd, options, selected, terminalWidth, terminalRows, accent, border) {
     const width = Math.max(1, terminalWidth);
-    const rule = `${BORDER}${"─".repeat(width)}${RESET_FG}`;
-    const title = ` ${BOLD}${ACCENT}Trust project folder?${RESET_FG}${RESET_BOLD}`;
+    const rule = `${border}${"─".repeat(width)}${RESET_FG}`;
+    const title = ` ${BOLD}${accent}Trust project folder?${RESET_FG}${RESET_BOLD}`;
     const path = ` ${MUTED}${sanitize(cwd)}${RESET_FG}`;
-    const choices = options.map((label, index) => choice(label, selected === index));
+    const choices = options.map((label, index) => choice(label, selected === index, accent));
     const closeKey = displayShortcutKeyLabel(DIALOG_CLOSE_SHORTCUT_HINT.key);
     const hint = ` ${DIM}↑↓${MUTED} navigate  ${DIM}Enter${MUTED} select  ${DIM}${closeKey}${MUTED} ${DIALOG_CLOSE_SHORTCUT_HINT.action}${RESET_FG}`;
     const explanation = wrap(EXPLANATION, Math.max(1, width - 2)).map(line => ` ${line}`);
@@ -35,8 +33,8 @@ export function renderProjectTrustDialog(cwd, options, selected, terminalWidth,
         return choiceWindow(choices, selected, 2);
     return [choices[selected] ?? choices[0] ?? ""];
 }
-function choice(label, selected) {
-    return selected ? ` ${ACCENT}→ ${label}${RESET_FG}` : `   ${label}`;
+function choice(label, selected, accent) {
+    return selected ? ` ${accent}→ ${label}${RESET_FG}` : `   ${label}`;
 }
 function choiceWindow(choices, selected, capacity) {
     const start = Math.min(Math.max(0, selected - Math.floor(capacity / 2)), Math.max(0, choices.length - capacity));

package/dist/features/owned-ui/project-trust-prompt.d.ts

@@ -22,6 +22,7 @@ export interface ConsoleProjectTrustPromptOptions {
         readonly rows?: number;
     };
     readonly presentation?: "bare" | "comparison";
+    readonly environment?: NodeJS.ProcessEnv;
 }
 /** Fixed pre-resource selector; no project resource is available. */
 export declare function createConsoleProjectTrustPrompt(options?: ConsoleProjectTrustPromptOptions): OwnedProjectTrustPrompt;

package/dist/features/owned-ui/project-trust-prompt.js

@@ -1,4 +1,5 @@
 import { EMERGENCY_TERMINAL_RESET } from "../../foundation/terminal-cleanup/terminal-reset.js";
+import { preTrustPalette, preTrustTerminalAppearance, preTrustTerminalColorMode, readPreTrustAccent } from "../../ui/settings/early-accent.js";
 const ENTER_ALTERNATE_SCREEN = "\u001b[?1049h";
 const HIDE_CURSOR = "\u001b[?25l";
 const CLEAR_HOME = "\u001b[2J\u001b[H";
@@ -34,8 +35,8 @@ export function createConsoleProjectTrustPrompt(options = {}) {
         if (choices.length === 0)
             throw new Error("project trust choices are unavailable");
         const comparison = options.presentation === "comparison";
-        const renderBareDialog = comparison
-            ? undefined : (await import("./project-trust-dialog.js")).renderProjectTrustDialog;
+        const renderBareDialog = comparison ? undefined : (await import("./project-trust-dialog.js")).renderProjectTrustDialog;
+        const palette = comparison ? null : trustPaletteOptions(options.environment ?? process.env);
         const wasRaw = input.isRaw === true;
         let selected = 0;
         let restored = false;
@@ -66,7 +67,7 @@ export function createConsoleProjectTrustPrompt(options = {}) {
         const render = () => {
             const width = Math.max(renderBareDialog ? 1 : 20, output.columns ?? 80);
             const rows = Math.max(1, output.rows ?? 24);
-            const lines = (renderBareDialog?.(cwd, choices.map(choice => choice.label), selected, width, rows) ?? [
+            const lines = (renderBareDialog?.(cwd, choices.map(choice => choice.label), selected, width, rows, palette.accent, palette.border) ?? [
                 `${BOLD}${ACCENT}Trust project folder?${RESET_FG}${RESET_BOLD}`,
                 cwd,
                 "",
@@ -179,6 +180,9 @@ export function createConsoleProjectTrustPrompt(options = {}) {
         }
     };
 }
+function trustPaletteOptions(environment) {
+    return preTrustPalette(readPreTrustAccent(environment), preTrustTerminalAppearance(environment), preTrustTerminalColorMode(environment));
+}
 function optionRow(label, selected) {
     return selected
         ? `${ACCENT}→ ${label}${RESET_FG}`

package/dist/features/owned-ui/reference-screen-app.d.ts

@@ -24,6 +24,8 @@ export interface ReferenceScreenOptions {
     readonly document: ReferenceDocumentProvider;
     /** The reader's scroll settings, read on every frame so a live change is honored. */
     readonly scrollSettings: () => OwnedUiViewportSettings;
+    /** The screen is a resident tab, such as the Changelog tab: it offers no screen-level close. */
+    readonly pinned?: boolean;
 }
 /**
  * Presents one read-only document full screen between two accent rules: the bold