@timurproko/a1 0.1.8-dev.3b54f21 → 0.1.8-dev.402

package/dist/{src/foundation/pi-component-adapter → integrations/pi/components}/shell-selectors-dialogs.d.ts

@@ -1,5 +1,5 @@
 import { ModelSelectorComponent, type SessionInfo, type SettingsCallbacks, type SettingsConfig } from "@earendil-works/pi-coding-agent";
-import type { OwnedUiDialog } from "../owned-ui-contracts/index.js";
+import type { OwnedUiDialog } from "../../../contracts/owned-ui/index.js";
 import { type TrustDecision, type TrustOption, type TrustUpdate } from "./upstream/components/trust-selector.js";
 import { type PiShellComponentPort, type PiShellEditorOptions, type PiShellSelectorOption, type PiShellSelectorOptions } from "./shell-shared-facade.js";
 export declare function createPiShellSelector(options: PiShellSelectorOptions): PiShellComponentPort;
@@ -67,6 +67,7 @@ export declare function createPiShellTreeSelector(options: {
     readonly onSelect: (id: string) => void;
     readonly onCancel: () => void;
     readonly onLabelChange: (entryId: string, label: string | undefined) => void;
+    readonly onCopy?: (text: string | undefined) => void;
     readonly initialSelectedId?: string;
     readonly initialFilterMode?: "default" | "no-tools" | "user-only" | "labeled-only" | "all";
 }): PiShellComponentPort;
@@ -87,11 +88,14 @@ export interface PiShellLoginDialogPort extends PiShellComponentPort {
     showWaiting(message: string): void;
     showProgress(message: string): void;
 }
-export declare function createPiShellLoginDialog(runtime: Pick<PiShellEditorOptions, "getColumns" | "getRows" | "requestRender">, providerId: string, onComplete: (success: boolean, message?: string) => void, providerName?: string): PiShellLoginDialogPort;
+export declare function createPiShellLoginDialog(runtime: Pick<PiShellEditorOptions, "getColumns" | "getRows" | "requestRender">, providerId: string, onComplete: (success: boolean, message?: string) => void, providerName?: string, title?: string): PiShellLoginDialogPort;
 export declare function createPiShellArmin(runtime: Pick<PiShellEditorOptions, "getColumns" | "getRows" | "requestRender">): PiShellComponentPort;
 export declare function createPiShellDaxnuts(runtime: Pick<PiShellEditorOptions, "getColumns" | "getRows" | "requestRender">): PiShellComponentPort;
 export declare function createPiShellEarendilAnnouncement(): PiShellComponentPort;
-export declare function createPiShellOperationLoader(runtime: Pick<PiShellEditorOptions, "getColumns" | "getRows" | "requestRender">, message: string): PiShellComponentPort;
+export interface PiShellOperationLoaderPort extends PiShellComponentPort {
+    readonly signal: AbortSignal;
+}
+export declare function createPiShellOperationLoader(runtime: Pick<PiShellEditorOptions, "getColumns" | "getRows" | "requestRender">, message: string): PiShellOperationLoaderPort;
 export declare function createPiShellReloadBox(): PiShellComponentPort;
 export interface PiShellAuthProviderOption extends PiShellSelectorOption {
     readonly providerId: string;
@@ -101,7 +105,7 @@ export interface PiShellAuthProviderOption extends PiShellSelectorOption {
         readonly source?: string;
     };
 }
-export declare function createPiShellAuthProviderSelector(mode: "login" | "logout", providers: readonly PiShellAuthProviderOption[], onSelect: (id: string) => void, onCancel: () => void): PiShellComponentPort;
+export declare function createPiShellAuthProviderSelector(mode: "login" | "logout", providers: readonly PiShellAuthProviderOption[], onSelect: (id: string) => void, onCancel: () => void, initialSearchInput?: string): PiShellComponentPort;
 export declare function createPiShellExtensionSelector(title: string, options: readonly string[], onSelect: (value: string) => void, onCancel: () => void): PiShellComponentPort;
 export declare function createPiShellThinkingSelector(currentLevel: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max", availableLevels: readonly ("off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max")[], onSelect: (level: string) => void, onCancel: () => void): PiShellComponentPort;
 export declare function createPiShellThemeSelector(currentTheme: string, onSelect: (theme: string) => void, onCancel: () => void, onPreview: (theme: string) => void): PiShellComponentPort;

package/dist/{src/foundation/pi-component-adapter → integrations/pi/components}/shell-selectors-dialogs.js

@@ -111,7 +111,10 @@ export function createPiShellSessionSelector(options) {
 }
 export function createPiShellTreeSelector(options) {
     ensureTheme();
-    return componentPort(new TreeSelectorComponent([...options.tree], options.currentLeafId, options.terminalHeight, options.onSelect, options.onCancel, options.onLabelChange, options.initialSelectedId, options.initialFilterMode));
+    const selector = new TreeSelectorComponent([...options.tree], options.currentLeafId, options.terminalHeight, options.onSelect, options.onCancel, options.onLabelChange, options.initialSelectedId, options.initialFilterMode);
+    if (options.onCopy)
+        selector.onCopy = options.onCopy;
+    return componentPort(selector);
 }
 export function createPiShellUserMessageSelector(messages, onSelect, onCancel, initialSelectedId) {
     ensureTheme();
@@ -119,9 +122,9 @@ export function createPiShellUserMessageSelector(messages, onSelect, onCancel, i
     const list = selector.getMessageList();
     return componentPort(selector, data => list.handleInput(data));
 }
-export function createPiShellLoginDialog(runtime, providerId, onComplete, providerName) {
+export function createPiShellLoginDialog(runtime, providerId, onComplete, providerName, title) {
     ensureTheme();
-    const dialog = new LoginDialogComponent(createTuiFacade(runtime), providerId, onComplete, providerName);
+    const dialog = new LoginDialogComponent(createTuiFacade(runtime), providerId, onComplete, providerName, title);
     return {
         ...componentPort(dialog),
         showAuth: (url, instructions) => dialog.showAuth(url, instructions),
@@ -148,7 +151,8 @@ export function createPiShellEarendilAnnouncement() {
 }
 export function createPiShellOperationLoader(runtime, message) {
     ensureTheme();
-    return componentPort(new BorderedLoader(createTuiFacade(runtime), piTheme(), message));
+    const loader = new BorderedLoader(createTuiFacade(runtime), piTheme(), message, { cancellable: true });
+    return { ...componentPort(loader), signal: loader.signal };
 }
 export function createPiShellReloadBox() {
     ensureTheme();
@@ -161,7 +165,7 @@ export function createPiShellReloadBox() {
     container.addChild(new DynamicBorder(borderColor));
     return componentPort(container);
 }
-export function createPiShellAuthProviderSelector(mode, providers, onSelect, onCancel) {
+export function createPiShellAuthProviderSelector(mode, providers, onSelect, onCancel, initialSearchInput) {
     ensureTheme();
     const selector = new OAuthSelectorComponent(mode, providers.map(provider => ({
         id: provider.providerId,
@@ -172,7 +176,7 @@ export function createPiShellAuthProviderSelector(mode, providers, onSelect, onC
         const selected = providers.find(provider => provider.providerId === providerId && provider.authType === authType);
         if (selected)
             onSelect(selected.id);
-    }, onCancel);
+    }, onCancel, initialSearchInput);
     return componentPort(selector);
 }
 export function createPiShellExtensionSelector(title, options, onSelect, onCancel) {

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

@@ -0,0 +1,213 @@
+import { visibleWidth, type AutocompleteProvider, type Component, type KeybindingsConfig, type TUI } from "#pi-tui";
+import type { OwnedUiImageAttachment, OwnedUiSessionViewModel, OwnedUiThinkingLevel, OwnedUiTranscriptBlock, SuggestionDecision } from "../../../contracts/owned-ui/index.js";
+import type { HistoryEditorConstructor } from "./history-editor-loader.js";
+import type { PiShellPromptInputPresentation } from "./prompt-input-port.js";
+import type { EditorRecallPort } from "./editor-interaction.js";
+import type { PresentationComponentPort } from "../../../contracts/presentation/index.js";
+/** Terminal-cell width authority used by Pi-rendered component rows. */
+export declare const piShellVisibleWidth: typeof visibleWidth;
+export declare const piShellTruncateToWidth: (text: string, width: number) => string;
+export interface PiShellComponentPort extends PresentationComponentPort {
+}
+export type PiShellClipboardContent = {
+    readonly kind: "text";
+    readonly text: string;
+} | {
+    readonly kind: "image";
+    readonly data: string;
+    readonly mimeType: string;
+};
+export interface PiShellEditorTextRange {
+    readonly start: number;
+    readonly end: number;
+}
+export interface PiShellEditorPointerEvent {
+    readonly kind: "press" | "motion" | "release";
+    readonly button: number;
+    readonly column: number;
+    /** One-based row relative to the top border of the editor body, excluding its menu. */
+    readonly row: number;
+}
+export interface PiShellEditorBodyGeometry {
+    /** Zero-based body offset in the most recently rendered component rows. */
+    readonly rowOffset: number;
+    /** Border-inclusive body height, excluding autocomplete. */
+    readonly rowCount: number;
+}
+export interface PiShellEditorPort extends PiShellComponentPort {
+    /** Present only for the owned above-prompt autocomplete presentation. */
+    bodyGeometry?(): PiShellEditorBodyGeometry;
+    readonly recall?: EditorRecallPort;
+    readonly historyReplacement?: typeof import("../../../contracts/owned-ui/index.js").PROMPT_HISTORY_EDITOR_REPLACEMENT;
+    /** Restores this editor's profile after another Pi component changed the global manager. */
+    activateKeybindings(): void;
+    keybindingConfig(): KeybindingsConfig;
+    reloadKeybindings(): void;
+    /** Uses Pi's terminal decoder rather than assuming one terminal escape spelling. */
+    matchesTerminalKey(data: string, key: "home" | "end" | "ctrl+home" | "ctrl+end" | "alt+home" | "ctrl+v"): boolean;
+    getText(): string;
+    setText(text: string): void;
+    insertText(text: string): void;
+    addToHistory(text: string): void;
+    setSubmitEnabled(enabled: boolean): void;
+    setSubmitHandler(handler: (text: string) => void): void;
+    setInterruptHandler(handler: () => void): void;
+    setAutocompleteCommands(commands: readonly PiShellAutocompleteCommand[]): void;
+    setPaddingX(padding: number): void;
+    setAutocompleteMaxVisible(maxVisible: number): void;
+    addAutocompleteProvider(factory: unknown): void;
+    setThinkingLevel(level: OwnedUiThinkingLevel): void;
+    setPromptSuggestion(text: string | null): void;
+    canPresentPromptSuggestion(): boolean;
+    promptSuggestionBlockReason?(): SuggestionDecision;
+    hasSelection(): boolean;
+    ownsPointer(): boolean;
+    handlePointer(event: PiShellEditorPointerEvent): boolean;
+    pasteClipboard(): boolean;
+    cancelPendingPastes?(): void;
+}
+export interface PiShellAutocompleteCommand {
+    readonly name: string;
+    readonly description?: string;
+    readonly argumentHint?: string;
+    readonly argumentOptions?: readonly PiShellSelectorOption[];
+}
+export interface PiShellViewComponentPort extends PiShellComponentPort {
+    update(view: OwnedUiSessionViewModel): void;
+}
+export type PiShellStatusPlacement = "live" | "dock" | "hidden";
+export interface PiShellStatusPort extends PiShellViewComponentPort {
+    setWorkingOverride(message: string | undefined): void;
+    setOutputPad(padding: 0 | 1): void;
+    /** Semantic row placement; callers must not inspect rendered text. */
+    placement(): PiShellStatusPlacement;
+    renderDock(width: number): readonly string[];
+    renderLive(width: number): readonly string[];
+}
+export interface PiShellQueuedInputPort extends PiShellComponentPort {
+    update(submissions: readonly string[]): void;
+}
+export interface PiShellHeaderPort extends PiShellComponentPort {
+    readonly expanded: boolean;
+    setExpanded(expanded: boolean): void;
+}
+export type PiShellResourceSection = "Context" | "Skills" | "Prompts" | "Extensions" | "Themes";
+export interface PiShellResourceEntry {
+    readonly section: PiShellResourceSection;
+    readonly label: string;
+    readonly sourcePath: string | null;
+    readonly diagnostic?: string | null;
+}
+export interface PiShellLoadedResourcesPort extends PiShellComponentPort {
+    setExpanded(expanded: boolean): void;
+}
+export interface PiShellImageAssetResolver {
+    resolve(assetId: string): OwnedUiImageAttachment | null;
+}
+export interface PiShellExtensionRendererResolver {
+    getMessageRenderer(customType: string): unknown;
+    getToolDefinition(toolName: string): unknown;
+    getShortcuts?(bindings: KeybindingsConfig): readonly {
+        readonly key: string;
+        readonly description: string;
+    }[];
+}
+export interface PiShellTranscriptComponentPort extends PiShellComponentPort {
+    readonly id: string;
+    readonly revision: number;
+    readonly presentationRevision?: number;
+    update(block: OwnedUiTranscriptBlock): void;
+    setExpanded(expanded: boolean): void;
+    setOutputPad(padding: 0 | 1): void;
+    setHideThinkingBlock(hidden: boolean): void;
+    setMermaidRenderingMode(mode: "off" | "final" | "streaming"): void;
+    setImagePresentation(showImages: boolean, imageWidthCells: number): void;
+}
+export interface PiShellStartupNotice {
+    readonly kind: "info" | "warning" | "error";
+    readonly message: string;
+}
+export interface PiShellHeaderOptions {
+    readonly getKeybindings?: () => KeybindingsConfig;
+    readonly quiet?: boolean;
+    readonly expanded?: boolean;
+    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;
+    /** Bare A1 adds ergonomic aliases while comparison profiles retain Pi defaults. */
+    readonly keybindingProfile?: "pi" | "a1";
+    readonly getColumns: () => number;
+    readonly getRows: () => number;
+    readonly requestRender: () => void;
+    readonly onSubmit: (text: string) => void;
+    readonly onChange?: (text: string) => void;
+    readonly onInterrupt?: () => void;
+    readonly onClear?: () => void;
+    readonly onExit?: () => void;
+    readonly onSuspend?: () => void;
+    readonly onExternalEditor?: () => void;
+    readonly onPasteImage?: () => void;
+    readonly onExtensionShortcut?: (data: string) => boolean;
+    readonly onModelSelect?: () => void;
+    readonly onModelCycle?: ((direction: "forward" | "backward") => void) | undefined;
+    readonly onThinkingCycle?: (() => void) | undefined;
+    readonly onThinkingToggle?: (() => void) | undefined;
+    readonly onToolsExpand?: (() => void) | undefined;
+    readonly onMessageCopy?: (() => void) | undefined;
+    readonly onFollowUp?: (() => void) | undefined;
+    readonly onDequeue?: (() => void) | undefined;
+    readonly onPromptSuggestionAccepted?: (text: string) => void;
+    readonly onCopyText?: (text: string) => void;
+    readonly readClipboardContent?: (signal?: AbortSignal) => Promise<PiShellClipboardContent | null>;
+    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;
+    /** 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[];
+    readonly promptPresentation?: {
+        readonly input: PiShellPromptInputPresentation;
+        readonly styleSuggestion: (text: string) => string;
+        readonly styleSuggestionCaret: (text: string) => string;
+    };
+}
+export interface PiShellSelectorOption {
+    readonly id: string;
+    readonly label: string;
+    readonly description?: string;
+}
+export interface PiShellSelectorOptions {
+    readonly title?: string;
+    readonly options: readonly PiShellSelectorOption[];
+    readonly maxVisible?: number;
+    readonly onSelect?: (id: string) => void;
+    readonly onCancel?: () => void;
+}
+export declare function createTuiFacade(options: Pick<PiShellEditorOptions, "getColumns" | "getRows" | "requestRender"> & {
+    readonly onSubmit?: (text: string) => void;
+}): TUI;
+export declare function componentPort(component: Component, handleInput?: (data: string) => void): PiShellComponentPort;
+export declare function componentFromPort(port: PiShellComponentPort): Component;
+export declare function formatSessionTokens(count: number): string;
+export declare function isAutocompleteProvider(value: unknown): value is AutocompleteProvider;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function ensureTheme(): void;

package/dist/{src/foundation/pi-component-adapter → integrations/pi/components}/shell-shared-facade.js

@@ -1,7 +1,10 @@
-import { setKeybindings, } from "#pi-tui";
+import { setKeybindings, visibleWidth, truncateToWidth, } from "#pi-tui";
 import { KeybindingsManager, } from "./upstream/adjacent/core/keybindings.js";
 import { ensurePiTheme, } from "./theme.js";
-// Pinned from packages/coding-agent/src/core/slash-commands.ts at 914cf14.
+/** Terminal-cell width authority used by Pi-rendered component rows. */
+export const piShellVisibleWidth = visibleWidth;
+export const piShellTruncateToWidth = (text, width) => truncateToWidth(text, width, "");
+// Provenance: pinned from packages/coding-agent/src/core/slash-commands.ts at 914cf14.
 export function createTuiFacade(options) {
     const children = [];
     const terminal = {

package/dist/integrations/pi/components/submitted-prompt-adapter.d.ts

@@ -0,0 +1,15 @@
+import { type Component } from "#pi-tui";
+import type { OwnedUiTranscriptBlock } from "../../../contracts/owned-ui/index.js";
+export interface PiShellSubmittedPromptComposer {
+    readonly layout: (width: number, source?: Date | number | null) => {
+        readonly contentWidth: number;
+    };
+    readonly compose: (contentRows: readonly string[], width: number, source?: Date | number | null, style?: {
+        readonly prefix?: (text: string) => string;
+        readonly timestamp?: (text: string) => string;
+    }) => readonly string[];
+}
+/** Branch summaries share the block kind but do not participate in prompt navigation. */
+export declare function isPiPromptStyleCompaction(block: OwnedUiTranscriptBlock): boolean;
+/** Pi owns Markdown and theme adaptation; the injected composer owns neutral row geometry. */
+export declare function createPiSubmittedPromptComponent(block: OwnedUiTranscriptBlock, composer: PiShellSubmittedPromptComposer, heading?: string): Component;

package/dist/integrations/pi/components/submitted-prompt-adapter.js

@@ -0,0 +1,43 @@
+import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
+import { Box, Markdown, Text } from "#pi-tui";
+import { piTheme } from "./theme.js";
+/** Branch summaries share the block kind but do not participate in prompt navigation. */
+export function isPiPromptStyleCompaction(block) {
+    return block.kind === "compaction" && block.status === "finalized"
+        && typeof block.payload === "object" && block.payload !== null
+        && block.payload.role === "compactionSummary";
+}
+/** Pi owns Markdown and theme adaptation; the injected composer owns neutral row geometry. */
+export function createPiSubmittedPromptComponent(block, composer, heading) {
+    const timestamp = numericTimestamp(block);
+    // Invariant: presentation-only chrome stays outside the summary's Markdown parser and stored text.
+    const header = heading === undefined ? undefined : new Text(heading, 0, 0);
+    const markdown = new Markdown(block.text, 0, 0, getMarkdownTheme(), { color: content => piTheme().fg("userMessageText", content) }, { preserveOrderedListMarkers: true, preserveBackslashEscapes: true });
+    const content = {
+        render(width) {
+            const layout = composer.layout(width, timestamp);
+            const bodyRows = markdown.render(layout.contentWidth);
+            const rows = header === undefined ? bodyRows : [
+                ...header.render(layout.contentWidth).map(row => piTheme().fg("userMessageText", row)),
+                ...(bodyRows.length === 0 ? [] : ["", ...bodyRows]),
+            ];
+            return [...composer.compose(rows, width, timestamp, {
+                    prefix: text => piTheme().fg("muted", text),
+                    timestamp: text => piTheme().fg("dim", text),
+                })];
+        },
+        invalidate() {
+            header?.invalidate();
+            markdown.invalidate();
+        },
+    };
+    const box = new Box(0, 0, line => piTheme().bg("userMessageBg", line));
+    box.addChild(content);
+    return box;
+}
+function numericTimestamp(block) {
+    if (typeof block.payload !== "object" || block.payload === null)
+        return null;
+    const value = block.payload.timestamp;
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}

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

package/dist/integrations/pi/components/tool-image-presentation.js

@@ -0,0 +1,86 @@
+import { convertToPng } from "@earendil-works/pi-coding-agent";
+import { getCapabilities, Image, Text } from "#pi-tui";
+import { piTheme } from "./theme.js";
+const MAX_BYTES = 20 * 1024 * 1024;
+const MAX_IMAGES = 16;
+const bytes = (data) => Math.floor(data.length * 3 / 4) - (data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0);
+/**
+ * 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 class ToolImagePresentation {
+    changed;
+    convert;
+    #entries = [];
+    #visible = false;
+    #disposed = false;
+    #active = false;
+    constructor(changed, convert = convertToPng) {
+        this.changed = changed;
+        this.convert = convert;
+    }
+    update(content, show) {
+        if (this.#disposed)
+            return;
+        const previous = this.#entries;
+        const next = [];
+        for (const part of content) {
+            if (part.type !== "image" || !part.data || !part.mimeType)
+                continue;
+            const source = { data: part.data, mimeType: part.mimeType };
+            const same = (entry) => entry.source.data === source.data && entry.source.mimeType === source.mimeType;
+            next.push(next.find(same) ?? previous.find(same) ?? { source, state: "waiting" });
+            if (next.length === MAX_IMAGES)
+                break;
+        }
+        this.#entries = next;
+        this.#visible = show && getCapabilities().images !== null;
+        this.#pump();
+    }
+    /** Public Image remains responsible for Kitty/iTerm protocol and dimension-aware fallback. */
+    components(width) {
+        if (this.#disposed || !this.#visible)
+            return [];
+        return this.#entries.map(entry => {
+            const source = entry.source;
+            if (getCapabilities().images === "kitty" && source.mimeType !== "image/png") {
+                if (entry.converted === undefined)
+                    return new Text(piTheme().fg("muted", entry.state === "unavailable" ? `[Image unavailable: ${source.mimeType}]` : `[Image converting: ${source.mimeType}]`), 1, 0);
+            }
+            const image = getCapabilities().images === "kitty" ? entry.converted ?? source : source;
+            return new Image(image.data, image.mimeType, { fallbackColor: text => piTheme().fg("toolOutput", text) }, { maxWidthCells: width });
+        });
+    }
+    dispose() {
+        this.#disposed = true;
+        this.#entries = [];
+    }
+    #pump() {
+        if (this.#disposed || this.#active || !this.#visible || getCapabilities().images !== "kitty")
+            return;
+        const entry = this.#entries.find(value => value.source.mimeType !== "image/png" && value.state === "waiting");
+        if (entry === undefined)
+            return;
+        entry.state = "converting";
+        this.#active = true;
+        // Concurrency: defer codec entry until the caller's synchronous component mutation finishes.
+        void Promise.resolve().then(() => this.#disposed || !this.#entries.includes(entry)
+            ? null : this.convert(entry.source.data, entry.source.mimeType)).catch(() => null).then(converted => {
+            this.#active = false;
+            if (this.#disposed)
+                return;
+            if (this.#entries.includes(entry)) {
+                // Invariant: limits match the existing 16 references / 20 MiB per image, not a new aggregate cap.
+                if (converted !== null && converted.mimeType === "image/png" && bytes(converted.data) <= MAX_BYTES) {
+                    entry.converted = converted;
+                    entry.state = "ready";
+                }
+                else
+                    entry.state = "unavailable";
+                this.changed();
+            }
+            this.#pump();
+        });
+    }
+}

package/dist/integrations/pi/components/tool-result-adapter.d.ts

@@ -0,0 +1,6 @@
+import type { ToolExecutionComponent } from "./upstream/components/tool-execution.js";
+import type { OwnedUiTranscriptBlock } from "../../../contracts/owned-ui/index.js";
+import { type PiShellImageAssetResolver } from "./shell-shared-facade.js";
+/** Reconstruct public Pi inputs once at the component boundary, never from diagnostic summaries. */
+export declare function updatePiToolResult(component: Pick<ToolExecutionComponent, "updateResult">, block: OwnedUiTranscriptBlock, assets?: PiShellImageAssetResolver): void;
+export declare function piToolArguments(block: OwnedUiTranscriptBlock): unknown;

package/dist/integrations/pi/components/tool-result-adapter.js

@@ -0,0 +1,27 @@
+import { isRecord } from "./shell-shared-facade.js";
+/** Reconstruct public Pi inputs once at the component boundary, never from diagnostic summaries. */
+export function updatePiToolResult(component, block, assets) {
+    const payload = isRecord(block.payload) ? block.payload : {};
+    if (block.kind !== "tool-result" && payload.partialResult !== true)
+        return;
+    const image = (index) => {
+        const reference = block.imageReferences?.[index];
+        const asset = reference === undefined ? null : assets?.resolve(reference.assetId);
+        return asset == null
+            ? { type: "text", text: `[Image unavailable: ${reference?.mimeType ?? "unknown"}]` }
+            : { type: "image", data: asset.data, mimeType: asset.mimeType };
+    };
+    const result = block.toolRendering?.result;
+    const content = result === undefined
+        ? [{ type: "text", text: block.text }, ...(block.imageReferences ?? []).map((_, index) => image(index))]
+        : result.content.map(part => part.type === "text"
+            ? { type: "text", text: block.text.slice(part.start, part.end) } : image(part.imageIndex));
+    component.updateResult({ content, details: result?.details, isError: payload.isError === true }, block.status === "live");
+}
+export function piToolArguments(block) {
+    if (block.toolRendering !== undefined)
+        return block.toolRendering.arguments;
+    // Compatibility: existing owned blocks and component consumers may lack rendering metadata.
+    const payload = isRecord(block.payload) ? block.payload : {};
+    return isRecord(payload.arguments) && "json" in payload.arguments ? payload.arguments.json : payload.arguments ?? {};
+}

package/dist/integrations/pi/components/transcript-image-resolver.d.ts

@@ -0,0 +1,7 @@
+import type { OwnedUiImageAttachment, OwnedUiTranscriptBlock } from "../../../contracts/owned-ui/index.js";
+import type { PiShellImageAssetResolver } from "./shell-shared-facade.js";
+export declare function createTranscriptImageResolver(source: PiShellImageAssetResolver | undefined, initial: OwnedUiTranscriptBlock): {
+    resolve: (id: string) => OwnedUiImageAttachment | null;
+    update: (block: OwnedUiTranscriptBlock) => void;
+    dispose: () => void;
+};

package/dist/integrations/pi/components/transcript-image-resolver.js

@@ -0,0 +1,19 @@
+// Concurrency: a mounted block can outlive its engine revision while delivery is pending; retain its immutable assets through rebuilds.
+export function createTranscriptImageResolver(source, initial) {
+    let images = new Map();
+    const update = (block) => {
+        const next = new Map();
+        for (const reference of block.imageReferences ?? []) {
+            const asset = source?.resolve(reference.assetId) ?? images.get(reference.assetId);
+            if (asset != null)
+                next.set(reference.assetId, asset);
+        }
+        images = next;
+    };
+    update(initial);
+    return {
+        resolve: (id) => images.get(id) ?? null,
+        update,
+        dispose: () => images.clear(),
+    };
+}

package/dist/{src/foundation/pi-component-adapter → integrations/pi/components}/upstream/adjacent/core/keybindings.d.ts

@@ -1,5 +1,5 @@
 /** Source-synchronized from Pi 0.84.2 packages/coding-agent/src/core/keybindings.ts. */
-import { type Keybinding, type KeybindingsConfig, type KeyId, KeybindingsManager as TuiKeybindingsManager } from "#pi-tui";
+import { type Keybinding, type KeybindingDefinitions, type KeybindingsConfig, type KeyId, KeybindingsManager as TuiKeybindingsManager } from "#pi-tui";
 export interface AppKeybindings {
     "app.interrupt": true;
     "app.clear": true;
@@ -43,6 +43,12 @@ export interface AppKeybindings {
     "app.tree.filter.all": true;
     "app.tree.filter.cycleForward": true;
     "app.tree.filter.cycleBackward": true;
+    "owned.editor.selectAll": true;
+    "owned.editor.cut": true;
+    "owned.editor.paste": true;
+    "owned.editor.redo": true;
+    "owned.editor.extendLeft": true;
+    "owned.editor.extendRight": true;
 }
 export type AppKeybinding = keyof AppKeybindings;
 declare module "#pi-tui" {
@@ -413,8 +419,11 @@ export declare function migrateKeybindingsConfig(rawConfig: Record<string, unkno
 };
 export declare class KeybindingsManager extends TuiKeybindingsManager {
     private configPath;
-    constructor(userBindings?: KeybindingsConfig, configPath?: string);
+    constructor(userBindings?: KeybindingsConfig, configPath?: string, definitions?: KeybindingDefinitions);
     static create(agentDir?: string): KeybindingsManager;
+    static fromOwnedBindings(bindings?: KeybindingsConfig): KeybindingsManager;
+    static createForOwnedInput(agentDir?: string): KeybindingsManager;
+    private static createWithDefinitions;
     reload(): void;
     getEffectiveConfig(): KeybindingsConfig;
     private static loadFromFile;

package/dist/{src/foundation/pi-component-adapter → integrations/pi/components}/upstream/adjacent/core/keybindings.js

@@ -147,6 +147,35 @@ export const KEYBINDINGS = {
         description: "Tree filter: cycle backward",
     },
 };
+/** Pi actions with bare-A1 aliases; the comparison profile keeps KEYBINDINGS unchanged. */
+const OWNED_INPUT_KEYBINDINGS = {
+    ...KEYBINDINGS,
+    "app.thinking.cycle": { ...KEYBINDINGS["app.thinking.cycle"], defaultKeys: "ctrl+l" },
+    "app.model.select": { ...KEYBINDINGS["app.model.select"], defaultKeys: [] },
+    "tui.editor.deleteWordBackward": {
+        ...KEYBINDINGS["tui.editor.deleteWordBackward"],
+        defaultKeys: [...KEYBINDINGS["tui.editor.deleteWordBackward"].defaultKeys, "ctrl+backspace"],
+    },
+    "tui.editor.deleteWordForward": {
+        ...KEYBINDINGS["tui.editor.deleteWordForward"],
+        defaultKeys: [...KEYBINDINGS["tui.editor.deleteWordForward"].defaultKeys, "ctrl+delete"],
+    },
+    "tui.editor.undo": {
+        ...KEYBINDINGS["tui.editor.undo"],
+        defaultKeys: [KEYBINDINGS["tui.editor.undo"].defaultKeys, "ctrl+z"],
+    },
+    // Ctrl+Z edits the prompt in bare A1 instead of suspending the process.
+    "app.suspend": { ...KEYBINDINGS["app.suspend"], defaultKeys: [] },
+    // Owned prompt-selection actions are intercepted before vanilla Pi editor
+    // actions. Keeping them in the keybinding manager makes the UX declarative,
+    // configurable, and independent of terminal escape-sequence spellings.
+    "owned.editor.selectAll": { defaultKeys: "ctrl+a", description: "Select all prompt text" },
+    "owned.editor.cut": { defaultKeys: "ctrl+x", description: "Cut selected prompt text" },
+    "owned.editor.paste": { defaultKeys: "ctrl+v", description: "Paste clipboard text" },
+    "owned.editor.redo": { defaultKeys: "ctrl+y", description: "Redo prompt edit" },
+    "owned.editor.extendLeft": { defaultKeys: "shift+left", description: "Extend prompt selection left" },
+    "owned.editor.extendRight": { defaultKeys: "shift+right", description: "Extend prompt selection right" },
+};
 const KEYBINDING_NAME_MIGRATIONS = {
     cursorUp: "tui.editor.cursorUp",
     cursorDown: "tui.editor.cursorDown",
@@ -270,14 +299,23 @@ function loadRawConfig(path) {
 }
 export class KeybindingsManager extends TuiKeybindingsManager {
     configPath;
-    constructor(userBindings = {}, configPath) {
-        super(KEYBINDINGS, userBindings);
+    constructor(userBindings = {}, configPath, definitions = KEYBINDINGS) {
+        super(definitions, userBindings);
         this.configPath = configPath;
     }
     static create(agentDir = getAgentDir()) {
+        return KeybindingsManager.createWithDefinitions(agentDir, KEYBINDINGS);
+    }
+    static fromOwnedBindings(bindings = {}) {
+        return new KeybindingsManager(bindings, undefined, OWNED_INPUT_KEYBINDINGS);
+    }
+    static createForOwnedInput(agentDir = getAgentDir()) {
+        return KeybindingsManager.createWithDefinitions(agentDir, OWNED_INPUT_KEYBINDINGS);
+    }
+    static createWithDefinitions(agentDir, definitions) {
         const configPath = join(agentDir, "keybindings.json");
         const userBindings = KeybindingsManager.loadFromFile(configPath);
-        return new KeybindingsManager(userBindings, configPath);
+        return new KeybindingsManager(userBindings, configPath, definitions);
     }
     reload() {
         if (!this.configPath)