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

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

@@ -1,3 +1,9 @@
+import type { PresentationComponentPort } from "./component.js";
+export type { PresentationComponentPort, PresentationPointerSurface } from "./component.js";
+export { samePointerSurfaces } from "./component.js";
+export type { CanvasBackgroundStyle, ShellPresentationPorts, ThemeSource, UiTheme, UiThemeBackground, UiThemeToken } from "./theme.js";
+export type { TerminalComponentPort, TerminalDamageDecision, TerminalDamageDecisionReason, TerminalDamageFrameDescriptor, TerminalDamageFrameSafety, TerminalDamageOptions, TerminalDamagePort, TerminalHyperlinkInspection, TerminalInputCoordinationDecision, TerminalInputCoordinationScheduler, TerminalInputDiagnosticsEvent, TerminalInputDiagnosticsPhase, TerminalInputListener, TerminalInputListenerResult, TerminalInputSurfaceKind, TerminalLayoutEntry, TerminalLayoutNode, TerminalOverlayAnchor, TerminalOverlayHandle, TerminalOverlayMargin, TerminalOverlayOptions, TerminalOverlayUnfocusOptions, TerminalPointerSurface, TerminalPort, TerminalPreInputListener, TerminalProgramStatus, TerminalRuntimeFactory, TerminalRuntimeOptions, TerminalRuntimePort, TerminalRuntimeState, TerminalScrollState, TerminalSizeValue, TerminalStopOptions, TerminalViewport, TerminalWheelScrollLines, } from "./terminal.js";
+export { SHARED_PROGRESS_ACCENT_ANSI, SHARED_PROGRESS_PALETTE } from "./progress-palette.generated.js";
 export type PresentationRuntimeState = "idle" | "running" | "stopping" | "stopped" | "failed";
 export interface SemanticShortcutHint {
     readonly key?: string;
@@ -33,21 +39,6 @@ export interface ShortcutHintRoles {
 export declare function displayShortcutKeyLabel(label: string): string;
 /** Renders the canonical semantic shortcut row independently of either presentation framework. */
 export declare function renderSemanticShortcutHints(entries: readonly SemanticShortcutHint[], roles: ShortcutHintRoles, indent?: number, separator?: string): string;
-export interface PresentationComponentPort {
-    render(width: number): readonly string[];
-    invalidate(): void;
-    handleInput?(data: string): void;
-    setFocused?(focused: boolean): void;
-    dispose?(): void;
-}
-/** A painted input surface in terminal coordinates (one-based, inclusive bounds). */
-export interface PresentationPointerSurface {
-    readonly component: PresentationComponentPort;
-    readonly columnStart: number;
-    readonly columnEnd: number;
-    readonly rowStart: number;
-    readonly rowEnd: number;
-}
 export interface PresentationEditorPort extends PresentationComponentPort {
     getText(): string;
     setText(text: string): void;

package/dist/contracts/presentation/index.js

@@ -1,3 +1,5 @@
+export { samePointerSurfaces } from "./component.js";
+export { SHARED_PROGRESS_ACCENT_ANSI, SHARED_PROGRESS_PALETTE } from "./progress-palette.generated.js";
 /** Canonical dismissal guidance for every A1-rendered dialog surface. */
 export const DIALOG_CLOSE_SHORTCUT_HINT = Object.freeze({ key: "esc", action: "close" });
 /** Canonical return guidance for a nested step within a dialog surface. */

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

@@ -0,0 +1,290 @@
+import type { PresentationComponentPort, PresentationPointerSurface } from "./component.js";
+/** A program-status report for terminals that show one (OSC 9;4 style); `clear` removes it. */
+export interface TerminalProgramStatus {
+    state: "idle" | "working" | "blocked" | "done" | "error" | "clear";
+    app?: string;
+    kind?: "permission" | "question" | "auth";
+}
+/** Lines one wheel notch scrolls, or `auto` to follow wheel velocity. */
+export type TerminalWheelScrollLines = number | "auto";
+/** Whether queued input may be applied immediately or must wait for the current presentation. */
+export type TerminalInputCoordinationDecision = "safe" | "barrier";
+/** What kind of surface owns the keyboard when input arrives. */
+export type TerminalInputSurfaceKind = "editor" | "owned" | "opaque";
+export interface TerminalInputCoordinationScheduler {
+    scheduleImmediate(callback: () => void): ReturnType<typeof setImmediate>;
+    cancelImmediate(handle: ReturnType<typeof setImmediate>): void;
+}
+export type TerminalRuntimeState = "idle" | "running" | "stopping" | "stopped" | "failed";
+export interface TerminalViewport {
+    readonly columns: number;
+    readonly rows: number;
+}
+export interface TerminalScrollState {
+    readonly scrollTop: number;
+    readonly viewportHeight: number;
+    readonly followingEnd: boolean;
+    readonly scrollbarVisible: boolean;
+}
+export type TerminalPointerSurface = PresentationPointerSurface;
+export interface TerminalComponentPort extends PresentationComponentPort {
+    readonly wantsKeyRelease?: boolean;
+}
+export interface TerminalPort {
+    start(onInput: (data: string) => void, onResize: () => void): void;
+    stop(): void;
+    drainInput(maxMs?: number, idleMs?: number): Promise<void>;
+    write(data: string): void;
+    readonly columns: number;
+    readonly rows: number;
+    readonly kittyProtocolActive: boolean;
+    moveBy(lines: number): void;
+    hideCursor(): void;
+    showCursor(): void;
+    clearLine(): void;
+    clearFromCursor(): void;
+    clearScreen(): void;
+    setTitle(title: string): void;
+    setProgress(active: boolean): void;
+    /** Optional for neutral test/decorator ports; the vendor adapter always supplies it. */
+    setProgramStatus?(status: TerminalProgramStatus): void;
+    /**
+     * Optional synchronous last-resort mode restore that the runtime invokes from a process `exit` handler when
+     * `stop()` did not run; the runtime adapter binds it to the undecorated terminal, so decorators need not forward it.
+     */
+    restoreOnExit?(before: string, after: string): void;
+}
+export type TerminalSizeValue = number | `${number}%`;
+export type TerminalOverlayAnchor = "center" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | "top-center" | "bottom-center" | "left-center" | "right-center";
+export interface TerminalOverlayMargin {
+    readonly top?: number;
+    readonly right?: number;
+    readonly bottom?: number;
+    readonly left?: number;
+}
+export interface TerminalOverlayOptions {
+    readonly width?: TerminalSizeValue;
+    readonly minWidth?: number;
+    readonly maxHeight?: TerminalSizeValue;
+    readonly anchor?: TerminalOverlayAnchor;
+    readonly offsetX?: number;
+    readonly offsetY?: number;
+    readonly row?: TerminalSizeValue;
+    readonly col?: TerminalSizeValue;
+    readonly margin?: TerminalOverlayMargin | number;
+    readonly visible?: (columns: number, rows: number) => boolean;
+    readonly nonCapturing?: boolean;
+    /** A1-owned input scheduling declaration; omitted extension overlays fail closed. */
+    readonly inputCoordination?: Exclude<TerminalInputSurfaceKind, "editor">;
+}
+export interface TerminalOverlayUnfocusOptions {
+    readonly target: TerminalComponentPort | null;
+}
+export interface TerminalOverlayHandle {
+    hide(): void;
+    setHidden(hidden: boolean): void;
+    isHidden(): boolean;
+    focus(): void;
+    unfocus(options?: TerminalOverlayUnfocusOptions): void;
+    isFocused(): boolean;
+    /** The most recently rendered terminal-relative rectangle of a visible overlay. */
+    getBounds(): {
+        readonly row: number;
+        readonly col: number;
+        readonly width: number;
+        readonly height: number;
+    } | undefined;
+}
+export interface TerminalInputListenerResult {
+    readonly consume?: boolean;
+    readonly data?: string;
+}
+export type TerminalInputListener = (data: string) => TerminalInputListenerResult | undefined;
+/** Runs at the terminal bridge before the runtime receives physical input. */
+export type TerminalPreInputListener = TerminalInputListener;
+export interface TerminalLayoutEntry {
+    readonly node: TerminalLayoutNode;
+    readonly basis?: number | "auto";
+    readonly grow?: number;
+    readonly shrink?: number;
+    readonly minSize?: number;
+    readonly maxSize?: number;
+    readonly visible?: (viewport: TerminalViewport) => boolean;
+}
+export type TerminalLayoutNode = {
+    readonly type: "component";
+    readonly component: TerminalComponentPort;
+} | {
+    readonly type: "stack";
+    readonly direction: "vertical" | "horizontal";
+    readonly children: readonly TerminalLayoutEntry[];
+    readonly gap?: number;
+    readonly align?: "stretch" | "start" | "center" | "end";
+} | {
+    readonly type: "scroll";
+    readonly id: string;
+    readonly child: TerminalLayoutNode;
+    readonly follow?: "none" | "end";
+    readonly primary?: boolean;
+    readonly overscroll?: "chain" | "contain";
+    readonly scrollbar?: "hidden" | "auto" | "always";
+    /** Styles the scrollbar track; the pinned runtime draws it as foreground text. */
+    readonly scrollbarTrackStyle?: (text: string) => string;
+    /** Styles the scrollbar thumb; the pinned runtime draws it as foreground text. */
+    readonly scrollbarThumbStyle?: (text: string) => string;
+    readonly scrollbarHideDelayMs?: number;
+};
+export type TerminalInputDiagnosticsPhase = "receipt" | "semantic-start" | "semantic-end" | "composition-start" | "composition-end" | "write-start" | "write-end";
+export interface TerminalInputDiagnosticsEvent {
+    readonly phase: TerminalInputDiagnosticsPhase;
+    readonly revision: number;
+    readonly atMs: number;
+    readonly pendingDepth: number;
+    readonly pendingPresentationDepth: 0 | 1;
+    readonly appliedRevision: number;
+}
+export interface TerminalRuntimeOptions {
+    readonly root: TerminalComponentPort;
+    /** Bare viewport only: painted overlays in back-to-front order; null while geometry is stale. */
+    readonly onOverlayGeometry?: (surfaces: readonly TerminalPointerSurface[] | null) => void;
+    readonly mode?: "regular" | "fullscreen";
+    readonly layoutRoot?: TerminalLayoutNode;
+    readonly terminal?: TerminalPort;
+    /** A1-owned public-boundary decorator; comparison paths omit it. */
+    readonly decorateTerminal?: (terminal: TerminalPort) => TerminalPort;
+    /** Bare-custom-viewport scheduling policy; comparison paths omit it. */
+    readonly inputCoordination?: {
+        readonly classify: (data: string, focusedOverlay?: Exclude<TerminalInputSurfaceKind, "editor">) => TerminalInputCoordinationDecision;
+        readonly onReceipt?: () => void;
+        readonly scheduler?: TerminalInputCoordinationScheduler;
+    };
+    /** Optional bounded evidence hook. Production composition omits it. */
+    readonly inputDiagnostics?: {
+        readonly onEvent: (event: TerminalInputDiagnosticsEvent) => void;
+        readonly now?: () => number;
+    };
+    readonly hardwareCursor?: boolean;
+    readonly mouse?: boolean;
+    /** Consume residual SGR mouse reports after every pre-input listener has run. */
+    readonly consumeUnhandledMouse?: boolean;
+    readonly wheelScrollLines?: TerminalWheelScrollLines;
+    readonly openUrl?: (url: string) => void;
+    readonly onRightClickPaste?: () => void;
+    readonly logDirectory?: string;
+}
+export interface TerminalStopOptions {
+    readonly preserveScreen?: boolean;
+    readonly drainInput?: boolean;
+    readonly drainMaxMs?: number;
+    readonly drainIdleMs?: number;
+}
+export interface TerminalDamageFrameDescriptor {
+    /**
+     * 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;
+    readonly transcript: {
+        readonly rowStart: number;
+        readonly rowEnd: number;
+    } | null;
+    readonly dock: {
+        readonly rowStart: number;
+        readonly rowEnd: number;
+    } | null;
+    /**
+     * Visible rows owned by the block that is currently streaming. A live block repaints
+     * every row it owns when it reflows, so the allowed damage follows the declared tail
+     * instead of assuming a one-row tail.
+     */
+    readonly liveTailRows?: number;
+    readonly verticalShiftRows: number;
+    readonly safeVerticalShift: boolean;
+    readonly cause: string;
+}
+export interface TerminalDamageFrameSafety {
+    readonly overlayActive: boolean;
+    readonly selectionActive: boolean;
+    readonly replacementSurfaceActive: boolean;
+}
+export type TerminalDamageDecisionReason = "transformed" | "suppressed-redundant-clear" | "hyperlink-cleanup" | "pending-hyperlink-cleanup" | "not-armed" | "unsafe-frame" | "stale-frame" | "unsupported-region-scroll" | "geometry-mismatch" | "grammar-mismatch" | "unsafe-terminal-content" | "incomplete-prior-frame" | "excessive-real-damage";
+export interface TerminalDamageDecision {
+    readonly frameId: number | null;
+    readonly transformed: boolean;
+    readonly reason: TerminalDamageDecisionReason;
+    readonly shiftRows: number;
+    readonly paintedRows: readonly number[];
+}
+/** What the shell's hyperlink analysis reports for one visible row. */
+export interface TerminalHyperlinkInspection {
+    readonly ranges: readonly unknown[];
+    readonly hasExplicitLink: boolean;
+    readonly signature: string;
+    readonly replaySafe: boolean;
+    readonly width: number;
+}
+export interface TerminalDamageOptions {
+    readonly regionalScroll: boolean;
+    /** The shell supplies visible-row analysis; the terminal layer owns no UI parser. */
+    readonly inspectHyperlinks: (content: string) => TerminalHyperlinkInspection;
+    readonly onResize?: () => void;
+    readonly onHyperlinkCleanupRequired?: () => void;
+}
+/** A terminal decorator that repaints only the rows a frame declares changed. */
+export interface TerminalDamagePort extends TerminalPort {
+    readonly lastDecision: TerminalDamageDecision;
+    readonly canvasBackgroundAnsi: string | null;
+    readonly presentationEpoch: number;
+    invalidatePresentation(): void;
+    /** Returns true when the background changed and a full repaint is needed. */
+    setCanvasBackground(ansi: string | null): boolean;
+    presentedRows(): readonly string[];
+    requestHyperlinkCleanup(rows?: readonly number[]): void;
+    arm(descriptor: TerminalDamageFrameDescriptor, safety: TerminalDamageFrameSafety): void;
+}
+/** The terminal runtime the shell drives: one root, overlays, input listeners, and modes. */
+export interface TerminalRuntimePort {
+    readonly state: TerminalRuntimeState;
+    readonly active: boolean;
+    readonly mode: "regular" | "fullscreen";
+    /** Full repaints since start, for rendering evidence. */
+    readonly fullRedraws: number;
+    readonly presentationHeld: boolean;
+    viewport(): TerminalViewport;
+    start(): void;
+    showOverlay(component: TerminalComponentPort, options?: TerminalOverlayOptions): TerminalOverlayHandle;
+    hasOverlay(): boolean;
+    hasFocusedOverlay(): boolean;
+    writeControl(data: string): void;
+    freezePresentation(): void;
+    beginPresentationHold(): () => void;
+    addPreInputListener(listener: TerminalPreInputListener): () => void;
+    addInputListener(listener: TerminalInputListener): () => void;
+    switchMode(mode: "regular" | "fullscreen"): boolean;
+    setHardwareCursor(enabled: boolean): void;
+    setClearOnShrink(enabled: boolean): void;
+    setWheelScrollLines(lines: TerminalWheelScrollLines): void;
+    setTerminalProgress(active: boolean): void;
+    setProgramStatus(status: TerminalProgramStatus): void;
+    setTitle(title: string): void;
+    writeAfterStop(text: string): void;
+    invalidate(): void;
+    requestRender(force?: boolean): void;
+    renderNow(force?: boolean): void;
+    stop(options?: TerminalStopOptions): Promise<void>;
+    dispose(options?: TerminalStopOptions): Promise<void>;
+}
+/** Builds the terminal runtime and its helpers; the vendor TUI adapter implements it. */
+export interface TerminalRuntimeFactory {
+    createRuntime(options: TerminalRuntimeOptions): TerminalRuntimePort;
+    createDamageTerminal(terminal: TerminalPort, options: TerminalDamageOptions): TerminalDamagePort;
+    /** Whether input on a surface may be applied before the current presentation completes. */
+    classifyInput(data: string, surface: TerminalInputSurfaceKind): TerminalInputCoordinationDecision;
+    /** Decodes an enhanced-keyboard sequence to the legacy byte form, or "" for a key release. */
+    legacyKeyInput(data: string): string;
+    /** Rebases a painted row's default background onto the given background sequence. */
+    rebaseDefaultBackground(content: string, backgroundAnsi: string): string;
+}

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

@@ -0,0 +1,46 @@
+/** Foreground roles a vendor-neutral surface paints with. */
+export type UiThemeToken = "accent" | "mdHeading" | "mdLink" | "text" | "muted" | "dim" | "border" | "error" | "success" | "scrollbarTrack" | "scrollbarThumb";
+/** Background roles for a selected row and for a row whose work is still pending. */
+export type UiThemeBackground = "selectedBg" | "toolPendingBg";
+export interface UiTheme {
+    fg(token: UiThemeToken, text: string): string;
+    bold(text: string): string;
+    /**
+     * The terminal's own foreground, left unpainted. What a list's own text is:
+     * a theme built for a light background would otherwise write near-black rows
+     * into a dark terminal, which is how the engine leaves its lists too.
+     */
+    plain(text: string): string;
+    /** Optional palette preview used by controls that choose the active accent. */
+    accentPreview?(color: string, text: string): string | null;
+    /** Selection background for an active list item or floating-surface row. */
+    highlight(text: string): string;
+    /** A control that is present but cannot act: quieter than quiet text. */
+    disabled(text: string): string;
+    /** Background for a floating surface, so it reads as above the content. */
+    panel(text: string): string;
+    /** Paints a declared background role behind already painted text. */
+    background(token: UiThemeBackground, text: string): string;
+}
+/**
+ * The active theme and its change notifications. The vendor adapter supplies it, so a surface paints
+ * from the live theme without importing the vendor's theme module.
+ */
+export interface ThemeSource {
+    /** The live theme; its painters read the current palette on every call. */
+    current(): UiTheme;
+    /** Calls `listener` after the active theme changes; returns the unsubscribe function. */
+    onChange(listener: () => void): () => void;
+}
+import type { TerminalRuntimeFactory } from "./terminal.js";
+/** How the full-screen canvas behind the session is painted. */
+export type CanvasBackgroundStyle = "transparent" | "accent" | "dark";
+/** What the application shell receives from the vendor presentation adapter. */
+export interface ShellPresentationPorts {
+    readonly theme: ThemeSource;
+    /** The terminal background sequence for a canvas style in the active theme, or null to leave the terminal's own. */
+    canvasBackground(style: CanvasBackgroundStyle): string | null;
+    /** Columns the pinned comparison layout pads command output with. */
+    readonly pinnedOutputPad: 0 | 1;
+    readonly terminalRuntime: TerminalRuntimeFactory;
+}

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

@@ -19,7 +19,7 @@ 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
+    // Rationale: development 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]
@@ -36,7 +36,6 @@ export function resolveDevelopmentLaunchEnvironment(canonicalPackageRoot, releas
             [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")),
-            [PRODUCT_IDENTITY.environment.databasePath]: resolve(source[PRODUCT_IDENTITY.environment.databasePath] ?? join(dataDir, PRODUCT_IDENTITY.endpoint.databaseFilename)),
         },
     };
 }

package/dist/features/launch/index.d.ts

@@ -3,7 +3,7 @@ export type { DevelopmentLaunchEnvironment } from "./development-launch.js";
 export { PI_PROFILE_RESOURCE_DIRECTORIES, initializeProductProfile } from "./initialize-profile.js";
 export type { InitializedProfile } from "./initialize-profile.js";
 export { interactiveLaunchIntent, parseSessionSelection } from "./intent.js";
-export type { InteractiveLaunchIntent, InteractiveLaunchMode, LaunchIntent, LaunchProfileId, SessionSelection } from "./intent.js";
+export type { InteractiveLaunchIntent, LaunchIntent, LaunchProfileId, SessionSelection } from "./intent.js";
 export { configurationRootForProfile, resolveLaunchProfilePaths, resolvePromptHistoryDataDir } from "./profile-paths.js";
 export type { LaunchProfilePathOptions, LaunchProfilePaths } from "./profile-paths.js";
 export { prepareInteractiveLaunch } from "./prepare-launch.js";

package/dist/features/launch/intent.d.ts

@@ -3,12 +3,10 @@ import type { LaunchProfileId } from "../../foundation/lifecycle/index.js";
 export { parseSessionSelection } from "../../foundation/lifecycle/index.js";
 export type { SessionSelection } from "../../foundation/lifecycle/index.js";
 export type { LaunchProfileId } from "../../foundation/lifecycle/index.js";
-export type InteractiveLaunchMode = "tabs" | "solo";
 export interface InteractiveLaunchIntent {
     readonly kind: "interactive";
     readonly profileId: LaunchProfileId;
-    readonly launchMode: InteractiveLaunchMode;
     readonly sessionSelection?: SessionSelection;
 }
 export type LaunchIntent = InteractiveLaunchIntent;
-export declare function interactiveLaunchIntent(profileId: LaunchProfileId, sessionSelection?: SessionSelection, launchMode?: InteractiveLaunchMode): InteractiveLaunchIntent;
+export declare function interactiveLaunchIntent(profileId: LaunchProfileId, sessionSelection?: SessionSelection): InteractiveLaunchIntent;

package/dist/features/launch/intent.js

@@ -1,11 +1,9 @@
 import { sessionSelectionArguments } from "../../foundation/lifecycle/index.js";
 export { parseSessionSelection } from "../../foundation/lifecycle/index.js";
-export function interactiveLaunchIntent(profileId, sessionSelection, launchMode = profileId === "a1" ? "tabs" : "solo") {
+export function interactiveLaunchIntent(profileId, sessionSelection) {
     if (sessionSelection !== undefined && profileId !== "a1") {
         throw new Error("session selection requires the A1 profile");
     }
-    if (profileId === "pi" && launchMode !== "solo")
-        throw new Error("the Pi comparison launch is always solo");
     sessionSelectionArguments(sessionSelection);
-    return Object.freeze({ kind: "interactive", profileId, launchMode, ...(sessionSelection === undefined ? {} : { sessionSelection }) });
+    return Object.freeze({ kind: "interactive", profileId, ...(sessionSelection === undefined ? {} : { sessionSelection }) });
 }

package/dist/features/launch/runtime-selection.d.ts

@@ -7,10 +7,10 @@ export type OwnedUiProfileId = LaunchProfileId;
 export interface InteractiveRuntimeSelection {
     readonly kind: "owned-ui";
     readonly profileId: OwnedUiProfileId;
-    readonly ownedSurfaces: "on" | "off";
+    readonly productMode: "bare" | "comparison";
 }
 export interface InteractiveRuntimeRunners {
-    readonly ownedUi: (profileId: OwnedUiProfileId, ownedSurfaces: "on" | "off") => Promise<number>;
+    readonly ownedUi: (profileId: OwnedUiProfileId, productMode: "bare" | "comparison") => Promise<number>;
 }
 export declare function selectInteractiveRuntime(profileId: string): InteractiveRuntimeSelection;
 export declare function runSelectedInteractiveRuntime(profileId: string, runners: InteractiveRuntimeRunners): Promise<number>;

package/dist/features/launch/runtime-selection.js

@@ -4,10 +4,10 @@ export function selectInteractiveRuntime(profileId) {
     return Object.freeze({
         kind: "owned-ui",
         profileId,
-        ownedSurfaces: profileId === "a1" ? "on" : "off",
+        productMode: profileId === "a1" ? "bare" : "comparison",
     });
 }
 export async function runSelectedInteractiveRuntime(profileId, runners) {
     const selection = selectInteractiveRuntime(profileId);
-    return await runners.ownedUi(selection.profileId, selection.ownedSurfaces);
+    return await runners.ownedUi(selection.profileId, selection.productMode);
 }

package/dist/features/launch/session-context.d.ts

@@ -1,4 +1,4 @@
-import { type NativeProcessIdentity, type SessionRepositoryIdentity, type SessionWorktreeInventoryEntry } from "../../foundation/lifecycle/index.js";
+import { type ProcessIdentity, type SessionRepositoryIdentity, type SessionWorktreeInventoryEntry } from "../../foundation/lifecycle/index.js";
 export { PRIMARY_SESSION_AGENT_ID } from "../../foundation/lifecycle/index.js";
 export type SessionContextRequest = {
     readonly action: "link-worktree";
@@ -19,6 +19,6 @@ export type SessionContextOutcome = {
 };
 export interface SessionContextRuntime {
     readonly runtimeId: string;
-    readonly inspectProcess: (pid: number) => Promise<NativeProcessIdentity | null>;
+    readonly inspectProcess: (pid: number) => Promise<ProcessIdentity | null>;
 }
 export declare function updateSessionRepositoryContext(identity: SessionRepositoryIdentity, request: SessionContextRequest, runtime: SessionContextRuntime): Promise<SessionContextOutcome>;

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

@@ -1,5 +1,5 @@
 import type { Readable, Writable } from "node:stream";
-export type OwnedProjectTrustChoiceId = "trust" | "trust-parent" | "trust-session" | "deny" | "deny-session";
+type OwnedProjectTrustChoiceId = "trust" | "trust-parent" | "trust-session" | "deny" | "deny-session";
 export interface OwnedProjectTrustPromptRequest {
     readonly cwd: string;
     readonly defaultDecision: "ask" | "always" | "never";
@@ -21,7 +21,7 @@ export interface ConsoleProjectTrustPromptOptions {
         readonly columns?: number;
         readonly rows?: number;
     };
-    readonly presentation?: "bare" | "comparison";
+    readonly productMode?: "bare" | "comparison";
     readonly environment?: NodeJS.ProcessEnv;
 }
 /** Fixed pre-resource selector; no project resource is available. */

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

@@ -34,7 +34,7 @@ export function createConsoleProjectTrustPrompt(options = {}) {
         }
         if (choices.length === 0)
             throw new Error("project trust choices are unavailable");
-        const comparison = options.presentation === "comparison";
+        const comparison = options.productMode === "comparison";
         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;

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

@@ -25,8 +25,6 @@ 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;
     /** Enables owned text selection for document routes that explicitly opt in. */
     readonly selection?: ReferenceDocumentSelectionOptions;
 }

package/dist/features/owned-ui/reference-screen-app.js

@@ -49,7 +49,6 @@ export class ReferenceScreenApp {
     #title;
     #document;
     #scrollSettings;
-    #pinned;
     #selection;
     #scroll = 0;
     #interruptArmed = false;
@@ -69,7 +68,6 @@ export class ReferenceScreenApp {
         this.#title = options.title;
         this.#document = options.document;
         this.#scrollSettings = options.scrollSettings;
-        this.#pinned = options.pinned === true;
         this.#selection = options.selection === undefined ? undefined : new ReferenceDocumentSelection(options.selection);
     }
     onActivate(host) {
@@ -178,8 +176,7 @@ export class ReferenceScreenApp {
         switch (action) {
             case "close":
                 this.#selection?.handleInput(data);
-                if (!this.#pinned)
-                    host.close();
+                host.close();
                 return { consumed: true };
             case "up":
                 this.#scrollBy(-1);
@@ -250,12 +247,8 @@ export class ReferenceScreenApp {
         }
         return { owned: true, changed: true };
     }
-    // Invariant: a pinned screen is its tab and `Esc` does not close it, so it shows no close hint.
     #hintEntries() {
-        const entries = REFERENCE_SCREEN_SHORTCUTS.hintEntries(SCOPE);
-        if (!this.#pinned)
-            return entries;
-        return entries.filter(entry => entry.key !== DIALOG_CLOSE_SHORTCUT_HINT.key || entry.action !== DIALOG_CLOSE_SHORTCUT_HINT.action);
+        return REFERENCE_SCREEN_SHORTCUTS.hintEntries(SCOPE);
     }
     // Invariant: the title is the first document row, as in v2, so it scrolls with the document.
     #content(width, theme) {

package/dist/features/owned-ui/release-note-state.d.ts

@@ -3,7 +3,7 @@ export interface ReleaseNoteClaim {
     acknowledge(): Promise<void>;
     release(): Promise<void>;
 }
-export interface ReleaseNoteStateOptions {
+interface ReleaseNoteStateOptions {
     readonly configDir: string;
     readonly profileId: string;
     readonly version: string;
@@ -11,3 +11,4 @@ export interface ReleaseNoteStateOptions {
 }
 /** Claims one stable note across concurrent sessions and acknowledges it only after presentation closes. */
 export declare function claimReleaseNote(options: ReleaseNoteStateOptions): Promise<ReleaseNoteClaim | null>;
+export {};

package/dist/features/owned-ui/settings-app.d.ts

@@ -13,15 +13,9 @@ export declare const SETTINGS_SHORTCUTS: ShortcutRegistry<Action>;
 export declare class SettingsApp implements UiApp {
     #private;
     readonly id = "settings";
-    /**
-     * `pinned` presents the screen as a resident Settings tab, which offers no screen-level close;
-     * `configurePlusMenu` opens the tab bar's Plus Menu dialog in place of this screen's own.
-     */
     constructor(session: OwnedSettingsManager, options: {
-        readonly pinned?: boolean;
         readonly searchInputFactory: SettingsSearchInputFactory;
         readonly copyText?: (text: string) => void;
-        readonly configurePlusMenu?: (() => boolean) | null;
         readonly dialogPanel?: (text: string) => string;
     });
     onActivate(host: AppHostServices): void;