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

package/dist/integrations/pi/session-ui/image-source.js

@@ -0,0 +1,171 @@
+import { ImageAttachmentError } from "../../../contracts/owned-ui/index.js";
+export const MAX_SOURCE_IMAGE_BYTES = 20 * 1024 * 1024;
+export const MAX_SOURCE_PIXELS = 40_000_000;
+export const MAX_SOURCE_DIMENSION = 32_768;
+export const IMAGE_PREPARATION_MS = 15_000;
+export function assertSourceBytes(length) {
+    if (length > MAX_SOURCE_IMAGE_BYTES)
+        throw new ImageAttachmentError("image-source-size");
+    if (!Number.isSafeInteger(length) || length <= 0)
+        throw new ImageAttachmentError("image-data");
+}
+export function sourceImageInfo(bytes, mimeType) {
+    assertSourceBytes(bytes.length);
+    try {
+        const info = readHeader(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength));
+        if (info.mimeType !== mimeType.toLowerCase())
+            throw new ImageAttachmentError("image-mime");
+        if (info.width <= 0 || info.height <= 0)
+            throw new ImageAttachmentError("image-data");
+        if (info.width > MAX_SOURCE_DIMENSION || info.height > MAX_SOURCE_DIMENSION || info.width * info.height > MAX_SOURCE_PIXELS) {
+            throw new ImageAttachmentError("image-pixels");
+        }
+        return info;
+    }
+    catch (error) {
+        if (error instanceof ImageAttachmentError)
+            throw error;
+        throw new ImageAttachmentError("image-data");
+    }
+}
+function readHeader(b) {
+    let orientation = 1;
+    let conversionUnsafe = false;
+    const info = (width, height, mimeType) => ({ width, height, mimeType, orientation, conversionUnsafe });
+    if (b.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+        if (b.toString("ascii", 12, 16) !== "IHDR" || b.readUInt32BE(8) !== 13)
+            throw new ImageAttachmentError("image-data");
+        for (let p = 8; p + 12 <= b.length;) {
+            const n = b.readUInt32BE(p);
+            if (p + n + 12 > b.length)
+                throw new ImageAttachmentError("image-data");
+            const type = b.toString("ascii", p + 4, p + 8);
+            if (type === "eXIf")
+                orientation = exifOrientation(b.subarray(p + 8, p + 8 + n));
+            if (type === "acTL" || type === "iCCP" || (type === "IHDR" && b[p + 16] === 16))
+                conversionUnsafe = true;
+            p += n + 12;
+        }
+        return info(b.readUInt32BE(16), b.readUInt32BE(20), "image/png");
+    }
+    if (b[0] === 255 && b[1] === 216) {
+        let width = 0, height = 0;
+        for (let p = 2; p < b.length;) {
+            if (b[p++] !== 255)
+                throw new ImageAttachmentError("image-data");
+            while (b[p] === 255)
+                p++;
+            const marker = b[p++];
+            if (marker === 218 || marker === 217)
+                break;
+            if (marker === 1 || (marker !== undefined && marker >= 208 && marker <= 215))
+                continue;
+            const n = b.readUInt16BE(p);
+            if (n < 2 || p + n > b.length)
+                throw new ImageAttachmentError("image-data");
+            if (marker === 225 && b.toString("ascii", p + 2, p + 8) === "Exif\0\0")
+                orientation = exifOrientation(b.subarray(p + 8, p + n));
+            if (marker === 226 && b.toString("ascii", p + 2, p + 13) === "ICC_PROFILE")
+                conversionUnsafe = true;
+            if (marker !== undefined && [192, 193, 194].includes(marker)) {
+                height = b.readUInt16BE(p + 3);
+                width = b.readUInt16BE(p + 5);
+                if (b[p + 7] === 4)
+                    conversionUnsafe = true;
+            }
+            p += n;
+        }
+        return info(width, height, "image/jpeg");
+    }
+    if (/^GIF8[79]a$/.test(b.toString("ascii", 0, 6))) {
+        conversionUnsafe = gifFrameCount(b) > 1;
+        return info(b.readUInt16LE(6), b.readUInt16LE(8), "image/gif");
+    }
+    if (b.toString("ascii", 0, 2) === "BM") {
+        const dib = b.readUInt32LE(14);
+        if (dib === 12)
+            return info(b.readUInt16LE(18), b.readUInt16LE(20), "image/bmp");
+        if (dib < 40)
+            throw new ImageAttachmentError("image-data");
+        return info(b.readInt32LE(18), Math.abs(b.readInt32LE(22)), "image/bmp");
+    }
+    if (b.toString("ascii", 0, 4) === "RIFF" && b.toString("ascii", 8, 12) === "WEBP") {
+        const kind = b.toString("ascii", 12, 16);
+        if (kind === "VP8X") {
+            conversionUnsafe = ((b[20] ?? 0) & 0x22) !== 0;
+            for (let p = 12; p + 8 <= b.length;) {
+                const n = b.readUInt32LE(p + 4);
+                if (p + n + 8 > b.length)
+                    throw new ImageAttachmentError("image-data");
+                if (b.toString("ascii", p, p + 4) === "EXIF")
+                    orientation = exifOrientation(b.subarray(p + 8, p + 8 + n));
+                p += 8 + n + (n % 2);
+            }
+            return info(1 + b.readUIntLE(24, 3), 1 + b.readUIntLE(27, 3), "image/webp");
+        }
+        if (kind === "VP8 " && b.toString("hex", 23, 26) === "9d012a")
+            return info(b.readUInt16LE(26) & 0x3fff, b.readUInt16LE(28) & 0x3fff, "image/webp");
+        if (kind === "VP8L" && b[20] === 47) {
+            const bits = b.readUInt32LE(21);
+            return info((bits & 0x3fff) + 1, ((bits >>> 14) & 0x3fff) + 1, "image/webp");
+        }
+    }
+    throw new ImageAttachmentError("image-conversion");
+}
+function gifFrameCount(b) {
+    let p = 13 + (((b[10] ?? 0) & 128) ? 3 * 2 ** (((b[10] ?? 0) & 7) + 1) : 0);
+    let frames = 0;
+    const skipBlocks = () => {
+        while (p < b.length) {
+            const length = b[p++] ?? 0;
+            if (length === 0)
+                return;
+            p += length;
+            if (p > b.length)
+                throw new ImageAttachmentError("image-data");
+        }
+        throw new ImageAttachmentError("image-data");
+    };
+    while (p < b.length) {
+        const marker = b[p++];
+        if (marker === 59)
+            return frames;
+        if (marker === 33) {
+            p++;
+            skipBlocks();
+            continue;
+        }
+        if (marker !== 44 || p + 9 > b.length)
+            throw new ImageAttachmentError("image-data");
+        frames++;
+        const packed = b[p + 8] ?? 0;
+        p += 9 + ((packed & 128) ? 3 * 2 ** ((packed & 7) + 1) : 0);
+        p++;
+        skipBlocks();
+    }
+    throw new ImageAttachmentError("image-data");
+}
+function exifOrientation(input) {
+    const b = input.toString("ascii", 0, 6) === "Exif\0\0" ? input.subarray(6) : input;
+    const little = b.toString("ascii", 0, 2) === "II";
+    if (!little && b.toString("ascii", 0, 2) !== "MM")
+        throw new ImageAttachmentError("image-conversion");
+    const u16 = (p) => little ? b.readUInt16LE(p) : b.readUInt16BE(p);
+    const u32 = (p) => little ? b.readUInt32LE(p) : b.readUInt32BE(p);
+    if (u16(2) !== 42)
+        throw new ImageAttachmentError("image-conversion");
+    const directory = u32(4);
+    const count = u16(directory);
+    if (directory + 2 + count * 12 > b.length)
+        throw new ImageAttachmentError("image-conversion");
+    for (let i = 0; i < count; i++) {
+        const p = directory + 2 + i * 12;
+        if (u16(p) !== 274)
+            continue;
+        const value = u16(p + 8);
+        if (u16(p + 2) !== 3 || u32(p + 4) !== 1 || value < 1 || value > 8)
+            throw new ImageAttachmentError("image-conversion");
+        return value;
+    }
+    return 1;
+}

package/dist/integrations/pi/session-ui/image-worker.d.ts

@@ -0,0 +1,17 @@
+import { type ImagePreparationLimits } from "./image-preparation.js";
+export type ImageWorkerRequest = {
+    readonly kind: "clipboard";
+} | {
+    readonly kind: "canonicalize";
+    readonly source: {
+        readonly data: string;
+        readonly mimeType: string;
+    };
+} | {
+    readonly kind: "prepare";
+    readonly source: {
+        readonly data: string;
+        readonly mimeType: string;
+    };
+    readonly limits?: ImagePreparationLimits;
+};

package/dist/integrations/pi/session-ui/image-worker.js

@@ -0,0 +1,23 @@
+import { parentPort, workerData } from "node:worker_threads";
+import { ImageAttachmentError } from "../../../contracts/owned-ui/index.js";
+import { prepareImage } from "./image-preparation.js";
+import { canonicalizeClipboardImage } from "./clipboard-image.js";
+import { readSystemClipboardContent } from "./system-clipboard.js";
+const controller = new AbortController();
+parentPort?.on("message", message => { if (message === "cancel")
+    controller.abort(); });
+const request = workerData;
+try {
+    const value = request.kind === "clipboard"
+        ? await readSystemClipboardContent(controller.signal)
+        : request.kind === "canonicalize" ? canonicalizeClipboardImage(request.source, true)
+            : await prepareImage(request.source, request.limits);
+    parentPort?.postMessage({ ok: true, value });
+}
+catch (error) {
+    // Security: never forward native/codec exceptions which may contain input data.
+    parentPort?.postMessage({ ok: false, code: error instanceof ImageAttachmentError ? error.code : "image-codec" });
+}
+finally {
+    parentPort?.close();
+}

package/dist/integrations/pi/session-ui/prompt-chips.d.ts

@@ -8,9 +8,18 @@ export interface PreparedPrompt {
     readonly text: string;
     readonly images: readonly PromptImageAttachment[];
 }
-/** 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 declare class PromptChipStore {
     #private;
+    beginPaste(currentText: string, read: (signal: AbortSignal) => Promise<PiShellClipboardContent | null>, onError: (error: unknown) => void): {
+        marker: string;
+        result: Promise<string>;
+    };
+    hasPending(text: string): boolean;
+    waitForPastes(text: string, signal: AbortSignal, readDraft?: () => string): Promise<PreparedPrompt>;
+    reconcileDraft(text: string): void;
+    resetPastes(text: string): string;
+    dispose(): Promise<void>;
     transformPastedContent(content: PiShellClipboardContent, currentText?: string): string;
     atomicRanges(line: string): readonly PiShellEditorTextRange[];
     hyperlinkRanges(text: string): readonly {

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

@@ -3,14 +3,109 @@ 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 } from "../../../contracts/owned-ui/index.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();
+    #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);
@@ -82,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>;
@@ -83,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;
@@ -92,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

@@ -94,6 +94,7 @@ export class OwnedUiSessionShellRoot {
                     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);
@@ -124,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({
@@ -202,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

@@ -6,9 +6,9 @@ import { MOUSE_TRACKING_OFF, MOUSE_TRACKING_ON, parseMouseInput, readVisibleHype
 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. */
@@ -46,6 +46,7 @@ export class OwnedUiSessionShell {
     #imageWidthCells = 80;
     #fullscreenExitOutput = "transcript";
     #compactionQueue = [];
+    #waitingImages = new Map();
     #lastClearTime = 0;
     #lastEscapeTime = 0;
     #activeLoginDialog;
@@ -58,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;
         });
@@ -107,30 +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().catch(error => {
-                        if (error instanceof ImageAttachmentError)
-                            this.#reportSubmissionError(error);
-                        return null;
-                    });
+                    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 (error) {
-                    if (error instanceof ImageAttachmentError) {
-                        this.#reportSubmissionError(error);
-                        return null;
-                    }
-                    // Compatibility: treat an unavailable or malformed image as text-capable clipboard input.
+                    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 };
             },
         }, {
@@ -439,7 +434,43 @@ export class OwnedUiSessionShell {
         return this.#stopped;
     }
     async submit(text) {
-        return this.#guardSubmission(text, () => this.#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();
@@ -510,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) {
@@ -589,7 +624,7 @@ export class OwnedUiSessionShell {
     }
     async queueFollowUp() {
         const draft = this.root.editor.getText();
-        return this.#guardSubmission(draft, () => this.#queueFollowUp(draft));
+        return this.#submitWhenReady(draft, () => this.#queueFollowUp(draft));
     }
     async #queueFollowUp(draft) {
         const displayInput = draft.trim();
@@ -599,7 +634,8 @@ export class OwnedUiSessionShell {
         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({
@@ -619,7 +655,8 @@ export class OwnedUiSessionShell {
         }, displayInput);
     }
     restoreQueuedInput() {
-        const queued = [...this.backend.clearQueuedWorkflows(), ...this.#compactionQueue.map(item => item.draft)];
+        const queued = [...this.#waitingImages.keys(), ...this.backend.clearQueuedWorkflows(), ...this.#compactionQueue.map(item => item.draft)];
+        this.#cancelWaitingImages();
         this.#compactionQueue = [];
         if (queued.length === 0)
             return;
@@ -1111,6 +1148,7 @@ export class OwnedUiSessionShell {
         if (this.#disposed)
             return;
         this.#disposed = true;
+        this.#cancelWaitingImages();
         const failures = [];
         const attempt = (action) => { try {
             action();
@@ -1118,6 +1156,8 @@ export class OwnedUiSessionShell {
         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());
@@ -1142,6 +1182,7 @@ export class OwnedUiSessionShell {
         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");
@@ -1174,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;
@@ -1490,6 +1533,8 @@ export class OwnedUiSessionShell {
             return await action();
         }
         catch (error) {
+            if (error instanceof ImageAttachmentError && error.code === "image-canceled")
+                return rejected("image submission canceled");
             return this.#recoverSubmission(draft, revision, error);
         }
     }

package/dist/integrations/pi/session-ui/system-clipboard.d.ts

@@ -11,10 +11,10 @@ export declare function preloadSystemClipboard(): void;
  * private clipboard module. Failures are deliberately non-fatal: a denied or
  * unavailable clipboard simply makes the paste action a no-op.
  */
-export declare function readSystemClipboardContent(): Promise<PiShellClipboardContent | null>;
+export declare function readSystemClipboardContent(signal?: AbortSignal): Promise<PiShellClipboardContent | null>;
 export declare function readSystemClipboardImage(reader: SystemClipboardImageReader): Promise<{
     readonly data: string;
     readonly mimeType: string;
 } | null>;
-export declare function readSystemClipboardText(): Promise<string | null>;
+export declare function readSystemClipboardText(signal?: AbortSignal): Promise<string | null>;
 export declare function writeSystemClipboardText(text: string): Promise<void>;