@timurproko/a1 0.1.8-dev.290 → 0.1.8-dev.322

package/dist/integrations/pi/engine/workflow-controllers.d.ts

@@ -17,5 +17,5 @@ export declare class PiWorkflowControllerPort implements AgentWorkflowPort {
     listWorkflows(): Promise<readonly AgentWorkflowDescriptor[]>;
     executeWorkflow(workflowId: string, input: AgentJsonValue, signal?: AbortSignal): Promise<AgentJsonValue>;
 }
-export declare const PI_BUILTIN_WORKFLOW_ROUTES: readonly ("name" | "share" | "model" | "login" | "logout" | "settings" | "reload" | "compact" | "new" | "resume" | "quit" | "session" | "scoped-models" | "export" | "import" | "copy" | "changelog" | "hotkeys" | "fork" | "clone" | "tree" | "trust" | "debug" | "arminsayshi" | "dementedelves")[];
+export declare const PI_BUILTIN_WORKFLOW_ROUTES: readonly ("name" | "share" | "model" | "login" | "logout" | "settings" | "reload" | "compact" | "new" | "resume" | "quit" | "session" | "tree" | "scoped-models" | "export" | "import" | "copy" | "changelog" | "hotkeys" | "fork" | "clone" | "trust" | "debug" | "arminsayshi" | "dementedelves")[];
 export declare const PI_WORKFLOW_CAPABILITIES: readonly WorkflowCapability[];

package/dist/integrations/pi/engine/workflows.d.ts

@@ -178,7 +178,7 @@ export interface PiWorkflowHost {
         readonly stdout: string;
         readonly stderr: string;
     }>;
-    readChangelog(): Promise<string>;
+    readChangelog(sinceVersion?: string): Promise<string>;
 }
 export interface PiBashWorkflowResult {
     readonly command: string;

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

@@ -11,7 +11,7 @@ export interface PreparedPrompt {
 /** Owns semantic chips and bounded pending paste references; cancels background work on reset or disposal. */
 export declare class PromptChipStore {
     #private;
-    beginPaste(currentText: string, read: (signal: AbortSignal) => Promise<PiShellClipboardContent | null>, onError: (error: unknown) => void): {
+    beginPaste(currentText: string, read: (signal: AbortSignal) => Promise<PiShellClipboardContent | null>, onError: (error: unknown) => void, onImage?: () => void): {
         marker: string;
         result: Promise<string>;
     };
@@ -21,6 +21,8 @@ export declare class PromptChipStore {
     resetPastes(text: string): string;
     dispose(): Promise<void>;
     transformPastedContent(content: PiShellClipboardContent, currentText?: string): string;
+    /** Hide provisional clipboard identities until the read identifies an actual image. */
+    hiddenRanges(line: string): readonly PiShellEditorTextRange[];
     atomicRanges(line: string): readonly PiShellEditorTextRange[];
     hyperlinkRanges(text: string): readonly {
         start: number;
@@ -28,5 +30,6 @@ export declare class PromptChipStore {
         target: string;
     }[];
     expandCopiedText(text: string): string;
+    prepareHistoryText(text: string): string;
     prepareSubmission(text: string): PreparedPrompt;
 }

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

@@ -15,27 +15,32 @@ export class PromptChipStore {
     #pending = new Map();
     #preparation = new ImagePreparationClient();
     #stopping = new Set();
-    beginPaste(currentText, read, onError) {
-        const marker = `[📷 preparing-${randomBytes(5).toString("hex")}]`;
+    beginPaste(currentText, read, onError, onImage = () => { }) {
+        const id = randomBytes(5).toString("hex");
+        // Invariant: reserve paste identity immediately, but only display a screenshot after identifying an image.
+        const marker = `[📷 screenshot-${id}]`;
         const job = this.#preparation.start(async (signal) => {
             const content = await read(signal);
             entry.kind = content?.kind === "image" ? "image" : "text";
-            if (content?.kind === "image" && this.#imageCount(currentText) >= 8)
-                throw new ImageAttachmentError("image-count");
+            if (content?.kind === "image") {
+                onImage();
+                if (this.#imageCount(currentText) >= 8)
+                    throw new ImageAttachmentError("image-count");
+            }
             return content;
         });
         const entry = { marker, job, references: 0, kind: "unknown", completion: job.result.then(content => {
                 if (content === null)
                     return "";
                 if (content.kind === "image") {
-                    return this.#addPreparedImage(content);
+                    return this.#addPreparedImage(content, id);
                 }
                 return this.transformPastedContent(content);
             }).catch(error => {
                 entry.error = error instanceof ImageAttachmentError ? error : new ImageAttachmentError("image-codec");
                 if (entry.error.code !== "image-canceled" && entry.references === 0)
                     onError(entry.error);
-                return marker.replace("preparing-", "failed-");
+                return marker.replace("screenshot-", "failed-");
             }).then(replacement => {
                 entry.replacement = replacement;
                 return replacement;
@@ -95,12 +100,17 @@ export class PromptChipStore {
     }
     async dispose() { await Promise.all([this.#preparation.dispose(), ...this.#stopping]); }
     #imageCount(text) {
-        const regular = [...this.#chips.values()].filter(chip => chip.kind === "image" && text.includes(chip.tag)).length;
-        return regular + [...this.#pending.values()].filter(entry => entry.kind !== "text" && (text.includes(entry.marker) || text.includes(entry.marker.replace("preparing-", "failed-")))).length;
+        const tags = new Set([...this.#chips.values()].filter(chip => chip.kind === "image" && text.includes(chip.tag)).map(chip => chip.tag));
+        for (const entry of this.#pending.values()) {
+            if (entry.kind !== "text" && (text.includes(entry.marker) || text.includes(entry.marker.replace("screenshot-", "failed-")))) {
+                // Invariant: a ready screenshot can retain its pending label but still occupies only one slot.
+                tags.add(entry.replacement ?? entry.marker);
+            }
+        }
+        return tags.size;
     }
-    #addPreparedImage(image) {
-        const suffix = image.mimeType === "image/jpeg" ? "jpg" : image.mimeType.split("/")[1] ?? "png";
-        const tag = `[📷 screenshot-${randomBytes(5).toString("hex")}${image.transformed ? "-resized" : ""}.${suffix}]`;
+    #addPreparedImage(image, id) {
+        const tag = `[📷 screenshot-${id}${image.transformed ? "-resized" : ""}]`;
         const attachment = Object.freeze({ type: "image", data: image.data, mimeType: image.mimeType });
         assertPromptImages([attachment]);
         this.#chips.set(tag, { kind: "image", tag, image: attachment });
@@ -114,7 +124,7 @@ export class PromptChipStore {
                 return "";
             assertPromptImages([...this.prepareSubmission(currentText).images, { type: "image", ...image }]);
             const id = randomBytes(5).toString("hex");
-            const tag = `[📷 screenshot-${id}.png]`;
+            const tag = `[📷 screenshot-${id}]`;
             this.#chips.set(tag, {
                 kind: "image",
                 tag,
@@ -142,6 +152,20 @@ export class PromptChipStore {
             return this.#recordUnique({ kind: "file", tag: `[${icon} ${label}]`, path: item.fullPath });
         }).join("");
     }
+    /** Hide provisional clipboard identities until the read identifies an actual image. */
+    hiddenRanges(line) {
+        const ranges = [];
+        for (const entry of this.#pending.values()) {
+            if (entry.kind === "image")
+                continue;
+            let from = 0;
+            while ((from = line.indexOf(entry.marker, from)) >= 0) {
+                ranges.push({ start: from, end: from + entry.marker.length });
+                from += entry.marker.length;
+            }
+        }
+        return ranges.sort((left, right) => left.start - right.start);
+    }
     atomicRanges(line) {
         return [...line.matchAll(CHIP_PATTERN)].map(match => ({
             start: match.index,
@@ -171,6 +195,9 @@ export class PromptChipStore {
     expandCopiedText(text) {
         return this.#replaceResolvable(text, false).text;
     }
+    prepareHistoryText(text) {
+        return this.#replaceResolvable(text, false).text.replace(CHIP_PATTERN, tag => this.#chips.get(tag)?.kind === "image" ? "" : tag).trim();
+    }
     prepareSubmission(text) {
         const expanded = this.#replaceResolvable(text, true);
         return { text: expanded.text, images: expanded.images };
@@ -178,7 +205,7 @@ export class PromptChipStore {
     #replaceResolvable(text, includeImages) {
         let expanded = text;
         for (const entry of this.#pending.values()) {
-            if (!expanded.includes(entry.marker) && !expanded.includes(entry.marker.replace("preparing-", "failed-")))
+            if (!expanded.includes(entry.marker) && !expanded.includes(entry.marker.replace("screenshot-", "failed-")))
                 continue;
             if (includeImages && entry.error !== undefined)
                 throw entry.error;

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

@@ -0,0 +1,30 @@
+import { type PromptHistoryKind, type PromptHistoryPort } from "../../../contracts/owned-ui/index.js";
+import type { PiShellEditorPort } from "../components/index.js";
+/** Merges bounded recall snapshots; the editor alone owns browsing, draft, cursor, and undo state. */
+export declare class PromptHistoryController {
+    #private;
+    readonly options: {
+        editor: PiShellEditorPort;
+        store: PromptHistoryPort;
+        limit: number;
+        fallback: readonly string[];
+        active(): boolean;
+        render(): void;
+        failure(message: string): void;
+    };
+    constructor(options: {
+        editor: PiShellEditorPort;
+        store: PromptHistoryPort;
+        limit: number;
+        fallback: readonly string[];
+        active(): boolean;
+        render(): void;
+        failure(message: string): void;
+    });
+    start(): void;
+    capture(text: string, kind: PromptHistoryKind, cwd: string, sessionId: string): void;
+    rememberRecovery(text: string): void;
+    synchronize(): void;
+    reset(fallback: readonly string[]): void;
+    close(): Promise<boolean>;
+}

package/dist/integrations/pi/session-ui/prompt-history-controller.js

@@ -0,0 +1,147 @@
+import { randomUUID } from "node:crypto";
+import { PROMPT_HISTORY_MAX_TEXT_BYTES } from "../../../contracts/owned-ui/index.js";
+/** Merges bounded recall snapshots; the editor alone owns browsing, draft, cursor, and undo state. */
+export class PromptHistoryController {
+    options;
+    #local = new Map();
+    #unsubscribe;
+    #snapshot;
+    #fallback;
+    #disposed = false;
+    #generation = 0;
+    #unsubscribeSnapshot;
+    #unsubscribeFailure;
+    #closeFailed = false;
+    #closePromise;
+    constructor(options) {
+        this.options = options;
+        if (options.editor.recall === undefined)
+            throw new Error("The selected editor does not expose typed history");
+        this.#snapshot = { revision: 0, limit: options.limit, entries: [] };
+        this.#fallback = boundedTexts([...options.fallback].reverse(), options.limit);
+        this.#unsubscribeSnapshot = this.#subscribeSnapshot();
+        this.#unsubscribeFailure = options.store.onFailure(code => {
+            if (this.#disposed)
+                this.#closeFailed = true;
+            else
+                options.failure(`Prompt history ${code}; current-session recall remains available.`);
+        });
+        this.#unsubscribe = [
+            options.editor.recall.observe(() => {
+                if (this.#disposed)
+                    return;
+                if (options.editor.recall.position().index === -1)
+                    this.synchronize();
+                options.store.refresh();
+            }),
+        ];
+        this.synchronize();
+    }
+    start() { this.options.store.start(); }
+    capture(text, kind, cwd, sessionId) {
+        const canonical = text.trim();
+        if (!canonical || this.#disposed)
+            return;
+        const id = randomUUID();
+        const generation = this.#generation;
+        this.#local.set(id, { text: canonical, committed: false });
+        this.#boundLocal();
+        this.synchronize();
+        void this.options.store.record({ id, text: canonical, timestamp: Date.now(), kind, cwd, sessionId }).then(outcome => {
+            if (this.#disposed || generation !== this.#generation)
+                return;
+            const local = this.#local.get(id);
+            if (local === undefined || outcome !== "committed")
+                return;
+            local.committed = true;
+            if (this.#snapshot.entries.some(entry => entry.submissionId === id))
+                this.#local.delete(id);
+            this.synchronize();
+        }).catch(() => {
+            if (!this.#disposed)
+                this.options.failure("Prompt history unavailable; current-session recall remains available.");
+        });
+    }
+    rememberRecovery(text) {
+        if (this.#disposed || !text.trim())
+            return;
+        const canonical = text.trim();
+        if ([...this.#local.values()].some(item => item.text === canonical)
+            || this.#snapshot.entries.some(item => item.text === canonical))
+            return;
+        this.#local.set(randomUUID(), { text: canonical, committed: false });
+        this.#boundLocal();
+        this.synchronize();
+    }
+    synchronize() {
+        if (this.#disposed || !this.options.active())
+            return;
+        const values = [...this.#local.values()].reverse().map(item => item.text)
+            .concat(this.#snapshot.entries.map(item => item.text), this.#fallback);
+        this.options.editor.recall.replace(boundedTexts(values, this.#snapshot.limit));
+        this.options.render();
+    }
+    reset(fallback) {
+        this.#generation++;
+        this.#unsubscribeSnapshot();
+        this.#unsubscribeSnapshot = this.#subscribeSnapshot();
+        this.#fallback = boundedTexts([...fallback].reverse(), this.options.limit);
+        this.#local.clear();
+        this.options.editor.recall.reset();
+        this.synchronize();
+        this.options.store.refresh();
+    }
+    close() {
+        if (this.#closePromise !== undefined)
+            return this.#closePromise;
+        this.#disposed = true;
+        this.#unsubscribeSnapshot();
+        for (const unsubscribe of this.#unsubscribe)
+            unsubscribe();
+        this.#local.clear();
+        this.#fallback = [];
+        this.#closePromise = this.options.store.close().then(() => !this.#closeFailed, () => false)
+            .finally(() => this.#unsubscribeFailure());
+        return this.#closePromise;
+    }
+    #subscribeSnapshot() {
+        const generation = this.#generation;
+        return this.options.store.onSnapshot(snapshot => {
+            if (this.#disposed || generation !== this.#generation || snapshot.revision < this.#snapshot.revision)
+                return;
+            this.#snapshot = snapshot;
+            for (const [id, entry] of this.#local) {
+                if (entry.committed)
+                    this.#local.delete(id);
+            }
+            this.synchronize();
+        });
+    }
+    #boundLocal() {
+        let bytes = [...this.#local.values()].reduce((sum, item) => sum + Buffer.byteLength(item.text), 0);
+        while (this.#local.size > this.options.limit || bytes > PROMPT_HISTORY_MAX_TEXT_BYTES) {
+            const id = this.#local.keys().next().value;
+            bytes -= Buffer.byteLength(this.#local.get(id).text);
+            this.#local.delete(id);
+        }
+    }
+}
+function boundedTexts(values, limit) {
+    const result = [];
+    const seen = new Set();
+    let bytes = 0;
+    for (const value of values) {
+        const text = value.trim();
+        if (!text || seen.has(text))
+            continue;
+        const size = Buffer.byteLength(text);
+        if (bytes + size > PROMPT_HISTORY_MAX_TEXT_BYTES)
+            continue;
+        result.push(text);
+        seen.add(text);
+        bytes += size;
+        if (result.length >= limit)
+            break;
+    }
+    return result;
+}

package/dist/integrations/pi/session-ui/session-shell-root.d.ts

@@ -18,6 +18,11 @@ export interface OwnedUiClipboardPort {
     writeText?(text: string): Promise<void>;
 }
 export interface OwnedUiSessionShellOptions {
+    readonly promptHistory?: {
+        readonly store: import("../../../contracts/owned-ui/index.js").PromptHistoryPort;
+        readonly limit: number;
+        readonly editor: import("../components/index.js").HistoryEditorConstructor;
+    };
     readonly backend: OwnedUiBackendPort;
     readonly cwd: string;
     readonly terminal?: OwnedUiTerminalPort;
@@ -67,6 +72,8 @@ export declare class OwnedUiSessionShellRoot implements PiTuiComponentPort {
         readonly onViewportFrame?: (frame: TranscriptViewportFrame) => void;
         readonly requestHyperlinkCleanup?: () => void;
         readonly enableDockInputReuse?: boolean;
+        readonly persistentHistory?: boolean;
+        readonly historyEditor?: import("../components/index.js").HistoryEditorConstructor;
         readonly onSubmit: (text: string) => void;
         readonly onPasteRejected?: (error: unknown) => void;
         readonly onInterrupt: () => void;
@@ -91,6 +98,7 @@ export declare class OwnedUiSessionShellRoot implements PiTuiComponentPort {
     setHideThinkingBlock(hidden: boolean): void;
     setMermaidRenderingMode(mode: "off" | "final" | "streaming"): void;
     setImagePresentation(showImages: boolean, imageWidthCells: number): void;
+    prepareHistoryText(text: string): string;
     preparePromptSubmission(text: string): PreparedPrompt;
     hasPendingPastes(text: string): boolean;
     waitForPromptPastes(text: string, signal: AbortSignal): Promise<PreparedPrompt>;
@@ -108,6 +116,31 @@ export declare class OwnedUiSessionShellRoot implements PiTuiComponentPort {
     applyTranscriptBlock(block: OwnedUiSessionViewModel["transcript"][number]): void;
     render(width: number): readonly string[];
     viewportFrameDescriptor(): TranscriptViewportFrameDescriptor | null;
+    /** Read-only, payload-free evidence; observing a pending frame must never render or repair it. */
+    viewportPresentationEvidence(): {
+        candidate: boolean;
+        candidateRevision: number | null;
+        currentRevision: number;
+        composedRevision: number | null;
+        currentPointer: {
+            readonly column: number;
+            readonly row: number;
+        } | null;
+        composedPointer: {
+            readonly column: number;
+            readonly row: number;
+        } | null;
+        frameId: number | null;
+        bottom: {
+            readonly row: number;
+            readonly columnStart: number;
+            readonly columnEnd: number;
+        } | null;
+        followingEnd: boolean;
+        scrollTop: number;
+        maxScroll: number;
+        cause: "detached" | "initial" | "steady" | "dock-input" | "follow-shift" | "geometry-change" | null;
+    };
     /** Visible non-selectable Steering, alignment, and Working rows, for rendering evidence. */
     viewportTransientTailRowCount(): number;
     hasActiveSelection(): boolean;