@timurproko/a1 0.1.8-dev.235df0e → 0.1.8-dev.260

package/dist/{src/foundation/pi-engine-adapter → integrations/pi/engine}/adapter.js

@@ -1,11 +1,14 @@
 import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { promisify } from "node:util";
-import { PRODUCT_IDENTITY } from "../../product-identity.js";
-import { copyToClipboard, DefaultPackageManager, getAgentDir, ProjectTrustStore, SessionManager, } 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, assertOwnedUiCommand, assertOwnedUiExtensionUiPort, assertOwnedUiSnapshot, } from "../owned-ui-contracts/index.js";
+import { PRODUCT_IDENTITY } from "../../../product-identity.js";
+import { configureOwnedHttpDispatcher } from "./http-dispatcher.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, assertOwnedUiCommand, assertOwnedUiExtensionUiPort, assertOwnedUiSnapshot, } from "../../../contracts/owned-ui/index.js";
 import { PINNED_PI_SETTINGS_CALLBACKS, PINNED_PI_WORKFLOW_COMMAND_NAMES, } from "./workflows.js";
 import { createPiRuntimeIntegration } from "./runtime-integration.js";
 import { PiSessionCommandIntegration } from "./session-integration.js";
@@ -16,19 +19,71 @@ const execFileAsync = promisify(execFile);
  * that a streaming burst never holds input, large enough that an ordinary turn is one
  * batch.
  */
-const EVENT_DELIVERY_BATCH = 16;
+// Performance: deliver at most one engine event per event-loop turn. Transcript updates can
+// be expensive in long sessions; a larger synchronous batch starves terminal
+// input and makes an in-progress mouse selection appear frozen.
+const EVENT_DELIVERY_BATCH = 1;
+const TOOL_UPDATE_COALESCE_MS = 50;
+const AUTH_REFRESH_TIMEOUT_MS = 15_000;
+// Provenance: Pi 0.84.2 core/model-resolver.ts defaultModelPerProvider.
+const PINNED_DEFAULT_MODEL_BY_PROVIDER = Object.freeze({
+    "amazon-bedrock": "us.anthropic.claude-opus-4-6-v1",
+    "ant-ling": "Ring-2.6-1T",
+    anthropic: "claude-opus-4-8",
+    openai: "gpt-5.5",
+    "azure-openai-responses": "gpt-5.4",
+    "openai-codex": "gpt-5.5",
+    radius: "auto",
+    nvidia: "nvidia/nemotron-3-super-120b-a12b",
+    deepseek: "deepseek-v4-pro",
+    google: "gemini-3.1-pro-preview",
+    "google-vertex": "gemini-3.1-pro-preview",
+    "github-copilot": "gpt-5.4",
+    openrouter: "moonshotai/kimi-k2.6",
+    "vercel-ai-gateway": "zai/glm-5.1",
+    xai: "grok-4.5",
+    groq: "openai/gpt-oss-120b",
+    cerebras: "zai-glm-4.7",
+    zai: "glm-5.1",
+    "zai-coding-cn": "glm-5.1",
+    mistral: "devstral-medium-latest",
+    minimax: "MiniMax-M2.7",
+    "minimax-cn": "MiniMax-M2.7",
+    moonshotai: "kimi-k2.6",
+    "moonshotai-cn": "kimi-k2.6",
+    huggingface: "moonshotai/Kimi-K2.6",
+    fireworks: "accounts/fireworks/models/kimi-k2p6",
+    together: "moonshotai/Kimi-K2.6",
+    baseten: "zai-org/GLM-5.2",
+    opencode: "kimi-k2.6",
+    "opencode-go": "kimi-k2.6",
+    "kimi-coding": "kimi-for-coding",
+    "cloudflare-workers-ai": "@cf/moonshotai/kimi-k2.6",
+    "cloudflare-ai-gateway": "workers-ai/@cf/moonshotai/kimi-k2.6",
+    "qwen-token-plan": "qwen3.7-max",
+    "qwen-token-plan-cn": "qwen3.7-max",
+    "qwen-token-plan-individual": "qwen3.8-max",
+    xiaomi: "mimo-v2.5-pro",
+    "xiaomi-token-plan-cn": "mimo-v2.5-pro",
+    "xiaomi-token-plan-ams": "mimo-v2.5-pro",
+    "xiaomi-token-plan-sgp": "mimo-v2.5-pro",
+});
 const DEFAULT_SURFACE = {
     columns: 100,
     rows: 32,
     focusedRegion: "editor",
     hardwareCursor: false,
 };
+/** Owns the pinned Pi session lifecycle and translates its events into the neutral agent-engine contract. */
 export class PiEngineAdapter {
     #runtimeFactory;
     #checkPackageUpdates;
     #cwd;
     #agentDir;
     #sessionId;
+    #sessionPath;
+    #sessionSelection;
+    #sessionForkPrompt;
     #workflowHost;
     #workflowInteraction;
     #listeners = new Set();
@@ -59,9 +114,15 @@ export class PiEngineAdapter {
     #activeCommandIds = [];
     #completedCommands = new Map();
     #transcript = [];
+    #transcriptIndex = new Map();
+    #transcriptSnapshot;
     #messageBlockIds = new WeakMap();
     #messageFallbackIds = new Map();
     #toolBlockIds = new Map();
+    #transcriptImageAssets = new Map();
+    #pendingToolUpdates = new Map();
+    #toolUpdateFlush = null;
+    #usageCache;
     #nextBlockSequence = 0;
     #diagnostics = [];
     #eventQueue = [];
@@ -75,12 +136,18 @@ export class PiEngineAdapter {
     #extensionShutdown;
     #extensionBound = false;
     #disposed = false;
-    /** Lists the themes installed on this machine, when the caller supplies one. */
+    #settingsProductMode;
+    #projectTrustPrompt;
+    #settingsIntegration;
+    #settingsIntegrationManager;
     #availableThemes;
     constructor(options = {}) {
         this.#cwd = options.cwd ?? process.cwd();
         this.#agentDir = options.agentDir ?? getAgentDir();
         this.#sessionId = options.sessionId ?? "owned-session-1";
+        this.#sessionPath = options.sessionPath;
+        this.#sessionSelection = options.sessionSelection;
+        this.#sessionForkPrompt = options.sessionForkPrompt;
         this.#runtimeFactory = options.createRuntime ?? createDefaultPiRuntime;
         this.#checkPackageUpdates = options.checkPackageUpdates
             ?? (options.createRuntime
@@ -88,6 +155,8 @@ export class PiEngineAdapter {
                 : settingsManager => checkDefaultPiPackageUpdates(this.#cwd, this.#agentDir, settingsManager));
         this.#workflowHost = options.workflowHost ?? defaultWorkflowHost();
         this.#availableThemes = options.availableThemes ?? null;
+        this.#settingsProductMode = options.settingsProductMode ?? "bare";
+        this.#projectTrustPrompt = options.projectTrustPrompt;
         this.#workflowInteraction = { prompt: async () => null, notify() { } };
     }
     setWorkflowInteractionHost(interaction) {
@@ -99,9 +168,35 @@ export class PiEngineAdapter {
     get sessionGeneration() {
         return this.#sessionGeneration;
     }
+    get cwd() {
+        return this.#runtime?.cwd ?? this.#cwd;
+    }
     get agentDir() {
         return this.#agentDir;
     }
+    resolveTranscriptImage(assetId) {
+        return this.#transcriptImageAssets.get(assetId) ?? null;
+    }
+    currentSessionFile() {
+        const value = this.#session?.sessionManager?.getSessionFile?.();
+        return typeof value === "string" && value.length > 0 ? value : null;
+    }
+    currentSessionResumeMetadata() {
+        const manager = this.#session?.sessionManager;
+        if (manager === undefined
+            || typeof manager.isPersisted !== "function"
+            || typeof manager.getSessionId !== "function"
+            || typeof manager.getSessionDir !== "function"
+            || typeof manager.usesDefaultSessionDir !== "function"
+            || manager.isPersisted() !== true
+            || !existsSync(this.currentSessionFile() ?? ""))
+            return null;
+        const sessionId = manager.getSessionId();
+        const sessionDir = manager.getSessionDir();
+        if (!sessionId || !sessionDir)
+            return null;
+        return { sessionId, sessionDir, usesDefaultSessionDir: manager.usesDefaultSessionDir() };
+    }
     get disposed() {
         return this.#disposed;
     }
@@ -112,12 +207,17 @@ export class PiEngineAdapter {
             cwd: this.#cwd,
             agentDir: this.#agentDir,
             sessionId: this.#sessionId,
+            ...(this.#sessionPath === undefined ? {} : { sessionPath: this.#sessionPath }),
+            ...(this.#sessionSelection === undefined ? {} : { sessionSelection: this.#sessionSelection }),
+            ...(this.#sessionForkPrompt === undefined ? {} : { sessionForkPrompt: this.#sessionForkPrompt }),
+            ...(this.#projectTrustPrompt === undefined ? {} : { projectTrustPrompt: this.#projectTrustPrompt }),
         }).catch(error => {
             this.#lifecycle = "failed";
             this.#addDiagnostic("error", "engine-startup", error instanceof Error ? error.message : String(error), false);
             throw error;
         });
         this.#runtime = runtime;
+        this.#cwd = runtime.cwd ?? this.#cwd;
         this.#gitBranch = await readGitBranch(this.#cwd);
         this.#terminal = {
             ...this.#terminal,
@@ -131,6 +231,7 @@ export class PiEngineAdapter {
             this.#addDiagnostic(diagnostic.type === "error" ? "error" : diagnostic.type === "warning" ? "warning" : "info", "engine-startup", diagnostic.message, diagnostic.type !== "error");
         }
         this.#bindSession(runtime.session);
+        await this.#announceChangelog(runtime.services.settingsManager);
         this.#lifecycle = "ready";
         this.#editor = { ...this.#editor, submitEnabled: true };
         this.#emitEvent({ type: "session-lifecycle", lifecycle: "ready", reason: null });
@@ -138,6 +239,19 @@ export class PiEngineAdapter {
         void this.#announcePackageUpdates(runtime.services.settingsManager);
         return this.view();
     }
+    async #announceChangelog(settingsManager) {
+        if (!settingsManager || typeof settingsManager.getLastChangelogVersion !== "function"
+            || typeof settingsManager.setLastChangelogVersion !== "function")
+            return;
+        if (settingsManager.getLastChangelogVersion() === VERSION)
+            return;
+        const markdown = await this.#workflowHost.readChangelog().catch(() => "");
+        if (markdown.trim().length > 0) {
+            this.#addDiagnostic("info", settingsManager.getCollapseChangelog() ? "changelog-collapsed" : "changelog-expanded", markdown, true);
+        }
+        settingsManager.setLastChangelogVersion(VERSION);
+        await settingsManager.flush();
+    }
     async #announcePackageUpdates(settingsManager) {
         if (process.env.PI_OFFLINE)
             return;
@@ -160,6 +274,7 @@ export class PiEngineAdapter {
         return () => this.#listeners.delete(listener);
     }
     async flushEvents() {
+        this.#flushPendingToolUpdates();
         while (this.#eventQueueProcessing)
             await this.#eventQueueProcessing;
     }
@@ -398,7 +513,8 @@ export class PiEngineAdapter {
             const session = this.#requireWorkflowSession();
             const result = await requireCapability(session.cycleModel, "cycleModel").call(session, direction);
             if (!isRecord(result) || !isRecord(result.model)) {
-                return workflowResult("model", "cancelled", "No other model is available");
+                const scoped = Array.isArray(session.scopedModels) && session.scopedModels.length > 0;
+                return workflowResult("model", "completed", scoped ? "Only one model in scope" : "Only one model available", undefined, "status");
             }
             const model = readModel(result.model);
             if (model)
@@ -406,7 +522,11 @@ export class PiEngineAdapter {
             if (result.thinkingLevel !== undefined)
                 this.#thinkingLevel = readThinkingLevel(result.thinkingLevel);
             this.#emitView();
-            return workflowResult("model", "completed", model ? `Selected model ${model.providerId}/${model.modelId}` : "Selected model");
+            const modelName = stringProperty(result.model, "name") ?? stringProperty(result.model, "id") ?? "model";
+            const reasoning = result.model.reasoning === true;
+            const thinking = this.#thinkingLevel;
+            const suffix = reasoning && thinking !== "off" ? ` (thinking: ${thinking})` : "";
+            return workflowResult("model", "completed", `Switched to ${modelName}${suffix}`, undefined, "status");
         }
         catch (error) {
             return workflowResult("model", "failed", error instanceof Error ? error.message : String(error));
@@ -422,16 +542,107 @@ export class PiEngineAdapter {
     /** Settings port for the live runtime, or null before the runtime is available. */
     settingsPort() {
         const settings = this.#runtime?.services.settingsManager;
-        if (!settings)
+        if (!settings || typeof settings.getCompactionEnabled !== "function")
             return null;
-        const session = this.#runtime?.session;
-        return new PiSettingsIntegration(settings, {
-            ...(this.#availableThemes === null ? {} : { themes: this.#availableThemes }),
-            thinkingLevels: () => {
-                const levels = session?.getAvailableThinkingLevels?.();
-                return Array.isArray(levels) ? levels.map(level => String(level)) : [];
-            },
-        });
+        if (this.#settingsIntegration === undefined || this.#settingsIntegrationManager !== settings) {
+            this.#settingsIntegrationManager = settings;
+            configureOwnedHttpDispatcher(settings.getHttpIdleTimeoutMs());
+            this.#settingsIntegration = new PiSettingsIntegration(settings, {
+                ...(this.#availableThemes === null ? {} : { themes: this.#availableThemes }),
+                thinkingLevels: () => {
+                    const levels = this.#runtime?.session?.getAvailableThinkingLevels?.();
+                    return Array.isArray(levels) ? levels.map(level => String(level)) : [];
+                },
+                productMode: this.#settingsProductMode,
+            });
+            this.#settingsIntegration.bindOwner("shell", {
+                enableSkillCommands: { apply: value => {
+                        if (typeof value !== "boolean")
+                            throw new TypeError("Skill commands value is invalid");
+                        settings.setEnableSkillCommands(value);
+                    } },
+                doubleEscapeAction: { apply: value => {
+                        if (value !== "tree" && value !== "fork" && value !== "none")
+                            throw new TypeError("Double-Escape action is invalid");
+                        settings.setDoubleEscapeAction(value);
+                    } },
+                treeFilterMode: { apply: value => {
+                        if (value !== "default" && value !== "no-tools" && value !== "user-only" && value !== "labeled-only" && value !== "all")
+                            throw new TypeError("Tree filter mode is invalid");
+                        settings.setTreeFilterMode(value);
+                    } },
+                showCacheMissNotices: { apply: value => {
+                        if (typeof value !== "boolean")
+                            throw new TypeError("Cache-miss notice setting is invalid");
+                        settings.setShowCacheMissNotices(value);
+                    } },
+            });
+            this.#settingsIntegration.bindOwner("startup", {
+                // Invariant: deferred application is the owner operation: the next preflight reads
+                // the persisted default before constructing project-backed services.
+                defaultProjectTrust: { apply() { } },
+                collapseChangelog: { apply() { } },
+            });
+            this.#settingsIntegration.bindOwner("agent", {
+                autoCompact: { apply: value => {
+                        if (typeof value !== "boolean")
+                            throw new TypeError("Auto compact value is invalid");
+                        this.#requireWorkflowSession().setAutoCompactionEnabled(value);
+                    } },
+                autoResizeImages: { apply: value => {
+                        if (typeof value !== "boolean")
+                            throw new TypeError("Auto-resize images value is invalid");
+                        settings.setImageAutoResize(value);
+                    } },
+                blockImages: { apply: value => {
+                        if (typeof value !== "boolean")
+                            throw new TypeError("Block images value is invalid");
+                        settings.setBlockImages(value);
+                    } },
+                steeringMode: { apply: value => {
+                        if (value !== "all" && value !== "one-at-a-time")
+                            throw new TypeError("Steering mode is invalid");
+                        this.#requireWorkflowSession().setSteeringMode(value);
+                    } },
+                followUpMode: { apply: value => {
+                        if (value !== "all" && value !== "one-at-a-time")
+                            throw new TypeError("Follow-up mode is invalid");
+                        this.#requireWorkflowSession().setFollowUpMode(value);
+                    } },
+                transport: { apply: value => {
+                        if (value !== "sse" && value !== "websocket" && value !== "websocket-cached" && value !== "auto")
+                            throw new TypeError("Transport is invalid");
+                        this.#requireWorkflowSession().agent.transport = value;
+                    } },
+                httpIdleTimeoutMs: { apply: value => {
+                        if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)
+                            throw new TypeError("HTTP idle timeout is invalid");
+                        // Invariant: provider streaming reads the manager per request; global fetch uses
+                        // the matching owned dispatcher and zero maps to disabled semantics.
+                        configureOwnedHttpDispatcher(value);
+                        settings.setHttpIdleTimeoutMs(value);
+                    } },
+                thinkingLevel: { apply: value => {
+                        if (!isThinkingLevel(value))
+                            throw new TypeError("Thinking level is invalid");
+                        this.#requireWorkflowSession().setThinkingLevel(value);
+                        this.#thinkingLevel = readThinkingLevel(this.#requireWorkflowSession().thinkingLevel);
+                        this.#emitView();
+                    } },
+                warnings: { apply: value => {
+                        if (!isRecord(value) || Object.values(value).some(flag => typeof flag !== "boolean"))
+                            throw new TypeError("Warnings setting is invalid");
+                        settings.setWarnings(value);
+                    } },
+            });
+        }
+        return this.#settingsIntegration;
+    }
+    bindSettingsOwner(owner, handlers) {
+        const settings = this.settingsPort();
+        if (settings === null)
+            return () => { };
+        return settings.bindOwner(owner, handlers);
     }
     pinnedModelSelectorContext() {
         const session = this.#requireWorkflowSession();
@@ -708,9 +919,9 @@ export class PiEngineAdapter {
             excludeFromContext,
         };
     }
-    applyPinnedSettingValue(callback, value) {
+    async applyPinnedSettingValue(callback, value) {
         try {
-            return this.#applyPinnedSetting(callback, value, true);
+            return await this.#applyPinnedSetting(callback, value, true);
         }
         catch (error) {
             return workflowResult("settings", "failed", error instanceof Error ? error.message : String(error));
@@ -724,7 +935,13 @@ export class PiEngineAdapter {
             const message = error instanceof Error ? error.message : String(error);
             const contextualMessage = request.command === "export"
                 ? `Failed to export session: ${message}`
-                : request.command === "reload" ? `Reload failed: ${message}` : message;
+                : request.command === "import"
+                    ? `Failed to import session: ${message}`
+                    : request.command === "new"
+                        ? `Failed to create session: ${message}`
+                        : request.command === "resume"
+                            ? `Failed to resume session: ${message}`
+                            : request.command === "reload" ? `Reload failed: ${message}` : message;
             return workflowResult(request.command, "failed", contextualMessage);
         }
     }
@@ -734,13 +951,13 @@ export class PiEngineAdapter {
             sessionId: this.#sessionId,
             revision: this.#viewRevision,
             lifecycle: this.#lifecycle,
-            transcript: this.#transcript.map(block => ({ ...block })),
+            transcript: this.#transcriptSnapshot ??= Object.freeze([...this.#transcript]),
             editor: { ...this.#editor, queuedSubmissions: [...this.#editor.queuedSubmissions] },
             status: {
                 ...this.#status,
                 diagnostics: [...this.#status.diagnostics],
                 badges: [...this.#status.badges],
-                usage: this.#readUsage(),
+                usage: this.#usageCache ??= this.#readUsage(),
                 footer: {
                     branch: this.#gitBranch,
                     sessionName: this.#session?.sessionManager?.getSessionName() ?? null,
@@ -806,6 +1023,12 @@ export class PiEngineAdapter {
         if (this.#disposed)
             return;
         this.#disposed = true;
+        if (this.#toolUpdateFlush !== null) {
+            clearTimeout(this.#toolUpdateFlush);
+            this.#toolUpdateFlush = null;
+        }
+        this.#pendingToolUpdates.clear();
+        this.#transcriptImageAssets.clear();
         this.#extensionBound = false;
         this.#extensionUi = undefined;
         this.#extensionShutdown = undefined;
@@ -831,22 +1054,66 @@ export class PiEngineAdapter {
             case "settings": {
                 if (!selection)
                     return workflowResult(request.command, "failed", "Settings requires the owned settings controller");
-                return this.#applyPinnedSetting(selection);
+                return await this.#applyPinnedSetting(selection);
             }
             case "model": {
                 const reference = selection ?? argument;
                 if (!reference)
                     return workflowResult(request.command, "failed", "Model requires the owned model controller");
-                const [providerId, modelId] = reference.split("/", 2);
-                if (!providerId || !modelId)
-                    return workflowResult(request.command, "failed", "Model requires provider/model");
-                const model = runtime.services.modelRuntime.getModel(providerId, modelId);
-                if (!model)
-                    return workflowResult(request.command, "failed", `Model is unavailable: ${reference}`);
+                const scopedModels = Array.isArray(session.scopedModels)
+                    ? session.scopedModels.map(item => item.model)
+                    : [];
+                let availableModels = scopedModels.length > 0
+                    ? scopedModels
+                    : [...(runtime.services.modelRuntime.getAvailableSnapshot?.() ?? [])];
+                let model = findExactWorkflowModel(reference, availableModels);
+                const messages = [];
+                if (model === undefined && scopedModels.length === 0) {
+                    messages.push({ kind: "status", message: "Refreshing model catalogs…" });
+                    const controller = new AbortController();
+                    let timedOut = false;
+                    const timeout = setTimeout(() => {
+                        timedOut = true;
+                        controller.abort();
+                    }, AUTH_REFRESH_TIMEOUT_MS);
+                    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." });
+                        }
+                        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.` });
+                        }
+                    }
+                    catch (error) {
+                        messages.push({
+                            kind: "warning",
+                            message: timedOut
+                                ? "Model refresh timed out; searching cached models."
+                                : `Could not refresh model catalogs: ${error instanceof Error ? error.message : String(error)}`,
+                        });
+                    }
+                    finally {
+                        clearTimeout(timeout);
+                    }
+                    availableModels = [...(runtime.services.modelRuntime.getAvailableSnapshot?.() ?? [])];
+                    model = findExactWorkflowModel(reference, availableModels);
+                }
+                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);
+                const providerId = stringProperty(model, "provider") ?? "unknown";
+                const modelId = stringProperty(model, "id") ?? reference;
                 this.#activeModel = { providerId, modelId, displayName: stringProperty(model, "name") ?? modelId };
                 this.#emitView();
-                return workflowResult(request.command, "completed", `Model: ${modelId}`);
+                const resultMessage = { kind: "status", message: `Model: ${modelId}` };
+                return messages.length === 0
+                    ? workflowResult(request.command, "completed", resultMessage.message)
+                    : workflowResult(request.command, "completed", resultMessage.message, undefined, "status", [...messages, resultMessage]);
             }
             case "scoped-models": {
                 if (!selection)
@@ -873,27 +1140,71 @@ export class PiEngineAdapter {
                     return workflowConfirmation(request.command, `Replace current session with ${path}?`);
                 }
                 if (!request.confirmed)
-                    return workflowResult(request.command, "cancelled", "Import cancelled");
-                const result = await requireCapability(runtime.importFromJsonl, "importFromJsonl").call(runtime, path);
-                if (isRecord(result) && result.cancelled === true)
-                    return workflowResult(request.command, "cancelled", "Import cancelled");
-                return workflowResult(request.command, "completed", `Session imported from: ${path}`);
+                    return workflowResult(request.command, "cancelled", "Import cancelled", undefined, "status");
+                try {
+                    const result = await requireCapability(runtime.importFromJsonl, "importFromJsonl").call(runtime, path, request.cwdOverride);
+                    if (isRecord(result) && result.cancelled === true)
+                        return workflowResult(request.command, "cancelled", "Import cancelled", undefined, "status");
+                    return workflowResult(request.command, "completed", `Session imported from: ${path}`);
+                }
+                catch (error) {
+                    const issue = isRecord(error) && isRecord(error.issue) ? error.issue : undefined;
+                    const fallbackCwd = issue === undefined ? undefined : stringProperty(issue, "fallbackCwd");
+                    if (fallbackCwd !== undefined && request.cwdOverride === undefined) {
+                        const sessionCwd = stringProperty(issue, "sessionCwd") ?? "the session working directory";
+                        return workflowConfirmation(request.command, `cwd from session file does not exist\n${sessionCwd}\n\ncontinue in current cwd\n${fallbackCwd}`, fallbackCwd);
+                    }
+                    throw error;
+                }
             }
             case "share": {
-                const auth = await this.#workflowHost.runCommand("gh", ["auth", "status"]).catch(error => {
-                    throw new Error(`GitHub CLI is unavailable or not logged in: ${error instanceof Error ? error.message : String(error)}`);
-                });
-                if (auth.stderr && !auth.stdout)
-                    throw new Error(auth.stderr.trim());
+                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 });
+                }
+                catch (error) {
+                    if (signal?.aborted || isAbortError(error))
+                        return workflowResult(request.command, "cancelled", "Share cancelled", undefined, "status");
+                    const message = commandMissing(error)
+                        ? "GitHub CLI (gh) is not installed. Install it from https://cli.github.com/"
+                        : "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 {
-                    await requireCapability(session.exportToHtml, "exportToHtml").call(session, temporary);
-                    const gist = await this.#workflowHost.runCommand("gh", ["gist", "create", "--public=false", temporary]);
+                    try {
+                        await requireCapability(session.exportToHtml, "exportToHtml").call(session, temporary);
+                    }
+                    catch (error) {
+                        return workflowResult(request.command, "failed", `Failed to export session: ${errorMessage(error, "Unknown error")}`);
+                    }
+                    if (signal?.aborted)
+                        return workflowResult(request.command, "cancelled", "Share cancelled", undefined, "status");
+                    let gist;
+                    try {
+                        gist = await this.#workflowHost.runCommand("gh", ["gist", "create", "--public=false", temporary], signal === undefined ? undefined : { signal });
+                    }
+                    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")}`);
+                    }
+                    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)
-                        throw new Error("Failed to parse gist ID from gh output");
-                    return workflowResult(request.command, "completed", `Share URL: https://pi.gptscript.ai/gist/${gistId}`, gistUrl);
+                        return workflowResult(request.command, "failed", "Failed to parse gist ID from gh output");
+                    return workflowResult(request.command, "completed", `Share URL: ${shareViewerUrl(gistId)}`, gistUrl);
                 }
                 finally {
                     await rm(temporary, { force: true });
@@ -912,7 +1223,7 @@ export class PiEngineAdapter {
                     const current = manager?.getSessionName();
                     return typeof current === "string"
                         ? workflowResult(request.command, "completed", `Session name: ${current}`)
-                        : workflowResult(request.command, "failed", "Usage: /name <name>");
+                        : workflowResult(request.command, "failed", "Usage: /name <name>", undefined, "warning");
                 }
                 requireCapability(session.setSessionName, "setSessionName").call(session, argument);
                 const normalized = manager?.getSessionName();
@@ -939,17 +1250,17 @@ export class PiEngineAdapter {
                     return workflowResult(request.command, "failed", "Fork requires the owned user-message controller");
                 const result = await requireCapability(runtime.fork, "fork").call(runtime, selection, { position: "before" });
                 if (isRecord(result) && result.cancelled === true)
-                    return workflowResult(request.command, "cancelled", "Fork cancelled");
+                    return workflowResult(request.command, "cancelled", "Fork cancelled", undefined, "silent");
                 return workflowResult(request.command, "completed", "Forked to new session");
             }
             case "clone": {
                 const manager = session.sessionManager;
                 const leaf = manager?.getLeafId?.();
                 if (typeof leaf !== "string")
-                    return workflowResult(request.command, "failed", "No session position is available to clone");
+                    return workflowResult(request.command, "completed", "Nothing to clone yet", undefined, "status");
                 const result = await requireCapability(runtime.fork, "fork").call(runtime, leaf, { position: "at" });
                 if (isRecord(result) && result.cancelled === true)
-                    return workflowResult(request.command, "cancelled", "Clone cancelled");
+                    return workflowResult(request.command, "cancelled", "Clone cancelled", undefined, "silent");
                 return workflowResult(request.command, "completed", "Cloned to new session");
             }
             case "tree": {
@@ -963,9 +1274,9 @@ export class PiEngineAdapter {
                         ...(request.treeSummary.customInstructions === undefined ? {} : { customInstructions: request.treeSummary.customInstructions }),
                     });
                 if (isRecord(result) && result.aborted === true)
-                    return workflowResult(request.command, "cancelled", "Branch summarization cancelled");
+                    return workflowResult(request.command, "cancelled", "Branch summarization cancelled", undefined, "status");
                 if (isRecord(result) && result.cancelled === true)
-                    return workflowResult(request.command, "cancelled", "Navigation cancelled");
+                    return workflowResult(request.command, "cancelled", "Navigation cancelled", undefined, "status");
                 return workflowResult(request.command, "completed", "Navigated to selected point");
             }
             case "trust": {
@@ -1000,6 +1311,7 @@ export class PiEngineAdapter {
                 const authType = authTypeValue === "api_key" ? "api_key" : "oauth";
                 const provider = modelRuntime.getProvider?.(providerId);
                 const providerName = stringProperty(provider, "name") ?? providerId;
+                const previousModel = session.model;
                 this.#workflowInteraction.startLogin?.({ providerId, providerName, authType });
                 try {
                     await requireCapability(modelRuntime.login, "login").call(modelRuntime, providerId, authType, {
@@ -1037,25 +1349,40 @@ export class PiEngineAdapter {
                     });
                 }
                 catch (error) {
-                    if (error instanceof Error && error.message === "Login cancelled")
-                        return workflowResult(request.command, "cancelled", "Login cancelled");
-                    throw error;
+                    if (error instanceof Error && error.message === "Login cancelled") {
+                        return workflowResult(request.command, "cancelled", "Login cancelled", undefined, "silent");
+                    }
+                    const detail = error instanceof Error ? error.message : String(error);
+                    const actionLabel = authType === "api_key" ? `Saved API key for ${providerName}` : `Logged in to ${providerName}`;
+                    const message = error instanceof CredentialSynchronizationError
+                        ? `${actionLabel}, but local model state could not be synchronized: ${detail}`
+                        : authType === "api_key"
+                            ? `Failed to save API key for ${providerName}: ${detail}`
+                            : `Failed to login to ${providerName}: ${detail}`;
+                    return workflowResult(request.command, "failed", message);
                 }
                 finally {
                     this.#workflowInteraction.finishLogin?.();
                 }
-                this.#reconcileActiveModelAvailability();
-                this.#emitView();
-                return workflowResult(request.command, "completed", `Logged in to ${providerName}. Credentials saved to ${join(this.#agentDir, "auth.json")}`);
+                return await this.#completeProviderAuthentication(providerId, providerName, authType, previousModel);
             }
             case "logout": {
                 if (!selection)
                     return workflowResult(request.command, "failed", "Logout requires the owned authentication controller");
                 const [credentialType = "oauth", providerId = selection] = selection.includes(":") ? selection.split(":", 2) : ["oauth", selection];
                 const modelRuntime = runtime.services.modelRuntime;
-                await requireCapability(modelRuntime.logout, "logout").call(modelRuntime, providerId, { signal: AbortSignal.timeout(15_000) });
                 const provider = modelRuntime.getProvider?.(providerId);
                 const providerName = stringProperty(provider, "name") ?? providerId;
+                try {
+                    await requireCapability(modelRuntime.logout, "logout").call(modelRuntime, providerId, { signal: AbortSignal.timeout(15_000) });
+                }
+                catch (error) {
+                    const detail = error instanceof Error ? error.message : String(error);
+                    const message = error instanceof CredentialSynchronizationError
+                        ? `Credentials removed for ${providerName}, but local model state could not be synchronized: ${detail}`
+                        : `Logout failed: ${detail}`;
+                    return workflowResult(request.command, "failed", message);
+                }
                 this.#reconcileActiveModelAvailability();
                 this.#emitView();
                 return workflowResult(request.command, "completed", credentialType === "api_key"
@@ -1065,12 +1392,17 @@ export class PiEngineAdapter {
             case "new": {
                 const result = await runtime.newSession();
                 if (isRecord(result) && result.cancelled === true)
-                    return workflowResult(request.command, "cancelled", "New session cancelled");
-                return workflowResult(request.command, "completed", "✓ New session started");
+                    return workflowResult(request.command, "cancelled", "New session cancelled", undefined, "silent");
+                return workflowResult(request.command, "completed", "✓ New session started", undefined, "accent");
             }
             case "compact": {
-                await session.compact(argument || undefined);
-                return workflowResult(request.command, "completed", "Compaction requested");
+                try {
+                    await session.compact(argument || undefined);
+                    return workflowResult(request.command, "completed", "Compaction requested", undefined, "silent");
+                }
+                catch (error) {
+                    return workflowResult(request.command, "failed", error instanceof Error ? error.message : String(error), undefined, "silent");
+                }
             }
             case "resume": {
                 if (!selection && !argument)
@@ -1079,7 +1411,7 @@ export class PiEngineAdapter {
                 try {
                     const result = await runtime.switchSession(sessionPath);
                     if (isRecord(result) && result.cancelled === true)
-                        return workflowResult(request.command, "cancelled", "Resume cancelled");
+                        return workflowResult(request.command, "cancelled", "Resume cancelled", undefined, "silent");
                     return workflowResult(request.command, "completed", "Resumed session");
                 }
                 catch (error) {
@@ -1092,18 +1424,18 @@ export class PiEngineAdapter {
                         return workflowConfirmation(request.command, `cwd from session file does not exist\n${sessionCwd}\n\ncontinue in current cwd\n${fallbackCwd}`);
                     }
                     if (!request.confirmed)
-                        return workflowResult(request.command, "cancelled", "Resume cancelled");
+                        return workflowResult(request.command, "cancelled", "Resume cancelled", undefined, "status");
                     const result = await runtime.switchSession(sessionPath, { cwdOverride: fallbackCwd });
                     if (isRecord(result) && result.cancelled === true)
-                        return workflowResult(request.command, "cancelled", "Resume cancelled");
+                        return workflowResult(request.command, "cancelled", "Resume cancelled", undefined, "silent");
                     return workflowResult(request.command, "completed", "Resumed session in current cwd");
                 }
             }
             case "reload": {
                 if (session.isStreaming)
-                    return workflowResult(request.command, "failed", "Wait for the current response to finish before reloading.");
+                    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.");
+                    return workflowResult(request.command, "failed", "Wait for compaction to finish before reloading.", undefined, "warning");
                 await requireCapability(session.reload, "reload").call(session);
                 await this.#bindExtensionUiToSession();
                 return workflowResult(request.command, "completed", "Reloaded keybindings, extensions, skills, prompts, themes, and context files");
@@ -1124,6 +1456,91 @@ export class PiEngineAdapter {
                 return workflowResult(request.command, "completed", "Demented elves announcement");
         }
     }
+    async #completeProviderAuthentication(providerId, providerName, authType, previousModel) {
+        const session = this.#requireWorkflowSession();
+        const modelRuntime = this.#runtime?.services.modelRuntime;
+        if (!modelRuntime)
+            throw new Error("engine runtime is unavailable");
+        const actionLabel = authType === "oauth" ? `Logged in to ${providerName}` : `Saved API key for ${providerName}`;
+        let selectedModelId;
+        let selectionError;
+        if (isUnknownModel(previousModel)) {
+            const available = modelRuntime.getAvailableSnapshot?.() ?? [];
+            const providerModels = available.filter(model => stringProperty(model, "provider") === providerId);
+            const defaultModelId = PINNED_DEFAULT_MODEL_BY_PROVIDER[providerId];
+            if (defaultModelId === undefined) {
+                selectionError = `${actionLabel}, but no default model is configured for provider "${providerId}". Use /model to select a model.`;
+            }
+            else if (providerModels.length === 0) {
+                selectionError = `${actionLabel}, but no models are available for that provider. Use /model to select a model.`;
+            }
+            else {
+                const selectedModel = providerModels.find(model => stringProperty(model, "id") === defaultModelId);
+                if (selectedModel === undefined) {
+                    selectionError = `${actionLabel}, but its default model "${defaultModelId}" is not available. Use /model to select a model.`;
+                }
+                else {
+                    try {
+                        await session.setModel(selectedModel);
+                        selectedModelId = stringProperty(selectedModel, "id") ?? defaultModelId;
+                        this.#activeModel = {
+                            providerId,
+                            modelId: selectedModelId,
+                            displayName: stringProperty(selectedModel, "name") ?? selectedModelId,
+                        };
+                    }
+                    catch (error) {
+                        selectionError = `${actionLabel}, but selecting its default model failed: ${error instanceof Error ? error.message : String(error)}. Use /model to select a model.`;
+                    }
+                }
+            }
+        }
+        this.#reconcileActiveModelAvailability();
+        this.#emitView();
+        const status = `${actionLabel}.${selectedModelId ? ` Selected ${selectedModelId}.` : ""} Credentials saved to ${join(this.#agentDir, "auth.json")}`;
+        const messages = [
+            { kind: "status", message: status },
+            ...(selectionError === undefined ? [] : [{ kind: "error", message: selectionError }]),
+        ];
+        this.#scheduleAuthenticatedProviderRefresh(providerId, actionLabel);
+        return workflowResult("login", "completed", status, undefined, "status", messages);
+    }
+    #scheduleAuthenticatedProviderRefresh(providerId, actionLabel) {
+        const runtime = this.#runtime;
+        const refresh = runtime?.services.modelRuntime.refresh;
+        if (!runtime || typeof refresh !== "function")
+            return;
+        const generation = this.#sessionGeneration;
+        const publish = this.#workflowInteraction.publish;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), AUTH_REFRESH_TIMEOUT_MS);
+        // Compatibility: post-authentication refresh starts on the next turn so its notices follow the saved-credential status.
+        void new Promise(resolve => setTimeout(resolve, 0))
+            .then(() => refresh.call(runtime.services.modelRuntime, { providers: [providerId], signal: controller.signal }))
+            .then(result => {
+            if (this.#disposed || this.#sessionGeneration !== generation)
+                return;
+            if (isRecord(result) && result.aborted === true) {
+                publish?.({ kind: "warning", message: `${actionLabel}, but its model catalog refresh timed out; using cached models.` });
+            }
+            else if (isRecord(result) && result.errors instanceof Map && result.errors.size > 0) {
+                publish?.({ kind: "warning", message: `${actionLabel}, but its model catalog could not be refreshed; using cached models.` });
+            }
+            this.#reconcileActiveModelAvailability();
+            this.#emitView();
+        })
+            .catch(error => {
+            if (this.#disposed || this.#sessionGeneration !== generation)
+                return;
+            publish?.({
+                kind: "warning",
+                message: controller.signal.aborted
+                    ? `${actionLabel}, but its model catalog refresh timed out; using cached models.`
+                    : `${actionLabel}, but its model catalog could not be refreshed: ${error instanceof Error ? error.message : String(error)}`,
+            });
+        })
+            .finally(() => clearTimeout(timeout));
+    }
     #requireWorkflowSession() {
         if (this.#disposed || !this.#runtime || !this.#session)
             throw new Error("engine adapter is not running");
@@ -1221,7 +1638,7 @@ export class PiEngineAdapter {
             return [];
         return sessionInfoOptions(await SessionManager.list(cwd, typeof sessionDir === "string" ? sessionDir : undefined));
     }
-    #applyPinnedSetting(selection, selectedValue, hasSelectedValue = false) {
+    async #applyPinnedSetting(selection, selectedValue, hasSelectedValue = false) {
         if (!PINNED_PI_SETTINGS_CALLBACKS.includes(selection)) {
             return workflowResult("settings", "failed", `Unknown setting callback: ${selection}`);
         }
@@ -1268,29 +1685,19 @@ export class PiEngineAdapter {
             selectedValue = currentValues[callback];
             hasSelectedValue = true;
         }
-        const settings = this.#runtime?.services.settingsManager;
-        if (!settings)
+        const port = this.settingsPort();
+        if (port === null)
             return workflowResult("settings", "failed", "Settings are unavailable");
-        const session = this.#requireWorkflowSession();
-        if (callback === "onThinkingLevelChange") {
-            if (!isThinkingLevel(selectedValue))
-                return workflowResult("settings", "failed", "Thinking level is invalid");
-            session.setThinkingLevel(selectedValue);
-        }
-        else {
-            const key = settingKeyForCallback(callback);
-            if (key === null)
-                return workflowResult("settings", "failed", `${settingLabel(callback)} is unavailable in this runtime`);
-            const value = agentJsonValue(selectedValue);
-            if (callback === "onAutoCompactChange") {
-                if (typeof value !== "boolean")
-                    return workflowResult("settings", "failed", "Auto compact value is invalid");
-                session.setAutoCompactionEnabled?.(value);
-            }
-            new PiSettingsIntegration(settings).writeSettingNow(key, value);
+        const key = settingKeyForCallback(callback);
+        if (key === null)
+            return workflowResult("settings", "failed", `${settingLabel(callback)} is unavailable in this runtime`);
+        const result = await port.writeSetting(key, agentJsonValue(selectedValue));
+        if (result.status === "failed" || result.status === "unavailable") {
+            return workflowResult("settings", "failed", result.failure ?? result.limitationReason ?? `${settingLabel(callback)} is unavailable`);
         }
         this.#emitView();
-        return workflowResult("settings", "completed", `${settingLabel(callback)}: ${String(selectedValue)}`);
+        const suffix = result.status === "deferred" ? ` (${result.application})` : "";
+        return workflowResult("settings", "completed", `${settingLabel(callback)}: ${String(selectedValue)}${suffix}`);
     }
     async #perform(command) {
         const runtime = this.#runtime;
@@ -1305,7 +1712,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}`);
@@ -1365,6 +1776,7 @@ export class PiEngineAdapter {
         this.#activeModel = readModel(session.model);
         this.#reconcileActiveModelAvailability();
         this.#thinkingLevel = readThinkingLevel(session.thinkingLevel);
+        this.#transcriptImageAssets.clear();
         this.#rebuildTranscript(session.messages, "finalized");
         this.#unsubscribe = session.subscribe(event => this.#handlePiEvent(event));
         if (this.#extensionUi !== undefined)
@@ -1414,7 +1826,24 @@ export class PiEngineAdapter {
             this.#emitView();
         }
     }
-    /** Shows the state named by `kind`, which becomes the state a later end can clear. */
+    // Performance: replacing the transcript rebuilds its index so block lookup stays constant-time.
+    #setTranscript(blocks) {
+        this.#transcript = blocks;
+        this.#transcriptIndex.clear();
+        for (const [index, block] of blocks.entries())
+            this.#transcriptIndex.set(block.id, index);
+        const retainedAssets = new Set(blocks.flatMap(block => block.imageReferences?.map(reference => reference.assetId) ?? []));
+        for (const assetId of this.#transcriptImageAssets.keys()) {
+            if (!retainedAssets.has(assetId))
+                this.#transcriptImageAssets.delete(assetId);
+        }
+        this.#transcriptSnapshot = undefined;
+    }
+    #transcriptBlock(id) {
+        const index = this.#transcriptIndex.get(id);
+        return index === undefined ? undefined : this.#transcript[index];
+    }
+    // Invariant: the named work state is the only state a matching end may clear.
     #enterWorkState(kind, message) {
         const wasBusy = this.#lifecycle === "busy";
         this.#statusKind = kind;
@@ -1424,21 +1853,16 @@ export class PiEngineAdapter {
             this.#emitEvent({ type: "session-lifecycle", lifecycle: "busy", reason: null });
         this.#emitEvent({ type: "status", status: this.#status });
     }
-    /**
-     * Ends one named state. A state the shell is not in is left alone, so a finished
-     * compaction or retry cannot clear the working state it never replaced. While the run
-     * continues, ending either of those returns to working rather than to idle.
-     */
+    // Invariant: ending retry or compaction cannot clear a different active work state.
     #endWorkState(kind) {
         if (this.#statusKind !== kind)
             return;
         if (this.#agentRunActive) {
-            this.#enterWorkState("working", "Working...");
+            this.#enterWorkState("working", "Working");
             return;
         }
         this.#leaveWorkStates();
     }
-    /** Leaves every work state and reports the session idle. */
     #leaveWorkStates() {
         this.#statusKind = null;
         this.#lifecycle = "ready";
@@ -1449,28 +1873,41 @@ export class PiEngineAdapter {
     #handlePiEvent(event) {
         if (!isRecord(event) || typeof event.type !== "string")
             return;
+        // Invariant: usage moves at message and lifecycle boundaries, not with stream chunks, so the
+        // two streaming event kinds keep the memo and everything else drops it.
+        if (event.type !== "message_update" && event.type !== "tool_execution_update")
+            this.#usageCache = undefined;
         switch (event.type) {
             case "agent_start":
                 this.#agentRunActive = true;
-                this.#enterWorkState("working", "Working...");
+                this.#emitEvent({ type: "agent-run-started" });
+                this.#enterWorkState("working", "Working");
                 return;
             case "message_start":
                 this.#upsertMessageBlock(event.message, "live");
                 return;
             case "message_update": {
-                const block = this.#upsertMessageBlock(event.message, "live");
-                if (block && isRecord(event.assistantMessageEvent) && typeof event.assistantMessageEvent.delta === "string") {
-                    this.#upsertTranscriptBlock({
-                        ...block,
-                        text: block.text.endsWith(event.assistantMessageEvent.delta)
-                            ? block.text
-                            : `${block.text}${event.assistantMessageEvent.delta}`,
-                    });
+                const delta = isRecord(event.assistantMessageEvent) && typeof event.assistantMessageEvent.delta === "string"
+                    ? event.assistantMessageEvent.delta
+                    : undefined;
+                // Invariant: the delta is folded in before the block is stored, so a chunk is one update to
+                // one block rather than a store without the delta followed by a store with it.
+                const blocks = this.#messageBlocks(event.message, "live", this.#transcript.length);
+                for (const [index, block] of blocks.entries()) {
+                    this.#upsertTranscriptBlock(index === 0 && delta !== undefined && !block.text.endsWith(delta)
+                        ? { ...block, text: `${block.text}${delta}` }
+                        : block);
                 }
                 return;
             }
             case "message_end":
                 this.#upsertMessageBlock(event.message, "finalized");
+                // Compatibility: preserve the same semantic boundary v2 counted. Transcript block
+                // finalization is intentionally not a substitute: rebuilds, retries,
+                // thinking parts, and tool rows can all finalize independently.
+                if (isRecord(event.message) && event.message.role === "assistant") {
+                    this.#emitEvent({ type: "assistant-message-completed" });
+                }
                 return;
             case "turn_end":
                 this.#upsertMessageBlock(event.message, "finalized");
@@ -1480,10 +1917,17 @@ export class PiEngineAdapter {
                 }
                 return;
             case "tool_execution_start":
-            case "tool_execution_update":
-            case "tool_execution_end":
+            case "tool_execution_end": {
+                // Concurrency: the end supersedes any update still waiting on the coalescing timer.
+                const toolCallId = stringValue(event.toolCallId);
+                if (toolCallId !== undefined)
+                    this.#pendingToolUpdates.delete(toolCallId);
                 this.#upsertToolExecutionBlock(event);
                 return;
+            }
+            case "tool_execution_update":
+                this.#coalesceToolExecutionUpdate(event);
+                return;
             case "agent_settled":
             case "agent_end": {
                 if (event.type === "agent_end" && event.willRetry === true)
@@ -1494,8 +1938,8 @@ export class PiEngineAdapter {
                 if (finalMessages.length > 0)
                     this.#rebuildTranscript(finalMessages, "finalized");
                 else
-                    this.#transcript = this.#transcript.map(block => block.status === "live" ? { ...block, status: "finalized" } : block);
-                // Ending a turn leaves the working state, as the recorded pinned baseline does, but
+                    this.#setTranscript(this.#transcript.map(block => block.status === "live" ? { ...block, status: "finalized" } : block));
+                // Compatibility: ending a turn leaves the working state, as the recorded pinned baseline does, but
                 // it leaves only that state: a compaction or retry being shown outlives the turn
                 // that ended under it. Settlement ends the run, and with it every state — the
                 // engine ends a turn for each continuation it makes and settles once.
@@ -1521,13 +1965,13 @@ export class PiEngineAdapter {
                 return;
             }
             case "auto_retry_start":
-                this.#enterWorkState("retry", "Retrying…");
+                this.#enterWorkState("retry", "Retrying");
                 return;
             case "auto_retry_end":
                 this.#endWorkState("retry");
                 return;
             case "compaction_start":
-                this.#enterWorkState("compaction", "Compacting…");
+                this.#enterWorkState("compaction", "Compacting");
                 return;
             case "compaction_end":
                 this.#endWorkState("compaction");
@@ -1620,7 +2064,13 @@ export class PiEngineAdapter {
                 }
             }
         }
-        this.#transcript = blocks;
+        // Performance: an authoritative rebuild restates most of what is already there. Reusing the block
+        // that already says it keeps its revision, and with it the rows the shell rendered for
+        // it — otherwise every turn that ends re-renders the whole session.
+        this.#setTranscript(blocks.map(block => {
+            const existing = this.#transcriptBlock(block.id);
+            return existing !== undefined && sameBlockContent(existing, block) ? existing : block;
+        }));
     }
     #upsertMessageBlock(message, status) {
         const blocks = this.#messageBlocks(message, status, this.#transcript.length);
@@ -1641,7 +2091,12 @@ export class PiEngineAdapter {
                     revision: this.#nextBlockRevision(baseId),
                     title: "User",
                     text: textFromContent(message.content),
-                    payload: { role: "user", imageCount: contentImageCount(message.content) },
+                    imageReferences: this.#imageReferences(message.content, "user"),
+                    payload: {
+                        role: "user",
+                        imageCount: contentImageCount(message.content),
+                        timestamp: typeof message.timestamp === "number" && Number.isFinite(message.timestamp) ? message.timestamp : null,
+                    },
                 }];
         }
         if (message.role === "bashExecution") {
@@ -1705,7 +2160,7 @@ export class PiEngineAdapter {
                 : this.#toolBlockIds.get(toolCallId) ?? `tool-${toolCallId}`;
             if (toolCallId !== undefined)
                 this.#toolBlockIds.set(toolCallId, blockId);
-            const existing = this.#transcript.find(block => block.id === blockId);
+            const existing = this.#transcriptBlock(blockId);
             const existingPayload = isRecord(existing?.payload) ? existing.payload : undefined;
             return [{
                     id: blockId,
@@ -1714,6 +2169,7 @@ export class PiEngineAdapter {
                     revision: this.#nextBlockRevision(blockId),
                     title: stringValue(message.toolName) ?? existing?.title ?? "Tool result",
                     text: textFromContent(message.content),
+                    imageReferences: this.#imageReferences(message.content, "tool-result"),
                     payload: {
                         ...(existingPayload ?? {}),
                         role: "toolResult",
@@ -1769,6 +2225,48 @@ export class PiEngineAdapter {
         }
         return blocks;
     }
+    #imageReferences(content, source) {
+        if (!Array.isArray(content))
+            return [];
+        const references = [];
+        for (const item of content) {
+            if (references.length >= 16 || !isRecord(item) || item.type !== "image"
+                || typeof item.data !== "string" || item.data.length === 0
+                || typeof item.mimeType !== "string" || !/^image\/[a-z0-9.+-]+$/i.test(item.mimeType))
+                continue;
+            const byteLength = Buffer.from(item.data, "base64").byteLength;
+            if (byteLength < 1 || byteLength > 20 * 1024 * 1024)
+                continue;
+            const assetId = `image-${createHash("sha256").update(item.mimeType).update("\0").update(item.data).digest("hex").slice(0, 24)}`;
+            this.#transcriptImageAssets.set(assetId, { type: "image", data: item.data, mimeType: item.mimeType });
+            references.push({ assetId, mimeType: item.mimeType, byteLength, source });
+        }
+        return references;
+    }
+    // Performance: coalescing each tool to its newest chunk bounds work by frames, not stream events.
+    #coalesceToolExecutionUpdate(event) {
+        const toolCallId = stringValue(event.toolCallId);
+        if (!toolCallId)
+            return;
+        this.#pendingToolUpdates.set(toolCallId, event);
+        this.#toolUpdateFlush ??= setTimeout(() => {
+            this.#toolUpdateFlush = null;
+            if (!this.#disposed)
+                this.#flushPendingToolUpdates();
+        }, TOOL_UPDATE_COALESCE_MS);
+    }
+    #flushPendingToolUpdates() {
+        if (this.#toolUpdateFlush !== null) {
+            clearTimeout(this.#toolUpdateFlush);
+            this.#toolUpdateFlush = null;
+        }
+        if (this.#pendingToolUpdates.size === 0)
+            return;
+        const pending = [...this.#pendingToolUpdates.values()];
+        this.#pendingToolUpdates.clear();
+        for (const update of pending)
+            this.#upsertToolExecutionBlock(update);
+    }
     #upsertToolExecutionBlock(event) {
         const toolCallId = stringValue(event.toolCallId);
         if (!toolCallId)
@@ -1788,7 +2286,9 @@ export class PiEngineAdapter {
                 toolCallId,
                 toolName: stringValue(event.toolName) ?? "unknown",
                 arguments: jsonSummary(event.args),
-                result: jsonSummary(source),
+                // Performance: a partial result repeats the whole accumulated output on every chunk;
+                // summarizing it each time would cost quadratic work over the stream.
+                result: ended ? jsonSummary(source) : { summary: "", json: null },
                 partialResult: event.type === "tool_execution_update",
                 argsComplete: ended,
                 isError: event.isError === true,
@@ -1796,11 +2296,20 @@ export class PiEngineAdapter {
         });
     }
     #upsertTranscriptBlock(block) {
-        const index = this.#transcript.findIndex(existing => existing.id === block.id);
-        if (index >= 0)
+        const index = this.#transcriptIndex.get(block.id);
+        if (index !== undefined) {
+            const existing = this.#transcript[index];
+            // Performance: nothing is emitted for a block that repeats itself, and keeping the
+            // revision keeps the rows it already rendered.
+            if (existing !== undefined && sameBlockContent(existing, block))
+                return;
             this.#transcript[index] = block;
-        else
+        }
+        else {
+            this.#transcriptIndex.set(block.id, this.#transcript.length);
             this.#transcript.push(block);
+        }
+        this.#transcriptSnapshot = undefined;
         this.#emitEvent({ type: "transcript-block", block });
     }
     #messageBlockId(message, fallbackIndex, status, occurrence) {
@@ -1818,7 +2327,7 @@ export class PiEngineAdapter {
             }
         }
         else {
-            id = [...cached].reverse().find(candidate => this.#transcript.some(block => block.id === candidate && block.status === "live"));
+            id = [...cached].reverse().find(candidate => this.#transcriptBlock(candidate)?.status === "live");
             if (id === undefined && status === "finalized")
                 id = cached.at(-1);
             if (id === undefined) {
@@ -1831,7 +2340,7 @@ export class PiEngineAdapter {
         return id;
     }
     #nextBlockRevision(id) {
-        const existing = this.#transcript.find(block => block.id === id);
+        const existing = this.#transcriptBlock(id);
         if (existing)
             return existing.revision + 1;
         this.#nextBlockSequence += 1;
@@ -1862,6 +2371,7 @@ export class PiEngineAdapter {
         this.#emitEvent({ type: "diagnostic", diagnostic });
     }
     #emitView() {
+        this.#usageCache = undefined;
         this.#viewRevision += 1;
         this.#emitEvent({ type: "session-view", view: this.view() });
     }
@@ -1906,7 +2416,7 @@ export class PiEngineAdapter {
                     }
                 }
                 deliveredSinceYield += 1;
-                // A microtask chain runs to exhaustion before the loop turns, so a streaming
+                // Concurrency: a microtask chain runs to exhaustion before the loop turns, so a streaming
                 // burst would hold typed input, pointer reports, and timed indicators until it
                 // drained. Yielding on a macrotask hands those their turn between batches.
                 if (deliveredSinceYield >= EVENT_DELIVERY_BATCH && this.#eventQueue.length > 0) {
@@ -1950,7 +2460,14 @@ export async function createPiEngineAdapter(options = {}) {
     return adapter;
 }
 async function createDefaultPiRuntime(input) {
-    return createPiRuntimeIntegration({ cwd: input.cwd, agentDir: input.agentDir });
+    return createPiRuntimeIntegration({
+        cwd: input.cwd,
+        agentDir: input.agentDir,
+        ...(input.sessionPath === undefined ? {} : { sessionPath: input.sessionPath }),
+        ...(input.sessionSelection === undefined ? {} : { sessionSelection: input.sessionSelection }),
+        ...(input.sessionForkPrompt === undefined ? {} : { sessionForkPrompt: input.sessionForkPrompt }),
+        ...(input.projectTrustPrompt === undefined ? {} : { projectTrustPrompt: input.projectTrustPrompt }),
+    });
 }
 async function checkDefaultPiPackageUpdates(cwd, agentDir, settingsManager) {
     const packageManager = new DefaultPackageManager({ cwd, agentDir, settingsManager });
@@ -2073,8 +2590,8 @@ function pinnedCacheWaste(entries, modelRuntime) {
 function defaultWorkflowHost() {
     return {
         copyText: copyToClipboard,
-        async runCommand(command, arguments_) {
-            const result = await execFileAsync(command, [...arguments_], { encoding: "utf8" });
+        async runCommand(command, arguments_, options) {
+            const result = await execFileAsync(command, [...arguments_], { encoding: "utf8", signal: options?.signal });
             return { stdout: result.stdout, stderr: result.stderr };
         },
         readChangelog: async () => "No changelog entries found.",
@@ -2110,14 +2627,22 @@ function workflowLoginNotification(event) {
     }
     return { type: event.type === "waiting" ? "waiting" : "progress", message };
 }
-function workflowResult(command, outcome, message, detail) {
-    return { command, outcome, message, ...(detail === undefined ? {} : { detail }) };
+function workflowResult(command, outcome, message, detail, messageKind, messages) {
+    return {
+        command,
+        outcome,
+        message,
+        ...(detail === undefined ? {} : { detail }),
+        ...(messageKind === undefined ? {} : { messageKind }),
+        ...(messages === undefined ? {} : { messages: Object.freeze([...messages]) }),
+    };
 }
-function workflowConfirmation(command, message) {
+function workflowConfirmation(command, message, detail) {
     return {
         command,
         outcome: "requires-confirmation",
         message,
+        ...(detail === undefined ? {} : { detail }),
         selectorTitle: "Confirm",
         options: [
             { id: "yes", label: "Yes" },
@@ -2125,6 +2650,19 @@ function workflowConfirmation(command, message) {
         ],
     };
 }
+function errorMessage(error, fallback) {
+    return error instanceof Error ? error.message : fallback;
+}
+function commandMissing(error) {
+    return isRecord(error) && error.code === "ENOENT";
+}
+function isAbortError(error) {
+    return isRecord(error) && (error.name === "AbortError" || error.code === "ABORT_ERR");
+}
+function shareViewerUrl(gistId) {
+    const baseUrl = process.env.PI_SHARE_VIEWER_URL || "https://pi.dev/session/";
+    return `${baseUrl}#${gistId}`;
+}
 function workflowOptions(value, idKey, labelKey) {
     if (!Array.isArray(value))
         return [];
@@ -2176,7 +2714,7 @@ function settingKeyForCallback(callback) {
         onAutoCompactChange: "autoCompact", onShowImagesChange: "showImages", onImageWidthCellsChange: "imageWidthCells",
         onAutoResizeImagesChange: "autoResizeImages", onBlockImagesChange: "blockImages", onEnableSkillCommandsChange: "enableSkillCommands",
         onSteeringModeChange: "steeringMode", onFollowUpModeChange: "followUpMode", onTransportChange: "transport",
-        onHttpIdleTimeoutMsChange: "httpIdleTimeoutMs", onThemeChange: "theme", onThemePreview: "theme",
+        onHttpIdleTimeoutMsChange: "httpIdleTimeoutMs", onThinkingLevelChange: "thinkingLevel", onThemeChange: "theme", onThemePreview: "theme",
         onHideThinkingBlockChange: "hideThinkingBlock", onMermaidRenderingModeChange: "mermaidRenderingMode",
         onShowCacheMissNoticesChange: "showCacheMissNotices", onCollapseChangelogChange: "collapseChangelog",
         onEnableInstallTelemetryChange: "enableInstallTelemetry", onQuietStartupChange: "quietStartup",
@@ -2343,6 +2881,24 @@ function stringProperty(value, key) {
     const item = value[key];
     return typeof item === "string" && item.length > 0 ? item : undefined;
 }
+function isUnknownModel(value) {
+    return isRecord(value)
+        && value.provider === "unknown"
+        && value.id === "unknown"
+        && value.api === "unknown";
+}
+function findExactWorkflowModel(reference, models) {
+    const normalized = reference.trim().toLowerCase();
+    const canonical = models.filter(model => {
+        const provider = stringProperty(model, "provider");
+        const id = stringProperty(model, "id");
+        return provider !== undefined && id !== undefined && `${provider}/${id}`.toLowerCase() === normalized;
+    });
+    if (canonical.length === 1)
+        return canonical[0];
+    const bare = models.filter(model => stringProperty(model, "id")?.toLowerCase() === normalized);
+    return bare.length === 1 ? bare[0] : undefined;
+}
 /**
  * Some ecosystem extensions retain a `pi-<name>` slash-command alias beside
  * their unprefixed command. A1 presents the product-neutral command once while
@@ -2367,6 +2923,37 @@ function compactResourceLabel(path) {
     const segments = path.replaceAll("\\", "/").split("/").filter(Boolean);
     return segments.at(-1) ?? path;
 }
+/**
+ * Whether two blocks say the same thing. A block that says what it already said is not a
+ * new revision: the shell renders a block once per revision, so bumping one it did not
+ * need re-renders it for nothing.
+ */
+function sameBlockContent(left, right) {
+    return left.kind === right.kind
+        && left.status === right.status
+        && left.title === right.title
+        && left.text === right.text
+        && sameValue(left.payload, right.payload)
+        && sameValue(left.imageReferences ?? [], right.imageReferences ?? []);
+}
+function sameValue(left, right) {
+    if (left === right)
+        return true;
+    if (typeof left !== typeof right || left === null || right === null)
+        return false;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length)
+            return false;
+        return left.every((value, index) => sameValue(value, right[index]));
+    }
+    if (typeof left !== "object")
+        return false;
+    const leftKeys = Object.keys(left);
+    const rightRecord = right;
+    if (leftKeys.length !== Object.keys(rightRecord).length)
+        return false;
+    return leftKeys.every(key => Object.hasOwn(rightRecord, key) && sameValue(left[key], rightRecord[key]));
+}
 function textFromContent(content) {
     if (typeof content === "string")
         return content;