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

package/dist/app/session-shell/prompt-submission.d.ts

@@ -6,7 +6,7 @@ import type { OwnedUiSessionShellRoot } from "./session-shell-root.js";
 import type { OwnedUiPresenterTerminal } from "./shell-host.js";
 interface PromptSubmissionPorts {
     readonly backend: Pick<OwnedUiSessionBackend, "session" | "identity" | "workflows">;
-    readonly root: Pick<OwnedUiSessionShellRoot, "editor" | "hasPendingPastes" | "waitForPromptPastes" | "setExtensionWidget" | "prepareHistoryText" | "imageChipAttachmentsFromEditor" | "preparePromptSubmission" | "omitUnsentPromptImages" | "resumeViewportFollowing" | "beginImageSubmissionStatus" | "workflow">;
+    readonly root: Pick<OwnedUiSessionShellRoot, "editor" | "promptChips" | "viewport" | "waitForPromptPastes" | "setExtensionWidget" | "beginImageSubmissionStatus" | "workflow">;
     readonly terminal: Pick<OwnedUiPresenterTerminal, "requestRender">;
     readonly cwd: string;
     readonly statusText: OwnedUiShellComponents["info"]["statusText"];

package/dist/app/session-shell/prompt-submission.js

@@ -42,7 +42,7 @@ export class PromptSubmission {
     /** Sends slash text the shell does not own as engine prompt input; history keeps what was typed. */
     sendSlashPrompt(text, typed = text) {
         this.#rememberInput(typed, "slash");
-        this.#ports.root.resumeViewportFollowing();
+        this.#ports.root.viewport.resumeFollowing();
         return this.execute({
             type: this.#ports.lifecycle() === "busy" ? "steer" : "prompt",
             correlationId: this.#ports.correlation("prompt-command"),
@@ -96,7 +96,7 @@ export class PromptSubmission {
         const previous = this.#waiting.get(draft);
         if (previous !== undefined)
             return previous.result;
-        if (!root.hasPendingPastes(draft))
+        if (!root.promptChips.hasPending(draft))
             return this.#guard(draft, action);
         const controller = new AbortController();
         const generation = backend.identity.sessionGeneration;
@@ -154,7 +154,7 @@ export class PromptSubmission {
         const history = this.#ports.promptHistory();
         if (history === null)
             return;
-        const reusable = root.prepareHistoryText(text);
+        const reusable = root.promptChips.prepareHistoryText(text);
         if (reusable.length === 0) {
             history.rememberRecovery(text);
             return;
@@ -164,7 +164,7 @@ export class PromptSubmission {
         // recall path treats an absent sidecar the same as a corrupt one.
         const sidecar = this.#ports.imageSidecar();
         if (sidecar !== undefined) {
-            for (const record of root.imageChipAttachmentsFromEditor(text)) {
+            for (const record of root.promptChips.imageChipAttachments(text)) {
                 sidecar.write(record.id, { tag: record.tag, data: record.image.data, mimeType: record.image.mimeType, savedAt: new Date().toISOString() });
             }
         }
@@ -178,7 +178,7 @@ export class PromptSubmission {
         if (displayInput.startsWith("/"))
             return this.#ports.slashCommand(displayInput);
         const { root, backend } = this.#ports;
-        const prepared = root.preparePromptSubmission(displayInput);
+        const prepared = root.promptChips.prepareSubmission(displayInput);
         assertPromptImages(prepared.images);
         const input = prepared.text.trim();
         if (input.startsWith("!")) {
@@ -189,8 +189,8 @@ export class PromptSubmission {
         // Compatibility: match interactive Pi: input during compaction is queued steering; the engine
         // shows it in the pending rows and delivers it when compaction ends.
         const type = this.#ports.lifecycle() === "busy" ? "steer" : "prompt";
-        this.#rememberInput(root.omitUnsentPromptImages(displayInput).trim(), type);
-        root.resumeViewportFollowing();
+        this.#rememberInput(root.promptChips.omitUnsentImages(displayInput).trim(), type);
+        root.viewport.resumeFollowing();
         const command = {
             type,
             correlationId: this.#ports.correlation(type),
@@ -237,13 +237,13 @@ export class PromptSubmission {
         const displayInput = draft.trim();
         if (!displayInput)
             return rejected("nothing to queue");
-        const prepared = root.preparePromptSubmission(displayInput);
+        const prepared = root.promptChips.prepareSubmission(displayInput);
         assertPromptImages(prepared.images);
         const text = prepared.text.trim();
         this.#rememberInput(displayInput, "follow-up");
         if (root.editor.getText() === draft)
             root.editor.setText("");
-        root.resumeViewportFollowing();
+        root.viewport.resumeFollowing();
         return this.execute({
             type: "follow-up",
             correlationId: this.#ports.correlation("follow-up"),

package/dist/app/session-shell/resource-labels.d.ts

@@ -0,0 +1,2 @@
+import type { OwnedUiSessionBackend, OwnedUiShellResourceEntry } from "../../contracts/owned-ui/index.js";
+export declare function shellResourceEntries(backend: OwnedUiSessionBackend): readonly OwnedUiShellResourceEntry[];

package/dist/app/session-shell/resource-labels.js

@@ -0,0 +1,158 @@
+// Rationale: the startup header lists loaded resources with the shortest label that stays unambiguous.
+export function shellResourceEntries(backend) {
+    const resources = backend.extensions.nonVisualResources().map(resource => ({
+        section: resource.kind === "skill"
+            ? "Skills"
+            : resource.kind === "prompt-template"
+                ? "Prompts"
+                : resource.kind === "theme"
+                    ? "Themes"
+                    : "Context",
+        label: resource.kind === "prompt-template"
+            ? `/${resource.label}`
+            : resource.kind === "agent-context" || resource.kind === "system-prompt"
+                ? compactResourceLabel(resource.sourcePath ?? resource.label)
+                : resource.label,
+        sourcePath: resource.sourcePath,
+        diagnostic: resource.diagnostic,
+    }));
+    const extensions = backend.extensions.extensionResources().filter(extension => !extension.hidden);
+    const loadedExtensions = extensions.filter(extension => extension.diagnostic === null);
+    const extensionLabels = compactExtensionLabels(loadedExtensions);
+    for (const extension of extensions) {
+        const labelIndex = loadedExtensions.indexOf(extension);
+        resources.push({
+            section: "Extensions",
+            label: extensionLabels[labelIndex] ?? compactResourceLabel(extension.sourcePath ?? extension.resolvedPath ?? "extension"),
+            sourcePath: extension.sourcePath ?? extension.resolvedPath,
+            diagnostic: extension.diagnostic,
+        });
+    }
+    return resources;
+}
+function compactResourceLabel(path) {
+    const segments = compactPathSegments(path);
+    const leaf = segments.at(-1) ?? path;
+    if ((leaf === "index.ts" || leaf === "index.js") && segments.length > 1)
+        return segments.at(-2) ?? leaf;
+    return leaf;
+}
+/**
+ * Pinned from InteractiveMode's compact extension-label helpers at Pi commit
+ * 914cf1472e715297caa30db4b9535d534a9eb718. The source metadata crosses an
+ * A1-owned boundary first; the owned shell never inspects Pi's private root.
+ */
+function compactExtensionLabels(extensions) {
+    const localExtensions = extensions
+        .filter(extension => !isPackageExtensionSource(extension.sourceInfo))
+        .map(extension => {
+        const path = extension.sourcePath ?? extension.resolvedPath ?? "extension";
+        const segments = compactPathSegments(path);
+        if (segments.length > 1 && (segments.at(-1) === "index.ts" || segments.at(-1) === "index.js"))
+            segments.pop();
+        return { extension, segments };
+    });
+    return extensions.map(extension => {
+        const resourcePath = extension.sourcePath ?? extension.resolvedPath ?? "extension";
+        if (isPackageExtensionSource(extension.sourceInfo)) {
+            return compactPackageExtensionLabel(resourcePath, extension.sourceInfo);
+        }
+        const localIndex = localExtensions.findIndex(item => item.extension === extension);
+        const segments = localExtensions[localIndex]?.segments;
+        if (!segments || segments.length === 0)
+            return compactResourceLabel(resourcePath);
+        for (let count = 1; count <= segments.length; count += 1) {
+            const candidate = segments.slice(-count).join("/");
+            if (localExtensions.every((item, itemIndex) => itemIndex === localIndex || item.segments.slice(-count).join("/") !== candidate)) {
+                return candidate;
+            }
+        }
+        return segments.join("/");
+    });
+}
+function compactPackageExtensionLabel(resourcePath, sourceInfo) {
+    const sourceLabel = compactPackageSourceLabel(sourceInfo.source);
+    if (!sourceLabel)
+        return compactResourceLabel(resourcePath);
+    const shortPath = shortPackagePath(resourcePath, sourceInfo).replaceAll("\\", "/");
+    const packagePath = shortPath.startsWith("extensions/") ? shortPath.slice("extensions/".length) : shortPath;
+    const slash = packagePath.lastIndexOf("/");
+    const fileName = slash < 0 ? packagePath : packagePath.slice(slash + 1);
+    const directory = slash < 0 ? "" : packagePath.slice(0, slash);
+    const extension = fileName.lastIndexOf(".");
+    const name = extension <= 0 ? fileName : fileName.slice(0, extension);
+    if (name === "index")
+        return !directory || directory === "." ? sourceLabel : `${sourceLabel}:${directory}`;
+    return `${sourceLabel}:${packagePath}`;
+}
+function compactPackageSourceLabel(source) {
+    if (source.startsWith("npm:"))
+        return source.slice("npm:".length) || source;
+    if (!source.startsWith("git:"))
+        return source;
+    const gitSource = source.slice("git:".length).trim();
+    let repositoryPath;
+    const scpLike = gitSource.match(/^git@[^:]+:(.+)$/);
+    if (scpLike?.[1]) {
+        repositoryPath = scpLike[1];
+    }
+    else if (/^[a-z]+:\/\//i.test(gitSource)) {
+        try {
+            repositoryPath = new URL(gitSource).pathname.replace(/^\/+/, "");
+        }
+        catch {
+            return source;
+        }
+    }
+    else {
+        const slash = gitSource.indexOf("/");
+        if (slash >= 0)
+            repositoryPath = gitSource.slice(slash + 1);
+    }
+    if (!repositoryPath)
+        return source;
+    const ref = repositoryPath.indexOf("@");
+    const withoutRef = ref < 0 ? repositoryPath : repositoryPath.slice(0, ref);
+    return withoutRef.replace(/\.git$/, "") || source;
+}
+function shortPackagePath(resourcePath, sourceInfo) {
+    const fullPath = normalizeResourcePath(resourcePath);
+    const baseDir = sourceInfo.baseDir === null ? undefined : normalizeResourcePath(sourceInfo.baseDir).replace(/\/$/, "");
+    if (baseDir) {
+        const npmRoot = baseDir.match(/^(.*\/node_modules)\/(@?[^/]+(?:\/[^/]+)?)$/);
+        if (npmRoot?.[1] && fullPath.startsWith(`${npmRoot[1]}/`))
+            return relativeResourcePath(baseDir, fullPath);
+        if (fullPath === baseDir)
+            return ".";
+        if (fullPath.startsWith(`${baseDir}/`))
+            return fullPath.slice(baseDir.length + 1);
+    }
+    const npmMatch = fullPath.match(/node_modules\/(@?[^/]+(?:\/[^/]+)?)\/(.*)/);
+    if (npmMatch?.[2] && sourceInfo.source.startsWith("npm:"))
+        return npmMatch[2];
+    const gitMatch = fullPath.match(/git\/[^/]+\/[^/]+\/(.*)/);
+    if (gitMatch?.[1] && sourceInfo.source.startsWith("git:"))
+        return gitMatch[1];
+    return resourcePath;
+}
+function relativeResourcePath(from, to) {
+    const fromSegments = from.split("/").filter(Boolean);
+    const toSegments = to.split("/").filter(Boolean);
+    let common = 0;
+    while (common < fromSegments.length && common < toSegments.length
+        && fromSegments[common]?.toLowerCase() === toSegments[common]?.toLowerCase())
+        common += 1;
+    return [...fromSegments.slice(common).map(() => ".."), ...toSegments.slice(common)].join("/") || ".";
+}
+function compactPathSegments(path) {
+    return normalizeResourcePath(path).split("/").filter(segment => segment.length > 0 && segment !== "~");
+}
+function normalizeResourcePath(path) {
+    return path.replaceAll("\\", "/");
+}
+function isPackageExtensionSource(sourceInfo) {
+    const source = sourceInfo?.source ?? "";
+    return source.startsWith("npm:") || source.startsWith("git:");
+}
+// Performance: one painter set per root keeps identities stable, so the neutral viewport retains row-level
+// selection variants while each callback still resolves the live theme.

package/dist/app/session-shell/session-prompt-history.d.ts

@@ -0,0 +1,29 @@
+import type { OwnedUiSessionViewModel, PromptHistoryImageSidecarAttachment, PromptHistoryImageSidecarPort } from "../../contracts/owned-ui/index.js";
+import type { OwnedUiShellEditorPort } from "../../contracts/owned-ui/index.js";
+import { PromptHistoryController } from "./prompt-history-controller.js";
+import type { OwnedUiShellHistoryOptions } from "./session-shell-root.js";
+type HistoryScope = "unique" | "shared";
+/** What prompt history needs from the session: the editor, the transcript, and a render request. */
+export interface SessionPromptHistoryPorts {
+    readonly editor: OwnedUiShellEditorPort;
+    usesDefaultInputSurface(): boolean;
+    rehydrate(text: string, resolveImage: (id: string) => PromptHistoryImageSidecarAttachment | null): string;
+    requestRender(): void;
+    transcript(): OwnedUiSessionViewModel["transcript"];
+    currentHistorySessionId(): string | null;
+}
+/**
+ * Binds persistent prompt history to the current session and scope, and replaces the store when either changes.
+ * Invariant: the controller is built in one place, so the initial and rebound histories behave the same.
+ */
+export declare class SessionPromptHistory {
+    #private;
+    constructor(options: OwnedUiShellHistoryOptions, ports: SessionPromptHistoryPorts);
+    get controller(): PromptHistoryController | null;
+    get imageSidecar(): PromptHistoryImageSidecarPort | undefined;
+    start(): void;
+    synchronize(): void;
+    close(): Promise<boolean>;
+    rebind(replaced: boolean, scope?: HistoryScope): void;
+}
+export {};

package/dist/app/session-shell/session-prompt-history.js

@@ -0,0 +1,80 @@
+import { PromptHistoryController } from "./prompt-history-controller.js";
+/** The user prompts in a transcript, oldest first: the recall a store-less or replaced history starts from. */
+function userTexts(transcript) {
+    return transcript.flatMap(block => block.kind === "user" ? [block.text] : []);
+}
+/**
+ * Binds persistent prompt history to the current session and scope, and replaces the store when either changes.
+ * Invariant: the controller is built in one place, so the initial and rebound histories behave the same.
+ */
+export class SessionPromptHistory {
+    #options;
+    #ports;
+    #controller;
+    #scope;
+    #sessionId;
+    #imageSidecar;
+    #started = false;
+    constructor(options, ports) {
+        this.#options = options;
+        this.#ports = ports;
+        this.#scope = options.scope ?? "unique";
+        this.#sessionId = options.sessionId;
+        this.#imageSidecar = options.imageSidecar;
+        this.#controller = this.#createController(options.store, userTexts(ports.transcript()));
+    }
+    get controller() { return this.#controller; }
+    get imageSidecar() { return this.#imageSidecar; }
+    start() {
+        this.#started = true;
+        this.#controller?.start();
+    }
+    synchronize() { this.#controller?.synchronize(); }
+    close() { return this.#controller?.close() ?? Promise.resolve(true); }
+    // Invariant: delivery recovery does not replace a store; conversation or live scope changes can.
+    rebind(replaced, scope) {
+        if (this.#options.forSession !== undefined || this.#options.forScope !== undefined) {
+            const sessionId = this.#ports.currentHistorySessionId();
+            const selectedScope = scope ?? this.#scope;
+            if (selectedScope !== this.#scope || sessionId !== this.#sessionId) {
+                if (!replaced)
+                    this.#ports.editor.recall?.restoreDraft?.();
+                const previous = this.#controller;
+                this.#controller = null;
+                this.#imageSidecar = undefined;
+                this.#scope = selectedScope;
+                this.#sessionId = sessionId ?? undefined;
+                void previous?.close().catch(() => false);
+                const destination = this.#options.forScope !== undefined
+                    ? this.#options.forScope(selectedScope, sessionId)
+                    : sessionId === null ? null : this.#options.forSession(sessionId);
+                if (destination !== null) {
+                    this.#imageSidecar = destination.imageSidecar;
+                    this.#controller = this.#createController(destination.store, replaced ? userTexts(this.#ports.transcript()) : []);
+                    if (this.#started)
+                        this.#controller.start();
+                }
+                else {
+                    // Security: missing identity must not reopen Shared or retain another session's recall.
+                    const fallback = replaced ? userTexts(this.#ports.transcript()).reverse() : [];
+                    this.#ports.editor.recall?.reset();
+                    this.#ports.editor.recall?.replace(fallback);
+                }
+                return;
+            }
+        }
+        if (replaced)
+            this.#controller?.reset(userTexts(this.#ports.transcript()));
+    }
+    #createController(store, fallback) {
+        return new PromptHistoryController({
+            editor: this.#ports.editor,
+            store,
+            limit: this.#options.limit,
+            fallback,
+            active: () => this.#ports.usesDefaultInputSurface(),
+            render: () => this.#ports.requestRender(),
+            rehydrate: value => this.#ports.rehydrate(value, id => this.#imageSidecar?.readAttachment(id) ?? null),
+        });
+    }
+}

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();
+    }
+}