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

package/dist/integrations/pi/components/upstream/history/kill-ring.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Adapted from @earendil-works/pi-tui 0.84.2, packages/tui/src/kill-ring.ts (MIT).
+ * Source commit: 914cf1472e715297caa30db4b9535d534a9eb718.
+ * Modifications: public imports and owned editor-local typed seams; see docs/architecture/history-editor-provenance.md.
+ */
+/**
+ * Ring buffer for Emacs-style kill/yank operations.
+ *
+ * Tracks killed (deleted) text entries. Consecutive kills can accumulate
+ * into a single entry. Supports yank (paste most recent) and yank-pop
+ * (cycle through older entries).
+ */
+export declare class KillRing {
+    private ring;
+    /**
+     * Add text to the kill ring.
+     *
+     * @param text - The killed text to add
+     * @param opts - Push options
+     * @param opts.prepend - If accumulating, prepend (backward deletion) or append (forward deletion)
+     * @param opts.accumulate - Merge with the most recent entry instead of creating a new one
+     */
+    push(text: string, opts: {
+        prepend: boolean;
+        accumulate?: boolean;
+    }): void;
+    /** Get most recent entry without modifying the ring. */
+    peek(): string | undefined;
+    /** Move last entry to front (for yank-pop cycling). */
+    rotate(): void;
+    get length(): number;
+}

package/dist/integrations/pi/components/upstream/history/kill-ring.js

@@ -0,0 +1,48 @@
+/**
+ * Adapted from @earendil-works/pi-tui 0.84.2, packages/tui/src/kill-ring.ts (MIT).
+ * Source commit: 914cf1472e715297caa30db4b9535d534a9eb718.
+ * Modifications: public imports and owned editor-local typed seams; see docs/architecture/history-editor-provenance.md.
+ */
+/**
+ * Ring buffer for Emacs-style kill/yank operations.
+ *
+ * Tracks killed (deleted) text entries. Consecutive kills can accumulate
+ * into a single entry. Supports yank (paste most recent) and yank-pop
+ * (cycle through older entries).
+ */
+export class KillRing {
+    ring = [];
+    /**
+     * Add text to the kill ring.
+     *
+     * @param text - The killed text to add
+     * @param opts - Push options
+     * @param opts.prepend - If accumulating, prepend (backward deletion) or append (forward deletion)
+     * @param opts.accumulate - Merge with the most recent entry instead of creating a new one
+     */
+    push(text, opts) {
+        if (!text)
+            return;
+        if (opts.accumulate && this.ring.length > 0) {
+            const last = this.ring.pop();
+            this.ring.push(opts.prepend ? text + last : last + text);
+        }
+        else {
+            this.ring.push(text);
+        }
+    }
+    /** Get most recent entry without modifying the ring. */
+    peek() {
+        return this.ring.length > 0 ? this.ring[this.ring.length - 1] : undefined;
+    }
+    /** Move last entry to front (for yank-pop cycling). */
+    rotate() {
+        if (this.ring.length > 1) {
+            const last = this.ring.pop();
+            this.ring.unshift(last);
+        }
+    }
+    get length() {
+        return this.ring.length;
+    }
+}

package/dist/integrations/pi/components/upstream/history/printable-key.d.ts

@@ -0,0 +1 @@
+export declare function decodePrintableKey(data: string): string | undefined;

package/dist/integrations/pi/components/upstream/history/printable-key.js

@@ -0,0 +1,40 @@
+/**
+ * Adapted from @earendil-works/pi-tui 0.84.2, packages/tui/src/keys.ts (MIT).
+ * Source commit: 914cf1472e715297caa30db4b9535d534a9eb718.
+ * Modifications: public imports and owned editor-local typed seams; see docs/architecture/history-editor-provenance.md.
+ */
+import { decodeKittyPrintable } from "#pi-tui";
+const MODIFIERS = {
+    shift: 1,
+    alt: 2,
+    ctrl: 4,
+    super: 8,
+};
+const LOCK_MASK = 64 + 128;
+function parseModifyOtherKeysSequence(data) {
+    const match = data.match(/^\x1b\[27;(\d+);(\d+)~$/);
+    if (!match)
+        return null;
+    const modValue = parseInt(match[1], 10);
+    const codepoint = parseInt(match[2], 10);
+    return { codepoint, modifier: modValue - 1 };
+}
+function decodeModifyOtherKeysPrintable(data) {
+    const parsed = parseModifyOtherKeysSequence(data);
+    if (!parsed)
+        return undefined;
+    const modifier = parsed.modifier & ~LOCK_MASK;
+    if ((modifier & ~MODIFIERS.shift) !== 0)
+        return undefined;
+    if (!Number.isFinite(parsed.codepoint) || parsed.codepoint < 32)
+        return undefined;
+    try {
+        return String.fromCodePoint(parsed.codepoint);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function decodePrintableKey(data) {
+    return decodeKittyPrintable(data) ?? decodeModifyOtherKeysPrintable(data);
+}

package/dist/integrations/pi/components/upstream/history/text-helpers.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Get the shared grapheme segmenter instance.
+ */
+export declare function getGraphemeSegmenter(): Intl.Segmenter;
+/**
+ * Get the shared word segmenter instance.
+ */
+export declare function getWordSegmenter(): Intl.Segmenter;
+export declare const cjkBreakRegex: RegExp;
+export declare const PUNCTUATION_REGEX: RegExp;
+/**
+ * Check if a character is whitespace.
+ */
+export declare function isWhitespaceChar(char: string): boolean;

package/dist/integrations/pi/components/upstream/history/text-helpers.js

@@ -0,0 +1,28 @@
+/**
+ * Adapted from @earendil-works/pi-tui 0.84.2, packages/tui/src/utils.ts (MIT).
+ * Source commit: 914cf1472e715297caa30db4b9535d534a9eb718.
+ * Modifications: public imports and owned editor-local typed seams; see docs/architecture/history-editor-provenance.md.
+ */
+// segmenters (shared instance)
+const graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+const wordSegmenter = new Intl.Segmenter(undefined, { granularity: "word" });
+/**
+ * Get the shared grapheme segmenter instance.
+ */
+export function getGraphemeSegmenter() {
+    return graphemeSegmenter;
+}
+/**
+ * Get the shared word segmenter instance.
+ */
+export function getWordSegmenter() {
+    return wordSegmenter;
+}
+export const cjkBreakRegex = /[\p{Script_Extensions=Han}\p{Script_Extensions=Hiragana}\p{Script_Extensions=Katakana}\p{Script_Extensions=Hangul}\p{Script_Extensions=Bopomofo}]/u;
+export const PUNCTUATION_REGEX = /[(){}[\]<>.,;:'"!?+\-=*/\\|&%^$#@~`]/;
+/**
+ * Check if a character is whitespace.
+ */
+export function isWhitespaceChar(char) {
+    return /\s/.test(char);
+}

package/dist/integrations/pi/components/upstream/history/undo-stack.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Adapted from @earendil-works/pi-tui 0.84.2, packages/tui/src/undo-stack.ts (MIT).
+ * Source commit: 914cf1472e715297caa30db4b9535d534a9eb718.
+ * Modifications: public imports and owned editor-local typed seams; see docs/architecture/history-editor-provenance.md.
+ */
+/**
+ * Generic undo stack with clone-on-push semantics.
+ *
+ * Stores deep clones of state snapshots. Popped snapshots are returned
+ * directly (no re-cloning) since they are already detached.
+ */
+export declare class UndoStack<S> {
+    private stack;
+    /** Push a deep clone of the given state onto the stack. */
+    push(state: S): void;
+    /** Pop and return the most recent snapshot, or undefined if empty. */
+    pop(): S | undefined;
+    /** Remove all snapshots. */
+    clear(): void;
+    updateSnapshots(update: (snapshot: S) => void): void;
+    get length(): number;
+}

package/dist/integrations/pi/components/upstream/history/undo-stack.js

@@ -0,0 +1,36 @@
+/**
+ * Adapted from @earendil-works/pi-tui 0.84.2, packages/tui/src/undo-stack.ts (MIT).
+ * Source commit: 914cf1472e715297caa30db4b9535d534a9eb718.
+ * Modifications: public imports and owned editor-local typed seams; see docs/architecture/history-editor-provenance.md.
+ */
+/**
+ * Generic undo stack with clone-on-push semantics.
+ *
+ * Stores deep clones of state snapshots. Popped snapshots are returned
+ * directly (no re-cloning) since they are already detached.
+ */
+export class UndoStack {
+    stack = [];
+    /** Push a deep clone of the given state onto the stack. */
+    push(state) {
+        this.stack.push(structuredClone(state));
+    }
+    /** Pop and return the most recent snapshot, or undefined if empty. */
+    pop() {
+        return this.stack.pop();
+    }
+    /** Remove all snapshots. */
+    clear() {
+        this.stack.length = 0;
+    }
+    updateSnapshots(update) {
+        this.stack = this.stack.map(snapshot => {
+            const copy = structuredClone(snapshot);
+            update(copy);
+            return copy;
+        });
+    }
+    get length() {
+        return this.stack.length;
+    }
+}

package/dist/integrations/pi/components/upstream/history/word-navigation.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Options for word navigation functions.
+ * When omitted, uses the default Intl.Segmenter word segmentation.
+ */
+export interface WordNavigationOptions {
+    /** Custom segmenter returning word segments for the given text. */
+    segment?: (text: string) => Iterable<Intl.SegmentData>;
+    /** Predicate identifying atomic segments that should be treated as single units (e.g. paste markers). */
+    isAtomicSegment?: (segment: string) => boolean;
+}
+/**
+ * Find the cursor position after moving one word backward from `cursor` in `text`.
+ * Skips trailing whitespace, then stops at the next word/punctuation boundary.
+ *
+ * Pure function - does not mutate any state.
+ */
+export declare function findWordBackward(text: string, cursor: number, options?: WordNavigationOptions): number;
+/**
+ * Find the cursor position after moving one word forward from `cursor` in `text`.
+ * Skips leading whitespace, then stops at the next word/punctuation boundary.
+ *
+ * Pure function - does not mutate any state.
+ */
+export declare function findWordForward(text: string, cursor: number, options?: WordNavigationOptions): number;

package/dist/integrations/pi/components/upstream/history/word-navigation.js

@@ -0,0 +1,100 @@
+/**
+ * Adapted from @earendil-works/pi-tui 0.84.2, packages/tui/src/word-navigation.ts (MIT).
+ * Source commit: 914cf1472e715297caa30db4b9535d534a9eb718.
+ * Modifications: public imports and owned editor-local typed seams; see docs/architecture/history-editor-provenance.md.
+ */
+import { getWordSegmenter, isWhitespaceChar, PUNCTUATION_REGEX } from "./text-helpers.js";
+const wordSegmenter = getWordSegmenter();
+/**
+ * Find the cursor position after moving one word backward from `cursor` in `text`.
+ * Skips trailing whitespace, then stops at the next word/punctuation boundary.
+ *
+ * Pure function - does not mutate any state.
+ */
+export function findWordBackward(text, cursor, options) {
+    if (cursor <= 0)
+        return 0;
+    const textBeforeCursor = text.slice(0, cursor);
+    const segmentFn = options?.segment;
+    const isAtomic = options?.isAtomicSegment;
+    const segments = segmentFn ? [...segmentFn(textBeforeCursor)] : [...wordSegmenter.segment(textBeforeCursor)];
+    let newCursor = cursor;
+    // Skip trailing whitespace
+    while (segments.length > 0 &&
+        !isAtomic?.(segments[segments.length - 1]?.segment || "") &&
+        isWhitespaceChar(segments[segments.length - 1]?.segment || "")) {
+        newCursor -= segments.pop()?.segment.length || 0;
+    }
+    if (segments.length === 0)
+        return newCursor;
+    const last = segments[segments.length - 1];
+    if (isAtomic?.(last.segment)) {
+        // Skip one atomic segment.
+        newCursor -= last.segment.length;
+    }
+    else if (last.isWordLike) {
+        // Skip inside one word-like segment, preserving ASCII punctuation boundaries.
+        const segment = last.segment;
+        const matches = [...segment.matchAll(new RegExp(PUNCTUATION_REGEX, "g"))];
+        if (matches.length <= 0) {
+            newCursor -= segment.length;
+        }
+        else {
+            const lastMatch = matches[matches.length - 1];
+            newCursor -= segment.length - (lastMatch.index + lastMatch[0].length);
+        }
+    }
+    else {
+        // Skip non-word non-whitespace run (punctuation)
+        while (segments.length > 0 &&
+            !isAtomic?.(segments[segments.length - 1]?.segment || "") &&
+            !segments[segments.length - 1]?.isWordLike &&
+            !isWhitespaceChar(segments[segments.length - 1]?.segment || "")) {
+            newCursor -= segments.pop()?.segment.length || 0;
+        }
+    }
+    return newCursor;
+}
+/**
+ * Find the cursor position after moving one word forward from `cursor` in `text`.
+ * Skips leading whitespace, then stops at the next word/punctuation boundary.
+ *
+ * Pure function - does not mutate any state.
+ */
+export function findWordForward(text, cursor, options) {
+    if (cursor >= text.length)
+        return text.length;
+    const textAfterCursor = text.slice(cursor);
+    const segmentFn = options?.segment;
+    const isAtomic = options?.isAtomicSegment;
+    const segments = segmentFn ? segmentFn(textAfterCursor) : wordSegmenter.segment(textAfterCursor);
+    const iterator = segments[Symbol.iterator]();
+    let next = iterator.next();
+    let newCursor = cursor;
+    // Skip leading whitespace
+    while (!next.done && !isAtomic?.(next.value.segment) && isWhitespaceChar(next.value.segment)) {
+        newCursor += next.value.segment.length;
+        next = iterator.next();
+    }
+    if (next.done)
+        return newCursor;
+    if (isAtomic?.(next.value.segment)) {
+        // Skip one atomic segment.
+        newCursor += next.value.segment.length;
+    }
+    else if (next.value.isWordLike) {
+        // Skip inside one word-like segment, preserving ASCII punctuation boundaries.
+        newCursor += PUNCTUATION_REGEX.exec(next.value.segment)?.index ?? next.value.segment.length;
+    }
+    else {
+        // Skip non-word non-whitespace run (punctuation)
+        while (!next.done &&
+            !isAtomic?.(next.value.segment) &&
+            !next.value.isWordLike &&
+            !isWhitespaceChar(next.value.segment)) {
+            newCursor += next.value.segment.length;
+            next = iterator.next();
+        }
+    }
+    return newCursor;
+}

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

@@ -1,5 +1,5 @@
 import type { PiSessionForkPrompt, PiSessionSelection } from "./session-selection.js";
-import { type AgentSessionRuntime, type AgentSessionServices, type SessionInfo } from "@earendil-works/pi-coding-agent";
+import { type AgentSession, type AgentSessionRuntime, type AgentSessionServices, type SessionInfo } from "@earendil-works/pi-coding-agent";
 import { OWNED_UI_EXTENSION_CONTRACT_VERSION, OWNED_UI_EXTENSION_RENDER_CALLBACKS, OWNED_UI_EXTENSION_UI_CALLBACKS, OWNED_UI_EXTENSION_UI_PROPERTIES, type OwnedUiCommand, type OwnedUiCommandOutcome, type OwnedUiImageAttachment, type OwnedUiPromptSuggestionGeneratorPort, type OwnedUiPromptSuggestionRequest, type OwnedUiPromptSuggestionResult, type OwnedUiEvent, type OwnedUiSessionViewModel, type OwnedUiSnapshot } from "../../../contracts/owned-ui/index.js";
 import { type PiAuthenticationProviderOption, type PiBashWorkflowResult, type PiPinnedSettingsCallback, type PiPinnedSettingsSnapshot, type PiWorkflowAutocompleteCommand, type PiWorkflowHost, type PiWorkflowInteractionHost, type PiWorkflowOption, type PiWorkflowRequest, type PiWorkflowResult } from "./workflows.js";
 import { PiSettingsIntegration } from "./settings-integration.js";
@@ -176,16 +176,28 @@ export declare class PiEngineAdapter implements OwnedUiPromptSuggestionGenerator
         readonly title: string;
         readonly options: readonly PiWorkflowOption[];
     };
+    pinnedAmbientAuthentication(selection: string): {
+        readonly providerId: string;
+        readonly providerName: string;
+        readonly title: string;
+        readonly message: string;
+    } | null;
     pinnedLogoutOptions(): Promise<readonly PiAuthenticationProviderOption[]>;
     pinnedForkOptions(): readonly PiWorkflowOption[];
     pinnedTreeSelectorContext(): PiTreeSelectorContext;
     pinnedSettingsSnapshot(): PiPinnedSettingsSnapshot;
     pinnedMessageRenderer(customType: string): unknown;
+    pinnedShortcutDescriptions(bindings: Parameters<AgentSession["extensionRunner"]["getShortcuts"]>[0]): readonly {
+        readonly key: string;
+        readonly description: string;
+    }[];
     pinnedToolDefinition(toolName: string): unknown;
+    copyWorkflowText(text: string): Promise<void>;
     clearQueuedWorkflows(): readonly string[];
     abortBashWorkflow(): void;
     executeBashWorkflow(command: string, excludeFromContext: boolean): Promise<PiBashWorkflowResult>;
     applyPinnedSettingValue(callback: PiPinnedSettingsCallback, value: unknown): Promise<PiWorkflowResult>;
+    reloadBlockedResult(): PiWorkflowResult | null;
     executeWorkflow(request: PiWorkflowRequest): Promise<PiWorkflowResult>;
     view(): OwnedUiSessionViewModel;
     snapshot(): OwnedUiSnapshot;

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

@@ -7,6 +7,7 @@ import { dirname, join, resolve } from "node:path";
 import { promisify } from "node:util";
 import { PRODUCT_IDENTITY } from "../../../product-identity.js";
 import { configureOwnedHttpDispatcher } from "./http-dispatcher.js";
+import { readPinnedCommandChangelog } from "./changelog.js";
 import { copyToClipboard, CredentialSynchronizationError, DefaultPackageManager, getAgentDir, ProjectTrustStore, SessionManager, VERSION, } from "@earendil-works/pi-coding-agent";
 import { OWNED_UI_EXTENSION_CONTRACT_VERSION, OWNED_UI_EXTENSION_RENDER_CALLBACKS, OWNED_UI_EXTENSION_UI_CALLBACKS, OWNED_UI_EXTENSION_UI_PROPERTIES, CONTEXTUAL_PROMPT_SUGGESTION_INSTRUCTION, assertOwnedUiCommand, assertOwnedUiExtensionUiPort, assertOwnedUiPromptSuggestionRequest, assertOwnedUiPromptSuggestionResult, assertOwnedUiSnapshot, normalizePromptSuggestionCandidate, } from "../../../contracts/owned-ui/index.js";
 import { PINNED_PI_SETTINGS_CALLBACKS, PINNED_PI_WORKFLOW_COMMAND_NAMES, } from "./workflows.js";
@@ -308,14 +309,22 @@ export class PiEngineAdapter {
         if (!settingsManager || typeof settingsManager.getLastChangelogVersion !== "function"
             || typeof settingsManager.setLastChangelogVersion !== "function")
             return;
-        if (settingsManager.getLastChangelogVersion() === VERSION)
+        if ((this.#session?.messages.length ?? 0) > 0)
             return;
-        const markdown = await this.#workflowHost.readChangelog().catch(() => "");
+        const lastVersion = settingsManager.getLastChangelogVersion();
+        if (lastVersion === VERSION)
+            return;
+        if (!lastVersion) {
+            settingsManager.setLastChangelogVersion(VERSION);
+            await settingsManager.flush();
+            return;
+        }
+        const markdown = await this.#workflowHost.readChangelog(lastVersion).catch(() => "");
         if (markdown.trim().length > 0) {
             this.#addDiagnostic("info", settingsManager.getCollapseChangelog() ? "changelog-collapsed" : "changelog-expanded", markdown, true);
+            settingsManager.setLastChangelogVersion(VERSION);
+            await settingsManager.flush();
         }
-        settingsManager.setLastChangelogVersion(VERSION);
-        await settingsManager.flush();
     }
     async #announcePackageUpdates(settingsManager) {
         if (process.env.PI_OFFLINE)
@@ -877,6 +886,17 @@ export class PiEngineAdapter {
         }));
         return { title: `Select authentication method for ${providerName}:`, options };
     }
+    pinnedAmbientAuthentication(selection) {
+        if (!selection.startsWith("api_key:"))
+            return null;
+        const providerId = selection.slice("api_key:".length);
+        const provider = this.#runtime?.services.modelRuntime.getProvider?.(providerId);
+        const method = dynamicObject(dynamicObject(provider, "auth"), "apiKey");
+        if (!method || typeof method.login === "function")
+            return null;
+        const providerName = stringProperty(provider, "name") ?? providerId;
+        return { providerId, providerName, title: `${providerName} setup`, message: `${stringProperty(method, "name") ?? "Authentication"} is configured outside pi.` };
+    }
     pinnedLogoutOptions() {
         return this.#logoutOptions();
     }
@@ -957,9 +977,16 @@ export class PiEngineAdapter {
     pinnedMessageRenderer(customType) {
         return this.#requireWorkflowSession().extensionRunner?.getMessageRenderer?.(customType);
     }
+    pinnedShortcutDescriptions(bindings) {
+        const shortcuts = this.#requireWorkflowSession().extensionRunner?.getShortcuts?.(bindings);
+        return shortcuts === undefined ? [] : [...shortcuts].map(([key, shortcut]) => ({ key, description: shortcut.description ?? shortcut.extensionPath }));
+    }
     pinnedToolDefinition(toolName) {
         return this.#requireWorkflowSession().extensionRunner?.getToolDefinition?.(toolName);
     }
+    async copyWorkflowText(text) {
+        await this.#workflowHost.copyText(text);
+    }
     clearQueuedWorkflows() {
         const session = this.#requireWorkflowSession();
         const result = session.clearQueue?.();
@@ -992,6 +1019,14 @@ export class PiEngineAdapter {
             return workflowResult("settings", "failed", error instanceof Error ? error.message : String(error));
         }
     }
+    reloadBlockedResult() {
+        const session = this.#requireWorkflowSession();
+        if (session.isStreaming)
+            return workflowResult("reload", "failed", "Wait for the current response to finish before reloading.", undefined, "warning");
+        if (session.isCompacting)
+            return workflowResult("reload", "failed", "Wait for compaction to finish before reloading.", undefined, "warning");
+        return null;
+    }
     async executeWorkflow(request) {
         try {
             return await this.#performWorkflow(request);
@@ -999,7 +1034,7 @@ export class PiEngineAdapter {
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             const contextualMessage = request.command === "export"
-                ? `Failed to export session: ${message}`
+                ? `Failed to export session: ${errorMessage(error, "Unknown error")}`
                 : request.command === "import"
                     ? `Failed to import session: ${message}`
                     : request.command === "new"
@@ -1133,8 +1168,18 @@ export class PiEngineAdapter {
                     : [...(runtime.services.modelRuntime.getAvailableSnapshot?.() ?? [])];
                 let model = findExactWorkflowModel(reference, availableModels);
                 const messages = [];
+                const generation = this.#sessionGeneration;
+                const current = () => !this.#disposed && generation === this.#sessionGeneration;
+                const publish = (message) => {
+                    if (!current())
+                        return;
+                    if (this.#workflowInteraction.publish)
+                        this.#workflowInteraction.publish(message);
+                    else
+                        messages.push(message);
+                };
                 if (model === undefined && scopedModels.length === 0) {
-                    messages.push({ kind: "status", message: "Refreshing model catalogs…" });
+                    publish({ kind: "status", message: "Refreshing model catalogs…" });
                     const controller = new AbortController();
                     let timedOut = false;
                     const timeout = setTimeout(() => {
@@ -1144,14 +1189,14 @@ export class PiEngineAdapter {
                     try {
                         const refreshed = await runtime.services.modelRuntime.refresh?.({ signal: controller.signal });
                         if (isRecord(refreshed) && refreshed.aborted === true && timedOut) {
-                            messages.push({ kind: "warning", message: "Model refresh timed out; searching cached models." });
+                            publish({ kind: "warning", message: "Model refresh timed out; searching cached models." });
                         }
                         else if (isRecord(refreshed) && refreshed.errors instanceof Map && refreshed.errors.size > 0) {
-                            messages.push({ kind: "warning", message: `Could not refresh ${[...refreshed.errors.keys()].join(", ")}; searching cached models.` });
+                            publish({ kind: "warning", message: `Could not refresh ${[...refreshed.errors.keys()].join(", ")}; searching cached models.` });
                         }
                     }
                     catch (error) {
-                        messages.push({
+                        publish({
                             kind: "warning",
                             message: timedOut
                                 ? "Model refresh timed out; searching cached models."
@@ -1164,13 +1209,25 @@ export class PiEngineAdapter {
                     availableModels = [...(runtime.services.modelRuntime.getAvailableSnapshot?.() ?? [])];
                     model = findExactWorkflowModel(reference, availableModels);
                 }
+                if (!current())
+                    return workflowResult(request.command, "cancelled", "Model selection cancelled", undefined, "silent");
                 if (model === undefined) {
                     return {
                         ...workflowResult(request.command, "requires-selection", "Select a model", reference, "silent"),
                         ...(messages.length === 0 ? {} : { messages: Object.freeze(messages) }),
                     };
                 }
-                await session.setModel(model);
+                try {
+                    await session.setModel(model);
+                }
+                catch (error) {
+                    if (!current())
+                        return workflowResult(request.command, "cancelled", "Model selection cancelled", undefined, "silent");
+                    const failure = { kind: "error", message: error instanceof Error ? error.message : String(error) };
+                    return workflowResult(request.command, "failed", failure.message, undefined, "error", messages.length === 0 ? undefined : [...messages, failure]);
+                }
+                if (!current())
+                    return workflowResult(request.command, "cancelled", "Model selection cancelled", undefined, "silent");
                 const providerId = stringProperty(model, "provider") ?? "unknown";
                 const modelId = stringProperty(model, "id") ?? reference;
                 this.#activeModel = { providerId, modelId, displayName: stringProperty(model, "name") ?? modelId };
@@ -1226,9 +1283,8 @@ export class PiEngineAdapter {
                 const signal = request.signal;
                 if (signal?.aborted)
                     return workflowResult(request.command, "cancelled", "Share cancelled", undefined, "status");
-                let auth;
                 try {
-                    auth = await this.#workflowHost.runCommand("gh", ["auth", "status"], signal === undefined ? undefined : { signal });
+                    await this.#workflowHost.runCommand("gh", ["auth", "status"], signal === undefined ? undefined : { signal });
                 }
                 catch (error) {
                     if (signal?.aborted || isAbortError(error))
@@ -1238,9 +1294,6 @@ export class PiEngineAdapter {
                         : "GitHub CLI is not logged in. Run 'gh auth login' first.";
                     return workflowResult(request.command, "failed", message);
                 }
-                if (auth.stderr && !auth.stdout) {
-                    return workflowResult(request.command, "failed", "GitHub CLI is not logged in. Run 'gh auth login' first.");
-                }
                 const temporary = join(tmpdir(), `${PRODUCT_IDENTITY.filesystem.temporaryPrefix}pi-session-${process.pid}.html`);
                 try {
                     try {
@@ -1258,13 +1311,10 @@ export class PiEngineAdapter {
                     catch (error) {
                         if (signal?.aborted || isAbortError(error))
                             return workflowResult(request.command, "cancelled", "Share cancelled", undefined, "status");
-                        return workflowResult(request.command, "failed", `Failed to create gist: ${errorMessage(error, "Unknown error")}`);
+                        return workflowResult(request.command, "failed", `Failed to create gist: ${shareCommandFailureDetail(error)}`);
                     }
                     if (signal?.aborted)
                         return workflowResult(request.command, "cancelled", "Share cancelled", undefined, "status");
-                    if (gist.stderr && !gist.stdout) {
-                        return workflowResult(request.command, "failed", `Failed to create gist: ${gist.stderr.trim() || "Unknown error"}`);
-                    }
                     const gistUrl = gist.stdout.trim();
                     const gistId = gistUrl.split("/").at(-1);
                     if (!gistId)
@@ -1497,13 +1547,17 @@ export class PiEngineAdapter {
                 }
             }
             case "reload": {
-                if (session.isStreaming)
-                    return workflowResult(request.command, "failed", "Wait for the current response to finish before reloading.", undefined, "warning");
-                if (session.isCompacting)
-                    return workflowResult(request.command, "failed", "Wait for compaction to finish before reloading.", undefined, "warning");
+                const blocked = this.reloadBlockedResult();
+                if (blocked)
+                    return blocked;
                 await requireCapability(session.reload, "reload").call(session);
                 await this.#bindExtensionUiToSession();
-                return workflowResult(request.command, "completed", "Reloaded keybindings, extensions, skills, prompts, themes, and context files");
+                const message = "Reloaded keybindings, extensions, skills, prompts, themes, and context files";
+                const modelError = runtime.services.modelRuntime.getError?.();
+                return workflowResult(request.command, "completed", message, undefined, "status", modelError ? [
+                    { kind: "error", message: `models.json error: ${modelError}` },
+                    { kind: "status", message },
+                ] : undefined);
             }
             case "quit": {
                 await this.dispose();
@@ -2698,7 +2752,7 @@ function defaultWorkflowHost() {
             const result = await execFileAsync(command, [...arguments_], { encoding: "utf8", signal: options?.signal });
             return { stdout: result.stdout, stderr: result.stderr };
         },
-        readChangelog: async () => "No changelog entries found.",
+        readChangelog: readPinnedCommandChangelog,
     };
 }
 function workflowLoginNotification(event) {
@@ -2757,6 +2811,13 @@ function workflowConfirmation(command, message, detail) {
 function errorMessage(error, fallback) {
     return error instanceof Error ? error.message : fallback;
 }
+function shareCommandFailureDetail(error) {
+    // Compatibility: Pi reports a failed child's stderr, not execFile's command wrapper.
+    if (isRecord(error) && (typeof error.code === "number" || typeof error.signal === "string") && typeof error.stderr === "string") {
+        return error.stderr.trim() || "Unknown error";
+    }
+    return errorMessage(error, "Unknown error");
+}
 function commandMissing(error) {
     return isRecord(error) && error.code === "ENOENT";
 }

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

@@ -0,0 +1,2 @@
+export declare function readPinnedCommandChangelog(sinceVersion?: string): Promise<string>;
+export declare function formatPinnedCommandChangelog(content: string, sinceVersion?: string): string;