@timurproko/a1 0.2.6 → 0.2.7-dev.1222

package/dist/app/session-shell/dock-chrome.d.ts

@@ -0,0 +1,34 @@
+import type { ImageAttachmentError, OwnedUiSessionViewModel } from "../../contracts/owned-ui/index.js";
+import type { TranscriptViewportFrame } from "../../ui/components/transcript-viewport.js";
+import { type PiShellReleaseUpdateBanner } from "../../integrations/pi/components/shell-presenters-info.js";
+import type { SessionViewportController } from "./session-viewport-controller.js";
+export interface DockNotice {
+    readonly kind: "status" | "warning" | "error" | "new-session";
+    readonly message: string;
+    readonly errorCode?: ImageAttachmentError["code"];
+}
+export interface DockChromePorts {
+    /** Chrome changed; the root invalidates its chrome components. */
+    readonly invalidateChrome: () => void;
+    readonly requestRender: () => void;
+    readonly viewport: Pick<SessionViewportController, "tailControlHovered" | "setTailControl">;
+}
+/**
+ * The transient chrome around bare A1's dock: the one command notice above the editor, the release
+ * banner above Working with its close control, and the short copy acknowledgement.
+ */
+export declare class DockChrome {
+    #private;
+    constructor(ports: DockChromePorts);
+    get notice(): DockNotice | undefined;
+    setNotice(notice: DockNotice): void;
+    dismissNotice(): void;
+    /** Forgets the notice without a chrome invalidation; the caller invalidates as part of a larger change. */
+    forgetNotice(): void;
+    renderNotice(width: number, outputPad: 0 | 1): readonly string[];
+    showCopyAcknowledgement(message: string): void;
+    clearCopyAcknowledgement(requestRender: boolean): void;
+    renderCopyAcknowledgement(width: number): string | undefined;
+    renderReleaseBanner(diagnostics: OwnedUiSessionViewModel["diagnostics"], width: number): PiShellReleaseUpdateBanner | undefined;
+    locateReleaseClose(frame: TranscriptViewportFrame, banner: PiShellReleaseUpdateBanner | undefined, tailEnd: number, tailLength: number): void;
+}

package/dist/app/session-shell/dock-chrome.js

@@ -0,0 +1,109 @@
+import { COPY_ACKNOWLEDGEMENT_DURATION_MS } from "../../ui/components/selection-copy.js";
+import { renderPiShellCommandMessage, renderPiShellReleaseUpdateBanner, renderPiShellStatusText, } from "../../integrations/pi/components/shell-presenters-info.js";
+import { PINNED_PI_LAYOUT, piTheme } from "../../integrations/pi/components/upstream/theme/theme.js";
+import { piShellTruncateToWidth } from "../../integrations/pi/components/shell-shared-facade.js";
+import { parseReleaseUpdateDiagnostic } from "./transcript-document.js";
+/**
+ * The transient chrome around bare A1's dock: the one command notice above the editor, the release
+ * banner above Working with its close control, and the short copy acknowledgement.
+ */
+export class DockChrome {
+    #ports;
+    #notice;
+    // Invariant: bare A1 docks the release notice above the live status; closing it lasts for this session only.
+    #releaseDismissed = false;
+    #releaseCloseTarget;
+    #copyAcknowledgement;
+    #copyAcknowledgementTimer;
+    constructor(ports) {
+        this.#ports = ports;
+    }
+    get notice() {
+        return this.#notice;
+    }
+    setNotice(notice) {
+        this.#notice = notice;
+        this.#ports.invalidateChrome();
+    }
+    dismissNotice() {
+        if (this.#notice === undefined)
+            return;
+        this.#notice = undefined;
+        this.#ports.invalidateChrome();
+    }
+    /** Forgets the notice without a chrome invalidation; the caller invalidates as part of a larger change. */
+    forgetNotice() {
+        this.#notice = undefined;
+    }
+    renderNotice(width, outputPad) {
+        const notice = this.#notice;
+        if (notice === undefined)
+            return [];
+        if (notice.kind === "status") {
+            // Compatibility: Pi pads its status text by one cell regardless of the output pad setting.
+            return ["", ...renderPiShellStatusText(notice.message, width, PINNED_PI_LAYOUT.outputPad)];
+        }
+        return renderPiShellCommandMessage({
+            kind: notice.kind === "new-session" ? "accent" : notice.kind,
+            message: notice.message,
+        }, width, outputPad);
+    }
+    showCopyAcknowledgement(message) {
+        this.clearCopyAcknowledgement(false);
+        this.#copyAcknowledgement = message;
+        const timer = setTimeout(() => {
+            if (this.#copyAcknowledgementTimer !== timer)
+                return;
+            this.#copyAcknowledgementTimer = undefined;
+            this.#copyAcknowledgement = undefined;
+            this.#ports.invalidateChrome();
+            this.#ports.requestRender();
+        }, COPY_ACKNOWLEDGEMENT_DURATION_MS);
+        timer.unref?.();
+        this.#copyAcknowledgementTimer = timer;
+        this.#ports.invalidateChrome();
+        this.#ports.requestRender();
+    }
+    clearCopyAcknowledgement(requestRender) {
+        if (this.#copyAcknowledgementTimer !== undefined)
+            clearTimeout(this.#copyAcknowledgementTimer);
+        this.#copyAcknowledgementTimer = undefined;
+        if (this.#copyAcknowledgement === undefined)
+            return;
+        this.#copyAcknowledgement = undefined;
+        this.#ports.invalidateChrome();
+        if (requestRender)
+            this.#ports.requestRender();
+    }
+    renderCopyAcknowledgement(width) {
+        if (this.#copyAcknowledgement === undefined || width <= 0)
+            return undefined;
+        return piTheme().fg("accent", piShellTruncateToWidth(this.#copyAcknowledgement, width));
+    }
+    renderReleaseBanner(diagnostics, width) {
+        if (this.#releaseDismissed)
+            return undefined;
+        const diagnostic = diagnostics.findLast(item => item.code === "release-update");
+        const release = diagnostic === undefined ? null : parseReleaseUpdateDiagnostic(diagnostic.message);
+        if (release === null)
+            return undefined;
+        return renderPiShellReleaseUpdateBanner(release, width, this.#ports.viewport.tailControlHovered(this.#releaseCloseTarget));
+    }
+    locateReleaseClose(frame, banner, tailEnd, tailLength) {
+        // Invariant: the tail is the document suffix, so the control's document row is fixed relative to its
+        // end; alignment gap rows precede it and the viewport scroll decides whether it is on screen.
+        const bannerStart = tailEnd + frame.descriptor.transientAlignmentGapRows - tailLength - frame.scrollTop + 1;
+        const rowStart = banner === undefined ? 0 : Math.max(1, bannerStart + banner.close.rowStart);
+        const rowEnd = banner === undefined ? 0 : Math.min(frame.hits.viewportHeight, bannerStart + banner.close.rowEnd);
+        this.#releaseCloseTarget = banner !== undefined && rowStart <= rowEnd
+            ? { rowStart, rowEnd, columnStart: banner.close.columnStart, columnEnd: banner.close.columnEnd }
+            : undefined;
+        this.#ports.viewport.setTailControl(this.#releaseCloseTarget === undefined ? undefined : {
+            ...this.#releaseCloseTarget,
+            activate: () => {
+                this.#releaseDismissed = true;
+                this.#releaseCloseTarget = undefined;
+            },
+        });
+    }
+}

package/dist/app/session-shell/exit-notice.d.ts

@@ -1,4 +1,4 @@
-import { type SessionResumeCommandMetadata } from "./session-shell.js";
+import { type SessionResumeCommandMetadata } from "./session-lifecycle.js";
 export interface ExitNoticeSource {
     readonly identity: {
         readonly sessionGeneration: number;

package/dist/app/session-shell/exit-notice.js

@@ -6,7 +6,7 @@
  */
 import { renameSync, rmSync, writeFileSync } from "node:fs";
 import { PRODUCT_IDENTITY } from "../../product-identity.js";
-import { formatSessionResumeCommand } from "./session-shell.js";
+import { formatSessionResumeCommand } from "./session-lifecycle.js";
 export function uncleanExitNoticeLines(resume) {
     return [
         `${PRODUCT_IDENTITY.displayName} was stopped unexpectedly.`,

package/dist/app/session-shell/extension-surface.d.ts

@@ -0,0 +1,30 @@
+import type { OwnedUiSessionViewModel } from "../../contracts/owned-ui/index.js";
+import type { PiShellComponentPort } from "../../integrations/pi/components/shell-shared-facade.js";
+export type ExtensionWidgetPlacement = "aboveEditor" | "belowEditor";
+/**
+ * What extensions draw into the shell: a header that replaces the built-in one, a footer, widgets
+ * above and below the editor, footer statuses, and a working message. It owns those components and
+ * disposes each one it replaces; the root decides what to invalidate after a change.
+ */
+export declare class ExtensionSurface {
+    #private;
+    get header(): PiShellComponentPort | null;
+    get footer(): PiShellComponentPort | null;
+    get working(): {
+        readonly message: string | undefined;
+        readonly visible: boolean;
+    };
+    placeWidget(key: string, component: PiShellComponentPort | null, placement: ExtensionWidgetPlacement): void;
+    replaceHeader(component: PiShellComponentPort | null): void;
+    replaceFooter(component: PiShellComponentPort | null): void;
+    setStatus(key: string, text: string | undefined): void;
+    setWorking(message: string | undefined, visible: boolean): void;
+    statuses(): Map<string, string>;
+    /** The view with extension statuses merged over the engine's footer statuses. */
+    withStatuses(view: OwnedUiSessionViewModel): OwnedUiSessionViewModel;
+    renderWidgets(placement: ExtensionWidgetPlacement, width: number): readonly string[];
+    invalidate(): void;
+    /** Disposes and forgets everything an extension set; working visibility is the extension's own choice and stays. */
+    reset(): void;
+    dispose(): void;
+}

package/dist/app/session-shell/extension-surface.js

@@ -0,0 +1,105 @@
+/**
+ * What extensions draw into the shell: a header that replaces the built-in one, a footer, widgets
+ * above and below the editor, footer statuses, and a working message. It owns those components and
+ * disposes each one it replaces; the root decides what to invalidate after a change.
+ */
+export class ExtensionSurface {
+    #header = null;
+    #footer = null;
+    #widgets = new Map();
+    #statuses = new Map();
+    #workingMessage;
+    #workingVisible = true;
+    get header() {
+        return this.#header;
+    }
+    get footer() {
+        return this.#footer;
+    }
+    get working() {
+        return { message: this.#workingMessage, visible: this.#workingVisible };
+    }
+    placeWidget(key, component, placement) {
+        const previous = this.#widgets.get(key)?.component;
+        if (component === null)
+            this.#widgets.delete(key);
+        else
+            this.#widgets.set(key, { component, placement });
+        if (previous !== undefined && previous !== component)
+            previous.dispose?.();
+    }
+    replaceHeader(component) {
+        if (this.#header !== component)
+            this.#header?.dispose?.();
+        this.#header = component;
+    }
+    replaceFooter(component) {
+        if (this.#footer !== component)
+            this.#footer?.dispose?.();
+        this.#footer = component;
+    }
+    setStatus(key, text) {
+        if (text === undefined)
+            this.#statuses.delete(key);
+        else
+            this.#statuses.set(key, text);
+    }
+    setWorking(message, visible) {
+        this.#workingMessage = message;
+        this.#workingVisible = visible;
+    }
+    statuses() {
+        return new Map(this.#statuses);
+    }
+    /** The view with extension statuses merged over the engine's footer statuses. */
+    withStatuses(view) {
+        const footer = view.status.footer;
+        const statuses = new Map(footer?.extensionStatuses ?? []);
+        for (const [key, text] of this.#statuses)
+            statuses.set(key, text);
+        return {
+            ...view,
+            status: {
+                ...view.status,
+                footer: {
+                    ...footer,
+                    branch: footer?.branch ?? null,
+                    sessionName: footer?.sessionName ?? null,
+                    availableProviderCount: footer?.availableProviderCount ?? 1,
+                    extensionStatuses: [...statuses],
+                },
+            },
+        };
+    }
+    renderWidgets(placement, width) {
+        const rows = [...this.#widgets.values()]
+            .filter(widget => widget.placement === placement)
+            .flatMap(widget => widget.component.render(width));
+        return placement === "aboveEditor" ? ["", ...rows] : rows;
+    }
+    invalidate() {
+        this.#header?.invalidate();
+        this.#footer?.invalidate();
+        for (const { component } of this.#widgets.values())
+            component.invalidate();
+    }
+    /** Disposes and forgets everything an extension set; working visibility is the extension's own choice and stays. */
+    reset() {
+        this.#header?.dispose?.();
+        this.#footer?.dispose?.();
+        for (const { component } of this.#widgets.values())
+            component.dispose?.();
+        this.#header = null;
+        this.#footer = null;
+        this.#widgets.clear();
+        this.#statuses.clear();
+        this.#workingMessage = undefined;
+    }
+    dispose() {
+        this.#header?.dispose?.();
+        this.#footer?.dispose?.();
+        for (const { component } of this.#widgets.values())
+            component.dispose?.();
+        this.#widgets.clear();
+    }
+}

package/dist/app/session-shell/helper-pool.d.ts

@@ -12,16 +12,14 @@ export interface HelperPoolOptions {
     readonly stop: (child: ChildProcess) => void;
     readonly idleMs?: number;
 }
-/**
- * Keeps one forked IPC helper ready so a request takes a live child instead of paying fork and module
- * load on its own critical path. The spare stays idle on its channel until it is taken; a spare that
- * exits or idles too long is dropped, and the next request forks cold and warms a replacement afterwards.
- */
+/** Holds one idle IPC helper; requests take it, and exits, expiry, or use trigger replacement. */
 export declare class HelperPool {
     #private;
     constructor(options: HelperPoolOptions);
     /** Whether a spare is currently held (ready or still starting). */
     get warmed(): boolean;
+    /** Whether the held spare has announced that module loading is complete. */
+    get ready(): boolean;
     /** Opts the pool in and forks the first spare; from here on `replenish` keeps one ready after each request. */
     warm(): void;
     /** Forks the next spare after a request released its child; a no-op until the owner warmed the pool. A fork failure leaves the pool empty. */

package/dist/app/session-shell/helper-pool.js

@@ -1,10 +1,6 @@
 /** How long an unused spare helper may idle before it is stopped so a background session holds no extra process. */
 export const HELPER_SPARE_IDLE_MS = 5 * 60_000;
-/**
- * Keeps one forked IPC helper ready so a request takes a live child instead of paying fork and module
- * load on its own critical path. The spare stays idle on its channel until it is taken; a spare that
- * exits or idles too long is dropped, and the next request forks cold and warms a replacement afterwards.
- */
+/** Holds one idle IPC helper; requests take it, and exits, expiry, or use trigger replacement. */
 export class HelperPool {
     #fork;
     #stop;
@@ -19,6 +15,8 @@ export class HelperPool {
     }
     /** Whether a spare is currently held (ready or still starting). */
     get warmed() { return this.#spare !== undefined; }
+    /** Whether the held spare has announced that module loading is complete. */
+    get ready() { return this.#spare?.ready === true; }
     /** Opts the pool in and forks the first spare; from here on `replenish` keeps one ready after each request. */
     warm() {
         if (this.#disposed)

package/dist/app/session-shell/input-surface-switch.d.ts

@@ -0,0 +1,36 @@
+import type { PiShellComponentPort, PiShellEditorPort } from "../../integrations/pi/components/shell-shared-facade.js";
+import { type PiTuiInputSurfaceKind } from "../../integrations/pi/tui-runtime/input-presentation-coordinator.js";
+import type { SessionViewportController } from "./session-viewport-controller.js";
+export interface InputSurfaceSwitchPorts {
+    /** Whether keystrokes that cannot change the transcript may repaint the dock alone. */
+    readonly dockInputReuse: boolean;
+    readonly viewport: Pick<SessionViewportController, "invalidateInputSurface" | "presentationRevision">;
+    /** The surface changed; listeners outside the root react. */
+    readonly onChanged?: () => void;
+}
+/**
+ * Which component receives the dock's input: the prompt editor, or a selector, dialog, or prompt
+ * that temporarily replaces it. It also records whether the latest keystroke is safe for a
+ * dock-only repaint; that receipt-time evidence never authorizes reuse by itself.
+ */
+export declare class InputSurfaceSwitch {
+    #private;
+    constructor(editor: PiShellEditorPort, ports: InputSurfaceSwitchPorts);
+    get surface(): PiShellComponentPort;
+    get coordination(): PiTuiInputSurfaceKind;
+    get usesEditor(): boolean;
+    get dockInputCandidate(): boolean;
+    get dockInputRevision(): number | undefined;
+    /**
+     * Shows `component` in the dock, or the editor for null. Returns false when the surface is
+     * unchanged, in which case only its coordination kind is updated.
+     */
+    set(component: PiShellComponentPort | null, disposePrevious: boolean, coordination: Exclude<PiTuiInputSurfaceKind, "editor">): boolean;
+    handleInput(data: string): void;
+    /** Reads and clears the dock-only candidate for one composition. */
+    takeDockInputCandidate(): boolean;
+    /** Something outside the dock changed, so the latest keystroke no longer qualifies for reuse. */
+    clearDockInputCandidate(): void;
+    /** Disposes a replacement surface; the editor is disposed by its owner. */
+    dispose(): void;
+}

package/dist/app/session-shell/input-surface-switch.js

@@ -0,0 +1,85 @@
+import { classifyPiTuiInput } from "../../integrations/pi/tui-runtime/input-presentation-coordinator.js";
+/**
+ * Which component receives the dock's input: the prompt editor, or a selector, dialog, or prompt
+ * that temporarily replaces it. It also records whether the latest keystroke is safe for a
+ * dock-only repaint; that receipt-time evidence never authorizes reuse by itself.
+ */
+export class InputSurfaceSwitch {
+    #editor;
+    #ports;
+    #surface;
+    #coordination = "editor";
+    #dockInputCandidate = false;
+    // Invariant: receipt-time eligibility is evidence, never authorization for composition-time reuse.
+    #dockInputRevision;
+    constructor(editor, ports) {
+        this.#editor = editor;
+        this.#ports = ports;
+        this.#surface = editor;
+    }
+    get surface() {
+        return this.#surface;
+    }
+    get coordination() {
+        return this.#coordination;
+    }
+    get usesEditor() {
+        return this.#surface === this.#editor;
+    }
+    get dockInputCandidate() {
+        return this.#dockInputCandidate;
+    }
+    get dockInputRevision() {
+        return this.#dockInputRevision;
+    }
+    /**
+     * Shows `component` in the dock, or the editor for null. Returns false when the surface is
+     * unchanged, in which case only its coordination kind is updated.
+     */
+    set(component, disposePrevious, coordination) {
+        const next = component ?? this.#editor;
+        const nextCoordination = next === this.#editor ? "editor" : coordination;
+        if (next === this.#surface) {
+            this.#coordination = nextCoordination;
+            return false;
+        }
+        this.#dockInputCandidate = false;
+        this.#ports.viewport.invalidateInputSurface();
+        this.#surface.setFocused?.(false);
+        if (disposePrevious && this.#surface !== this.#editor)
+            this.#surface.dispose?.();
+        this.#surface = next;
+        this.#coordination = nextCoordination;
+        this.#ports.onChanged?.();
+        this.#surface.setFocused?.(true);
+        return true;
+    }
+    handleInput(data) {
+        this.#dockInputCandidate = this.#ports.dockInputReuse && classifyPiTuiInput(data, this.#coordination) === "safe";
+        this.#dockInputRevision = this.#dockInputCandidate ? this.#ports.viewport.presentationRevision : undefined;
+        try {
+            this.#surface.handleInput?.(data);
+        }
+        catch (error) {
+            this.#dockInputCandidate = false;
+            throw error;
+        }
+    }
+    /** Reads and clears the dock-only candidate for one composition. */
+    takeDockInputCandidate() {
+        const candidate = this.#dockInputCandidate;
+        this.#dockInputCandidate = false;
+        return candidate;
+    }
+    /** Something outside the dock changed, so the latest keystroke no longer qualifies for reuse. */
+    clearDockInputCandidate() {
+        this.#dockInputCandidate = false;
+        this.#dockInputRevision = undefined;
+    }
+    /** Disposes a replacement surface; the editor is disposed by its owner. */
+    dispose() {
+        this.clearDockInputCandidate();
+        if (this.#surface !== this.#editor)
+            this.#surface.dispose?.();
+    }
+}

package/dist/app/session-shell/login-interaction.d.ts

@@ -0,0 +1,27 @@
+import type { OwnedUiWorkflowInteractionRequest, OwnedUiWorkflowLoginNotification, OwnedUiWorkflowLoginStart } from "../../contracts/owned-ui/index.js";
+import type { ProgramStatusReporter } from "../../integrations/pi/components/upstream/program-status-reporter.js";
+import type { SessionConcern } from "./session-concern.js";
+import type { OwnedUiSessionShellRoot } from "./session-shell-root.js";
+import { type OwnedUiPresenterTerminal } from "./shell-host.js";
+export interface LoginInteractionPorts {
+    readonly terminal: Pick<OwnedUiPresenterTerminal, "viewport" | "requestRender">;
+    readonly root: Pick<OwnedUiSessionShellRoot, "setInputSurface">;
+    readonly programStatus: Pick<ProgramStatusReporter, "setBlocked">;
+    /** The blocked-on-authentication state changed; the presenter republishes terminal progress. */
+    readonly syncProgress: () => void;
+}
+/**
+ * The engine's login flow in the dock: one login dialog at a time, the prompts and selections the
+ * engine asks through it, and the terminal's blocked-on-authentication status while it is open.
+ */
+export declare class LoginInteraction implements SessionConcern {
+    #private;
+    constructor(ports: LoginInteractionPorts);
+    start(request: OwnedUiWorkflowLoginStart): void;
+    /** Answers an engine prompt through the open dialog; null when no login is in progress or it is cancelled. */
+    requestInput(request: OwnedUiWorkflowInteractionRequest): Promise<string | null>;
+    notify(event: OwnedUiWorkflowLoginNotification): void;
+    finish(): void;
+    /** A replaced session forgets its dialog; the presenter clears the input surface as part of the same replacement. */
+    onSessionReplaced(): void;
+}

package/dist/app/session-shell/login-interaction.js

@@ -0,0 +1,91 @@
+import { createPiShellExtensionSelector, createPiShellLoginDialog, } from "../../integrations/pi/components/shell-selectors-dialogs.js";
+import { componentRuntime } from "./shell-host.js";
+/**
+ * The engine's login flow in the dock: one login dialog at a time, the prompts and selections the
+ * engine asks through it, and the terminal's blocked-on-authentication status while it is open.
+ */
+export class LoginInteraction {
+    #ports;
+    #dialog;
+    constructor(ports) {
+        this.#ports = ports;
+    }
+    start(request) {
+        this.finish();
+        const dialog = createPiShellLoginDialog(componentRuntime(this.#ports.terminal), request.providerId, success => {
+            if (!success)
+                this.finish();
+        }, request.providerName);
+        this.#dialog = dialog;
+        this.#ports.root.setInputSurface(dialog);
+        this.#ports.programStatus.setBlocked("authentication", {
+            kind: "auth",
+            message: `Log in to ${request.providerName}`,
+        });
+        this.#ports.syncProgress();
+        this.#ports.terminal.requestRender();
+    }
+    /** Answers an engine prompt through the open dialog; null when no login is in progress or it is cancelled. */
+    requestInput(request) {
+        const dialog = this.#dialog;
+        if (!dialog)
+            return Promise.resolve(null);
+        if (request.type === "select") {
+            return new Promise(resolve => {
+                const options = request.options ?? [];
+                const labels = options.map(option => option.label);
+                const restoreDialog = () => {
+                    if (this.#dialog === dialog)
+                        this.#ports.root.setInputSurface(dialog);
+                    this.#ports.terminal.requestRender();
+                };
+                const selector = createPiShellExtensionSelector(request.message, labels, label => {
+                    const id = options.find(option => option.label === label)?.id;
+                    restoreDialog();
+                    resolve(id ?? null);
+                }, () => {
+                    restoreDialog();
+                    resolve(null);
+                });
+                this.#ports.root.setInputSurface(selector, false);
+                this.#ports.terminal.requestRender();
+            });
+        }
+        const response = request.type === "manual-code"
+            ? dialog.showManualInput(request.message)
+            : dialog.showPrompt(request.message, request.placeholder);
+        this.#ports.terminal.requestRender();
+        return response.then(value => value, () => null);
+    }
+    notify(event) {
+        const dialog = this.#dialog;
+        if (!dialog)
+            return;
+        if (event.type === "auth_url")
+            dialog.showAuth(event.url, event.instructions);
+        else if (event.type === "device_code") {
+            dialog.showDeviceCode(event);
+            dialog.showWaiting("Waiting for authentication...");
+        }
+        else if (event.type === "info")
+            dialog.showInfo(event.message, event.links);
+        else if (event.type === "waiting")
+            dialog.showWaiting(event.message);
+        else
+            dialog.showProgress(event.message);
+        this.#ports.terminal.requestRender();
+    }
+    finish() {
+        if (!this.#dialog)
+            return;
+        this.#dialog = undefined;
+        this.#ports.root.setInputSurface(null);
+        this.#ports.programStatus.setBlocked("authentication", undefined);
+        this.#ports.syncProgress();
+        this.#ports.terminal.requestRender();
+    }
+    /** A replaced session forgets its dialog; the presenter clears the input surface as part of the same replacement. */
+    onSessionReplaced() {
+        this.#dialog = undefined;
+    }
+}

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

@@ -0,0 +1,48 @@
+import type { OwnedUiCommand, OwnedUiCommandResult, OwnedUiSessionBackend, OwnedUiSessionViewModel, PromptHistoryImageSidecarPort } from "../../contracts/owned-ui/index.js";
+import type { PromptHistoryController } from "./prompt-history-controller.js";
+import type { ResidentTabCoordinator } from "./resident-tab-coordinator.js";
+import type { SessionConcern } from "./session-concern.js";
+import type { OwnedUiSessionShellRoot } from "./session-shell-root.js";
+import type { OwnedUiPresenterTerminal } from "./shell-host.js";
+export interface PromptSubmissionPorts {
+    readonly backend: Pick<OwnedUiSessionBackend, "session" | "identity" | "workflows">;
+    readonly root: Pick<OwnedUiSessionShellRoot, "editor" | "hasPendingPastes" | "waitForPromptPastes" | "setExtensionWidget" | "prepareHistoryText" | "imageChipAttachmentsFromEditor" | "preparePromptSubmission" | "omitUnsentPromptImages" | "resumeViewportFollowing" | "beginImageSubmissionStatus" | "appendWorkflowResult">;
+    readonly terminal: Pick<OwnedUiPresenterTerminal, "requestRender">;
+    readonly residentTab: ResidentTabCoordinator;
+    readonly cwd: string;
+    promptHistory(): PromptHistoryController | null;
+    imageSidecar(): PromptHistoryImageSidecarPort | undefined;
+    disposed(): boolean;
+    correlation(prefix: string): string;
+    lifecycle(): OwnedUiSessionViewModel["lifecycle"];
+    currentSessionFile(): string | null;
+    /** Slash input the presenter routes itself: owned routes, workflows, and skills. */
+    slashCommand(text: string): Promise<OwnedUiCommandResult>;
+    /** A prompt is about to be submitted; a pending suggestion for the old draft no longer applies. */
+    invalidateSuggestions(): void;
+}
+/**
+ * Turns editor input into engine commands: prompts, steering, follow-ups, and bash, each recorded
+ * in history first. It holds a submission whose image pastes are still preparing, journals prompts
+ * for resident tabs, and recovers the draft when a submission is rejected.
+ */
+export declare class PromptSubmission implements SessionConcern {
+    #private;
+    constructor(ports: PromptSubmissionPorts);
+    /** True while a submission waits for its image pastes. */
+    get waiting(): boolean;
+    /** The editor changed; a later recovery never overwrites input typed after its submission. */
+    noteEditorChange(): void;
+    submit(text: string): Promise<OwnedUiCommandResult>;
+    queueFollowUp(draft: string): Promise<OwnedUiCommandResult>;
+    cancelWaiting(): void;
+    /** Puts waiting submissions and the engine's queued input back into the editor. */
+    restoreQueued(): void;
+    /** Sends slash text the shell does not own as engine prompt input; history keeps what was typed. */
+    sendSlashPrompt(text: string, typed?: string): Promise<OwnedUiCommandResult>;
+    /** Executes a command; with a draft, a rejected or failed submission puts the draft back for recovery. */
+    execute(command: OwnedUiCommand, draft?: string): Promise<OwnedUiCommandResult>;
+    reportError(error?: unknown, message?: string): void;
+    onSessionReplaced(): void;
+    dispose(): void;
+}