@timurproko/a1 0.1.8-dev.368 → 0.1.8-dev.402

package/dist/composition/owned-ui.d.ts

@@ -23,6 +23,8 @@ export interface OwnedUiCompositionOptions {
     readonly projectTrustPrompt?: PiProjectTrustPreflightPrompt;
     /** Explicit local diagnostic destination; ignored by comparison/settings-free compositions. */
     readonly suggestionDiagnosticsPath?: string;
+    /** Optional local metadata-only clipboard diagnostics; never enabled in comparison profiles. */
+    readonly clipboardDiagnosticsPath?: string;
 }
 export interface OwnedUiComposition {
     readonly application: OwnedUiApplicationPort;

package/dist/composition/owned-ui.js

@@ -5,7 +5,7 @@ import { resolvePromptHistoryDataDir } from "../features/launch/index.js";
 import { resolveProductPaths } from "../foundation/lifecycle/index.js";
 import { applyConfiguredPiTheme, getAvailablePiThemes, loadHistoryEditor } from "../integrations/pi/components/index.js";
 import { createPiEngineAdapter, } from "../integrations/pi/engine/index.js";
-import { OwnedUiSessionShell } from "../integrations/pi/session-ui/index.js";
+import { ClipboardDiagnosticCapture, OwnedUiSessionShell } from "../integrations/pi/session-ui/index.js";
 import { OwnedUiSettingsSession, OwnedUiSettingsStore } from "../ui/settings/index.js";
 import { createPiTerminalBridge } from "../integrations/pi/tui-runtime/index.js";
 import { createOwnedRouteHost } from "./settings-route-host.js";
@@ -63,16 +63,32 @@ export async function composeOwnedUi(options = {}) {
         }),
         imageSidecar: new PromptImageSidecar(historyProfileLocation.imagesDir),
     };
-    const shell = new OwnedUiSessionShell({
-        backend: adapter,
-        cwd: adapter.cwd,
-        ...(options.terminal === undefined ? {} : { terminal: createPiTerminalBridge(options.terminal) }),
-        ...(routeHost === null ? {} : { routeHost }),
-        ...(ownedSurfaces ? { sessionLayout: "custom-viewport" } : {}),
-        ...(viewportSettings === null ? {} : { viewportSettings }),
-        ...(promptSuggestions === null ? {} : { promptSuggestions }),
-        ...(promptHistory === null ? {} : { promptHistory: { ...promptHistory, editor: await loadHistoryEditor() } }),
-    });
+    const clipboardDestination = options.clipboardDiagnosticsPath ?? process.env[PRODUCT_IDENTITY.environment.clipboardDiagnostics];
+    const clipboardDiagnostics = settings !== null && ownedSurfaces && clipboardDestination?.trim()
+        ? new ClipboardDiagnosticCapture(clipboardDestination) : null;
+    let shell;
+    try {
+        shell = new OwnedUiSessionShell({
+            backend: adapter,
+            cwd: adapter.cwd,
+            ...(options.terminal === undefined ? {} : { terminal: createPiTerminalBridge(options.terminal) }),
+            ...(routeHost === null ? {} : { routeHost }),
+            ...(ownedSurfaces ? { sessionLayout: "custom-viewport" } : {}),
+            ...(clipboardDiagnostics === null ? {} : {
+                responseCopy: { onEvent: event => clipboardDiagnostics.copy(event) },
+                pasteDiagnostics: event => clipboardDiagnostics.paste(event),
+                inputPresentation: { onEvent: event => clipboardDiagnostics.runtime(event) },
+            }),
+            ...(viewportSettings === null ? {} : { viewportSettings }),
+            ...(promptSuggestions === null ? {} : { promptSuggestions }),
+            ...(promptHistory === null ? {} : { promptHistory: { ...promptHistory, editor: await loadHistoryEditor() } }),
+        });
+    }
+    catch (error) {
+        clipboardDiagnostics?.dispose();
+        suggestionDiagnostics?.dispose();
+        throw error;
+    }
     const application = {
         get disposed() { return adapter.disposed; },
         start: () => shell.start(),
@@ -84,6 +100,7 @@ export async function composeOwnedUi(options = {}) {
             }
             finally {
                 suggestionDiagnostics?.dispose();
+                clipboardDiagnostics?.dispose();
             }
         },
     };

package/dist/contracts/owned-ui/image-attachments.d.ts

@@ -1,8 +1,15 @@
 import type { OwnedUiImageAttachment } from "./model.js";
 export declare const MAX_PROMPT_IMAGES = 8;
+/** Owned clipboard text is bounded before transfer, normalization, or editor insertion. */
+export declare const MAX_CLIPBOARD_TEXT_BYTES: number;
 /** Limit applies to canonical ASCII base64, not decoded image bytes. */
 export declare const MAX_IMAGE_DATA_BYTES: number;
 declare const MESSAGES: {
+    readonly "paste-timeout": "Clipboard paste timed out. The editor is still available.";
+    readonly "paste-unavailable": "Could not paste; the clipboard is unavailable.";
+    readonly "paste-size": "Pasted text exceeds the 16 MiB limit.";
+    readonly "paste-busy": "Clipboard preparation is full (8 pending pastes).";
+    readonly "paste-write-failed": "Paste skipped because the preceding copy failed.";
     readonly "image-size": "Image exceeds the 8 MiB encoded base64 limit. Reduce the image size and paste it again.";
     readonly "image-count": "A prompt supports at most 8 images. Remove an attachment before adding another.";
     readonly "image-data": "Image data is invalid. Paste a valid image again.";

package/dist/contracts/owned-ui/image-attachments.js

@@ -1,7 +1,14 @@
 export const MAX_PROMPT_IMAGES = 8;
+/** Owned clipboard text is bounded before transfer, normalization, or editor insertion. */
+export const MAX_CLIPBOARD_TEXT_BYTES = 16 * 1024 * 1024;
 /** Limit applies to canonical ASCII base64, not decoded image bytes. */
 export const MAX_IMAGE_DATA_BYTES = 8 * 1024 * 1024;
 const MESSAGES = {
+    "paste-timeout": "Clipboard paste timed out. The editor is still available.",
+    "paste-unavailable": "Could not paste; the clipboard is unavailable.",
+    "paste-size": "Pasted text exceeds the 16 MiB limit.",
+    "paste-busy": "Clipboard preparation is full (8 pending pastes).",
+    "paste-write-failed": "Paste skipped because the preceding copy failed.",
     "image-size": "Image exceeds the 8 MiB encoded base64 limit. Reduce the image size and paste it again.",
     "image-count": "A prompt supports at most 8 images. Remove an attachment before adding another.",
     "image-data": "Image data is invalid. Paste a valid image again.",

package/dist/foundation/release/dependency-certification.js

@@ -82,9 +82,16 @@ async function publishCertification(dataDir, identity, document, replaceInvalid)
     try {
         await publishLockedCertification(dataDir, identity, document, replaceInvalid, path);
     }
-    finally {
-        await releaseLock();
+    catch (publicationError) {
+        try {
+            await releaseLock();
+        }
+        catch (releaseError) {
+            throw new AggregateError([publicationError, releaseError], "dependency certification publication and lease release failed");
+        }
+        throw publicationError;
     }
+    await releaseLock();
 }
 async function publishLockedCertification(dataDir, identity, document, replaceInvalid, path) {
     const existing = await managedDependencyCertificationPath(dataDir, identity.layerId);
@@ -130,11 +137,7 @@ async function acquirePublicationLock(path) {
                 // Concurrency: a nonempty directory cannot replace another nonempty directory on either
                 // platform. Publishing the complete owner atomically also avoids partially written leases.
                 await rename(candidate, path);
-                return async () => {
-                    const released = `${path}.released-${token}`;
-                    await rename(path, released);
-                    await rm(released, { recursive: true, force: true });
-                };
+                return () => releasePublicationLock(path, token);
             }
             catch (error) {
                 if (!["EEXIST", "ENOTEMPTY", "EPERM", "EACCES"].some(code => hasCode(error, code)))
@@ -182,6 +185,61 @@ async function acquirePublicationLock(path) {
         await rm(candidate, { recursive: true, force: true });
     }
 }
+/** Retire this generation once; retries after retirement can only touch its private cleanup path. */
+async function releasePublicationLock(path, token) {
+    const released = `${path}.released-${token}`;
+    const deadline = Date.now() + 1_000;
+    let retired = false;
+    let delay = 20;
+    while (true) {
+        try {
+            if (!retired) {
+                await assertPublicationLockOwner(path, token);
+                await rename(path, released);
+                retired = true;
+            }
+            // Concurrency: a successor can own `path` now. Never inspect or delete it during cleanup.
+            await rm(released, { recursive: true, force: true });
+            return;
+        }
+        catch (error) {
+            const phase = retired ? "cleanup" : "retirement";
+            if (!isReleaseContention(error)) {
+                throw new Error(`dependency certification lease release ${phase} failed: ${error instanceof Error ? error.message : "unknown error"}`, { cause: error });
+            }
+            const remaining = deadline - Date.now();
+            if (remaining <= 0) {
+                throw new Error(`dependency certification lease release ${phase} deadline exceeded (${error.code})`, { cause: error });
+            }
+            await new Promise(resolvePromise => setTimeout(resolvePromise, Math.min(delay, remaining)));
+            delay = Math.min(delay * 2, 100);
+        }
+    }
+}
+/** Ownership uncertainty is never authority to retire a missing, linked, or replaced generation. */
+async function assertPublicationLockOwner(path, token) {
+    try {
+        const metadata = await lstat(path);
+        if (!metadata.isDirectory() || metadata.isSymbolicLink() || await realpath(path) !== path)
+            throw new Error("invalid lock directory");
+        const ownerPath = resolve(path, "owner.json");
+        const ownerMetadata = await lstat(ownerPath);
+        if (!ownerMetadata.isFile() || ownerMetadata.isSymbolicLink() || await realpath(ownerPath) !== ownerPath)
+            throw new Error("invalid owner file");
+        const owner = JSON.parse(await readFile(ownerPath, "utf8"));
+        if (!owner || typeof owner !== "object" || !("pid" in owner) || !("token" in owner)
+            || owner.pid !== process.pid || owner.token !== token)
+            throw new Error("owner generation differs");
+    }
+    catch (error) {
+        if (isReleaseContention(error))
+            throw error;
+        throw new Error("publication lease release ownership could not be verified", { cause: error });
+    }
+}
+function isReleaseContention(error) {
+    return ["EPERM", "EACCES", "EBUSY"].some(code => hasCode(error, code));
+}
 function validateCertification(value, identity, allowLegacyPlatform = false) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         throw new Error(`dependency layer certification differs from manifest: ${identity.layerId}`);

package/dist/integrations/pi/components/owned-editor-ux.d.ts

@@ -1,6 +1,6 @@
 import type { SelectionEditor as Editor } from "./editor-interaction.js";
 import type { KeybindingsManager } from "./upstream/adjacent/core/keybindings.js";
-import type { PiShellClipboardContent, PiShellEditorTextRange } from "./shell-shared-facade.js";
+import type { PiShellClipboardContent, PiShellEditorTextRange, PiShellPasteReservation } from "./shell-shared-facade.js";
 /**
  * Middleware boundary around Pi's editor. Interceptors may claim an input or
  * delegate to the next interceptor/vanilla editor, and may decorate the rows
@@ -46,16 +46,18 @@ export declare class OwnedEditorUxInterception {
 export interface PromptSelectionUxOptions {
     readonly copyText: (text: string) => void;
     readonly readClipboardContent: () => Promise<PiShellClipboardContent | null>;
-    readonly beginClipboardPaste?: () => {
-        readonly marker: string;
-        readonly result: Promise<string>;
-    };
+    readonly beginClipboardPaste?: () => PiShellPasteReservation;
+    readonly beginTextPaste?: (text: string) => PiShellPasteReservation;
+    readonly deferTextPaste?: (text: string) => boolean;
+    readonly onPasteRejected?: (error: unknown) => void;
+    readonly onPasteInput?: (bytes: number) => void;
     readonly transformPastedContent: (content: PiShellClipboardContent) => string;
     readonly atomicRanges: (line: string) => readonly PiShellEditorTextRange[];
     readonly hiddenRanges?: (line: string) => readonly PiShellEditorTextRange[];
     readonly expandCopiedText: (text: string) => string;
     readonly paintSelection: (line: string, from: number, to: number, atomic: boolean) => string;
-    readonly decorateRow: (row: string, width: number) => string;
+    /** Row indices restart at zero for each complete decoration pass. */
+    readonly decorateRow: (row: string, width: number, rowIndex: number) => string;
     readonly requestRender: () => void;
     readonly getRows: () => number;
     /** Presentation-only columns reserved before semantic editor text. */

package/dist/integrations/pi/components/owned-editor-ux.js

@@ -1,3 +1,4 @@
+import { ImageAttachmentError, MAX_CLIPBOARD_TEXT_BYTES } from "../../../contracts/owned-ui/index.js";
 import { CURSOR_MARKER, decodeKittyPrintable, visibleWidth, } from "#pi-tui";
 import { promptPathWordRanges } from "./path-word-ranges.js";
 export class OwnedEditorUxInterception {
@@ -267,7 +268,7 @@ class PromptSelectionInterceptor {
                 }
             }
         }
-        return rows.map(row => this.options.decorateRow(row, width));
+        return rows.map((row, index) => this.options.decorateRow(row, width, index));
     }
     reset() {
         this.#selection = undefined;
@@ -447,20 +448,57 @@ class PromptSelectionInterceptor {
                 const before = data.slice(0, start);
                 this.handleInput(before, (replacement = before) => next(replacement));
             }
-            this.#terminalPaste = "";
+            this.#terminalPaste = { parts: [], piece: "", tail: "", bytes: 0, oversized: false };
             data = data.slice(start + 6);
         }
-        // Compatibility: the terminal's StdinBuffer assembles split opening delimiters;
-        // retain the body here too so editor-level chunks cannot allocate a native paste ID.
-        this.#terminalPaste += data;
-        const end = this.#terminalPaste.indexOf("\x1b[201~");
-        if (end < 0)
+        // Protocol: inspect only the new fragment plus a delimiter-sized suffix, not the whole growing body.
+        const pending = this.#terminalPaste;
+        const fragment = pending.tail + data;
+        const end = fragment.indexOf("\x1b[201~");
+        const append = (part) => {
+            if (pending.oversized || part.length === 0)
+                return;
+            if (this.options.beginTextPaste !== undefined) {
+                pending.bytes += Buffer.byteLength(part);
+                if (pending.bytes > MAX_CLIPBOARD_TEXT_BYTES) {
+                    pending.oversized = true;
+                    pending.parts = [];
+                    pending.piece = "";
+                    return;
+                }
+            }
+            // Performance: bound fragment metadata even if a terminal supplies one character per input chunk.
+            pending.piece += part;
+            if (pending.piece.length >= 16_384) {
+                pending.parts.push(pending.piece);
+                pending.piece = "";
+            }
+        };
+        if (end < 0) {
+            let cut = Math.max(0, fragment.length - 5);
+            if (cut > 0 && /[\uD800-\uDBFF]/u.test(fragment[cut - 1]) && /[\uDC00-\uDFFF]/u.test(fragment[cut]))
+                cut--;
+            append(fragment.slice(0, cut));
+            pending.tail = fragment.slice(cut);
             return true;
-        const text = this.#terminalPaste.slice(0, end);
-        const remaining = this.#terminalPaste.slice(end + 6);
+        }
+        append(fragment.slice(0, end));
+        const remaining = fragment.slice(end + 6);
         this.#terminalPaste = undefined;
+        this.options.onPasteInput?.(pending.bytes);
+        if (pending.oversized) {
+            this.options.onPasteRejected?.(new ImageAttachmentError("paste-size"));
+            if (remaining.length > 0)
+                this.handleInput(remaining, (replacement = remaining) => next(replacement));
+            return true;
+        }
+        const text = pending.parts.join("") + pending.piece;
+        if (text.length > 0)
+            this.#redoStack = [];
         if (text.length === 0)
             this.pasteClipboard();
+        else if (this.options.beginTextPaste !== undefined && (this.options.deferTextPaste?.(text) ?? true))
+            this.#pasteFromClipboard(text);
         else {
             const transformed = this.options.transformPastedContent({ kind: "text", text });
             if (transformed === text && this.#orderedSelection() === undefined)
@@ -478,18 +516,24 @@ class PromptSelectionInterceptor {
             this.handleInput(remaining, (replacement = remaining) => next(replacement));
         return true;
     }
-    #pasteFromClipboard() {
-        if (this.options.beginClipboardPaste !== undefined) {
+    #pasteFromClipboard(source) {
+        const begin = source === undefined ? this.options.beginClipboardPaste
+            : this.options.beginTextPaste === undefined ? undefined : () => this.options.beginTextPaste(source);
+        if (begin !== undefined) {
             const generation = this.#pasteGeneration;
             const restore = this.#orderedSelection() === undefined ? "" : this.#selectedText();
-            const paste = this.options.beginClipboardPaste();
+            const paste = begin();
+            this.#redoStack = [];
             if (this.#orderedSelection() !== undefined)
                 this.#replaceSelection(paste.marker);
             else
                 this.editor.insertTextAtCursor(paste.marker);
             this.#requestRender();
-            const replace = (text) => { if (generation === this.#pasteGeneration)
-                this.#replacePasteMarker(paste.marker, text || restore); };
+            const replace = (text) => {
+                if (generation === this.#pasteGeneration)
+                    this.#replacePasteMarker(paste.marker, paste.isCurrent?.() === false ? restore : text || restore);
+                paste.complete?.();
+            };
             void paste.result.then(replace).catch(() => replace(restore));
             return;
         }
@@ -520,10 +564,12 @@ class PromptSelectionInterceptor {
     #replacePasteMarker(marker, replacement) {
         const current = this.editor.getText();
         const from = current.indexOf(marker);
-        if (from < 0)
+        const text = normalizeInsertedText(replacement);
+        if (from < 0) {
+            this.#rewritePasteSnapshots(marker, text);
             return;
+        }
         const to = from + marker.length;
-        const text = normalizeInsertedText(replacement);
         const lines = editorState(this.editor).lines;
         const remap = (position) => {
             const offset = positionOffset(lines, position);
@@ -533,12 +579,23 @@ class PromptSelectionInterceptor {
         const selection = this.#selection === undefined ? undefined : { anchor: remap(this.#selection.anchor), head: remap(this.#selection.head) };
         const next = current.slice(0, from) + text + current.slice(to);
         // Compatibility: completing a paste updates its provisional undo snapshots, not the user's undo history.
-        if (this.editor.interaction !== undefined) {
+        if (this.editor.interaction !== undefined)
             this.editor.interaction.replaceLines(next.split("\n"));
+        else
+            editorState(this.editor).lines = next.split("\n");
+        this.#rewritePasteSnapshots(marker, text);
+        this.#setCursor(positionAtOffset(next, cursor));
+        this.editor.onChange?.(this.editor.getText());
+        this.editor.invalidate();
+        if (selection !== undefined)
+            this.#selection = { anchor: positionAtOffset(next, selection.anchor), head: positionAtOffset(next, selection.head) };
+        this.#requestRender();
+    }
+    #rewritePasteSnapshots(marker, text) {
+        // Concurrency: even a removed reservation must be retired from redo/undo snapshots, or a canceled paste can reappear.
+        if (this.editor.interaction !== undefined)
             this.editor.interaction.updateUndoStates(state => replaceSnapshotMarker(state, marker, text));
-        }
         else {
-            editorState(this.editor).lines = next.split("\n");
             const undo = Reflect.get(this.editor, "undoStack");
             const snapshots = typeof undo === "object" && undo !== null ? Reflect.get(undo, "stack") : undefined;
             if (Array.isArray(snapshots))
@@ -554,12 +611,6 @@ class PromptSelectionInterceptor {
             snapshot.text = state.lines.join("\n");
             snapshot.cursor = { line: state.cursorLine, col: state.cursorCol };
         }
-        this.#setCursor(positionAtOffset(next, cursor));
-        this.editor.onChange?.(this.editor.getText());
-        this.editor.invalidate();
-        if (selection !== undefined)
-            this.#selection = { anchor: positionAtOffset(next, selection.anchor), head: positionAtOffset(next, selection.head) };
-        this.#requestRender();
     }
     #replaceSelection(text) {
         const selection = this.#orderedSelection();
@@ -757,7 +808,6 @@ class PromptSelectionInterceptor {
 }
 function installAtomicSegmentation(editor, rangesForText, wordDirection) {
     const transform = (text, mode, values) => {
-        const segments = [...values].filter(isEditorSegment);
         const ranges = rangesForText(text).map(range => ({ ...range, wordLike: false }));
         if (mode === "word") {
             for (const range of contextualPathRanges(editor, text, wordDirection())) {
@@ -766,6 +816,12 @@ function installAtomicSegmentation(editor, rangesForText, wordDirection) {
             }
         }
         ranges.sort((left, right) => left.start - right.start);
+        if (mode === "grapheme" && ranges.length > 0 && hasSegmentLookup(values)) {
+            const indexed = atomicSegmentsByBoundary(text, ranges, offset => values.containing(offset));
+            if (indexed !== undefined)
+                return indexed;
+        }
+        const segments = [...values].filter(isEditorSegment);
         if (ranges.length === 0)
             return segments;
         const merged = [];
@@ -803,6 +859,39 @@ function installAtomicSegmentation(editor, rangesForText, wordDirection) {
     Reflect.set(editor, "segment", (text, mode) => transform(text, mode, original(text, mode)));
     Reflect.set(editor, ATOMIC_SEGMENTATION, true);
 }
+/** Narrow the optional indexed segment capability without a dynamic callback invocation. */
+function hasSegmentLookup(values) {
+    return typeof values === "object" && values !== null && "containing" in values && typeof values.containing === "function";
+}
+/** Skip atomic interiors using the supplied segmenter's boundaries; preserve the iterable fallback exactly. */
+function atomicSegmentsByBoundary(text, ranges, containing) {
+    const merged = [];
+    let offset = 0, rangeIndex = 0;
+    while (offset < text.length) {
+        const segment = containing(offset);
+        if (!isEditorSegment(segment) || segment.index !== offset || segment.segment.length === 0)
+            return undefined;
+        while ((ranges[rangeIndex]?.end ?? Number.POSITIVE_INFINITY) <= offset)
+            rangeIndex++;
+        const range = ranges[rangeIndex];
+        if (range !== undefined && offset >= range.start && offset < range.end) {
+            if (range.end > text.length)
+                return undefined;
+            const last = containing(range.end - 1);
+            if (!isEditorSegment(last) || last.index + last.segment.length < range.end)
+                return undefined;
+            if (offset === range.start)
+                merged.push({ segment: text.slice(range.start, range.end).replaceAll(" ", ATOMIC_SPACE_SENTINEL), index: range.start, input: text });
+            // Compatibility: the old iterable consumes the entire final grapheme, even if it crosses the chip end.
+            offset = last.index + last.segment.length;
+        }
+        else {
+            merged.push(segment);
+            offset += segment.segment.length;
+        }
+    }
+    return merged;
+}
 function contextualPathRanges(editor, text, direction) {
     if (direction === undefined)
         return promptPathWordRanges(text);

package/dist/integrations/pi/components/shell-editor-autocomplete.js

@@ -76,6 +76,10 @@ export function createPiShellEditor(options) {
                 copyText: options.onCopyText ?? (() => { }),
                 readClipboardContent: options.readClipboardContent ?? (async () => null),
                 ...(options.beginClipboardPaste === undefined ? {} : { beginClipboardPaste: options.beginClipboardPaste }),
+                ...(options.beginTextPaste === undefined ? {} : { beginTextPaste: options.beginTextPaste }),
+                ...(options.deferTextPaste === undefined ? {} : { deferTextPaste: options.deferTextPaste }),
+                ...(options.onPasteRejected === undefined ? {} : { onPasteRejected: options.onPasteRejected }),
+                ...(options.onPasteInput === undefined ? {} : { onPasteInput: options.onPasteInput }),
                 transformPastedContent: options.transformPastedContent ?? (content => content.kind === "text" ? content.text : ""),
                 atomicRanges: options.editorAtomicRanges ?? (() => []),
                 hiddenRanges: options.editorHiddenRanges ?? (() => []),

package/dist/integrations/pi/components/shell-presenters-transcript.js

@@ -1,6 +1,8 @@
-import { AssistantMessageComponent, BashExecutionComponent, CompactionSummaryMessageComponent, CustomMessageComponent, DynamicBorder, getMarkdownTheme, parseSkillBlock, ToolExecutionComponent, UserMessageComponent, } from "@earendil-works/pi-coding-agent";
+import { AssistantMessageComponent, BashExecutionComponent, CompactionSummaryMessageComponent, CustomMessageComponent, DynamicBorder, getMarkdownTheme, parseSkillBlock, UserMessageComponent, } from "@earendil-works/pi-coding-agent";
+import { ToolExecutionComponent } from "./upstream/components/tool-execution.js";
 import { SkillInvocationMessageComponent } from "./upstream/components/skill-invocation-message.js";
 import { piToolArguments as toolArguments, updatePiToolResult as updateToolResult } from "./tool-result-adapter.js";
+import { createTranscriptImageResolver } from "./transcript-image-resolver.js";
 import { createMermaidMarkdownTransformer } from "./upstream/components/mermaid.js";
 import { Container, Image, Spacer, Text, } from "#pi-tui";
 import { PRODUCT_TEXT } from "../../../product-identity.js";
@@ -11,6 +13,7 @@ import { componentPort, createTuiFacade, ensureTheme, isRecord, } from "./shell-
 export function createPiShellTranscriptComponent(initial, cwd, extensions, submittedPrompt, initialOutputPad = PINNED_PI_LAYOUT.outputPad, initialHideThinkingBlock = false, initialMermaidRenderingMode = "off", initialShowImages = true, initialImageWidthCells = 80, imageAssets, presentation) {
     ensureTheme();
     let block = initial;
+    const retainedImages = createTranscriptImageResolver(imageAssets, initial);
     let expanded = false;
     let outputPad = initialOutputPad;
     let hideThinkingBlock = initialHideThinkingBlock;
@@ -22,6 +25,7 @@ export function createPiShellTranscriptComponent(initial, cwd, extensions, submi
     let updating = false;
     let dirty = false;
     let presentationRevision = 0;
+    let mountedTool;
     const mutate = (action) => {
         const previous = updating;
         updating = true;
@@ -33,6 +37,7 @@ export function createPiShellTranscriptComponent(initial, cwd, extensions, submi
         }
     };
     const rebuild = () => {
+        mountedTool?.dispose();
         const token = ++mount;
         const requestRender = () => {
             if (disposed || updating || token !== mount || dirty)
@@ -41,8 +46,12 @@ export function createPiShellTranscriptComponent(initial, cwd, extensions, submi
             presentationRevision++;
             presentation?.changed();
         };
-        return mutate(() => withTranscriptImages(transcriptComponent(block, cwd, expanded, extensions, submittedPrompt, outputPad, hideThinkingBlock, mermaidRenderingMode, showImages, imageWidthCells, imageAssets, createTuiFacade({ getColumns: presentation?.getColumns ?? (() => 80),
-            getRows: presentation?.getRows ?? (() => 24), requestRender })), block, imageAssets, showImages, imageWidthCells));
+        return mutate(() => {
+            const next = transcriptComponent(block, cwd, expanded, extensions, submittedPrompt, outputPad, hideThinkingBlock, mermaidRenderingMode, showImages, imageWidthCells, retainedImages, createTuiFacade({ getColumns: presentation?.getColumns ?? (() => 80),
+                getRows: presentation?.getRows ?? (() => 24), requestRender }));
+            mountedTool = next instanceof ToolExecutionComponent ? next : undefined;
+            return withTranscriptImages(next, block, retainedImages, showImages, imageWidthCells);
+        });
     };
     let component = rebuild();
     return {
@@ -56,13 +65,14 @@ export function createPiShellTranscriptComponent(initial, cwd, extensions, submi
             return warning === undefined ? rows : [...rows, ...new Text(piTheme().fg("warning", warning), outputPad, 0).render(width)];
         },
         invalidate: () => mutate(() => component.invalidate()),
-        dispose: () => { disposed = true; mount++; },
+        dispose: () => { disposed = true; mount++; mountedTool?.dispose(); retainedImages.dispose(); },
         update(next) {
             if (next.id !== block.id)
                 throw new TypeError("Pi transcript component identity cannot change");
             const previous = block;
             block = next;
-            if (!mutate(() => updateTranscriptComponent(component, previous, next, expanded, imageAssets)))
+            retainedImages.update(next);
+            if (!mutate(() => updateTranscriptComponent(component, previous, next, expanded, retainedImages)))
                 component = rebuild();
         },
         setExpanded(next) {

package/dist/integrations/pi/components/shell-shared-facade.d.ts

@@ -134,6 +134,13 @@ export interface PiShellHeaderOptions {
     readonly notices?: readonly PiShellStartupNotice[];
     readonly resources?: readonly PiShellResourceEntry[];
 }
+/** An owned paste reserves its edit immediately and acknowledges completion only after insertion. */
+export interface PiShellPasteReservation {
+    readonly marker: string;
+    readonly result: Promise<string>;
+    complete?(): void;
+    isCurrent?(): boolean;
+}
 export interface PiShellEditorOptions {
     readonly persistentHistory?: boolean;
     readonly historyEditor?: HistoryEditorConstructor;
@@ -162,16 +169,18 @@ export interface PiShellEditorOptions {
     readonly onPromptSuggestionAccepted?: (text: string) => void;
     readonly onCopyText?: (text: string) => void;
     readonly readClipboardContent?: (signal?: AbortSignal) => Promise<PiShellClipboardContent | null>;
-    readonly beginClipboardPaste?: () => {
-        readonly marker: string;
-        readonly result: Promise<string>;
-    };
+    readonly beginClipboardPaste?: () => PiShellPasteReservation;
+    readonly beginTextPaste?: (text: string) => PiShellPasteReservation;
+    readonly deferTextPaste?: (text: string) => boolean;
+    readonly onPasteRejected?: (error: unknown) => void;
+    readonly onPasteInput?: (bytes: number) => void;
     readonly editorHiddenRanges?: (line: string) => readonly PiShellEditorTextRange[];
     readonly transformPastedContent?: (content: PiShellClipboardContent) => string;
     readonly editorAtomicRanges?: (line: string) => readonly PiShellEditorTextRange[];
     readonly expandCopiedEditorText?: (text: string) => string;
     readonly paintEditorSelection?: (line: string, from: number, to: number, atomic: boolean) => string;
-    readonly decorateEditorRow?: (row: string, width: number) => string;
+    /** Row indices restart at zero for each complete owned editor decoration pass. */
+    readonly decorateEditorRow?: (row: string, width: number, rowIndex: number) => string;
     readonly cwd?: string;
     readonly agentDir?: string;
     readonly autocompleteCommands?: readonly PiShellAutocompleteCommand[];

package/dist/integrations/pi/components/tool-image-presentation.d.ts

@@ -0,0 +1,21 @@
+import { convertToPng } from "@earendil-works/pi-coding-agent";
+import { type Component } from "#pi-tui";
+/**
+ * Own only current attachment presentation; tool renderers still receive original result content.
+ * Unlike pinned 0.84.2's index cache, entries follow immutable source bytes and stale completions
+ * cannot republish. At most one conversion runs per mount; queued work is only the current set.
+ */
+export declare class ToolImagePresentation {
+    #private;
+    private readonly changed;
+    private readonly convert;
+    constructor(changed: () => void, convert?: typeof convertToPng);
+    update(content: readonly {
+        type: string;
+        data?: string;
+        mimeType?: string;
+    }[], show: boolean): void;
+    /** Public Image remains responsible for Kitty/iTerm protocol and dimension-aware fallback. */
+    components(width: number): Component[];
+    dispose(): void;
+}