@timurproko/a1 0.1.8-dev.139 → 0.1.8-dev.157

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

@@ -1,7 +1,8 @@
 import { getSelectListTheme } from "@earendil-works/pi-coding-agent";
-import { CombinedAutocompleteProvider, setKeybindings, } from "#pi-tui";
+import { CombinedAutocompleteProvider, matchesKey, setKeybindings, } from "#pi-tui";
 import { KeybindingsManager } from "./upstream/adjacent/core/keybindings.js";
 import { OwnedEditor } from "./upstream/components/owned-editor.js";
+import { OwnedEditorUxInterception, createPromptSelectionInterceptor, } from "./owned-editor-ux.js";
 import { PINNED_PI_LAYOUT, piTheme, } from "./theme.js";
 import { createTuiFacade, ensureTheme, isAutocompleteProvider, } from "./shell-shared-facade.js";
 export const PINNED_PI_BUILTIN_SLASH_COMMANDS = [
@@ -31,7 +32,9 @@ export const PINNED_PI_BUILTIN_SLASH_COMMANDS = [
 export function createPiShellEditor(options) {
     ensureTheme();
     const tui = createTuiFacade(options);
-    const keybindings = KeybindingsManager.create(options.agentDir);
+    const keybindings = options.keybindingProfile === "a1"
+        ? KeybindingsManager.createForOwnedInput(options.agentDir)
+        : KeybindingsManager.create(options.agentDir);
     setKeybindings(keybindings);
     const editor = new OwnedEditor(tui, {
         borderColor: (value) => piTheme().fg("borderMuted", value),
@@ -40,6 +43,24 @@ export function createPiShellEditor(options) {
         paddingX: PINNED_PI_LAYOUT.editorPaddingX,
         autocompleteMaxVisible: PINNED_PI_LAYOUT.autocompleteMaxVisible,
     });
+    const editorUx = options.keybindingProfile === "a1"
+        ? new OwnedEditorUxInterception([
+            createPromptSelectionInterceptor(editor, keybindings, {
+                copyText: options.onCopyText ?? (() => { }),
+                readClipboardContent: options.readClipboardContent ?? (async () => null),
+                transformPastedContent: options.transformPastedContent ?? (content => content.kind === "text" ? content.text : ""),
+                atomicRanges: options.editorAtomicRanges ?? (() => []),
+                expandCopiedText: options.expandCopiedEditorText ?? (text => text),
+                paintSelection: options.paintEditorSelection ?? (line => line),
+                decorateRow: options.decorateEditorRow ?? (row => row),
+                requestRender: options.requestRender,
+                getRows: options.getRows,
+            }),
+        ], {
+            render: width => editor.render(width),
+            handleInput: data => editor.handleInput(data),
+        })
+        : undefined;
     let thinkingLevel = "off";
     let isBashMode = false;
     const updateBorderColor = () => {
@@ -108,15 +129,28 @@ export function createPiShellEditor(options) {
     if (options.onDequeue !== undefined)
         editor.onAction("app.message.dequeue", options.onDequeue);
     return {
-        render: width => editor.render(width),
-        handleInput: data => editor.handleInput(data),
+        render: width => editorUx?.render(width) ?? editor.render(width),
+        activateKeybindings: () => setKeybindings(keybindings),
+        matchesTerminalKey: (data, key) => matchesKey(data, key),
+        handleInput: data => {
+            if (editorUx === undefined)
+                editor.handleInput(data);
+            else
+                editorUx.handleInput(data);
+        },
         invalidate: () => editor.invalidate(),
         setFocused: focused => {
             editor.focused = focused;
         },
         getText: () => editor.getExpandedText(),
-        setText: text => editor.setText(text),
-        insertText: text => editor.insertTextAtCursor(text),
+        setText: text => {
+            editorUx?.reset();
+            editor.setText(text);
+        },
+        insertText: text => {
+            editorUx?.reset();
+            editor.insertTextAtCursor(text);
+        },
         addToHistory: text => editor.addToHistory(text),
         setSubmitEnabled: enabled => {
             editor.disableSubmit = !enabled;
@@ -139,6 +173,10 @@ export function createPiShellEditor(options) {
             thinkingLevel = level;
             updateBorderColor();
         },
+        hasSelection: () => editorUx?.hasSelection() ?? false,
+        ownsPointer: () => editorUx?.ownsPointer() ?? false,
+        handlePointer: event => editorUx?.handlePointer(event) ?? false,
+        pasteClipboard: () => editorUx?.pasteClipboard() ?? false,
     };
 }
 function autocompleteCommand(command, addition) {

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

@@ -1,13 +1,34 @@
-import { type AutocompleteProvider, type Component, type TUI } from "#pi-tui";
+import { visibleWidth, type AutocompleteProvider, type Component, type TUI } from "#pi-tui";
 import type { OwnedUiSessionViewModel, OwnedUiThinkingLevel, OwnedUiTranscriptBlock } from "../../../contracts/owned-ui/index.js";
-export interface PiShellComponentPort {
-    render(width: number): readonly string[];
-    handleInput?(data: string): void;
-    invalidate(): void;
-    setFocused?(focused: boolean): void;
-    dispose?(): void;
+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 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 of the editor component. */
+    readonly row: number;
 }
 export interface PiShellEditorPort extends PiShellComponentPort {
+    /** Restores this editor's profile after another Pi component changed the global manager. */
+    activateKeybindings(): void;
+    /** Uses Pi's terminal decoder rather than assuming one terminal escape spelling. */
+    matchesTerminalKey(data: string, key: "home" | "end" | "ctrl+v"): boolean;
     getText(): string;
     setText(text: string): void;
     insertText(text: string): void;
@@ -18,6 +39,10 @@ export interface PiShellEditorPort extends PiShellComponentPort {
     setAutocompleteCommands(commands: readonly PiShellAutocompleteCommand[]): void;
     addAutocompleteProvider(factory: unknown): void;
     setThinkingLevel(level: OwnedUiThinkingLevel): void;
+    hasSelection(): boolean;
+    ownsPointer(): boolean;
+    handlePointer(event: PiShellEditorPointerEvent): boolean;
+    pasteClipboard(): boolean;
 }
 export interface PiShellAutocompleteCommand {
     readonly name: string;
@@ -69,6 +94,8 @@ export interface PiShellHeaderOptions {
     readonly resources?: readonly PiShellResourceEntry[];
 }
 export interface PiShellEditorOptions {
+    /** Bare A1 adds ergonomic aliases while comparison profiles retain Pi defaults. */
+    readonly keybindingProfile?: "pi" | "a1";
     readonly getColumns: () => number;
     readonly getRows: () => number;
     readonly requestRender: () => void;
@@ -89,6 +116,13 @@ export interface PiShellEditorOptions {
     readonly onMessageCopy?: (() => void) | undefined;
     readonly onFollowUp?: (() => void) | undefined;
     readonly onDequeue?: (() => void) | undefined;
+    readonly onCopyText?: (text: string) => void;
+    readonly readClipboardContent?: () => Promise<PiShellClipboardContent | null>;
+    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;
     readonly cwd?: string;
     readonly agentDir?: string;
     readonly autocompleteCommands?: readonly PiShellAutocompleteCommand[];

package/dist/integrations/pi/components/shell-shared-facade.js

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

package/dist/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,10 @@ 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 createForOwnedInput(agentDir?: string): KeybindingsManager;
+    private static createWithDefinitions;
     reload(): void;
     getEffectiveConfig(): KeybindingsConfig;
     private static loadFromFile;

package/dist/integrations/pi/components/upstream/adjacent/core/keybindings.js

@@ -147,6 +147,33 @@ 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,
+    "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 +297,20 @@ 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 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)

package/dist/integrations/pi/engine/adapter.js

@@ -1320,7 +1320,11 @@ export class PiEngineAdapter {
             case "retry":
             case "compact": {
                 const result = await this.#sessionCommands?.execute(command.type === "prompt" || command.type === "steer" || command.type === "follow-up"
-                    ? { type: command.type, text: command.text }
+                    ? {
+                        type: command.type,
+                        text: command.text,
+                        ...(command.images === undefined ? {} : { images: [...command.images] }),
+                    }
                     : { type: command.type });
                 if (!result || result.outcome === "rejected" || result.outcome === "failed") {
                     throw new Error(command.type === "retry" ? "no previous prompt is available to retry" : `Pi session command failed: ${command.type}`);

package/dist/integrations/pi/engine/session-integration.d.ts

@@ -1,4 +1,4 @@
-import type { AgentSession, AgentSessionEvent } from "@earendil-works/pi-coding-agent";
+import type { AgentSession, AgentSessionEvent, PromptOptions } from "@earendil-works/pi-coding-agent";
 import { type AgentCommandOutcome, type AgentEvent } from "../../../contracts/agent-engine/index.js";
 export interface PiDocumentedSessionCommands {
     readonly isStreaming: AgentSession["isStreaming"];
@@ -18,6 +18,7 @@ export interface PiDocumentedSessionCommands {
 export type PiSessionCommand = {
     readonly type: "prompt" | "steer" | "follow-up";
     readonly text: string;
+    readonly images?: NonNullable<PromptOptions["images"]>;
 } | {
     readonly type: "abort" | "retry" | "compact";
 } | {

package/dist/integrations/pi/engine/session-integration.js

@@ -9,18 +9,29 @@ export class PiSessionCommandIntegration {
         switch (command.type) {
             case "prompt":
                 this.#lastPrompt = command.text;
-                await this.session.prompt(command.text, this.session.isStreaming ? { streamingBehavior: "followUp" } : undefined);
+                await this.session.prompt(command.text, command.images === undefined
+                    ? this.session.isStreaming ? { streamingBehavior: "followUp" } : undefined
+                    : {
+                        ...(this.session.isStreaming ? { streamingBehavior: "followUp" } : {}),
+                        images: [...command.images],
+                    });
                 return { outcome: "completed" };
             case "steer":
                 this.#lastPrompt = command.text;
                 // Match interactive Pi: prompt() owns template/extension expansion and
                 // turns the accepted steering message into the visible user row while
                 // later messages remain in the pending queue.
-                await this.session.prompt(command.text, { streamingBehavior: "steer" });
+                await this.session.prompt(command.text, {
+                    streamingBehavior: "steer",
+                    ...(command.images === undefined ? {} : { images: [...command.images] }),
+                });
                 return { outcome: "completed" };
             case "follow-up":
                 this.#lastPrompt = command.text;
-                await this.session.prompt(command.text, { streamingBehavior: "followUp" });
+                await this.session.prompt(command.text, {
+                    streamingBehavior: "followUp",
+                    ...(command.images === undefined ? {} : { images: [...command.images] }),
+                });
                 return { outcome: "completed" };
             case "abort":
                 if (this.session.isRetrying)

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

@@ -0,0 +1,23 @@
+import type { PiShellClipboardContent, PiShellEditorTextRange } from "../components/index.js";
+export interface PromptImageAttachment {
+    readonly type: "image";
+    readonly data: string;
+    readonly mimeType: string;
+}
+export interface PreparedPrompt {
+    readonly text: string;
+    readonly images: readonly PromptImageAttachment[];
+}
+/** Owns semantic clipboard records while the prompt displays compact chips. */
+export declare class PromptChipStore {
+    #private;
+    transformPastedContent(content: PiShellClipboardContent): string;
+    atomicRanges(line: string): readonly PiShellEditorTextRange[];
+    hyperlinkRanges(text: string): readonly {
+        start: number;
+        end: number;
+        target: string;
+    }[];
+    expandCopiedText(text: string): string;
+    prepareSubmission(text: string): PreparedPrompt;
+}

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

@@ -0,0 +1,242 @@
+import { randomBytes } from "node:crypto";
+import { existsSync, statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const CHIP_PATTERN = /\[(?:📷 [^\]]+|📁 [^\]]+|📄 [^\]]+|🖼 {1,2}[^\]]+|🔗 [^\]]+)\]/gu;
+const IMAGE_EXTENSION = /\.(?:jpe?g|png|webp|gif|bmp|tiff?)$/iu;
+const URL_PATTERN = /^https?:\/\/[^\s\u0000-\u001f\u007f]+$/iu;
+const URL_DISPLAY_LENGTH = 40;
+/** Owns semantic clipboard records while the prompt displays compact chips. */
+export class PromptChipStore {
+    #chips = new Map();
+    transformPastedContent(content) {
+        if (content.kind === "image") {
+            const id = randomBytes(5).toString("hex");
+            const tag = `[📷 screenshot-${id}.png]`;
+            this.#chips.set(tag, {
+                kind: "image",
+                tag,
+                image: { type: "image", data: content.data, mimeType: content.mimeType },
+            });
+            return tag;
+        }
+        const text = content.text;
+        if (this.#chips.has(text.trim()))
+            return text.trim();
+        const url = text.trim();
+        if (URL_PATTERN.test(url)) {
+            const label = url.length <= URL_DISPLAY_LENGTH ? url : `${url.slice(0, URL_DISPLAY_LENGTH)}…`;
+            return this.#recordUnique({ kind: "url", tag: `[🔗 ${label}]`, label, url });
+        }
+        const paths = pathsFromClipboard(text);
+        if (paths.length === 0)
+            return text;
+        return paths.map(item => {
+            const label = pathLabel(item.fullPath);
+            if (item.kind === "folder") {
+                return this.#recordUnique({ kind: "folder", tag: `[📁 ${label}]`, path: item.fullPath });
+            }
+            const icon = IMAGE_EXTENSION.test(item.fullPath) ? "🖼 " : "📄";
+            return this.#recordUnique({ kind: "file", tag: `[${icon} ${label}]`, path: item.fullPath });
+        }).join("");
+    }
+    atomicRanges(line) {
+        return [...line.matchAll(CHIP_PATTERN)].map(match => ({
+            start: match.index,
+            end: match.index + match[0].length,
+        }));
+    }
+    hyperlinkRanges(text) {
+        const ranges = [];
+        for (const chip of this.#chips.values()) {
+            if (chip.kind !== "url")
+                continue;
+            const labelOffset = chip.tag.indexOf(chip.label);
+            if (labelOffset < 0)
+                continue;
+            let searchFrom = 0;
+            while (searchFrom <= text.length - chip.tag.length) {
+                const tagStart = text.indexOf(chip.tag, searchFrom);
+                if (tagStart < 0)
+                    break;
+                const start = tagStart + labelOffset;
+                ranges.push({ start, end: start + chip.label.length, target: chip.url });
+                searchFrom = tagStart + chip.tag.length;
+            }
+        }
+        return ranges.sort((left, right) => right.start - left.start);
+    }
+    expandCopiedText(text) {
+        return this.#replaceResolvable(text, false).text;
+    }
+    prepareSubmission(text) {
+        const expanded = this.#replaceResolvable(text, true);
+        return { text: expanded.text, images: expanded.images };
+    }
+    #replaceResolvable(text, includeImages) {
+        let expanded = text;
+        const images = [];
+        const seenImages = new Set();
+        for (const [tag, chip] of this.#chips) {
+            if (!expanded.includes(tag))
+                continue;
+            if (chip.kind === "image") {
+                if (includeImages && !seenImages.has(tag)) {
+                    images.push(chip.image);
+                    seenImages.add(tag);
+                }
+                continue;
+            }
+            const value = chip.kind === "url" ? chip.url : chip.path;
+            expanded = expanded.replaceAll(tag, value);
+        }
+        return { text: expanded, images };
+    }
+    #recordUnique(chip) {
+        const existing = this.#chips.get(chip.tag);
+        if (existing === undefined || sameChipValue(existing, chip)) {
+            this.#chips.set(chip.tag, chip);
+            return chip.tag;
+        }
+        const suffix = randomBytes(2).toString("hex");
+        const uniqueTag = `${chip.tag.slice(0, -1)} #${suffix}]`;
+        const unique = { ...chip, tag: uniqueTag };
+        this.#chips.set(uniqueTag, unique);
+        return uniqueTag;
+    }
+}
+function pathsFromClipboard(text) {
+    const normalized = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+    if (normalized.length === 0)
+        return [];
+    const paths = [];
+    for (const line of normalized.split("\n").filter(value => value.trim().length > 0)) {
+        const wholeLine = existingClipboardPath(line);
+        if (wholeLine !== null) {
+            paths.push(wholeLine);
+            continue;
+        }
+        const tokens = tokenizePathLine(line)?.filter(token => token.quoted || token.text !== "&");
+        if (tokens === undefined || tokens.length === 0)
+            return [];
+        for (let index = 0; index < tokens.length;) {
+            const token = tokens[index];
+            if (token === undefined)
+                return [];
+            if (token.quoted) {
+                const quoted = existingClipboardPath(token.text);
+                if (quoted === null)
+                    return [];
+                paths.push(quoted);
+                index += 1;
+                continue;
+            }
+            if (normalizePath(token.text) === null)
+                return [];
+            let runEnd = index;
+            while (runEnd < tokens.length && tokens[runEnd]?.quoted !== true)
+                runEnd += 1;
+            let matched = null;
+            let matchedEnd = index;
+            for (let end = runEnd; end > index; end -= 1) {
+                matched = existingClipboardPath(tokens.slice(index, end).map(candidate => candidate.text).join(" "));
+                if (matched !== null) {
+                    matchedEnd = end;
+                    break;
+                }
+            }
+            if (matched === null)
+                return [];
+            paths.push(matched);
+            index = matchedEnd;
+        }
+    }
+    return paths;
+}
+function existingClipboardPath(value) {
+    const fullPath = normalizePath(unquote(value.trim()));
+    if (fullPath === null || !existsSync(fullPath))
+        return null;
+    try {
+        const stat = statSync(fullPath);
+        if (stat.isDirectory())
+            return { fullPath, kind: "folder" };
+        if (stat.isFile())
+            return { fullPath, kind: "file" };
+    }
+    catch {
+        // Clipboard path probing is best-effort.
+    }
+    return null;
+}
+function tokenizePathLine(line) {
+    const tokens = [];
+    let index = 0;
+    while (index < line.length) {
+        while (index < line.length && /\s/u.test(line[index] ?? ""))
+            index += 1;
+        if (index >= line.length)
+            break;
+        const quote = line[index] === '"' || line[index] === "'" ? line[index] : undefined;
+        if (quote !== undefined) {
+            index += 1;
+            const start = index;
+            while (index < line.length && line[index] !== quote)
+                index += 1;
+            if (index >= line.length)
+                return undefined;
+            tokens.push({ text: line.slice(start, index), quoted: true });
+            index += 1;
+            if (index < line.length && !/\s/u.test(line[index] ?? ""))
+                return undefined;
+            continue;
+        }
+        const start = index;
+        while (index < line.length && !/\s/u.test(line[index] ?? ""))
+            index += 1;
+        tokens.push({ text: line.slice(start, index), quoted: false });
+    }
+    return tokens;
+}
+function normalizePath(value) {
+    let candidate = value;
+    if (/^file:\/\//iu.test(candidate)) {
+        try {
+            candidate = fileURLToPath(candidate);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (process.platform === "win32") {
+        const msys = /^\/([A-Za-z])\/(.*)$/u.exec(candidate);
+        if (msys !== null)
+            candidate = `${msys[1]}:\\${msys[2]?.replaceAll("/", "\\") ?? ""}`;
+    }
+    return /^(?:[A-Za-z]:\\|\/)/u.test(candidate) ? path.normalize(candidate) : null;
+}
+function unquote(value) {
+    let result = value.startsWith("& ") ? value.slice(2).trim() : value;
+    if ((result.startsWith('"') && result.endsWith('"')) || (result.startsWith("'") && result.endsWith("'"))) {
+        result = result.slice(1, -1).trim();
+    }
+    return result;
+}
+function pathLabel(fullPath) {
+    const basename = path.basename(fullPath);
+    if (basename.length > 0)
+        return basename;
+    return path.parse(fullPath).root.replace(/[\\/]+$/u, "") || fullPath;
+}
+function sameChipValue(left, right) {
+    if (left.kind !== right.kind)
+        return false;
+    if (left.kind === "url" && right.kind === "url")
+        return left.url === right.url;
+    if ((left.kind === "file" || left.kind === "folder") && (right.kind === "file" || right.kind === "folder")) {
+        return path.normalize(left.path) === path.normalize(right.path);
+    }
+    if (left.kind === "image" && right.kind === "image")
+        return left.image.data === right.image.data;
+    return false;
+}

package/dist/integrations/pi/session-ui/route-host.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Compatibility export. Owned application route lifecycle belongs to the
+ * vendor-neutral UI app owner; the Pi shell only hosts that contract.
+ */
+export type { UiRouteHost, UiRouteSurface } from "../../../ui/apps/index.js";

package/dist/integrations/pi/{owned-ui → session-ui}/session-shell-root.d.ts

@@ -1,11 +1,20 @@
 import type { OwnedUiSessionViewModel, OwnedUiViewportSettings, OwnedUiViewportSettingsPort } from "../../../contracts/owned-ui/index.js";
-import type { UiRouteHost } from "./route-host.js";
+import type { UiRouteHost } from "../../../ui/apps/index.js";
 import { type PiEngineAdapter, type PiWorkflowResult } from "../engine/index.js";
-import { type PiShellComponentPort, type PiShellEditorPort, type PiShellExtensionRendererResolver, type PiShellHeaderOptions, type PiShellHeaderPort, type PiShellLoadedResourcesPort, type PiShellResourceEntry, type PiShellTranscriptComponentPort } from "../components/index.js";
+import { type PiShellClipboardContent, type PiShellComponentPort, type PiShellEditorPort, type PiShellExtensionRendererResolver, type PiShellHeaderOptions, type PiShellHeaderPort, type PiShellLoadedResourcesPort, type PiShellResourceEntry, type PiShellTranscriptComponentPort } from "../components/index.js";
 import { type PiTuiComponentPort, type PiTuiLayoutNode, type PiTuiTerminalPort } from "../tui-runtime/index.js";
+import { type PreparedPrompt } from "./prompt-chips.js";
 export type OwnedUiBackendPort = PiEngineAdapter;
 export type OwnedUiTerminalPort = PiTuiTerminalPort;
 type OwnedUiStartupOptions = PiShellHeaderOptions;
+export interface OwnedUiClipboardPort {
+    readText(): Promise<string | null>;
+    readImage?(): Promise<{
+        readonly data: string;
+        readonly mimeType: string;
+    } | null>;
+    writeText?(text: string): Promise<void>;
+}
 export interface OwnedUiSessionShellOptions {
     readonly backend: OwnedUiBackendPort;
     readonly cwd: string;
@@ -20,6 +29,8 @@ export interface OwnedUiSessionShellOptions {
     readonly sessionLayout?: "pinned" | "custom-viewport";
     /** Live profile-local settings, supplied only to the bare-A1 composition. */
     readonly viewportSettings?: OwnedUiViewportSettingsPort;
+    /** Optional platform seam; production uses A1's system clipboard adapter. */
+    readonly clipboard?: OwnedUiClipboardPort;
 }
 export declare class OwnedUiSessionShellRoot implements PiTuiComponentPort {
     #private;
@@ -29,7 +40,7 @@ export declare class OwnedUiSessionShellRoot implements PiTuiComponentPort {
     constructor(view: OwnedUiSessionViewModel, cwd: string, handlers: {
         readonly getColumns: () => number;
         readonly getRows: () => number;
-        readonly requestRender: () => void;
+        readonly requestRender: (force?: boolean) => void;
         readonly onSubmit: (text: string) => void;
         readonly onInterrupt: () => void;
         readonly onClear?: () => void;
@@ -41,7 +52,10 @@ export declare class OwnedUiSessionShellRoot implements PiTuiComponentPort {
         readonly onMessageCopy?: () => void;
         readonly onFollowUp?: () => void;
         readonly onDequeue?: () => void;
+        readonly onCopyText?: (text: string) => void;
+        readonly readClipboardContent?: () => Promise<PiShellClipboardContent | null>;
     }, startup?: PiShellHeaderOptions, agentDir?: string, extensionRenderers?: PiShellExtensionRendererResolver, sessionLayout?: "pinned" | "custom-viewport");
+    preparePromptSubmission(text: string): PreparedPrompt;
     update(view: OwnedUiSessionViewModel): void;
     /**
      * Applies one block: its component is created or updated in place and the order grows