@timurproko/a1 0.1.8-dev.ece8cef → 0.2.1-dev.590

package/dist/integrations/pi/components/skills-command.js

@@ -0,0 +1,119 @@
+/** The collapsed bare-A1 replacement for the per-skill command listing. */
+export const SKILLS_COMMAND_NAME = "skills";
+export const SKILLS_COMMAND_DESCRIPTION = "Browse, search, and apply a skill";
+/** Pi's own command prefix; the engine expands `/skill:<name>` regardless of how the menu presents it. */
+export const SKILL_COMMAND_PREFIX = "skill:";
+const SKILLS_TUNNEL_PREFIX = `${SKILLS_COMMAND_NAME}:`;
+/** The tunnel form follows v2: a name without whitespace right after the colon. */
+const SKILLS_TUNNEL_INPUT = /^\/skills:(\S*)$/u;
+const SKILLS_TUNNEL_SUBMISSION = /^\/skills:([A-Za-z0-9][A-Za-z0-9_-]*)(\s[\s\S]*)?$/u;
+/** One line of description, as the v2 extension shows it beside a row. */
+export function oneLineSkillDescription(description) {
+    return description.replace(/\s+/gu, " ").trim();
+}
+/** The skills the engine registered as `skill:<name>` commands, in its order. */
+export function skillsFromCommands(commands) {
+    return commands.flatMap(command => command.name.startsWith(SKILL_COMMAND_PREFIX) && command.name.length > SKILL_COMMAND_PREFIX.length
+        ? [{ name: command.name.slice(SKILL_COMMAND_PREFIX.length), description: oneLineSkillDescription(command.description ?? "") }]
+        : []);
+}
+/**
+ * Replace every `skill:<name>` entry with one `skills` command whose argument completions are the
+ * skill names. A list without skill entries (registration disabled, or no skills) is returned
+ * unchanged with no `skills` command, so the collapsed presentation never invents a command.
+ */
+export function collapseSkillCommands(commands) {
+    const skills = skillsFromCommands(commands);
+    if (skills.length === 0)
+        return { commands, skills };
+    const collapsed = [];
+    const collapsedCommand = {
+        name: SKILLS_COMMAND_NAME,
+        description: SKILLS_COMMAND_DESCRIPTION,
+        argumentOptions: skills.map(skill => ({
+            id: skill.name,
+            label: skill.name,
+            ...(skill.description.length === 0 ? {} : { description: skill.description }),
+        })),
+    };
+    let inserted = false;
+    for (const command of commands) {
+        if (!command.name.startsWith(SKILL_COMMAND_PREFIX)) {
+            collapsed.push(command);
+            continue;
+        }
+        if (inserted)
+            continue;
+        inserted = true;
+        collapsed.push(collapsedCommand);
+    }
+    return { commands: collapsed, collapsedCommand, skills };
+}
+/** Case-insensitive substring match on the name or description; a leading `skill:`/`skills:` in the query is ignored for the name. */
+export function skillMatchesQuery(skill, query) {
+    const normalized = query.trim().toLowerCase();
+    if (normalized.length === 0)
+        return true;
+    const withoutPrefix = normalized.startsWith(SKILLS_TUNNEL_PREFIX)
+        ? normalized.slice(SKILLS_TUNNEL_PREFIX.length)
+        : normalized.startsWith(SKILL_COMMAND_PREFIX) ? normalized.slice(SKILL_COMMAND_PREFIX.length) : normalized;
+    return skill.name.toLowerCase().includes(withoutPrefix)
+        || `${SKILL_COMMAND_PREFIX}${skill.name}`.toLowerCase().includes(normalized)
+        || skill.description.toLowerCase().includes(normalized);
+}
+/** Resolve a `/skills` argument token to a skill, accepting the name with or without `skill:`. */
+export function findSkillByArgument(skills, token) {
+    const name = token.startsWith(SKILL_COMMAND_PREFIX) ? token.slice(SKILL_COMMAND_PREFIX.length) : token;
+    return skills.find(skill => skill.name === name);
+}
+/** The `/skill:<name>` prompt the engine expands, with any arguments after one space. */
+export function skillPrompt(name, args = "") {
+    const trimmed = args.trim();
+    return trimmed.length === 0 ? `/${SKILL_COMMAND_PREFIX}${name}` : `/${SKILL_COMMAND_PREFIX}${name} ${trimmed}`;
+}
+/**
+ * Rewrite a submitted tunnel form `/skills:<name> rest` to `/skill:<name> rest`; anything else is
+ * returned unchanged so ordinary prompts, `/skills <name>`, and `/skill:` input keep their text.
+ */
+export function rewriteSkillsTunnelSubmission(text) {
+    const match = SKILLS_TUNNEL_SUBMISSION.exec(text);
+    if (match === null)
+        return text;
+    return `/${SKILL_COMMAND_PREFIX}${match[1]}${match[2] ?? ""}`;
+}
+/** The tunnel query when single-line content before the cursor is exactly `/skills:<query>`. */
+export function skillsTunnelQuery(lines, cursorLine, cursorCol) {
+    if (cursorLine !== 0 || lines.length !== 1)
+        return null;
+    const match = SKILLS_TUNNEL_INPUT.exec((lines[0] ?? "").slice(0, cursorCol));
+    return match === null ? null : match[1] ?? "";
+}
+export function skillsTunnelItems(skills, query) {
+    return skills.filter(skill => skillMatchesQuery(skill, query)).map(skill => ({
+        value: `${SKILLS_TUNNEL_PREFIX}${skill.name}`,
+        label: `${SKILLS_TUNNEL_PREFIX}${skill.name}`,
+        ...(skill.description.length === 0 ? {} : { description: skill.description }),
+    }));
+}
+/**
+ * Wrap the pinned combined provider with the `skills` tunnel: `/skills:<query>` lists matching
+ * skills as `skills:<name>` rows and shows nothing when none match; every other request, the
+ * completion application, and the file-completion decision are delegated unchanged so extension
+ * wrappers registered over this provider see one ordinary provider.
+ */
+export function createSkillsTunnelProvider(base, skills) {
+    return {
+        ...(base.triggerCharacters === undefined ? {} : { triggerCharacters: base.triggerCharacters }),
+        async getSuggestions(lines, cursorLine, cursorCol, options) {
+            const query = skillsTunnelQuery(lines, cursorLine, cursorCol);
+            if (query === null)
+                return base.getSuggestions(lines, cursorLine, cursorCol, options);
+            const items = skillsTunnelItems(skills, query);
+            if (options.signal.aborted || items.length === 0)
+                return null;
+            return { prefix: (lines[cursorLine] ?? "").slice(0, cursorCol), items };
+        },
+        applyCompletion: (lines, cursorLine, cursorCol, item, prefix) => base.applyCompletion(lines, cursorLine, cursorCol, item, prefix),
+        shouldTriggerFileCompletion: (lines, cursorLine, cursorCol) => base.shouldTriggerFileCompletion?.(lines, cursorLine, cursorCol) ?? true,
+    };
+}

package/dist/integrations/pi/components/skills-dialog.d.ts

@@ -0,0 +1,9 @@
+import { type PiShellComponentPort } from "./shell-shared-facade.js";
+import { type PiShellSkillSummary } from "./skills-command.js";
+export interface PiShellSkillsSelectorOptions {
+    /** The skills the engine registered, in its discovery order. */
+    readonly skills: readonly PiShellSkillSummary[];
+    readonly onSelect: (name: string) => void;
+    readonly onCancel: () => void;
+}
+export declare function createPiShellSkillsSelector(options: PiShellSkillsSelectorOptions): PiShellComponentPort;

package/dist/integrations/pi/components/skills-dialog.js

@@ -0,0 +1,128 @@
+import { DynamicBorder } from "../startup-public.js";
+import { Container, getKeybindings, Input, Spacer, Text } from "@earendil-works/pi-tui";
+import { addPiModalHeader, adoptPiModalFrame } from "./modal-frame.js";
+import { PINNED_PI_LAYOUT, piTheme, renderPiModalShortcutHints } from "./theme.js";
+import { componentPort, ensureTheme, piShellTruncateToWidth, piShellVisibleWidth } from "./shell-shared-facade.js";
+import { SKILL_COMMAND_PREFIX, skillMatchesQuery } from "./skills-command.js";
+/** A single line clipped at the viewport width: no wrap, no ellipsis, padded to the full width. */
+class ClippedLine {
+    #text;
+    constructor(text) { this.#text = text; }
+    invalidate() { }
+    render(width) {
+        const line = piShellTruncateToWidth(this.#text.split("\n", 1)[0] ?? "", width);
+        return [line + " ".repeat(Math.max(0, width - piShellVisibleWidth(line)))];
+    }
+}
+/**
+ * The A1-owned searchable Skills dialog. Its composition is the model selector's (border, spacer,
+ * search input, spacer, list, spacer, hint footer, border) built from public pi-tui components; its
+ * content follows the v2 skills extension: an accent bold title, `skill:<name>` rows, the selected
+ * skill's description cut to one line under the rows, the pinned scroll counter on overflow,
+ * and the two empty states. Enter applies the selected skill with no arguments; the query is never appended.
+ */
+class SkillsSelectorComponent extends Container {
+    #searchInput = new Input();
+    #listContainer = new Container();
+    #skills;
+    #onSelect;
+    #onCancel;
+    #filtered;
+    #selectedIndex = 0;
+    #focused = false;
+    constructor(options) {
+        super();
+        this.#skills = options.skills;
+        this.#filtered = options.skills;
+        this.#onSelect = options.onSelect;
+        this.#onCancel = options.onCancel;
+        this.#searchInput.onSubmit = () => this.#selectCurrent();
+        const header = addPiModalHeader(this, new DynamicBorder(), new Text(piTheme().fg("accent", piTheme().bold("Skills")), 0, 0));
+        this.addChild(new Spacer(1));
+        this.addChild(this.#searchInput);
+        this.addChild(new Spacer(1));
+        this.addChild(this.#listContainer);
+        this.addChild(new Spacer(1));
+        const bindings = getKeybindings();
+        this.addChild(new Text(renderPiModalShortcutHints([
+            { key: "↑↓", action: "navigate" },
+            { key: bindings.getKeys("tui.select.confirm").join("/"), action: "select" },
+            { key: bindings.getKeys("tui.select.cancel").join("/"), action: "cancel" },
+        ]), 0, 0));
+        this.addChild(new DynamicBorder());
+        adoptPiModalFrame(this, { topIndex: 0, bottomIndex: this.children.length - 1, header });
+        this.#updateList();
+    }
+    // Protocol: focus propagates to the search input so the terminal cursor follows the query.
+    get focused() { return this.#focused; }
+    set focused(value) {
+        this.#focused = value;
+        this.#searchInput.focused = value;
+    }
+    handleInput(data) {
+        const keybindings = getKeybindings();
+        if (keybindings.matches(data, "tui.select.up")) {
+            if (this.#filtered.length === 0)
+                return;
+            this.#selectedIndex = this.#selectedIndex === 0 ? this.#filtered.length - 1 : this.#selectedIndex - 1;
+            this.#updateList();
+        }
+        else if (keybindings.matches(data, "tui.select.down")) {
+            if (this.#filtered.length === 0)
+                return;
+            this.#selectedIndex = this.#selectedIndex === this.#filtered.length - 1 ? 0 : this.#selectedIndex + 1;
+            this.#updateList();
+        }
+        else if (keybindings.matches(data, "tui.select.confirm")) {
+            this.#selectCurrent();
+        }
+        else if (keybindings.matches(data, "tui.select.cancel")) {
+            this.#onCancel();
+        }
+        else {
+            const before = this.#searchInput.getValue();
+            this.#searchInput.handleInput(data);
+            const query = this.#searchInput.getValue();
+            if (query === before)
+                return;
+            this.#filtered = this.#skills.filter(skill => skillMatchesQuery(skill, query));
+            this.#selectedIndex = 0;
+            this.#updateList();
+        }
+    }
+    #selectCurrent() {
+        const selected = this.#filtered[this.#selectedIndex];
+        if (selected !== undefined)
+            this.#onSelect(selected.name);
+    }
+    #updateList() {
+        this.#listContainer.clear();
+        const theme = piTheme();
+        if (this.#filtered.length === 0) {
+            this.#listContainer.addChild(new Text(theme.fg("muted", this.#skills.length === 0 ? "  No skills yet" : "  No matching skills"), 0, 0));
+            return;
+        }
+        const maxVisible = PINNED_PI_LAYOUT.selectorMaxVisible;
+        const start = Math.max(0, Math.min(this.#selectedIndex - Math.floor(maxVisible / 2), this.#filtered.length - maxVisible));
+        const end = Math.min(start + maxVisible, this.#filtered.length);
+        for (let index = start; index < end; index++) {
+            const skill = this.#filtered[index];
+            const selected = index === this.#selectedIndex;
+            const label = `${SKILL_COMMAND_PREFIX}${skill.name}`;
+            this.#listContainer.addChild(new Text(`${selected ? theme.fg("accent", "→ ") : "  "}${selected ? theme.fg("accent", label) : label}`, 0, 0));
+        }
+        if (start > 0 || end < this.#filtered.length) {
+            this.#listContainer.addChild(new Text(theme.fg("muted", `  (${this.#selectedIndex + 1}/${this.#filtered.length})`), 0, 0));
+        }
+        const description = this.#filtered[this.#selectedIndex]?.description ?? "";
+        if (description.length > 0) {
+            this.#listContainer.addChild(new Spacer(1));
+            // Invariant: the description never wraps; it is cut at the viewport width with no ellipsis.
+            this.#listContainer.addChild(new ClippedLine(theme.fg("muted", `  ${description}`)));
+        }
+    }
+}
+export function createPiShellSkillsSelector(options) {
+    ensureTheme();
+    return componentPort(new SkillsSelectorComponent(options));
+}

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

@@ -0,0 +1,17 @@
+import { type Component } from "@earendil-works/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;
+/** Keep prompt timestamps metadata-grey even inside hover and quiet whole-row wrappers. */
+export declare function paintPiSubmittedPromptTimestamp(text: string): string;
+/** 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,52 @@
+import { getMarkdownTheme } from "../startup-public.js";
+import { Box, Markdown, Text } from "@earendil-works/pi-tui";
+import { protectPromptChipWrapping } from "../../../contracts/owned-ui/index.js";
+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";
+}
+/** Keep prompt timestamps metadata-grey even inside hover and quiet whole-row wrappers. */
+export function paintPiSubmittedPromptTimestamp(text) {
+    // Protocol: combine the intensity/foreground reset so quietSticky does not immediately
+    // reapply faint; the semantic foreground that follows remains theme-controlled.
+    return `\u001b[22;39m${piTheme().fg("dim", text)}`;
+}
+/** 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 chipWrapping = block.kind === "user" ? protectPromptChipWrapping(block.text) : undefined;
+    const markdown = new Markdown(chipWrapping?.text ?? 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 renderedBodyRows = markdown.render(layout.contentWidth);
+            const bodyRows = chipWrapping === undefined ? renderedBodyRows : renderedBodyRows.map(row => chipWrapping.restore(row));
+            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: paintPiSubmittedPromptTimestamp,
+                })];
+        },
+        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/theme.d.ts

@@ -0,0 +1,5 @@
+import { type SemanticShortcutHint } from "../../../contracts/presentation/index.js";
+export * from "./upstream/theme/theme.js";
+export type PiModalShortcutHint = SemanticShortcutHint;
+/** The common bare-A1 modal footer: quiet display-cased keys, muted names, and whitespace-only gaps. */
+export declare function renderPiModalShortcutHints(entries: readonly PiModalShortcutHint[], indent?: number): string;

package/dist/integrations/pi/components/theme.js

@@ -0,0 +1,11 @@
+import { renderSemanticShortcutHints, } from "../../../contracts/presentation/index.js";
+import { piTheme } from "./upstream/theme/theme.js";
+export * from "./upstream/theme/theme.js";
+/** The common bare-A1 modal footer: quiet display-cased keys, muted names, and whitespace-only gaps. */
+export function renderPiModalShortcutHints(entries, indent = 0) {
+    const theme = piTheme();
+    return renderSemanticShortcutHints(entries, {
+        key: text => theme.fg("dim", text),
+        action: text => theme.fg("muted", text),
+    }, indent);
+}

package/dist/integrations/pi/components/thinking-selector-dialog.d.ts

@@ -0,0 +1,8 @@
+import { type ThinkingSelectorLevel } from "./upstream/components/thinking-selector.js";
+import { type PiShellComponentPort } from "./shell-shared-facade.js";
+export interface PiShellThinkingSelectorPresentation {
+    readonly profile: "bare";
+    readonly cycleBinding: string | readonly string[];
+}
+/** Lazily loaded because thinking-selector code does not belong to the startup graph before `/thinking` opens. */
+export declare function createPiShellThinkingSelector(currentLevel: ThinkingSelectorLevel, availableLevels: readonly ThinkingSelectorLevel[], onSelect: (level: string) => void, onCancel: () => void, onSelectAsDefault?: (level: string) => void, defaultLevel?: ThinkingSelectorLevel, presentation?: PiShellThinkingSelectorPresentation): PiShellComponentPort;

package/dist/integrations/pi/components/thinking-selector-dialog.js

@@ -0,0 +1,22 @@
+import { ThinkingSelectorComponent } from "../startup-public.js";
+import { OwnedThinkingSelectorComponent } from "./upstream/components/thinking-selector.js";
+import { componentPort, ensureTheme } from "./shell-shared-facade.js";
+function displayKeybinding(binding) {
+    const keys = typeof binding === "string" ? [binding] : binding;
+    return keys.map(key => key.split("+").map(part => {
+        const display = process.platform === "darwin" && part.toLowerCase() === "alt" ? "option" : part;
+        return display.charAt(0).toUpperCase() + display.slice(1);
+    }).join("+")).join("/");
+}
+/** Lazily loaded because thinking-selector code does not belong to the startup graph before `/thinking` opens. */
+export function createPiShellThinkingSelector(currentLevel, availableLevels, onSelect, onCancel, onSelectAsDefault, defaultLevel, presentation) {
+    ensureTheme();
+    if (presentation?.profile === "bare") {
+        const cycleKey = displayKeybinding(presentation.cycleBinding);
+        const selector = new OwnedThinkingSelectorComponent(currentLevel, [...availableLevels], onSelect, onCancel, cycleKey || "Unbound", onSelectAsDefault, defaultLevel);
+        return componentPort(selector, data => selector.handleInput(data));
+    }
+    const selector = new ThinkingSelectorComponent(currentLevel, [...availableLevels], onSelect, onCancel, onSelectAsDefault, defaultLevel);
+    const list = selector.getSelectList();
+    return componentPort(selector, data => list.handleInput(data));
+}

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

@@ -0,0 +1,21 @@
+import { convertToPng } from "../startup-public.js";
+import { type Component } from "@earendil-works/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,83 @@
+import { convertToPng } from "../startup-public.js";
+import { getCapabilities, Image, Text } from "@earendil-works/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 {
+    #entries = [];
+    #visible = false;
+    #disposed = false;
+    #active = false;
+    changed;
+    convert;
+    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(),
+    };
+}