@timurproko/a1 0.1.8-dev.282 → 0.1.8-dev.289

package/dist/integrations/pi/session-ui/prompt-chips.js

@@ -3,18 +3,116 @@ import { existsSync, statSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { canonicalizeClipboardImage } from "./clipboard-image.js";
+import { assertImageEncodedSize, assertPromptImages, ImageAttachmentError } from "../../../contracts/owned-ui/index.js";
+import { ImagePreparationClient } from "./image-preparation-client.js";
 const CHIP_PATTERN = /\[(?:📷 [^\]]+|📁 [^\]]+|📄 [^\]]+|🖼 {1,2}[^\]]+|🔗 [^\]]+)\]/gu;
 const IMAGE_EXTENSION = /\.(?:jpe?g|png|webp|gif|bmp|tiff?)$/iu;
 const URL_PATTERN = /^https?:\/\/[^\s\u0000-\u001f\u007f]+$/iu;
 const URL_DISPLAY_LENGTH = 40;
-/** Owns semantic clipboard records while the prompt displays compact chips. */
+/** Owns semantic chips and bounded pending paste references; cancels background work on reset or disposal. */
 export class PromptChipStore {
     #chips = new Map();
-    transformPastedContent(content) {
+    #pending = new Map();
+    #preparation = new ImagePreparationClient();
+    #stopping = new Set();
+    beginPaste(currentText, read, onError) {
+        const marker = `[📷 preparing-${randomBytes(5).toString("hex")}]`;
+        const job = this.#preparation.start(async (signal) => {
+            const content = await read(signal);
+            entry.kind = content?.kind === "image" ? "image" : "text";
+            if (content?.kind === "image" && this.#imageCount(currentText) >= 8)
+                throw new ImageAttachmentError("image-count");
+            return content;
+        });
+        const entry = { marker, job, references: 0, kind: "unknown", completion: job.result.then(content => {
+                if (content === null)
+                    return "";
+                if (content.kind === "image") {
+                    return this.#addPreparedImage(content);
+                }
+                return this.transformPastedContent(content);
+            }).catch(error => {
+                entry.error = error instanceof ImageAttachmentError ? error : new ImageAttachmentError("image-codec");
+                if (entry.error.code !== "image-canceled" && entry.references === 0)
+                    onError(entry.error);
+                return marker.replace("preparing-", "failed-");
+            }).then(replacement => {
+                entry.replacement = replacement;
+                return replacement;
+            }) };
+        this.#pending.set(marker, entry);
+        return { marker, result: entry.completion };
+    }
+    hasPending(text) {
+        return [...this.#pending.values()].some(item => text.includes(item.marker) && item.replacement === undefined);
+    }
+    async waitForPastes(text, signal, readDraft = () => "") {
+        const entries = [...this.#pending.values()].filter(item => text.includes(item.marker));
+        for (const entry of entries)
+            entry.references++;
+        try {
+            await new Promise((resolve, reject) => {
+                const abort = () => reject(new ImageAttachmentError("image-canceled"));
+                if (signal.aborted) {
+                    abort();
+                    return;
+                }
+                signal.addEventListener("abort", abort, { once: true });
+                void Promise.all(entries.map(item => item.completion)).then(() => {
+                    signal.removeEventListener("abort", abort);
+                    resolve();
+                }, reject);
+            });
+            return this.prepareSubmission(text);
+        }
+        finally {
+            for (const entry of entries) {
+                entry.references--;
+                if (signal.aborted && entry.references === 0 && !readDraft().includes(entry.marker))
+                    entry.job.cancel();
+            }
+        }
+    }
+    reconcileDraft(text) {
+        for (const entry of this.#pending.values()) {
+            if (entry.references === 0 && entry.replacement === undefined && !text.includes(entry.marker))
+                entry.job.cancel();
+        }
+    }
+    resetPastes(text) {
+        let remaining = text;
+        for (const entry of this.#pending.values())
+            if (entry.replacement === undefined)
+                remaining = remaining.replaceAll(entry.marker, "");
+        const stopped = this.#preparation.dispose();
+        this.#stopping.add(stopped);
+        void stopped.finally(() => this.#stopping.delete(stopped));
+        this.#preparation = new ImagePreparationClient();
+        for (const entry of this.#pending.values())
+            if (entry.replacement === undefined)
+                entry.job.cancel();
+        return remaining;
+    }
+    async dispose() { await Promise.all([this.#preparation.dispose(), ...this.#stopping]); }
+    #imageCount(text) {
+        const regular = [...this.#chips.values()].filter(chip => chip.kind === "image" && text.includes(chip.tag)).length;
+        return regular + [...this.#pending.values()].filter(entry => entry.kind !== "text" && (text.includes(entry.marker) || text.includes(entry.marker.replace("preparing-", "failed-")))).length;
+    }
+    #addPreparedImage(image) {
+        const suffix = image.mimeType === "image/jpeg" ? "jpg" : image.mimeType.split("/")[1] ?? "png";
+        const tag = `[📷 screenshot-${randomBytes(5).toString("hex")}${image.transformed ? "-resized" : ""}.${suffix}]`;
+        const attachment = Object.freeze({ type: "image", data: image.data, mimeType: image.mimeType });
+        assertPromptImages([attachment]);
+        this.#chips.set(tag, { kind: "image", tag, image: attachment });
+        return tag;
+    }
+    transformPastedContent(content, currentText = "") {
         if (content.kind === "image") {
+            assertImageEncodedSize(content.data);
             const image = canonicalizeClipboardImage(content);
             if (image === null)
                 return "";
+            assertPromptImages([...this.prepareSubmission(currentText).images, { type: "image", ...image }]);
             const id = randomBytes(5).toString("hex");
             const tag = `[📷 screenshot-${id}.png]`;
             this.#chips.set(tag, {
@@ -79,10 +177,22 @@ export class PromptChipStore {
     }
     #replaceResolvable(text, includeImages) {
         let expanded = text;
+        for (const entry of this.#pending.values()) {
+            if (!expanded.includes(entry.marker) && !expanded.includes(entry.marker.replace("preparing-", "failed-")))
+                continue;
+            if (includeImages && entry.error !== undefined)
+                throw entry.error;
+            if (includeImages && entry.replacement === undefined)
+                throw new ImageAttachmentError("image-pending");
+            if (entry.replacement !== undefined)
+                expanded = expanded.replaceAll(entry.marker, entry.replacement);
+        }
         const images = [];
         const seenImages = new Set();
-        for (const [tag, chip] of this.#chips) {
-            if (!expanded.includes(tag))
+        for (const match of expanded.matchAll(CHIP_PATTERN)) {
+            const tag = match[0];
+            const chip = this.#chips.get(tag);
+            if (chip === undefined)
                 continue;
             if (chip.kind === "image") {
                 if (includeImages && !seenImages.has(tag)) {

package/dist/integrations/pi/session-ui/session-shell-root.d.ts

@@ -10,8 +10,8 @@ export type OwnedUiBackendPort = PiEngineAdapter;
 export type OwnedUiTerminalPort = PiTuiTerminalPort;
 type OwnedUiStartupOptions = PiShellHeaderOptions;
 export interface OwnedUiClipboardPort {
-    readText(): Promise<string | null>;
-    readImage?(): Promise<{
+    readText(signal?: AbortSignal): Promise<string | null>;
+    readImage?(signal?: AbortSignal): Promise<{
         readonly data: string;
         readonly mimeType: string;
     } | null>;
@@ -68,6 +68,7 @@ export declare class OwnedUiSessionShellRoot implements PiTuiComponentPort {
         readonly requestHyperlinkCleanup?: () => void;
         readonly enableDockInputReuse?: boolean;
         readonly onSubmit: (text: string) => void;
+        readonly onPasteRejected?: (error: unknown) => void;
         readonly onInterrupt: () => void;
         readonly onClear?: () => void;
         readonly onExit: () => void;
@@ -82,7 +83,7 @@ export declare class OwnedUiSessionShellRoot implements PiTuiComponentPort {
         readonly onPromptSuggestionAccepted?: (text: string) => void;
         readonly onInputSurfaceChanged?: () => void;
         readonly onCopyText?: (text: string) => void;
-        readonly readClipboardContent?: () => Promise<PiShellClipboardContent | null>;
+        readonly readClipboardContent?: (signal?: AbortSignal) => Promise<PiShellClipboardContent | null>;
     }, startup?: PiShellHeaderOptions, agentDir?: string, extensionRenderers?: PiShellExtensionRendererResolver, sessionLayout?: "pinned" | "custom-viewport", imageAssets?: PiShellImageAssetResolver);
     setEditorPaddingX(padding: number): void;
     setAutocompleteMaxVisible(maxVisible: number): void;
@@ -91,6 +92,10 @@ export declare class OwnedUiSessionShellRoot implements PiTuiComponentPort {
     setMermaidRenderingMode(mode: "off" | "final" | "streaming"): void;
     setImagePresentation(showImages: boolean, imageWidthCells: number): void;
     preparePromptSubmission(text: string): PreparedPrompt;
+    hasPendingPastes(text: string): boolean;
+    waitForPromptPastes(text: string, signal: AbortSignal): Promise<PreparedPrompt>;
+    resetPendingPastes(): void;
+    disposePendingPastes(): Promise<void>;
     canPreparePromptSuggestion(): boolean;
     canPresentPromptSuggestion(): boolean;
     setPromptSuggestion(text: string | null): void;

package/dist/integrations/pi/session-ui/session-shell-root.js

@@ -85,7 +85,16 @@ export class OwnedUiSessionShellRoot {
             ...handlers,
             keybindingProfile: this.#customViewport ? "a1" : "pi",
             paintEditorSelection: (line, from, to, atomic) => backgroundSgrSpan(line, from, to, atomic ? "\u001b[7m" : "\u001b[27m\u001b[48;2;38;79;120m", atomic ? "\u001b[27m" : "\u001b[49m", piShellVisibleWidth),
-            transformPastedContent: content => this.#promptChips.transformPastedContent(content),
+            transformPastedContent: content => {
+                try {
+                    return this.#promptChips.transformPastedContent(content, this.editor.getText());
+                }
+                catch (error) {
+                    handlers.onPasteRejected?.(error);
+                    return "";
+                }
+            },
+            ...(this.#customViewport ? { beginClipboardPaste: () => this.#promptChips.beginPaste(this.editor.getText(), signal => handlers.readClipboardContent?.(signal) ?? Promise.resolve(null), error => handlers.onPasteRejected?.(error)) } : {}),
             editorAtomicRanges: line => this.#promptChips.atomicRanges(line),
             decorateEditorRow: (row, width) => {
                 const plain = stripAnsi(row);
@@ -116,7 +125,11 @@ export class OwnedUiSessionShellRoot {
                     styleSuggestionCaret: caretCell,
                 },
             } : {}),
-            ...(handlers.onEditorChange === undefined ? {} : { onChange: handlers.onEditorChange }),
+            onChange: text => {
+                handlers.onEditorChange?.(text);
+                // Concurrency: Pi clears before onSubmit; capture waiting references before pruning removed chips.
+                queueMicrotask(() => this.#promptChips.reconcileDraft(this.editor.getText()));
+            },
             ...(handlers.onPromptSuggestionAccepted === undefined ? {} : { onPromptSuggestionAccepted: handlers.onPromptSuggestionAccepted }),
         });
         this.#viewportController = new SessionViewportController({
@@ -194,6 +207,18 @@ export class OwnedUiSessionShellRoot {
     preparePromptSubmission(text) {
         return this.#promptChips.prepareSubmission(text);
     }
+    hasPendingPastes(text) { return this.#promptChips.hasPending(text); }
+    waitForPromptPastes(text, signal) {
+        return this.#promptChips.waitForPastes(text, signal, () => this.editor.getText());
+    }
+    resetPendingPastes() {
+        this.editor.cancelPendingPastes?.();
+        this.editor.setText(this.#promptChips.resetPastes(this.editor.getText()));
+    }
+    disposePendingPastes() {
+        this.resetPendingPastes();
+        return this.#promptChips.dispose();
+    }
     canPreparePromptSuggestion() {
         return this.usesDefaultInputSurface()
             && this.#view.dialog === null

package/dist/integrations/pi/session-ui/session-shell.js

@@ -1,12 +1,14 @@
 import { PRODUCT_TEXT } from "../../../product-identity.js";
+import { boundedCleanup } from "../../../foundation/terminal-cleanup/index.js";
+import { assertOwnedUiCommand, assertPromptImages, ImageAttachmentError } from "../../../contracts/owned-ui/index.js";
 import { ContextualPromptSuggestionController } from "./prompt-suggestion-controller.js";
 import { MOUSE_TRACKING_OFF, MOUSE_TRACKING_ON, parseMouseInput, readVisibleHyperlinks } from "../../../ui/components/index.js";
 import { PINNED_PI_HIDDEN_COMMAND_NAMES, PINNED_PI_WORKFLOW_COMMAND_NAMES, } from "../engine/index.js";
 import { createPiExtensionUiBridge, createPiQueuedInputStatus, createPiShellArmin, createPiShellAuthProviderSelector, createPiShellChangelog, createPiShellDaxnuts, createPiShellDialog, createPiShellEarendilAnnouncement, createPiShellEditor, createPiShellExtensionSelector, createPiShellFooter, createPiShellHeader, createPiShellHotkeys, createPiShellLoadedResources, createPiShellLoginDialog, createPiShellModelSelector, createPiShellOperationLoader, createPiShellReloadBox, createPiShellScopedModelsSelector, createPiShellSelector, createPiShellSessionInfo, createPiShellSessionSelector, createPiShellSettingsSelector, createPiShellStatus, createPiShellTranscriptComponent, createPiShellTreeSelector, createPiShellTrustSelector, createPiShellUserMessageSelector, onPiThemeChange, piTheme, renderPiShellPackageUpdateNotice, renderPiShellStartupDiagnostic, renderPiShellStatusText, renderPiShellTranscriptBlock, } from "../components/index.js";
 import { DamageAwareTerminalAdapter, PiTuiRuntimeAdapter, classifyPiTuiInput, } from "../tui-runtime/index.js";
-import { canonicalizeClipboardImage } from "./clipboard-image.js";
+import { runImageWorker } from "./image-preparation-client.js";
 import { STREAM_PRESENTATION_INTERVAL_MS, StreamPresentationCoalescer, } from "./stream-presentation-coalescer.js";
-import { preloadSystemClipboard, readSystemClipboardContent, writeSystemClipboardText, } from "./system-clipboard.js";
+import { writeSystemClipboardText, } from "./system-clipboard.js";
 import { OwnedUiSessionShellRoot, shellResourceEntries, } from "./session-shell-root.js";
 export { OwnedUiSessionShellRoot } from "./session-shell-root.js";
 /** Coordinates backend, owned presentation, and Pi TUI lifecycles for one interactive session. */
@@ -27,6 +29,7 @@ export class OwnedUiSessionShell {
     #routeHost;
     #dialogHandle;
     #sequence = 0;
+    #editorRevision = 0;
     #started = false;
     #disposed = false;
     #pointerReporting = false;
@@ -43,6 +46,7 @@ export class OwnedUiSessionShell {
     #imageWidthCells = 80;
     #fullscreenExitOutput = "transcript";
     #compactionQueue = [];
+    #waitingImages = new Map();
     #lastClearTime = 0;
     #lastEscapeTime = 0;
     #activeLoginDialog;
@@ -55,8 +59,6 @@ export class OwnedUiSessionShell {
         this.#cwd = options.cwd;
         this.#routeHost = options.routeHost ?? null;
         this.#customViewport = options.sessionLayout === "custom-viewport";
-        if (this.#customViewport && options.clipboard === undefined)
-            preloadSystemClipboard();
         this.#stopped = new Promise(resolve => {
             this.#resolveStopped = resolve;
         });
@@ -76,7 +78,8 @@ export class OwnedUiSessionShell {
                 replacementSurfaceActive: !this.root.usesDefaultInputSurface(),
             }),
             enableDockInputReuse: options.inputPresentation?.viewportReuse !== false,
-            onSubmit: text => { void this.submit(text); },
+            onSubmit: text => { void this.submit(text).catch(() => this.#reportSubmissionError()); },
+            onPasteRejected: error => this.#reportSubmissionError(error),
             onInterrupt: () => { void this.interrupt(); },
             onClear: () => { void this.clearOrExit(); },
             onExit: () => { void this.shutdown(); },
@@ -88,11 +91,14 @@ export class OwnedUiSessionShell {
                 this.runtime.requestRender();
             },
             onMessageCopy: () => { void this.runWorkflow({ command: "copy", argument: "" }); },
-            onFollowUp: () => { void this.queueFollowUp(); },
+            onFollowUp: () => { void this.queueFollowUp().catch(() => this.#reportSubmissionError()); },
             onDequeue: () => this.restoreQueuedInput(),
-            onEditorChange: () => promptSuggestionController?.invalidate(),
+            onEditorChange: () => { this.#editorRevision++; promptSuggestionController?.invalidate(); },
             onPromptSuggestionAccepted: () => promptSuggestionController?.accept(),
-            onInputSurfaceChanged: () => promptSuggestionController?.invalidate(),
+            onInputSurfaceChanged: () => {
+                this.root.clearViewportPointerState();
+                promptSuggestionController?.invalidate();
+            },
             onCopyText: text => {
                 runtime?.writeControl(`\u001b]52;c;${Buffer.from(text, "utf8").toString("base64")}\u0007`);
                 const write = options.clipboard === undefined
@@ -100,22 +106,26 @@ export class OwnedUiSessionShell {
                     : options.clipboard.writeText?.(text) ?? Promise.resolve();
                 pendingClipboardWrite = write.catch(() => { });
             },
-            readClipboardContent: async () => {
+            readClipboardContent: async (signal = new AbortController().signal) => {
                 await pendingClipboardWrite;
+                if (signal.aborted)
+                    throw new ImageAttachmentError("image-canceled");
                 if (options.clipboard === undefined)
-                    return readSystemClipboardContent();
+                    return runImageWorker({ kind: "clipboard" }, signal);
                 try {
-                    const image = await options.clipboard.readImage?.();
+                    const image = await options.clipboard.readImage?.(signal);
                     if (image !== null && image !== undefined) {
-                        const canonical = canonicalizeClipboardImage(image);
+                        const canonical = await runImageWorker({ kind: "canonicalize", source: image }, signal);
                         if (canonical !== null)
                             return { kind: "image", ...canonical };
                     }
                 }
-                catch {
-                    // Compatibility: treat an unavailable or malformed image as text-capable clipboard input.
+                catch (error) {
+                    if (error instanceof ImageAttachmentError)
+                        throw error;
+                    // Compatibility: an unavailable native image reader can still provide clipboard text.
                 }
-                const text = await options.clipboard.readText();
+                const text = await options.clipboard.readText(signal);
                 return text === null ? null : { kind: "text", text };
             },
         }, {
@@ -226,8 +236,11 @@ export class OwnedUiSessionShell {
                 // surface. Letting the transcript pre-router inspect those reports
                 // steals settings value menus and numeric +/- controls before the
                 // settings app can receive them.
-                if (this.runtime.hasOverlay() || !this.root.usesDefaultInputSurface())
+                if (this.runtime.hasOverlay() || !this.root.usesDefaultInputSurface()) {
+                    if (data.includes("\u001b[<"))
+                        this.root.clearViewportPointerState();
                     return undefined;
+                }
                 const routed = this.root.handleViewportPreInput(data, true);
                 if (routed.copyText !== undefined) {
                     this.runtime.writeControl(`\u001b]52;c;${Buffer.from(routed.copyText, "utf8").toString("base64")}\u0007`);
@@ -421,6 +434,45 @@ export class OwnedUiSessionShell {
         return this.#stopped;
     }
     async submit(text) {
+        return this.#submitWhenReady(text, () => this.#submit(text));
+    }
+    #submitWhenReady(draft, action) {
+        const previous = this.#waitingImages.get(draft);
+        if (previous !== undefined)
+            return previous.result;
+        if (!this.root.hasPendingPastes(draft))
+            return this.#guardSubmission(draft, action);
+        const controller = new AbortController();
+        const generation = this.backend.sessionGeneration;
+        const result = this.#guardSubmission(draft, async () => {
+            await this.root.waitForPromptPastes(draft, controller.signal);
+            if (controller.signal.aborted || this.#disposed || this.backend.sessionGeneration !== generation)
+                return rejected("image submission canceled");
+            return action();
+        }).finally(() => {
+            this.#waitingImages.delete(draft);
+            if (!this.#disposed)
+                this.#showWaitingImages();
+        });
+        this.#waitingImages.set(draft, { controller, result });
+        if (this.root.editor.getText() === draft)
+            this.root.editor.setText("");
+        this.#showWaitingImages();
+        return result;
+    }
+    #showWaitingImages() {
+        const count = this.#waitingImages.size;
+        this.root.setExtensionWidget("owned-image-preparation", count === 0 ? null : {
+            render: width => [...renderPiShellStatusText(`Waiting for images (${count} submission${count === 1 ? "" : "s"}) — Esc cancels; dequeue restores`, width)],
+            invalidate: () => { },
+        }, "aboveEditor");
+        this.runtime.requestRender();
+    }
+    #cancelWaitingImages() {
+        for (const item of this.#waitingImages.values())
+            item.controller.abort();
+    }
+    async #submit(text) {
         this.#promptSuggestions?.invalidate();
         const displayInput = text.trim();
         if (!displayInput)
@@ -428,6 +480,7 @@ export class OwnedUiSessionShell {
         if (displayInput.startsWith("/"))
             return this.#slashCommand(displayInput);
         const prepared = this.root.preparePromptSubmission(displayInput);
+        assertPromptImages(prepared.images);
         const input = prepared.text.trim();
         if (input.startsWith("!")) {
             const excludeFromContext = input.startsWith("!!");
@@ -458,6 +511,7 @@ export class OwnedUiSessionShell {
             this.root.editor.addToHistory(displayInput);
             this.#compactionQueue.push({
                 text: input,
+                draft: displayInput,
                 type: "steer",
                 ...(prepared.images.length === 0 ? {} : { images: prepared.images }),
             });
@@ -474,7 +528,7 @@ export class OwnedUiSessionShell {
             sessionId: this.backend.sessionId,
             text: input,
             ...(prepared.images.length === 0 ? {} : { images: prepared.images }),
-        });
+        }, displayInput);
     }
     async clearOrExit(now = Date.now()) {
         this.#promptSuggestions?.invalidate();
@@ -487,6 +541,10 @@ export class OwnedUiSessionShell {
     }
     async interrupt(now = Date.now()) {
         this.#promptSuggestions?.invalidate();
+        if (this.#waitingImages.size > 0) {
+            this.#cancelWaitingImages();
+            return { outcome: "completed", diagnostic: null };
+        }
         if (this.view().lifecycle === "busy")
             return this.abort();
         if (this.root.editor.getText().trim().length > 0) {
@@ -565,17 +623,24 @@ export class OwnedUiSessionShell {
         return workflowAdapterResult(result);
     }
     async queueFollowUp() {
-        const displayInput = this.root.editor.getText().trim();
+        const draft = this.root.editor.getText();
+        return this.#submitWhenReady(draft, () => this.#queueFollowUp(draft));
+    }
+    async #queueFollowUp(draft) {
+        const displayInput = draft.trim();
         if (!displayInput)
             return rejected("nothing to queue");
         const prepared = this.root.preparePromptSubmission(displayInput);
+        assertPromptImages(prepared.images);
         const text = prepared.text.trim();
         this.root.editor.addToHistory(displayInput);
-        this.root.editor.setText("");
+        if (this.root.editor.getText() === draft)
+            this.root.editor.setText("");
         this.root.resumeViewportFollowing();
         if (this.view().status.workingMessage?.startsWith("Compacting") === true) {
             this.#compactionQueue.push({
                 text,
+                draft: displayInput,
                 type: "follow-up",
                 ...(prepared.images.length === 0 ? {} : { images: prepared.images }),
             });
@@ -587,10 +652,11 @@ export class OwnedUiSessionShell {
             sessionId: this.backend.sessionId,
             text,
             ...(prepared.images.length === 0 ? {} : { images: prepared.images }),
-        });
+        }, displayInput);
     }
     restoreQueuedInput() {
-        const queued = [...this.backend.clearQueuedWorkflows(), ...this.#compactionQueue.map(item => item.text)];
+        const queued = [...this.#waitingImages.keys(), ...this.backend.clearQueuedWorkflows(), ...this.#compactionQueue.map(item => item.draft)];
+        this.#cancelWaitingImages();
         this.#compactionQueue = [];
         if (queued.length === 0)
             return;
@@ -1082,34 +1148,44 @@ export class OwnedUiSessionShell {
         if (this.#disposed)
             return;
         this.#disposed = true;
-        this.root.clearViewportPointerState();
-        this.#setPointerReporting(false, true);
-        this.#removeViewportPreInput();
-        this.#streamPresentation.dispose();
-        this.#promptSuggestions?.dispose();
-        this.#unsubscribePromptSuggestions();
-        this.#unsubscribeSettings();
-        const exitMode = this.backend.disposed
-            ? this.#fullscreenExitOutput
-            : this.backend.pinnedSettingsSnapshot().fullscreenExitOutput;
-        const exitTranscript = this.root.exitTranscript(this.runtime.viewport().columns);
-        const resume = this.backend.currentSessionResumeMetadata();
-        const resumeHint = resume === null
-            ? ""
-            : `${dim("To resume this session:")} ${formatSessionResumeCommand(resume)}`;
-        const fullscreenExitText = this.runtime.mode !== "fullscreen"
-            ? ""
-            : exitMode === "resume-hint"
-                ? resumeHint
-                : [exitTranscript, resumeHint].filter(Boolean).join("\n\n");
-        this.#unbindPiSettings();
-        this.#unbindTerminalSettings();
-        this.#unbindShutdownSettings();
-        this.#unsubscribe();
-        this.#dialogHandle?.hide();
-        await this.backend.unbindExtensionUi();
-        this.#extensionBridge.dispose();
-        await this.runtime.dispose();
+        this.#cancelWaitingImages();
+        const failures = [];
+        const attempt = (action) => { try {
+            action();
+        }
+        catch (error) {
+            failures.push(error);
+        } };
+        let pasteCleanup = Promise.resolve();
+        attempt(() => { pasteCleanup = this.root.disposePendingPastes(); });
+        attempt(() => this.root.clearViewportPointerState());
+        attempt(() => this.#setPointerReporting(false, true));
+        attempt(() => this.#removeViewportPreInput());
+        attempt(() => this.#streamPresentation.dispose());
+        attempt(() => this.#promptSuggestions?.dispose());
+        attempt(() => this.#unsubscribePromptSuggestions());
+        attempt(() => this.#unsubscribeSettings());
+        let fullscreenExitText = "";
+        attempt(() => {
+            const exitMode = this.backend.disposed ? this.#fullscreenExitOutput : this.backend.pinnedSettingsSnapshot().fullscreenExitOutput;
+            const exitTranscript = this.root.exitTranscript(this.runtime.viewport().columns);
+            const resume = this.backend.currentSessionResumeMetadata();
+            const resumeHint = resume === null ? "" : `${dim("To resume this session:")} ${formatSessionResumeCommand(resume)}`;
+            fullscreenExitText = this.runtime.mode !== "fullscreen" ? ""
+                : exitMode === "resume-hint" ? resumeHint : [exitTranscript, resumeHint].filter(Boolean).join("\n\n");
+        });
+        attempt(() => this.#unbindPiSettings());
+        attempt(() => this.#unbindTerminalSettings());
+        attempt(() => this.#unbindShutdownSettings());
+        attempt(() => this.#unsubscribe());
+        attempt(() => this.#dialogHandle?.hide());
+        attempt(() => this.#extensionBridge.dispose());
+        // Invariant: terminal restoration precedes any potentially stalled backend teardown.
+        await this.runtime.dispose().catch(error => failures.push(error));
+        await boundedCleanup(() => pasteCleanup).catch(error => failures.push(error));
+        await boundedCleanup(() => this.backend.unbindExtensionUi()).catch(error => failures.push(error));
+        if (failures.length > 0)
+            throw new AggregateError(failures, "Owned UI disposal failed");
         if (fullscreenExitText.length > 0)
             this.runtime.writeAfterStop(`${fullscreenExitText}\n`);
     }
@@ -1139,6 +1215,8 @@ export class OwnedUiSessionShell {
         this.#streamPresentation.noteImmediatePresentation();
         const view = this.view();
         if (this.backend.sessionGeneration !== this.#sessionGeneration) {
+            this.#cancelWaitingImages();
+            this.root.resetPendingPastes();
             this.#promptSuggestions?.invalidate();
             this.#sessionGeneration = this.backend.sessionGeneration;
             this.#activeLoginDialog = undefined;
@@ -1423,11 +1501,60 @@ export class OwnedUiSessionShell {
                 sessionId: this.backend.sessionId,
                 text: item.text,
                 ...(item.images === undefined ? {} : { images: item.images }),
-            });
+            }, item.draft);
+        }
+    }
+    async #execute(command, draft) {
+        if (draft === undefined)
+            return this.backend.execute(command);
+        const revision = this.#editorRevision;
+        try {
+            assertOwnedUiCommand(command);
+        }
+        catch (error) {
+            return this.#recoverSubmission(draft, revision, error);
+        }
+        try {
+            const result = await this.backend.execute(command);
+            if (result.outcome === "rejected")
+                return this.#recoverSubmission(draft, revision);
+            return result;
         }
+        catch {
+            // Security: dispatch might already have reached the provider. Never retry automatically.
+            this.root.editor.addToHistory(draft);
+            this.#reportSubmissionError(undefined, "Submission failed; delivery is uncertain. Check the conversation before retrying. Press Up to recover the draft.");
+            return { outcome: "failed", diagnostic: "submission delivery is uncertain" };
+        }
+    }
+    async #guardSubmission(draft, action) {
+        const revision = this.#editorRevision;
+        try {
+            return await action();
+        }
+        catch (error) {
+            if (error instanceof ImageAttachmentError && error.code === "image-canceled")
+                return rejected("image submission canceled");
+            return this.#recoverSubmission(draft, revision, error);
+        }
+    }
+    #recoverSubmission(draft, revision, error) {
+        this.root.editor.addToHistory(draft);
+        // Concurrency: never overwrite input typed (even typed and cleared) after this submission.
+        if (revision === this.#editorRevision && this.root.editor.getText().length === 0)
+            this.root.editor.setText(draft);
+        const message = error instanceof ImageAttachmentError ? error.message : "Submission rejected. Check the prompt and attachments.";
+        this.#reportSubmissionError(error, `${message} Press Up to recover the draft.`);
+        return rejected(message);
     }
-    async #execute(command) {
-        return this.backend.execute(command);
+    #reportSubmissionError(error, message) {
+        // Security: arbitrary provider/extension error messages can contain the entire request.
+        try {
+            this.root.appendWorkflowResult({ command: "debug", outcome: "failed", message: message
+                    ?? (error instanceof ImageAttachmentError ? error.message : "Submission failed. Check the prompt and try again.") });
+            this.runtime.requestRender();
+        }
+        catch { /* Security: error presentation cannot create another rejected submission callback. */ }
     }
     #simple(type) {
         return { type, correlationId: this.#correlation(type), sessionId: this.backend.sessionId };