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

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

@@ -0,0 +1,46 @@
+import type { OwnedUiCommandResult, OwnedUiSessionBackend, OwnedUiShellSkillSummary, OwnedUiWorkflowRequest } from "../../contracts/owned-ui/index.js";
+import type { SessionDialogCoordinator } from "./dialog-coordinator.js";
+import type { OwnedUiPresenterTerminal } from "./shell-host.js";
+import type { OwnedUiSessionShellOptions, OwnedUiSessionShellRoot } from "./session-shell-root.js";
+import type { WorkflowSelectors } from "./workflow-router.js";
+/** What the selectors need from the session; typed ports, never the presenter. */
+export interface SessionSelectorPorts {
+    readonly root: Pick<OwnedUiSessionShellRoot, "setInputSurface" | "setFooterLevel" | "workflow" | "editor">;
+    readonly terminal: OwnedUiPresenterTerminal;
+    readonly dialogs: SessionDialogCoordinator;
+    readonly presenters: OwnedUiSessionShellOptions["presenters"];
+    readonly backend: Pick<OwnedUiSessionBackend, "catalog" | "settings">;
+    readonly customViewport: boolean;
+    disposed(): boolean;
+    runWorkflow(request: OwnedUiWorkflowRequest): Promise<OwnedUiCommandResult>;
+    sendSlashPrompt(text: string, typed: string): Promise<OwnedUiCommandResult>;
+    reportError(): void;
+    input(title: string, placeholder: string, options?: {
+        readonly retainSurfaceOnSettle?: boolean;
+    }): Promise<string | undefined>;
+    shutdown(): void;
+}
+/**
+ * Opens the session's selectors and dialogs in the input dock and runs each choice as a workflow.
+ * Invariant: the workflow router reaches dialogs only through this collaborator, never through the presenter.
+ */
+export declare class SessionSelectors implements WorkflowSelectors {
+    #private;
+    constructor(ports: SessionSelectorPorts);
+    showThinkingSelector(): Promise<void>;
+    /** The Skills dialog: a replacement input like the model selector, applying the chosen skill through the prompt path. */
+    showSkillsSelector(skills: readonly OwnedUiShellSkillSummary[]): void;
+    showModelSelector(initialSearchInput?: string): void;
+    showForkSelector(): void;
+    showLogoutSelector(): Promise<void>;
+    showLoginMethodSelector(providerReference: string): void;
+    showTreeSelector(initialSelectedId?: string): Promise<void>;
+    showLoginAuthTypeSelector(): void;
+    showLoginProviderSelector(authType?: "oauth" | "api_key", initialSearchInput?: string): void;
+    showSessionSelector(): Promise<void>;
+    showSettingsSelector(): void;
+    showTrustSelector(): void;
+    showScopedModelsSelector(): void;
+    /** The bare-A1 unified Models dialog: switch on Enter, scope on Space, persist on Ctrl+S, all through the engine. */
+    showModelsDialog(initialQuery?: string): void;
+}

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

@@ -0,0 +1,269 @@
+/**
+ * Opens the session's selectors and dialogs in the input dock and runs each choice as a workflow.
+ * Invariant: the workflow router reaches dialogs only through this collaborator, never through the presenter.
+ */
+export class SessionSelectors {
+    #ports;
+    #root;
+    #terminal;
+    #dialogs;
+    #presenters;
+    #backend;
+    #customViewport;
+    // Invariant: the host's optional members follow the layout, so it is built only once the layout is known.
+    #dialogHost;
+    constructor(ports) {
+        this.#ports = ports;
+        this.#root = ports.root;
+        this.#terminal = ports.terminal;
+        this.#dialogs = ports.dialogs;
+        this.#presenters = ports.presenters;
+        this.#backend = ports.backend;
+        this.#customViewport = ports.customViewport;
+        this.#dialogHost = this.#createDialogHost();
+    }
+    // Rationale: presenters see the shell only as a dialog host; selectors open in the input dock and run choices as workflows.
+    #createDialogHost() {
+        const isDisposed = () => this.#ports.disposed();
+        return {
+            get disposed() { return isDisposed(); },
+            setInputSurface: surface => this.#root.setInputSurface(surface),
+            requestRender: () => this.#terminal.requestRender(),
+            viewport: () => this.#terminal.viewport(),
+            appendWorkflowStatus: text => this.#root.workflow.appendStatus(text),
+            appendWorkflowResult: result => this.#root.workflow.appendResult(result),
+            runWorkflow: request => this.#ports.runWorkflow(request),
+            // Invariant: the custom bare-A1 surface holds frames while optional selectors load and is permanently
+            // fullscreen; the pinned comparison profiles render immediately and keep Pi's TUI mode switch.
+            ...(this.#customViewport
+                ? { beginPresentationHold: () => this.#terminal.beginPresentationHold() }
+                : { switchTuiMode: mode => this.#terminal.switchMode(mode) }),
+        };
+    }
+    async showThinkingSelector() {
+        const snapshot = this.#backend.settings.snapshot();
+        const close = () => {
+            this.#root.setFooterLevel(true);
+            this.#root.setInputSurface(null);
+            this.#terminal.requestRender();
+        };
+        const select = (level) => {
+            close();
+            void this.#ports.runWorkflow({ command: "thinking", argument: "", selection: level });
+        };
+        const releasePresentation = this.#customViewport ? this.#terminal.beginPresentationHold() : undefined;
+        try {
+            const selectors = await this.#presenters.components.dialogs.lazySelectors();
+            const component = await selectors.createThinking({
+                currentLevel: snapshot.thinkingLevel,
+                availableLevels: snapshot.availableThinkingLevels,
+                onSelect: select,
+                onCancel: close,
+                onSelectAsDefault: level => this.#backend.settings.setDefaultThinkingLevel(level),
+                defaultLevel: snapshot.defaultThinkingLevel,
+                ...(this.#backend.settings.productMode === "bare" ? {
+                    presentation: {
+                        profile: "bare",
+                        cycleBinding: this.#root.editor.keybindingConfig()["app.thinking.cycle"] ?? [],
+                    },
+                } : {}),
+            });
+            if (this.#ports.disposed())
+                return;
+            this.#root.setFooterLevel(false);
+            this.#present(component);
+        }
+        finally {
+            releasePresentation?.();
+        }
+    }
+    /** The Skills dialog: a replacement input like the model selector, applying the chosen skill through the prompt path. */
+    showSkillsSelector(skills) {
+        const close = this.#dialogs.closeInputSurface;
+        const component = this.#presenters.components.dialogs.skillsSelector({
+            skills,
+            onSelect: name => {
+                close();
+                void this.#ports.sendSlashPrompt(this.#presenters.components.skills.prompt(name), this.#presenters.components.skills.prompt(name)).catch(() => this.#ports.reportError());
+            },
+            onCancel: close,
+        });
+        this.#present(component);
+    }
+    showModelSelector(initialSearchInput) {
+        this.#presenters.openModelSelector(this.#dialogHost, initialSearchInput);
+    }
+    showForkSelector() {
+        const options = this.#backend.catalog.pinnedForkOptions();
+        if (options.length === 0) {
+            this.#root.workflow.appendResult({ command: "fork", outcome: "completed", message: "No messages to fork from", messageKind: "status" });
+            this.#terminal.requestRender();
+            return;
+        }
+        const close = this.#dialogs.closeInputSurface;
+        const component = this.#presenters.components.dialogs.userMessageSelector(options, selection => {
+            close();
+            void this.#ports.runWorkflow({ command: "fork", argument: "", selection });
+        }, close);
+        this.#present(component);
+    }
+    async showLogoutSelector() {
+        let options;
+        try {
+            options = await this.#backend.catalog.pinnedLogoutOptions();
+        }
+        catch (error) {
+            this.#root.workflow.appendResult({
+                command: "logout",
+                outcome: "failed",
+                message: `Could not read stored credentials: ${error instanceof Error ? error.message : String(error)}`,
+            });
+            this.#terminal.requestRender();
+            return;
+        }
+        if (options.length === 0) {
+            this.#root.workflow.appendStatus("No stored credentials to remove. /logout only removes credentials saved by /login; environment variables and models.json config are unchanged.");
+            this.#terminal.requestRender();
+            return;
+        }
+        const close = this.#dialogs.closeInputSurface;
+        const component = this.#presenters.components.dialogs.authProviderSelector("logout", options, selection => {
+            close();
+            void this.#ports.runWorkflow({ command: "logout", argument: "", selection });
+        }, close);
+        this.#present(component);
+    }
+    showLoginMethodSelector(providerReference) {
+        const method = this.#backend.catalog.pinnedLoginMethodOptions(providerReference);
+        if (method.options.length === 0) {
+            this.showLoginProviderSelector(undefined, providerReference);
+            return;
+        }
+        if (method.options.length === 1) {
+            const selection = method.options[0]?.id;
+            if (selection)
+                void this.#ports.runWorkflow({ command: "login", argument: "", selection });
+            return;
+        }
+        const close = this.#dialogs.closeInputSurface;
+        const labels = method.options.map(option => option.label);
+        const component = this.#presenters.components.dialogs.extensionSelector(method.title, labels, label => {
+            const selection = method.options.find(option => option.label === label)?.id;
+            if (!selection)
+                return;
+            close();
+            void this.#ports.runWorkflow({ command: "login", argument: "", selection });
+        }, close);
+        this.#present(component);
+    }
+    showTreeSelector(initialSelectedId) {
+        return this.#presenters.openTreeSelector(this.#dialogHost, (entryId, skipSummaryPrompt) => {
+            void this.#completeTreeSelection(entryId, skipSummaryPrompt);
+        }, initialSelectedId);
+    }
+    showLoginAuthTypeSelector() {
+        const close = this.#dialogs.closeInputSurface;
+        const labels = ["Sign in with an account", "Sign in with an API key"];
+        const component = this.#presenters.components.dialogs.extensionSelector("Select authentication method:", labels, label => {
+            close();
+            this.showLoginProviderSelector(label === labels[0] ? "oauth" : "api_key");
+        }, close);
+        this.#present(component);
+    }
+    showLoginProviderSelector(authType, initialSearchInput) {
+        const options = this.#backend.catalog.pinnedLoginOptions(authType);
+        if (options.length === 0) {
+            this.#root.workflow.appendStatus(authType === "oauth" ? "No account providers available." : authType === "api_key" ? "No API key providers available." : "No login providers available.");
+            this.#terminal.requestRender();
+            return;
+        }
+        const close = this.#dialogs.closeInputSurface;
+        const component = this.#presenters.components.dialogs.authProviderSelector("login", options, id => {
+            close();
+            void this.#ports.runWorkflow({ command: "login", argument: "", selection: id });
+        }, () => {
+            close();
+            if (authType !== undefined)
+                this.showLoginAuthTypeSelector();
+        }, initialSearchInput);
+        this.#present(component);
+    }
+    showSessionSelector() {
+        return this.#presenters.openSessionSelector(this.#dialogHost, () => { void this.#ports.shutdown(); });
+    }
+    showSettingsSelector() {
+        this.#presenters.openSettingsSelector(this.#dialogHost);
+    }
+    showTrustSelector() {
+        const context = this.#backend.catalog.pinnedProjectTrustContext();
+        const close = this.#dialogs.closeInputSurface;
+        const component = this.#presenters.components.dialogs.trustSelector({
+            ...context,
+            onSelect: selection => {
+                try {
+                    this.#backend.catalog.persistProjectTrust(selection.updates);
+                    close();
+                    this.#root.workflow.appendStatus(`Saved trust decision: ${selection.trusted ? "trusted" : "untrusted"}. Restart pi for this to take effect.`);
+                }
+                catch (error) {
+                    close();
+                    this.#root.workflow.appendResult({ command: "trust", outcome: "failed", message: error instanceof Error ? error.message : String(error) });
+                }
+                this.#terminal.requestRender();
+            },
+            onCancel: close,
+        });
+        this.#present(component);
+    }
+    showScopedModelsSelector() {
+        this.#presenters.openScopedModelsSelector(this.#dialogHost);
+    }
+    /** The bare-A1 unified Models dialog: switch on Enter, scope on Space, persist on Ctrl+S, all through the engine. */
+    showModelsDialog(initialQuery) {
+        this.#presenters.openModelsDialog(this.#dialogHost, initialQuery);
+    }
+    #treeSummary() {
+        return new Promise(resolve => {
+            this.#root.setInputSurface(this.#presenters.components.dialogs.extensionSelector("Summarize Branch?", ["No summary", "Summarize", "Summarize with custom prompt"], resolve, () => resolve(undefined)), true, "opaque");
+            this.#terminal.requestRender();
+        });
+    }
+    async #completeTreeSelection(entryId, skipSummaryPrompt) {
+        let summarize = false;
+        let customInstructions;
+        if (!skipSummaryPrompt) {
+            while (true) {
+                const choice = await this.#treeSummary();
+                if (choice === undefined) {
+                    await this.showTreeSelector(entryId);
+                    return;
+                }
+                summarize = choice !== "No summary";
+                if (choice === "Summarize with custom prompt") {
+                    customInstructions = await this.#ports.input("Custom Summarization Instructions", "", { retainSurfaceOnSettle: true });
+                    if (customInstructions === undefined)
+                        continue;
+                }
+                break;
+            }
+        }
+        this.#root.setInputSurface(null);
+        this.#terminal.requestRender();
+        const result = await this.#ports.runWorkflow({
+            command: "tree",
+            argument: "",
+            selection: entryId,
+            treeSummary: {
+                summarize,
+                ...(customInstructions === undefined ? {} : { customInstructions }),
+            },
+        });
+        if (result.diagnostic === "Branch summarization cancelled")
+            await this.showTreeSelector(entryId);
+    }
+    // Invariant: a selector replaces the editor in the input dock and paints in the same frame.
+    #present(component) {
+        this.#root.setInputSurface(component);
+        this.#terminal.requestRender();
+    }
+}

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

@@ -1,31 +1,23 @@
-import { ImageAttachmentError } from "../../contracts/owned-ui/index.js";
-import type { OwnedUiBackgroundSettingsPort, OwnedUiPromptSuggestionGeneratorPort, OwnedUiSessionBackend, OwnedUiSessionPresenters, OwnedUiSessionViewModel, OwnedUiTranscriptRendererPort, OwnedUiWorkflowMessage, OwnedUiWorkflowResult, OwnedUiViewportSettings, OwnedUiViewportSettingsPort, OwnedUiQuitOutroSettingsPort, SuggestionDecision, SuggestionDiagnosticObserver } from "../../contracts/owned-ui/index.js";
-import type { PiTuiPointerSurface } from "../../integrations/pi/tui-runtime/contracts.js";
+import type { OwnedUiShellComponents, OwnedUiShellHotkeysPresentation, OwnedUiShellClipboardContent, OwnedUiShellComponentPort, OwnedUiShellEditorPort, OwnedUiShellHeaderOptions, OwnedUiShellHeaderPort, OwnedUiShellHistoryEditor, OwnedUiShellImageAssetResolver, OwnedUiShellKeybindingsHost, OwnedUiShellLoadedResourcesPort } from "../../contracts/owned-ui/index.js";
+import type { TerminalComponentPort, TerminalInputCoordinationScheduler, TerminalInputDiagnosticsEvent, TerminalInputSurfaceKind, TerminalLayoutNode, TerminalPort } from "../../contracts/presentation/index.js";
+import type { ShellPresentationPorts, ThemeSource } from "../../contracts/presentation/index.js";
+import type { OwnedUiBackgroundSettingsPort, OwnedUiPromptSuggestionGeneratorPort, OwnedUiSessionBackend, OwnedUiSessionPresenters, OwnedUiSessionViewModel, OwnedUiTranscriptRendererPort, OwnedUiViewportSettings, OwnedUiViewportSettingsPort, OwnedUiQuitOutroSettingsPort, SuggestionDecision, SuggestionDiagnosticObserver } from "../../contracts/owned-ui/index.js";
 import type { UiRouteHost, UiRouteInput } from "../../ui/apps/contracts.js";
 import type { TranscriptViewportFrame, TranscriptViewportFrameDescriptor } from "../../ui/components/transcript-viewport.js";
-import type { PiShellLazySelectorLoader } from "../../integrations/pi/components/lazy-selectors.js";
-import type { PiShellHotkeysPresentation } from "../../integrations/pi/components/shell-presenters-info.js";
-import { type PiShellClipboardContent, type PiShellComponentPort, type PiKeybindingsHost, type PiShellEditorPort, type PiShellHeaderOptions, type PiShellHeaderPort, type PiShellImageAssetResolver, type PiShellLoadedResourcesPort, type PiShellResourceEntry, type PiShellTranscriptComponentPort } from "../../integrations/pi/components/shell-shared-facade.js";
-import { type PiTuiInputCoordinationScheduler, type PiTuiInputSurfaceKind } from "../../integrations/pi/tui-runtime/input-presentation-coordinator.js";
-import type { PiTuiComponentPort, PiTuiInputDiagnosticsEvent, PiTuiLayoutNode, PiTuiTerminalPort } from "../../integrations/pi/tui-runtime/contracts.js";
-import { type PreparedPrompt } from "./prompt-chips.js";
+import { PromptChipStore, type PreparedPrompt } from "./prompt-chips.js";
 import type { PastePreparationClientOptions } from "./paste-preparation-client.js";
 import type { OwnedUiClipboardServices } from "./clipboard-services.js";
-import { type SessionViewportInputResult } from "./session-viewport-controller.js";
+import type { OwnedUiClipboardPort } from "./shell-clipboard.js";
+import { SessionViewportController, type SessionViewportInputResult } from "./session-viewport-controller.js";
 import type { ResponseCopyExecutor } from "./response-copy-transport.js";
 import type { ResponseCopyEvent } from "./response-copy-protocol.js";
 import type { PasteEvent, PasteSource } from "./paste-protocol.js";
+import { DockChrome } from "./dock-chrome.js";
+import { WorkflowOutput } from "./workflow-output.js";
+import { TranscriptDocument } from "./transcript-document.js";
 import type { StreamPresentationScheduler } from "./stream-presentation-coalescer.js";
-export type OwnedUiTerminalPort = PiTuiTerminalPort;
-type OwnedUiStartupOptions = PiShellHeaderOptions;
-export interface OwnedUiClipboardPort {
-    readText(signal?: AbortSignal): Promise<string | null>;
-    readImage?(signal?: AbortSignal): Promise<{
-        readonly data: string;
-        readonly mimeType: string;
-    } | null>;
-    writeText?(text: string, signal?: AbortSignal): Promise<void>;
-}
+type OwnedUiTerminalPort = TerminalPort;
+type OwnedUiStartupOptions = OwnedUiShellHeaderOptions;
 /** The engine session the shell presents and the composition's decisions about it. */
 export interface OwnedUiShellEngineOptions {
     readonly backend: OwnedUiSessionBackend;
@@ -78,8 +70,8 @@ export interface OwnedUiShellPresentationOptions {
         readonly seed?: number;
     };
     readonly input?: {
-        readonly scheduler?: PiTuiInputCoordinationScheduler;
-        readonly onEvent?: (event: PiTuiInputDiagnosticsEvent) => void;
+        readonly scheduler?: TerminalInputCoordinationScheduler;
+        readonly onEvent?: (event: TerminalInputDiagnosticsEvent) => void;
         readonly now?: () => number;
         /** Evidence-only baseline seam; production leaves coordination enabled. */
         readonly coordination?: boolean;
@@ -98,7 +90,7 @@ export interface OwnedUiShellHistoryOptions {
     readonly forScope?: (scope: "unique" | "shared", sessionId: string | null) => Pick<OwnedUiShellHistoryOptions, "store" | "imageSidecar"> | null;
     readonly onScopeChange?: (listener: (scope: "unique" | "shared") => void) => () => void;
     readonly limit: number;
-    readonly editor: import("../../integrations/pi/components/index.js").HistoryEditorConstructor;
+    readonly editor: OwnedUiShellHistoryEditor;
     /** Optional per-profile filesystem sidecar for image chip payloads. When present, submit
      * writes each referenced attachment and recall reads them back to rehydrate live chips.
      * When absent, image chips silently strip on recall, matching the missing-sidecar path. */
@@ -124,8 +116,6 @@ export interface OwnedUiShellDiagnosticOptions {
     readonly paste?: (event: PasteEvent) => void;
     /** Test seams for isolated paste preparation: an in-process starter, or the forked helper's entry. */
     readonly pastePreparation?: Omit<PastePreparationClientOptions, "onEvent" | "spareIdleMs">;
-    /** Test seam for pending and failed optional selector-module preparation. */
-    readonly lazySelectors?: PiShellLazySelectorLoader;
 }
 /** Live prompt-image admission policy supplied only by the bare-A1 profile. */
 export interface OwnedUiShellPromptImagesOptions {
@@ -141,13 +131,13 @@ export interface OwnedUiShellSkillsOptions {
 export interface OwnedUiShellSharedServices {
     readonly clipboard?: OwnedUiClipboardServices;
     /** Must match the shell's layout: the owned-input profile for the custom viewport, Pi's otherwise. */
-    readonly keybindings?: PiKeybindingsHost;
+    readonly keybindings?: OwnedUiShellKeybindingsHost;
 }
 /** What composes an owned session shell, grouped by the collaborator that provides each part. */
 export interface OwnedUiSessionShellOptions {
     readonly engine: OwnedUiShellEngineOptions;
-    /** Resolves selectors and engine-backed transcript renderers. */
-    readonly presenters: OwnedUiSessionPresenters;
+    /** Resolves selectors, engine-backed transcript renderers, and the vendor presentation ports. */
+    readonly presenters: OwnedUiSessionPresenters & ShellPresentationPorts;
     readonly presentation?: OwnedUiShellPresentationOptions;
     readonly history?: OwnedUiShellHistoryOptions;
     readonly suggestions?: OwnedUiShellSuggestionOptions;
@@ -158,84 +148,73 @@ export interface OwnedUiSessionShellOptions {
     readonly diagnostics?: OwnedUiShellDiagnosticOptions;
     readonly shared?: OwnedUiShellSharedServices;
 }
+/** What the render root needs from its presenter: terminal size and render requests, the theme, and input callbacks. */
+interface OwnedUiSessionShellRootHandlers {
+    readonly presentation: ShellPresentationPorts;
+    readonly components: OwnedUiShellComponents;
+    readonly getColumns: () => number;
+    readonly getRows: () => number;
+    readonly requestRender: (force?: boolean) => void;
+    readonly onViewportFrame?: (frame: TranscriptViewportFrame) => void;
+    readonly requestHyperlinkCleanup?: (rows?: readonly number[]) => void;
+    readonly enableDockInputReuse?: boolean;
+    readonly persistentHistory?: boolean;
+    readonly historyEditor?: OwnedUiShellHistoryEditor;
+    readonly onSubmit: (text: string) => void;
+    readonly onPasteRejected?: (error: unknown) => void;
+    readonly onInterrupt: () => void;
+    readonly onClear?: () => void;
+    readonly onExit: () => void;
+    readonly onModelSelect: () => void;
+    readonly onModelCycle?: (direction: "forward" | "backward") => void;
+    readonly onThinkingCycle: () => void;
+    readonly onThinkingToggle?: () => void;
+    readonly onMessageCopy?: () => void;
+    readonly onFollowUp?: () => void;
+    readonly onDequeue?: () => void;
+    readonly onEditorChange?: (text: string) => void;
+    readonly onPromptSuggestionAccepted?: (text: string) => void;
+    readonly onInputSurfaceChanged?: () => void;
+    readonly onPromptSuggestionEligibilityChanged?: () => void;
+    readonly onCopyText?: (text: string, cut: boolean) => void;
+    readonly readClipboardContent?: (signal?: AbortSignal) => Promise<OwnedUiShellClipboardContent | null>;
+    readonly captureClipboardPaste?: () => PasteSource;
+    readonly pasteDiagnostics?: (event: PasteEvent) => void;
+    readonly pastePreparation?: Omit<PastePreparationClientOptions, "onEvent">;
+    readonly keybindings?: OwnedUiShellKeybindingsHost;
+    readonly promptImageLimit?: () => number;
+    readonly skillsPresentation?: () => "collapse" | "expand";
+}
 /** Composes session state into the owned transcript, viewport, editor, and dock. */
-export declare class OwnedUiSessionShellRoot implements PiTuiComponentPort {
+export declare class OwnedUiSessionShellRoot implements TerminalComponentPort {
     #private;
-    readonly editor: PiShellEditorPort;
-    readonly header: PiShellHeaderPort;
-    readonly resources: PiShellLoadedResourcesPort;
-    constructor(view: OwnedUiSessionViewModel, cwd: string, handlers: {
-        readonly getColumns: () => number;
-        readonly getRows: () => number;
-        readonly requestRender: (force?: boolean) => void;
-        readonly onViewportFrame?: (frame: TranscriptViewportFrame) => void;
-        readonly requestHyperlinkCleanup?: (rows?: readonly number[]) => void;
-        readonly enableDockInputReuse?: boolean;
-        readonly persistentHistory?: boolean;
-        readonly historyEditor?: import("../../integrations/pi/components/index.js").HistoryEditorConstructor;
-        readonly onSubmit: (text: string) => void;
-        readonly onPasteRejected?: (error: unknown) => void;
-        readonly onInterrupt: () => void;
-        readonly onClear?: () => void;
-        readonly onExit: () => void;
-        readonly onModelSelect: () => void;
-        readonly onModelCycle?: (direction: "forward" | "backward") => void;
-        readonly onThinkingCycle: () => void;
-        readonly onThinkingToggle?: () => void;
-        readonly onMessageCopy?: () => void;
-        readonly onFollowUp?: () => void;
-        readonly onDequeue?: () => void;
-        readonly onEditorChange?: (text: string) => void;
-        readonly onPromptSuggestionAccepted?: (text: string) => void;
-        readonly onInputSurfaceChanged?: () => void;
-        readonly onPromptSuggestionEligibilityChanged?: () => void;
-        readonly onCopyText?: (text: string, cut: boolean) => void;
-        readonly readClipboardContent?: (signal?: AbortSignal) => Promise<PiShellClipboardContent | null>;
-        readonly captureClipboardPaste?: () => PasteSource;
-        readonly pasteDiagnostics?: (event: PasteEvent) => void;
-        readonly pastePreparation?: Omit<PastePreparationClientOptions, "onEvent">;
-        readonly keybindings?: PiKeybindingsHost;
-        readonly promptImageLimit?: () => number;
-        readonly skillsPresentation?: () => "collapse" | "expand";
-    }, startup?: PiShellHeaderOptions, agentDir?: string, extensionRenderers?: OwnedUiTranscriptRendererPort, sessionLayout?: "pinned" | "custom-viewport", imageAssets?: PiShellImageAssetResolver);
+    readonly editor: OwnedUiShellEditorPort;
+    readonly header: OwnedUiShellHeaderPort;
+    readonly resources: OwnedUiShellLoadedResourcesPort;
+    /** The transcript's semantic rows, caches, and engine-backed block renderers. */
+    readonly transcript: TranscriptDocument;
+    readonly promptChips: PromptChipStore;
+    readonly viewport: SessionViewportController;
+    /** Workflow results, messages, and status lines appended to the transcript. */
+    readonly workflow: WorkflowOutput;
+    /** The dock's notices, copy acknowledgement, and release banner. */
+    readonly chrome: DockChrome;
+    constructor(view: OwnedUiSessionViewModel, cwd: string, handlers: OwnedUiSessionShellRootHandlers, startup?: OwnedUiShellHeaderOptions, agentDir?: string, extensionRenderers?: OwnedUiTranscriptRendererPort, sessionLayout?: "pinned" | "custom-viewport", imageAssets?: OwnedUiShellImageAssetResolver);
     setEditorPaddingX(padding: number): void;
     setAutocompleteMaxVisible(maxVisible: number): void;
     setOutputPad(padding: 0 | 1): void;
     setHideThinkingBlock(hidden: boolean): void;
     setMermaidRenderingMode(mode: "off" | "final" | "streaming"): void;
     setImagePresentation(showImages: boolean, imageWidthCells: number): void;
-    prepareHistoryText(text: string): string;
-    omitUnsentPromptImages(text: string): string;
-    rehydrateHistoryText(text: string, resolveImage: (id: string) => import("../../contracts/owned-ui/index.js").PromptHistoryImageSidecarAttachment | null): string;
-    imageChipAttachmentsFromEditor(text: string): {
-        readonly id: string;
-        readonly tag: string;
-        readonly image: {
-            readonly type: "image";
-            readonly data: string;
-            readonly mimeType: string;
-        };
-    }[];
-    preparePromptSubmission(text: string): PreparedPrompt;
     reconcilePromptImageLimitNotice(text?: string): boolean;
-    hasPendingPastes(text: string): boolean;
     waitForPromptPastes(text: string, signal: AbortSignal): Promise<PreparedPrompt>;
     resetPendingPastes(): void;
-    /** Forks the spare paste helper so the first paste of the session takes a live child. */
-    warmPastePreparation(): void;
     disposePendingPastes(): Promise<void>;
     promptSuggestionPrepareBlockReason(): SuggestionDecision;
-    canPreparePromptSuggestion(): boolean;
     promptSuggestionPresentationBlockReason(): SuggestionDecision;
     canPresentPromptSuggestion(): boolean;
     setPromptSuggestion(text: string | null): void;
     update(view: OwnedUiSessionViewModel): void;
-    /**
-     * Applies one block: its component is created or updated in place and the order grows
-     * only when the block is new. A streamed chunk costs one component update rather than a
-     * walk of the whole transcript.
-     */
-    applyTranscriptBlock(block: OwnedUiSessionViewModel["transcript"][number]): void;
     render(width: number): readonly string[];
     viewportFrameDescriptor(): TranscriptViewportFrameDescriptor | null;
     /** Read-only, payload-free evidence; observing a pending frame must never render or repair it. */
@@ -267,59 +246,43 @@ export declare class OwnedUiSessionShellRoot implements PiTuiComponentPort {
     viewportTransientTailRowCount(): number;
     hasActiveSelection(): boolean;
     setViewportConfig(config: OwnedUiViewportSettings): void;
-    setFullscreenCopyOnSelect(enabled: boolean): void;
-    showCopyAcknowledgement(message: string): void;
-    resumeViewportFollowing(): void;
-    noteCompletedAssistantMessage(): void;
-    /** A new session binding owns new mounts even when it reuses semantic invocation ids. */
-    resetTranscript(): void;
-    resetViewport(): void;
-    clearViewportPointerState(): void;
-    setViewportOverlaySurfaces(surfaces: readonly PiTuiPointerSurface[] | null): void;
     viewportInputGeometryReady(width: number, height: number): boolean;
     handleViewportPreInput(data: string, allowWheel?: boolean, now?: number, editorActive?: boolean): SessionViewportInputResult;
-    dismissNotice(): void;
     /** The pinned-profile layout regions of this session; the terminal host arranges them with `pinnedLayoutRoot`. */
     layoutParts(): PinnedLayoutParts;
-    transcriptComponent(id: string): PiShellTranscriptComponentPort | undefined;
-    exitTranscript(width: number): string;
-    appendWorkflowStatus(message: string): void;
-    appendWorkflowMessage(message: OwnedUiWorkflowMessage, errorCode?: ImageAttachmentError["code"]): void;
-    appendWorkflowResult(result: OwnedUiWorkflowResult, errorCode?: ImageAttachmentError["code"]): void;
     toggleThinkingVisibility(): void;
     get toolsExpanded(): boolean;
     setToolsExpanded(expanded: boolean): void;
-    setExtensionWidget(key: string, component: PiShellComponentPort | null, placement: "aboveEditor" | "belowEditor"): void;
-    setExtensionHeader(component: PiShellComponentPort | null): void;
-    setExtensionFooter(component: PiShellComponentPort | null): void;
+    setExtensionWidget(key: string, component: OwnedUiShellComponentPort | null, placement: "aboveEditor" | "belowEditor"): void;
+    setExtensionHeader(component: OwnedUiShellComponentPort | null): void;
+    setExtensionFooter(component: OwnedUiShellComponentPort | null): void;
     setExtensionStatus(key: string, text: string | undefined): void;
     setExtensionWorking(message: string | undefined, visible?: boolean): void;
     beginImageSubmissionStatus(): () => void;
-    hotkeysPresentation(): PiShellHotkeysPresentation;
+    hotkeysPresentation(): OwnedUiShellHotkeysPresentation;
     resetWorkflowPresentation(): void;
     resetExtensionUi(): void;
     addExtensionNotification(message: string, type: "info" | "warning" | "error"): void;
     extensionFooterData(): unknown;
     usesDefaultInputSurface(): boolean;
-    inputCoordinationSurface(): PiTuiInputSurfaceKind;
+    inputCoordinationSurface(): TerminalInputSurfaceKind;
     viewportCompositionEvidence(): {
         readonly full: number;
         readonly dockOnly: number;
     };
     transcriptRenderCount(): number;
     setFooterLevel(visible: boolean): void;
-    setInputSurface(component: PiShellComponentPort | null, disposePrevious?: boolean, coordination?: Exclude<PiTuiInputSurfaceKind, "editor">): void;
+    setInputSurface(component: OwnedUiShellComponentPort | null, disposePrevious?: boolean, coordination?: Exclude<TerminalInputSurfaceKind, "editor">): void;
     handleInput(data: string): void;
     invalidate(): void;
     setFocused(focused: boolean): void;
     dispose(): void;
 }
 export type PinnedLayoutPart = "document" | "queued" | "aboveWidgets" | "status" | "editor" | "belowWidgets" | "footer";
-export type PinnedLayoutParts = Readonly<Record<PinnedLayoutPart, PiTuiComponentPort>>;
+export type PinnedLayoutParts = Readonly<Record<PinnedLayoutPart, TerminalComponentPort>>;
 /**
  * The pinned-profile screen: a followed transcript scroll above the dock. The runtime mounts one such layout,
  * so its single `transcript` scroll view is shared by whichever session the parts currently resolve to.
  */
-export declare function pinnedLayoutRoot(parts: PinnedLayoutParts): PiTuiLayoutNode;
-export declare function shellResourceEntries(backend: OwnedUiSessionBackend): readonly PiShellResourceEntry[];
+export declare function pinnedLayoutRoot(parts: PinnedLayoutParts, theme: ThemeSource): TerminalLayoutNode;
 export {};