@timurproko/a1 0.1.8-dev.49ff83a → 0.1.8-dev.508

package/dist/src/foundation/pi-engine-adapter/adapter.js

@@ -1,2367 +0,0 @@
-import { execFile } from "node:child_process";
-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 { PINNED_PI_SETTINGS_CALLBACKS, PINNED_PI_WORKFLOW_COMMAND_NAMES, } from "./workflows.js";
-import { createPiRuntimeIntegration } from "./runtime-integration.js";
-import { PiSessionCommandIntegration } from "./session-integration.js";
-import { PiSettingsIntegration } from "./settings-integration.js";
-const execFileAsync = promisify(execFile);
-const DEFAULT_SURFACE = {
-    columns: 100,
-    rows: 32,
-    focusedRegion: "editor",
-    hardwareCursor: false,
-};
-export class PiEngineAdapter {
-    #runtimeFactory;
-    #checkPackageUpdates;
-    #cwd;
-    #agentDir;
-    #sessionId;
-    #workflowHost;
-    #workflowInteraction;
-    #listeners = new Set();
-    #runtime;
-    #session;
-    #unsubscribe;
-    #sequence = 0;
-    #viewRevision = 0;
-    #lifecycle = "starting";
-    #editor = {
-        text: "",
-        queuedSubmissions: [],
-        selection: null,
-        cursorOffset: 0,
-        historyRevision: 0,
-        submitEnabled: false,
-    };
-    #sessionGeneration = 0;
-    #status = {
-        title: "Pi",
-        workingMessage: null,
-        diagnostics: [],
-        badges: [],
-    };
-    #terminal = DEFAULT_SURFACE;
-    #activeModel = null;
-    #thinkingLevel = "medium";
-    #activeCommandIds = [];
-    #completedCommands = new Map();
-    #transcript = [];
-    #messageBlockIds = new WeakMap();
-    #messageFallbackIds = new Map();
-    #toolBlockIds = new Map();
-    #nextBlockSequence = 0;
-    #diagnostics = [];
-    #eventQueue = [];
-    #eventQueueProcessing;
-    #droppedEventCount = 0;
-    #sessionCommands;
-    #gitBranch = null;
-    #extensionUi;
-    #extensionShutdown;
-    #extensionBound = false;
-    #disposed = false;
-    /** Lists the themes installed on this machine, when the caller supplies one. */
-    #availableThemes;
-    constructor(options = {}) {
-        this.#cwd = options.cwd ?? process.cwd();
-        this.#agentDir = options.agentDir ?? getAgentDir();
-        this.#sessionId = options.sessionId ?? "owned-session-1";
-        this.#runtimeFactory = options.createRuntime ?? createDefaultPiRuntime;
-        this.#checkPackageUpdates = options.checkPackageUpdates
-            ?? (options.createRuntime
-                ? async () => []
-                : settingsManager => checkDefaultPiPackageUpdates(this.#cwd, this.#agentDir, settingsManager));
-        this.#workflowHost = options.workflowHost ?? defaultWorkflowHost();
-        this.#availableThemes = options.availableThemes ?? null;
-        this.#workflowInteraction = { prompt: async () => null, notify() { } };
-    }
-    setWorkflowInteractionHost(interaction) {
-        this.#workflowInteraction = interaction;
-    }
-    get sessionId() {
-        return this.#sessionId;
-    }
-    get sessionGeneration() {
-        return this.#sessionGeneration;
-    }
-    get agentDir() {
-        return this.#agentDir;
-    }
-    get disposed() {
-        return this.#disposed;
-    }
-    async start() {
-        if (this.#runtime)
-            return this.view();
-        const runtime = await this.#runtimeFactory({
-            cwd: this.#cwd,
-            agentDir: this.#agentDir,
-            sessionId: this.#sessionId,
-        }).catch(error => {
-            this.#lifecycle = "failed";
-            this.#addDiagnostic("error", "engine-startup", error instanceof Error ? error.message : String(error), false);
-            throw error;
-        });
-        this.#runtime = runtime;
-        this.#gitBranch = await readGitBranch(this.#cwd);
-        this.#terminal = {
-            ...this.#terminal,
-            hardwareCursor: runtime.services.settingsManager?.getShowHardwareCursor?.() ?? this.#terminal.hardwareCursor,
-        };
-        runtime.setRebindSession(async (session) => {
-            this.#bindSession(session);
-            this.#emitView();
-        });
-        for (const diagnostic of [...runtime.diagnostics, ...runtime.services.diagnostics]) {
-            this.#addDiagnostic(diagnostic.type === "error" ? "error" : diagnostic.type === "warning" ? "warning" : "info", "engine-startup", diagnostic.message, diagnostic.type !== "error");
-        }
-        this.#bindSession(runtime.session);
-        this.#lifecycle = "ready";
-        this.#editor = { ...this.#editor, submitEnabled: true };
-        this.#emitEvent({ type: "session-lifecycle", lifecycle: "ready", reason: null });
-        this.#emitView();
-        void this.#announcePackageUpdates(runtime.services.settingsManager);
-        return this.view();
-    }
-    async #announcePackageUpdates(settingsManager) {
-        if (process.env.PI_OFFLINE)
-            return;
-        let updates;
-        try {
-            updates = await this.#checkPackageUpdates(settingsManager);
-        }
-        catch {
-            return;
-        }
-        if (this.#disposed || updates.length === 0)
-            return;
-        const packages = updates.map(name => `- ${name}`).join("\n");
-        this.#addDiagnostic("info", "package-updates", `Package updates are available. Run pi update --extensions\nPackages:\n${packages}`, true);
-        this.#emitView();
-    }
-    onEvent(listener) {
-        this.#listeners.add(listener);
-        listener(this.#event({ type: "session-view", view: this.view() }));
-        return () => this.#listeners.delete(listener);
-    }
-    async flushEvents() {
-        while (this.#eventQueueProcessing)
-            await this.#eventQueueProcessing;
-    }
-    nonVisualResources() {
-        const loader = this.#runtime?.services.resourceLoader;
-        if (!loader)
-            return [];
-        const resources = [];
-        const skills = collectionResult(loader.getSkills(), "skills");
-        for (const [index, skill] of skills.values.entries()) {
-            resources.push({
-                kind: "skill",
-                id: `skill-${index}-${stringProperty(skill, "name") ?? "unknown"}`,
-                label: stringProperty(skill, "name") ?? "Unnamed skill",
-                sourcePath: stringProperty(skill, "filePath") ?? stringProperty(skill, "path") ?? stringProperty(skill, "location") ?? null,
-                diagnostic: null,
-            });
-        }
-        resources.push(...skills.diagnostics.map((diagnostic, index) => ({
-            kind: "skill",
-            id: `skill-diagnostic-${index}`,
-            label: "Skill diagnostic",
-            sourcePath: null,
-            diagnostic,
-        })));
-        const prompts = collectionResult(loader.getPrompts(), "prompts");
-        for (const [index, prompt] of prompts.values.entries()) {
-            resources.push({
-                kind: "prompt-template",
-                id: `prompt-${index}-${stringProperty(prompt, "name") ?? "unknown"}`,
-                label: stringProperty(prompt, "name") ?? "Prompt template",
-                sourcePath: stringProperty(prompt, "filePath") ?? stringProperty(prompt, "path") ?? null,
-                diagnostic: null,
-            });
-        }
-        resources.push(...prompts.diagnostics.map((diagnostic, index) => ({
-            kind: "prompt-template",
-            id: `prompt-diagnostic-${index}`,
-            label: "Prompt diagnostic",
-            sourcePath: null,
-            diagnostic,
-        })));
-        const agentsFilesResult = loader.getAgentsFiles();
-        const agentsFiles = unknownArray(isRecord(agentsFilesResult) ? agentsFilesResult.agentsFiles : undefined);
-        for (const [index, file] of agentsFiles.entries()) {
-            resources.push({
-                kind: "agent-context",
-                id: `agent-context-${index}`,
-                label: "Agent context",
-                sourcePath: stringProperty(file, "path") ?? null,
-                diagnostic: null,
-            });
-        }
-        const systemPrompt = loader.getSystemPromptSource();
-        if (isRecord(systemPrompt) && typeof systemPrompt.path === "string") {
-            resources.push({
-                kind: "system-prompt",
-                id: "system-prompt",
-                label: "System prompt",
-                sourcePath: systemPrompt.path,
-                diagnostic: null,
-            });
-        }
-        for (const [index, source] of unknownArray(loader.getAppendSystemPromptSources()).entries()) {
-            resources.push({
-                kind: "system-prompt",
-                id: `append-system-prompt-${index}`,
-                label: "Append system prompt",
-                sourcePath: stringProperty(source, "path") ?? null,
-                diagnostic: null,
-            });
-        }
-        if (loader.getThemes !== undefined) {
-            const themes = collectionResult(loader.getThemes(), "themes");
-            for (const [index, theme] of themes.values.entries()) {
-                const sourcePath = stringProperty(theme, "sourcePath");
-                if (!sourcePath)
-                    continue;
-                resources.push({
-                    kind: "theme",
-                    id: `theme-${index}-${stringProperty(theme, "name") ?? "unknown"}`,
-                    label: stringProperty(theme, "name") ?? compactResourceLabel(sourcePath),
-                    sourcePath,
-                    diagnostic: null,
-                });
-            }
-            resources.push(...themes.diagnostics.map((diagnostic, index) => ({
-                kind: "theme",
-                id: `theme-diagnostic-${index}`,
-                label: "Theme diagnostic",
-                sourcePath: null,
-                diagnostic,
-            })));
-        }
-        return resources;
-    }
-    extensionResources() {
-        const loader = this.#runtime?.services.resourceLoader;
-        if (loader?.getExtensions === undefined)
-            return [];
-        let result;
-        try {
-            result = loader.getExtensions();
-        }
-        catch (error) {
-            return [extensionResourceDiagnostic(0, null, `Extension discovery failed: ${error instanceof Error ? error.message : String(error)}`)];
-        }
-        if (!isRecord(result))
-            return [extensionResourceDiagnostic(0, null, "Extension discovery returned a malformed result")];
-        const resources = [];
-        if (!Array.isArray(result.extensions)) {
-            resources.push(extensionResourceDiagnostic(resources.length, null, "Extension discovery returned a malformed extensions collection"));
-        }
-        else {
-            for (const extension of result.extensions) {
-                if (!isRecord(extension) || typeof extension.path !== "string" || extension.path.length === 0
-                    || typeof extension.resolvedPath !== "string" || extension.resolvedPath.length === 0
-                    || (extension.hidden !== undefined && typeof extension.hidden !== "boolean")) {
-                    resources.push(extensionResourceDiagnostic(resources.length, null, "Extension discovery returned malformed extension metadata"));
-                    continue;
-                }
-                resources.push({
-                    kind: "extension",
-                    id: `extension-${resources.length}`,
-                    sourcePath: extension.path,
-                    resolvedPath: extension.resolvedPath,
-                    loaded: true,
-                    hidden: extension.hidden === true,
-                    diagnostic: null,
-                });
-            }
-        }
-        if (!Array.isArray(result.errors)) {
-            resources.push(extensionResourceDiagnostic(resources.length, null, "Extension discovery returned a malformed errors collection"));
-        }
-        else {
-            for (const error of result.errors) {
-                if (!isRecord(error) || typeof error.path !== "string" || typeof error.error !== "string") {
-                    resources.push(extensionResourceDiagnostic(resources.length, null, "Extension discovery returned malformed error metadata"));
-                    continue;
-                }
-                resources.push(extensionResourceDiagnostic(resources.length, error.path, error.error));
-            }
-        }
-        return resources;
-    }
-    visualExtensionSupport() {
-        return {
-            available: this.#extensionBound,
-            contractComplete: true,
-            contractVersion: OWNED_UI_EXTENSION_CONTRACT_VERSION,
-            binding: this.#extensionBound ? "bound" : "unbound",
-            uiCallbacks: OWNED_UI_EXTENSION_UI_CALLBACKS,
-            uiProperties: OWNED_UI_EXTENSION_UI_PROPERTIES,
-            renderCallbacks: OWNED_UI_EXTENSION_RENDER_CALLBACKS,
-            diagnostic: this.#extensionBound
-                ? `Pinned public extension UI lifecycle is bound through the ${PRODUCT_IDENTITY.displayName}-owned bridge.`
-                : `The complete ${PRODUCT_IDENTITY.displayName}-owned extension UI contract is available; the active session has not been bound to the owned UI bridge.`,
-        };
-    }
-    async bindExtensionUi(ui, shutdown) {
-        assertPiExtensionUiContext(ui);
-        this.#extensionUi = ui;
-        this.#extensionShutdown = shutdown;
-        await this.#bindExtensionUiToSession();
-    }
-    async unbindExtensionUi() {
-        this.#extensionUi = undefined;
-        this.#extensionShutdown = undefined;
-        this.#extensionBound = false;
-    }
-    workflowAutocompleteCommands() {
-        const commands = [
-            {
-                name: "model",
-                description: "Select model (opens selector UI)",
-                argumentHint: "<provider/model>",
-                argumentOptions: this.#modelOptions(),
-                source: "builtin",
-            },
-            {
-                name: "login",
-                description: "Configure provider authentication",
-                argumentHint: "<provider>",
-                argumentOptions: this.#loginOptions().map(option => ({ ...option, id: option.id.split(":").at(-1) ?? option.id })),
-                source: "builtin",
-            },
-        ];
-        const usedNames = new Set(PINNED_PI_WORKFLOW_COMMAND_NAMES);
-        const loader = this.#runtime?.services.resourceLoader;
-        if (!loader)
-            return commands;
-        const prompts = collectionResult(loader.getPrompts(), "prompts");
-        for (const prompt of prompts.values) {
-            const name = stringProperty(prompt, "name");
-            if (!name || usedNames.has(name))
-                continue;
-            const argumentHint = stringProperty(prompt, "argumentHint");
-            commands.push({
-                name,
-                description: stringProperty(prompt, "description") ?? "Prompt template",
-                ...(argumentHint === undefined ? {} : { argumentHint }),
-                source: "prompt",
-            });
-            usedNames.add(name);
-        }
-        const settings = this.#runtime?.services.settingsManager;
-        const skillsEnabled = settings?.getEnableSkillCommands?.() !== false;
-        if (skillsEnabled) {
-            const skills = collectionResult(loader.getSkills(), "skills");
-            for (const skill of skills.values) {
-                const resourceName = stringProperty(skill, "name");
-                const name = resourceName ? `skill:${resourceName}` : undefined;
-                if (!name || usedNames.has(name))
-                    continue;
-                commands.push({ name, description: stringProperty(skill, "description") ?? "Skill", source: "skill" });
-                usedNames.add(name);
-            }
-        }
-        const extensionCommands = this.#session?.extensionRunner?.getRegisteredCommands?.();
-        if (Array.isArray(extensionCommands)) {
-            for (const command of extensionCommands.filter(isRecord)) {
-                const name = stringProperty(command, "name");
-                if (!name || usedNames.has(name))
-                    continue;
-                commands.push({ name, description: stringProperty(command, "description") ?? "Extension command", source: "extension" });
-                usedNames.add(name);
-            }
-        }
-        return commands;
-    }
-    async cycleModelWorkflow(direction) {
-        try {
-            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 model = readModel(result.model);
-            if (model)
-                this.#activeModel = model;
-            if (result.thinkingLevel !== undefined)
-                this.#thinkingLevel = readThinkingLevel(result.thinkingLevel);
-            this.#emitView();
-            return workflowResult("model", "completed", model ? `Selected model ${model.providerId}/${model.modelId}` : "Selected model");
-        }
-        catch (error) {
-            return workflowResult("model", "failed", error instanceof Error ? error.message : String(error));
-        }
-    }
-    /**
-     * The theme the engine is configured with, in the engine's own grammar: a
-     * theme's name, or a `light/dark` pair meaning "follow the terminal".
-     */
-    configuredTheme() {
-        return this.#runtime?.services.settingsManager.getThemeSetting();
-    }
-    /** Settings port for the live runtime, or null before the runtime is available. */
-    settingsPort() {
-        const settings = this.#runtime?.services.settingsManager;
-        if (!settings)
-            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)) : [];
-            },
-        });
-    }
-    pinnedModelSelectorContext() {
-        const session = this.#requireWorkflowSession();
-        const runtime = this.#runtime;
-        if (!runtime)
-            throw new Error("engine runtime is unavailable");
-        const scoped = session.scopedModels;
-        const modelRuntime = runtime.services.modelRuntime;
-        const selectorRuntime = typeof modelRuntime.getAvailableSnapshot === "function"
-            ? modelRuntime
-            : {
-                getAvailableSnapshot: () => session.model === undefined ? [] : [session.model],
-                getModel: (providerId, modelId) => modelRuntime.getModel(providerId, modelId),
-                getError: () => undefined,
-                refresh: async () => undefined,
-            };
-        const settingsManager = runtime.services.settingsManager;
-        const selectorSettings = typeof settingsManager?.setDefaultModelAndProvider === "function"
-            ? settingsManager
-            : { setDefaultModelAndProvider() { } };
-        return {
-            currentModel: this.#activeModel === null ? undefined : session.model,
-            settingsManager: selectorSettings,
-            modelRuntime: selectorRuntime,
-            scopedModels: Array.isArray(scoped) ? scoped : [],
-        };
-    }
-    pinnedProjectTrustContext() {
-        const runtime = this.#runtime;
-        if (!runtime)
-            throw new Error("engine runtime is unavailable");
-        const cwd = resolve(this.#cwd);
-        const parent = dirname(cwd);
-        const trustStore = new ProjectTrustStore(this.#agentDir);
-        const trustOptions = [
-            { label: "Trust", trusted: true, updates: [{ path: cwd, decision: true }], savedPath: cwd },
-            ...(parent === cwd ? [] : [{
-                    label: `Trust parent folder (${parent})`,
-                    trusted: true,
-                    updates: [{ path: parent, decision: true }, { path: cwd, decision: null }],
-                    savedPath: parent,
-                }]),
-            { label: "Do not trust", trusted: false, updates: [{ path: cwd, decision: false }], savedPath: cwd },
-        ];
-        return {
-            cwd,
-            savedDecision: trustStore.getEntry(cwd),
-            projectTrusted: runtime.services.settingsManager?.isProjectTrusted?.() === true,
-            trustOptions,
-        };
-    }
-    persistProjectTrust(updates) {
-        new ProjectTrustStore(this.#agentDir).setMany([...updates]);
-    }
-    pinnedSessionSelectorContext() {
-        const session = this.#requireWorkflowSession();
-        const manager = session.sessionManager;
-        const cwd = manager?.getCwd?.();
-        const sessionDir = manager?.getSessionDir?.();
-        const currentSessionFilePath = manager?.getSessionFile?.();
-        const usesDefaultSessionDir = manager?.usesDefaultSessionDir?.() === true;
-        const resolvedCwd = typeof cwd === "string" ? cwd : this.#cwd;
-        const resolvedSessionDir = typeof sessionDir === "string" ? sessionDir : undefined;
-        return {
-            currentSessionFilePath: typeof currentSessionFilePath === "string" ? currentSessionFilePath : undefined,
-            loadCurrentSessions: onProgress => SessionManager.list(resolvedCwd, resolvedSessionDir, onProgress),
-            loadAllSessions: onProgress => usesDefaultSessionDir
-                ? SessionManager.listAll(onProgress)
-                : resolvedSessionDir === undefined ? SessionManager.listAll(onProgress) : SessionManager.listAll(resolvedSessionDir, onProgress),
-            renameSession: async (sessionFilePath, nextName) => {
-                const next = (nextName ?? "").trim();
-                if (!next)
-                    return;
-                SessionManager.open(sessionFilePath).appendSessionInfo(next);
-            },
-        };
-    }
-    pinnedScopedModelsContext() {
-        const session = this.#requireWorkflowSession();
-        const runtime = this.#runtime;
-        if (!runtime)
-            throw new Error("engine runtime is unavailable");
-        const models = scopedModelRecords(runtime.services.modelRuntime);
-        const scoped = session.scopedModels;
-        if (Array.isArray(scoped) && scoped.length > 0) {
-            return {
-                models: models.map(item => item.descriptor),
-                enabledModelIds: scoped.map(scopedModelReference).filter((id) => id !== undefined),
-            };
-        }
-        const patterns = runtime.services.settingsManager?.getEnabledModels?.();
-        return {
-            models: models.map(item => item.descriptor),
-            enabledModelIds: Array.isArray(patterns)
-                ? resolveConfiguredModelIds(patterns.filter((value) => typeof value === "string"), models)
-                : null,
-        };
-    }
-    updateScopedModels(enabledModelIds) {
-        const session = this.#requireWorkflowSession();
-        const runtime = this.#runtime;
-        if (!runtime)
-            throw new Error("engine runtime is unavailable");
-        const models = scopedModelRecords(runtime.services.modelRuntime);
-        const availableIds = new Set(models.map(item => `${item.descriptor.provider}/${item.descriptor.id}`));
-        const selected = enabledModelIds?.filter(id => availableIds.has(id)) ?? [];
-        const allAvailableEnabled = enabledModelIds !== null && availableIds.size > 0 && selected.length === availableIds.size;
-        const scoped = enabledModelIds !== null && selected.length > 0 && !allAvailableEnabled
-            ? selected.flatMap(id => {
-                const item = models.find(candidate => `${candidate.descriptor.provider}/${candidate.descriptor.id}` === id);
-                return item === undefined ? [] : [{ model: item.model }];
-            })
-            : [];
-        requireCapability(session.setScopedModels, "setScopedModels").call(session, scoped);
-        this.#emitView();
-    }
-    persistScopedModels(enabledModelIds) {
-        const runtime = this.#runtime;
-        if (!runtime)
-            throw new Error("engine runtime is unavailable");
-        const availableCount = scopedModelRecords(runtime.services.modelRuntime).length;
-        const patterns = enabledModelIds === null || enabledModelIds.length === availableCount
-            ? undefined
-            : [...enabledModelIds];
-        requireCapability(runtime.services.settingsManager?.setEnabledModels, "setEnabledModels").call(runtime.services.settingsManager, patterns === undefined ? undefined : [...patterns]);
-    }
-    async refreshScopedModels(signal) {
-        const runtime = this.#runtime;
-        if (!runtime)
-            throw new Error("engine runtime is unavailable");
-        const result = await runtime.services.modelRuntime.refresh?.({ signal });
-        const context = this.pinnedScopedModelsContext();
-        if (isRecord(result) && result.aborted === true) {
-            return { ...context, status: "Model refresh timed out; showing cached models.", statusKind: "warning" };
-        }
-        const errors = isRecord(result) ? result.errors : undefined;
-        if (errors instanceof Map && errors.size > 0) {
-            return {
-                ...context,
-                status: `Could not refresh ${[...errors.keys()].join(", ")}; showing cached models.`,
-                statusKind: "warning",
-            };
-        }
-        return { ...context, status: "Model catalogs refreshed.", statusKind: "success" };
-    }
-    pinnedLoginOptions(authType) {
-        return this.#loginOptions(authType);
-    }
-    pinnedLoginMethodOptions(providerReference) {
-        const runtime = this.#runtime;
-        if (!runtime)
-            throw new Error("engine runtime is unavailable");
-        const modelRuntime = runtime.services.modelRuntime;
-        const normalized = providerReference.trim().toLowerCase();
-        const providers = modelRuntime.getProviders?.();
-        const matches = Array.isArray(providers) ? providers.filter(isRecord).filter(candidate => stringProperty(candidate, "id")?.toLowerCase() === normalized
-            || stringProperty(candidate, "name")?.toLowerCase() === normalized) : [];
-        const providerId = matches.length === 1 ? stringProperty(matches[0], "id") ?? providerReference : providerReference;
-        const provider = modelRuntime.getProvider?.(providerId);
-        const providerName = stringProperty(provider, "name") ?? providerId;
-        const oauth = dynamicObject(dynamicObject(provider, "auth"), "oauth");
-        const loginLabel = stringProperty(oauth, "loginLabel") ?? "Sign in with an account";
-        const options = this.#loginOptions().filter(option => option.id.endsWith(`:${providerId}`)).map(option => ({
-            id: option.id,
-            label: option.id.startsWith("api_key:") ? "Sign in with an API key" : loginLabel,
-            ...(option.description === undefined ? {} : { description: option.description }),
-        }));
-        return { title: `Select authentication method for ${providerName}:`, options };
-    }
-    pinnedLogoutOptions() {
-        return this.#logoutOptions();
-    }
-    pinnedForkOptions() {
-        const session = this.#requireWorkflowSession();
-        const messages = requireCapability(session.getUserMessagesForForking, "getUserMessagesForForking").call(session);
-        return workflowOptions(messages, "entryId", "text");
-    }
-    pinnedTreeSelectorContext() {
-        const manager = this.#requireWorkflowSession().sessionManager;
-        const settings = this.#runtime?.services.settingsManager;
-        const tree = manager?.getTree?.();
-        const leaf = manager?.getLeafId?.();
-        const configuredFilter = settings?.getTreeFilterMode?.();
-        const filterMode = configuredFilter === "no-tools" || configuredFilter === "user-only" || configuredFilter === "labeled-only" || configuredFilter === "all"
-            ? configuredFilter
-            : "default";
-        return {
-            tree: Array.isArray(tree) ? tree : [],
-            currentLeafId: typeof leaf === "string" ? leaf : null,
-            filterMode,
-            skipSummaryPrompt: settings?.getBranchSummarySkipPrompt?.() === true,
-            appendLabelChange: (entryId, label) => {
-                requireCapability(manager?.appendLabelChange, "appendLabelChange").call(manager, entryId, label);
-            },
-        };
-    }
-    pinnedSettingsSnapshot() {
-        const session = this.#requireWorkflowSession();
-        const settings = this.#runtime?.services.settingsManager;
-        const setting = (getter, fallback) => {
-            const value = getter?.call(settings);
-            return value === undefined ? fallback : value;
-        };
-        const levels = session.getAvailableThinkingLevels?.();
-        const themes = collectionResult(this.#runtime?.services.resourceLoader?.getThemes?.(), "themes").values
-            .map(theme => stringProperty(theme, "name"))
-            .filter((name) => !!name);
-        return {
-            autoCompact: typeof session.autoCompactionEnabled === "boolean"
-                ? session.autoCompactionEnabled
-                : setting(settings?.getCompactionEnabled, true),
-            showImages: setting(settings?.getShowImages, true),
-            imageWidthCells: setting(settings?.getImageWidthCells, 80),
-            autoResizeImages: setting(settings?.getImageAutoResize, true),
-            blockImages: setting(settings?.getBlockImages, false),
-            enableSkillCommands: setting(settings?.getEnableSkillCommands, true),
-            steeringMode: session.steeringMode ?? setting(settings?.getSteeringMode, "one-at-a-time"),
-            followUpMode: session.followUpMode ?? setting(settings?.getFollowUpMode, "one-at-a-time"),
-            transport: setting(settings?.getTransport, "sse"),
-            httpIdleTimeoutMs: setting(settings?.getHttpIdleTimeoutMs, 300_000),
-            thinkingLevel: readThinkingLevel(session.thinkingLevel),
-            availableThinkingLevels: Array.isArray(levels) ? levels.map(readThinkingLevel) : ["off", "minimal", "low", "medium", "high", "xhigh"],
-            currentTheme: setting(settings?.getThemeSetting, setting(settings?.getTheme, "dark")),
-            terminalTheme: "dark",
-            availableThemes: themes.length > 0 ? themes : ["dark", "light"],
-            hideThinkingBlock: setting(settings?.getHideThinkingBlock, false),
-            mermaidRenderingMode: setting(settings?.getMermaidRenderingMode, "off"),
-            showCacheMissNotices: setting(settings?.getShowCacheMissNotices, false),
-            collapseChangelog: setting(settings?.getCollapseChangelog, true),
-            enableInstallTelemetry: setting(settings?.getEnableInstallTelemetry, true),
-            doubleEscapeAction: setting(settings?.getDoubleEscapeAction, "tree"),
-            treeFilterMode: setting(settings?.getTreeFilterMode, "default"),
-            showHardwareCursor: setting(settings?.getShowHardwareCursor, false),
-            editorPaddingX: setting(settings?.getEditorPaddingX, 0),
-            outputPad: setting(settings?.getOutputPad, 1),
-            autocompleteMaxVisible: setting(settings?.getAutocompleteMaxVisible, 5),
-            quietStartup: setting(settings?.getQuietStartup, false),
-            defaultProjectTrust: setting(settings?.getDefaultProjectTrust, "ask"),
-            clearOnShrink: setting(settings?.getClearOnShrink, false),
-            showTerminalProgress: setting(settings?.getShowTerminalProgress, false),
-            tuiMode: setting(settings?.getTuiMode, "regular"),
-            fullscreenExitOutput: setting(settings?.getFullscreenExitOutput, "transcript"),
-            fullscreenScrollbar: setting(settings?.getFullscreenScrollbar, "auto"),
-            warnings: setting(settings?.getWarnings, { anthropicExtraUsage: true }),
-        };
-    }
-    pinnedMessageRenderer(customType) {
-        return this.#requireWorkflowSession().extensionRunner?.getMessageRenderer?.(customType);
-    }
-    pinnedToolDefinition(toolName) {
-        return this.#requireWorkflowSession().extensionRunner?.getToolDefinition?.(toolName);
-    }
-    clearQueuedWorkflows() {
-        const session = this.#requireWorkflowSession();
-        const result = session.clearQueue?.();
-        if (!isRecord(result))
-            return [];
-        return [...readStringArray(result.steering), ...readStringArray(result.followUp)];
-    }
-    abortBashWorkflow() {
-        this.#requireWorkflowSession().abortBash?.();
-    }
-    async executeBashWorkflow(command, excludeFromContext) {
-        const session = this.#requireWorkflowSession();
-        const result = await requireCapability(session.executeBash, "executeBash").call(session, command, undefined, { excludeFromContext });
-        if (!isRecord(result))
-            throw new Error("Pi bash workflow returned a malformed result");
-        return {
-            command,
-            output: typeof result.output === "string" ? result.output : "",
-            exitCode: typeof result.exitCode === "number" ? result.exitCode : undefined,
-            cancelled: result.cancelled === true,
-            truncated: result.truncated === true,
-            excludeFromContext,
-        };
-    }
-    applyPinnedSettingValue(callback, value) {
-        try {
-            return this.#applyPinnedSetting(callback, value, true);
-        }
-        catch (error) {
-            return workflowResult("settings", "failed", error instanceof Error ? error.message : String(error));
-        }
-    }
-    async executeWorkflow(request) {
-        try {
-            return await this.#performWorkflow(request);
-        }
-        catch (error) {
-            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;
-            return workflowResult(request.command, "failed", contextualMessage);
-        }
-    }
-    view() {
-        return {
-            contractVersion: 1,
-            sessionId: this.#sessionId,
-            revision: this.#viewRevision,
-            lifecycle: this.#lifecycle,
-            transcript: this.#transcript.map(block => ({ ...block })),
-            editor: { ...this.#editor, queuedSubmissions: [...this.#editor.queuedSubmissions] },
-            status: {
-                ...this.#status,
-                diagnostics: [...this.#status.diagnostics],
-                badges: [...this.#status.badges],
-                usage: this.#readUsage(),
-                footer: {
-                    branch: this.#gitBranch,
-                    sessionName: this.#session?.sessionManager?.getSessionName() ?? null,
-                    availableProviderCount: new Set(this.#runtime?.services.modelRuntime.getAvailableSnapshot?.().map(model => model.provider).filter(provider => provider !== undefined) ?? []).size,
-                    extensionStatuses: [],
-                },
-            },
-            terminal: { ...this.#terminal },
-            activeModel: this.#activeModel === null ? null : { ...this.#activeModel },
-            thinkingLevel: this.#thinkingLevel,
-            activeCommandIds: [...this.#activeCommandIds],
-            dialog: null,
-            overlay: null,
-            customizations: [],
-            diagnostics: this.#diagnostics.map(diagnostic => ({ ...diagnostic })),
-        };
-    }
-    snapshot() {
-        const snapshot = {
-            contractVersion: 1,
-            snapshotId: `snapshot-${this.#viewRevision}`,
-            sessionId: this.#sessionId,
-            sequence: this.#sequence,
-            view: this.view(),
-        };
-        assertOwnedUiSnapshot(snapshot);
-        return snapshot;
-    }
-    async execute(command) {
-        assertOwnedUiCommand(command);
-        if (command.sessionId !== this.#sessionId) {
-            return this.#finishCommand(command, "rejected", "command targets a different owned session");
-        }
-        if (this.#disposed || !this.#runtime || !this.#session) {
-            return this.#finishCommand(command, "rejected", "engine adapter is not running");
-        }
-        const existing = this.#completedCommands.get(command.correlationId);
-        if (existing)
-            return existing;
-        if (this.#activeCommandIds.includes(command.correlationId)) {
-            return this.#finishCommand(command, "rejected", "duplicate engine command correlation id");
-        }
-        this.#activeCommandIds.push(command.correlationId);
-        this.#emitEvent({
-            type: "command-outcome",
-            correlationId: command.correlationId,
-            outcome: "accepted",
-            diagnostic: null,
-        });
-        try {
-            await this.#perform(command);
-            this.#emitView();
-            return this.#recordCommand(command, "completed", null);
-        }
-        catch (error) {
-            const diagnostic = error instanceof Error ? error.message : String(error);
-            this.#addDiagnostic("error", "engine-command", diagnostic, true);
-            this.#emitView();
-            return this.#recordCommand(command, "failed", diagnostic);
-        }
-    }
-    async dispose() {
-        if (this.#disposed)
-            return;
-        this.#disposed = true;
-        this.#extensionBound = false;
-        this.#extensionUi = undefined;
-        this.#extensionShutdown = undefined;
-        this.#lifecycle = "stopping";
-        this.#emitEvent({ type: "session-lifecycle", lifecycle: "stopping", reason: null });
-        this.#unsubscribe?.();
-        this.#unsubscribe = undefined;
-        await this.#runtime?.dispose();
-        this.#lifecycle = "stopped";
-        this.#emitEvent({ type: "session-lifecycle", lifecycle: "stopped", reason: null });
-        this.#emitView();
-        await this.flushEvents();
-    }
-    async #performWorkflow(request) {
-        const session = this.#requireWorkflowSession();
-        const runtime = this.#runtime;
-        if (!runtime)
-            throw new Error("engine runtime is unavailable");
-        const argument = request.argument.trim();
-        const selected = request.selection?.trim();
-        const selection = selected && selected.length > 0 ? selected : undefined;
-        switch (request.command) {
-            case "settings": {
-                if (!selection)
-                    return workflowResult(request.command, "failed", "Settings requires the owned settings controller");
-                return 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}`);
-                await session.setModel(model);
-                this.#activeModel = { providerId, modelId, displayName: stringProperty(model, "name") ?? modelId };
-                this.#emitView();
-                return workflowResult(request.command, "completed", `Model: ${modelId}`);
-            }
-            case "scoped-models": {
-                if (!selection)
-                    return workflowResult(request.command, "failed", "Scoped models requires the owned scoped-model controller");
-                const [providerId, modelId] = selection.split("/", 2);
-                const model = providerId && modelId ? runtime.services.modelRuntime.getModel(providerId, modelId) : undefined;
-                if (!model)
-                    return workflowResult(request.command, "failed", `Model is unavailable: ${selection}`);
-                requireCapability(session.setScopedModels, "setScopedModels").call(session, [{ model }]);
-                return workflowResult(request.command, "completed", `Enabled scoped model ${selection}`);
-            }
-            case "export": {
-                const path = pathArgument(argument);
-                const file = path?.toLowerCase().endsWith(".jsonl")
-                    ? requireCapability(session.exportToJsonl, "exportToJsonl").call(session, path)
-                    : await requireCapability(session.exportToHtml, "exportToHtml").call(session, path);
-                return workflowResult(request.command, "completed", `Session exported to: ${String(file)}`);
-            }
-            case "import": {
-                const path = pathArgument(argument);
-                if (!path)
-                    return workflowResult(request.command, "failed", "Usage: /import <path.jsonl>");
-                if (request.confirmed === undefined) {
-                    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}`);
-            }
-            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 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]);
-                    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);
-                }
-                finally {
-                    await rm(temporary, { force: true });
-                }
-            }
-            case "copy": {
-                const text = requireCapability(session.getLastAssistantText, "getLastAssistantText").call(session);
-                if (typeof text !== "string" || text.length === 0)
-                    return workflowResult(request.command, "failed", "No agent messages to copy yet.");
-                await this.#workflowHost.copyText(text);
-                return workflowResult(request.command, "completed", "Copied last agent message to clipboard");
-            }
-            case "name": {
-                const manager = session.sessionManager;
-                if (!argument) {
-                    const current = manager?.getSessionName();
-                    return typeof current === "string"
-                        ? workflowResult(request.command, "completed", `Session name: ${current}`)
-                        : workflowResult(request.command, "failed", "Usage: /name <name>");
-                }
-                requireCapability(session.setSessionName, "setSessionName").call(session, argument);
-                const normalized = manager?.getSessionName();
-                const actual = typeof normalized === "string" ? normalized : argument;
-                return workflowResult(request.command, "completed", `Session name set: ${actual}`, actual === argument ? undefined : `Session name was normalized from ${JSON.stringify(argument)} to ${JSON.stringify(actual)}`);
-            }
-            case "session": {
-                const manager = session.sessionManager;
-                const stats = requireCapability(session.getSessionStats, "getSessionStats").call(session);
-                const entries = manager?.getEntries();
-                return {
-                    ...workflowResult(request.command, "completed", "Session Info"),
-                    presentation: pinnedSessionInfoPresentation(stats, manager?.getSessionName(), Array.isArray(entries) ? entries : [], runtime.services.modelRuntime),
-                };
-            }
-            case "changelog": {
-                const changelog = await this.#workflowHost.readChangelog();
-                return workflowResult(request.command, "completed", "What's New", changelog);
-            }
-            case "hotkeys":
-                return workflowResult(request.command, "completed", "Keyboard Shortcuts", pinnedHotkeySummary());
-            case "fork": {
-                if (!selection)
-                    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, "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");
-                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, "completed", "Cloned to new session");
-            }
-            case "tree": {
-                if (!selection)
-                    return workflowResult(request.command, "failed", "Tree navigation requires the owned tree controller");
-                const navigateTree = requireCapability(session.navigateTree, "navigateTree");
-                const result = request.treeSummary === undefined
-                    ? await navigateTree.call(session, selection)
-                    : await navigateTree.call(session, selection, {
-                        summarize: request.treeSummary.summarize,
-                        ...(request.treeSummary.customInstructions === undefined ? {} : { customInstructions: request.treeSummary.customInstructions }),
-                    });
-                if (isRecord(result) && result.aborted === true)
-                    return workflowResult(request.command, "cancelled", "Branch summarization cancelled");
-                if (isRecord(result) && result.cancelled === true)
-                    return workflowResult(request.command, "cancelled", "Navigation cancelled");
-                return workflowResult(request.command, "completed", "Navigated to selected point");
-            }
-            case "trust": {
-                if (!selection)
-                    return workflowResult(request.command, "failed", "Trust requires the owned trust controller");
-                requireCapability(runtime.services.settingsManager?.setProjectTrusted, "setProjectTrusted").call(runtime.services.settingsManager, selection === "trust");
-                return workflowResult(request.command, "completed", selection === "trust" ? "Project trusted" : "Project trust removed");
-            }
-            case "login": {
-                if (!selection && !argument)
-                    return workflowResult(request.command, "failed", "Login requires the owned authentication controller");
-                const modelRuntime = runtime.services.modelRuntime;
-                let loginSelection = selection ?? argument;
-                if (!selection && argument && !argument.includes(":")) {
-                    const normalized = argument.toLowerCase();
-                    const providers = modelRuntime.getProviders?.();
-                    const providerMatches = Array.isArray(providers) ? providers.filter(isRecord).filter(candidate => stringProperty(candidate, "id")?.toLowerCase() === normalized
-                        || stringProperty(candidate, "name")?.toLowerCase() === normalized) : [];
-                    const providerReference = providerMatches.length === 1 ? stringProperty(providerMatches[0], "id") ?? argument : argument;
-                    const matching = this.#loginOptions().filter(option => option.id.endsWith(`:${providerReference}`));
-                    if (matching.length > 1) {
-                        const provider = modelRuntime.getProvider?.(providerReference);
-                        const providerName = stringProperty(provider, "name") ?? providerReference;
-                        return workflowResult(request.command, "failed", `Authentication method for ${providerName} requires the owned authentication controller`);
-                    }
-                    if (matching[0])
-                        loginSelection = matching[0].id;
-                }
-                const [authTypeValue = "oauth", providerId = loginSelection] = loginSelection.includes(":")
-                    ? loginSelection.split(":", 2)
-                    : ["oauth", loginSelection];
-                const authType = authTypeValue === "api_key" ? "api_key" : "oauth";
-                const provider = modelRuntime.getProvider?.(providerId);
-                const providerName = stringProperty(provider, "name") ?? providerId;
-                this.#workflowInteraction.startLogin?.({ providerId, providerName, authType });
-                try {
-                    await requireCapability(modelRuntime.login, "login").call(modelRuntime, providerId, authType, {
-                        signal: AbortSignal.timeout(120_000),
-                        prompt: async (prompt) => {
-                            const promptType = stringProperty(prompt, "type");
-                            const options = isRecord(prompt) && Array.isArray(prompt.options)
-                                ? prompt.options.filter(isRecord).flatMap(option => {
-                                    const id = stringProperty(option, "id");
-                                    const label = stringProperty(option, "label");
-                                    return id && label ? [{ id, label }] : [];
-                                })
-                                : [];
-                            const response = await this.#workflowInteraction.prompt({
-                                type: promptType === "select"
-                                    ? "select"
-                                    : promptType === "manual_code"
-                                        ? "manual-code"
-                                        : authType === "api_key"
-                                            ? "secret"
-                                            : "text",
-                                message: stringProperty(prompt, "message") ?? `Authenticate ${providerName}`,
-                                ...(stringProperty(prompt, "placeholder") === undefined ? {} : { placeholder: stringProperty(prompt, "placeholder") }),
-                                ...(options.length === 0 ? {} : { options }),
-                            });
-                            if (response === null)
-                                throw new Error("Login cancelled");
-                            return response;
-                        },
-                        notify: (event) => {
-                            const notification = workflowLoginNotification(event);
-                            if (notification)
-                                this.#workflowInteraction.notify(notification);
-                        },
-                    });
-                }
-                catch (error) {
-                    if (error instanceof Error && error.message === "Login cancelled")
-                        return workflowResult(request.command, "cancelled", "Login cancelled");
-                    throw error;
-                }
-                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")}`);
-            }
-            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;
-                this.#reconcileActiveModelAvailability();
-                this.#emitView();
-                return workflowResult(request.command, "completed", credentialType === "api_key"
-                    ? `Removed stored API key for ${providerName}. Environment variables and models.json config are unchanged.`
-                    : `Logged out of ${providerName}`);
-            }
-            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");
-            }
-            case "compact": {
-                await session.compact(argument || undefined);
-                return workflowResult(request.command, "completed", "Compaction requested");
-            }
-            case "resume": {
-                if (!selection && !argument)
-                    return workflowResult(request.command, "failed", "Resume requires the owned session controller");
-                const sessionPath = selection ?? argument;
-                try {
-                    const result = await runtime.switchSession(sessionPath);
-                    if (isRecord(result) && result.cancelled === true)
-                        return workflowResult(request.command, "cancelled", "Resume cancelled");
-                    return workflowResult(request.command, "completed", "Resumed session");
-                }
-                catch (error) {
-                    const issue = isRecord(error) && isRecord(error.issue) ? error.issue : undefined;
-                    const fallbackCwd = issue === undefined ? undefined : stringProperty(issue, "fallbackCwd");
-                    if (fallbackCwd === undefined)
-                        throw error;
-                    if (request.confirmed === 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}`);
-                    }
-                    if (!request.confirmed)
-                        return workflowResult(request.command, "cancelled", "Resume cancelled");
-                    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, "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.");
-                if (session.isCompacting)
-                    return workflowResult(request.command, "failed", "Wait for compaction to finish before reloading.");
-                await requireCapability(session.reload, "reload").call(session);
-                await this.#bindExtensionUiToSession();
-                return workflowResult(request.command, "completed", "Reloaded keybindings, extensions, skills, prompts, themes, and context files");
-            }
-            case "quit": {
-                await this.dispose();
-                return workflowResult(request.command, "completed", "Shutdown complete");
-            }
-            case "debug": {
-                const debugPath = join(this.#agentDir, "pi-debug.log");
-                await mkdir(dirname(debugPath), { recursive: true });
-                await writeFile(debugPath, `${JSON.stringify(this.snapshot(), null, 2)}\n`, "utf8");
-                return workflowResult(request.command, "completed", "✓ Debug log written", debugPath);
-            }
-            case "arminsayshi":
-                return workflowResult(request.command, "completed", "Armin says hi");
-            case "dementedelves":
-                return workflowResult(request.command, "completed", "Demented elves announcement");
-        }
-    }
-    #requireWorkflowSession() {
-        if (this.#disposed || !this.#runtime || !this.#session)
-            throw new Error("engine adapter is not running");
-        return this.#session;
-    }
-    #modelOptions() {
-        const runtime = this.#runtime;
-        if (!runtime)
-            return [];
-        const models = runtime.services.modelRuntime.getAvailableSnapshot?.();
-        if (!Array.isArray(models)) {
-            const active = this.#activeModel;
-            return active ? [{ id: `${active.providerId}/${active.modelId}`, label: active.displayName, description: `${active.providerId}/${active.modelId}` }] : [];
-        }
-        return models.filter(isRecord).flatMap(model => {
-            const provider = stringProperty(model, "provider");
-            const id = stringProperty(model, "id");
-            if (!provider || !id)
-                return [];
-            return [{ id: `${provider}/${id}`, label: stringProperty(model, "name") ?? id, description: `${provider}/${id}` }];
-        });
-    }
-    #loginOptions(authType) {
-        const runtime = this.#runtime;
-        const modelRuntime = runtime?.services.modelRuntime;
-        if (!modelRuntime)
-            return [];
-        const providers = modelRuntime.getProviders?.();
-        if (!Array.isArray(providers))
-            return [];
-        return providers.filter(isRecord).flatMap(provider => {
-            const id = stringProperty(provider, "id");
-            if (!id)
-                return [];
-            const name = stringProperty(provider, "name") ?? id;
-            const auth = isRecord(provider.auth) ? provider.auth : {};
-            const authStatus = modelRuntime.getProviderAuthStatus?.(id);
-            const source = authStatus?.label ?? authStatus?.source;
-            const status = authStatus?.configured === true
-                ? {
-                    type: modelRuntime.isUsingOAuth?.(id) === true ? "oauth" : "api_key",
-                    ...(source === undefined ? {} : { source }),
-                }
-                : undefined;
-            return [
-                ...(authType !== "api_key" && auth.oauth ? [{
-                        id: `oauth:${id}`,
-                        providerId: id,
-                        label: name,
-                        description: "Account / OAuth",
-                        authType: "oauth",
-                        ...(status === undefined ? {} : { status }),
-                    }] : []),
-                ...(authType !== "oauth" && auth.apiKey ? [{
-                        id: `api_key:${id}`,
-                        providerId: id,
-                        label: name,
-                        description: "API key",
-                        authType: "api_key",
-                        ...(status === undefined ? {} : { status }),
-                    }] : []),
-            ];
-        }).sort((left, right) => left.label.localeCompare(right.label));
-    }
-    async #logoutOptions() {
-        const runtime = this.#runtime;
-        if (!runtime)
-            return [];
-        const modelRuntime = runtime.services.modelRuntime;
-        const credentials = await requireCapability(modelRuntime.listCredentials, "listCredentials").call(modelRuntime, { signal: AbortSignal.timeout(15_000) });
-        if (!Array.isArray(credentials))
-            return [];
-        return credentials.filter(isRecord).flatMap(credential => {
-            const providerId = stringProperty(credential, "providerId");
-            if (!providerId)
-                return [];
-            const credentialType = stringProperty(credential, "type") === "api_key" ? "api_key" : "oauth";
-            const provider = modelRuntime.getProvider?.(providerId);
-            return [{
-                    id: `${credentialType}:${providerId}`,
-                    providerId,
-                    label: stringProperty(provider, "name") ?? providerId,
-                    description: credentialType,
-                    authType: credentialType,
-                    status: { type: credentialType, source: "stored credential" },
-                }];
-        });
-    }
-    async #sessionOptions() {
-        const session = this.#requireWorkflowSession();
-        const manager = session.sessionManager;
-        const cwd = manager?.getCwd?.();
-        const sessionDir = manager?.getSessionDir?.();
-        if (typeof cwd !== "string")
-            return [];
-        return sessionInfoOptions(await SessionManager.list(cwd, typeof sessionDir === "string" ? sessionDir : undefined));
-    }
-    #applyPinnedSetting(selection, selectedValue, hasSelectedValue = false) {
-        if (!PINNED_PI_SETTINGS_CALLBACKS.includes(selection)) {
-            return workflowResult("settings", "failed", `Unknown setting callback: ${selection}`);
-        }
-        const callback = selection;
-        if (callback === "onCancel")
-            return workflowResult("settings", "cancelled", "Settings cancelled");
-        if (callback === "onThemePreview")
-            return workflowResult("settings", "completed", "Theme preview refreshed");
-        if (!hasSelectedValue) {
-            const snapshot = this.pinnedSettingsSnapshot();
-            const currentValues = {
-                onAutoCompactChange: snapshot.autoCompact,
-                onShowImagesChange: snapshot.showImages,
-                onImageWidthCellsChange: snapshot.imageWidthCells,
-                onAutoResizeImagesChange: snapshot.autoResizeImages,
-                onBlockImagesChange: snapshot.blockImages,
-                onEnableSkillCommandsChange: snapshot.enableSkillCommands,
-                onSteeringModeChange: snapshot.steeringMode,
-                onFollowUpModeChange: snapshot.followUpMode,
-                onTransportChange: snapshot.transport,
-                onHttpIdleTimeoutMsChange: snapshot.httpIdleTimeoutMs,
-                onThinkingLevelChange: snapshot.thinkingLevel,
-                onThemeChange: snapshot.currentTheme,
-                onHideThinkingBlockChange: snapshot.hideThinkingBlock,
-                onMermaidRenderingModeChange: snapshot.mermaidRenderingMode,
-                onShowCacheMissNoticesChange: snapshot.showCacheMissNotices,
-                onCollapseChangelogChange: snapshot.collapseChangelog,
-                onEnableInstallTelemetryChange: snapshot.enableInstallTelemetry,
-                onQuietStartupChange: snapshot.quietStartup,
-                onDefaultProjectTrustChange: snapshot.defaultProjectTrust,
-                onDoubleEscapeActionChange: snapshot.doubleEscapeAction,
-                onTreeFilterModeChange: snapshot.treeFilterMode,
-                onShowHardwareCursorChange: snapshot.showHardwareCursor,
-                onEditorPaddingXChange: snapshot.editorPaddingX,
-                onOutputPadChange: snapshot.outputPad,
-                onAutocompleteMaxVisibleChange: snapshot.autocompleteMaxVisible,
-                onClearOnShrinkChange: snapshot.clearOnShrink,
-                onShowTerminalProgressChange: snapshot.showTerminalProgress,
-                onTuiModeChange: snapshot.tuiMode,
-                onFullscreenExitOutputChange: snapshot.fullscreenExitOutput,
-                onFullscreenScrollbarChange: snapshot.fullscreenScrollbar,
-                onWarningsChange: snapshot.warnings,
-            };
-            selectedValue = currentValues[callback];
-            hasSelectedValue = true;
-        }
-        const settings = this.#runtime?.services.settingsManager;
-        if (!settings)
-            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);
-        }
-        this.#emitView();
-        return workflowResult("settings", "completed", `${settingLabel(callback)}: ${String(selectedValue)}`);
-    }
-    async #perform(command) {
-        const runtime = this.#runtime;
-        const session = this.#session;
-        if (!runtime || !session)
-            throw new Error("engine session is unavailable");
-        switch (command.type) {
-            case "prompt":
-            case "steer":
-            case "follow-up":
-            case "abort":
-            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 });
-                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}`);
-                }
-                return;
-            }
-            case "set-model": {
-                const model = runtime.services.modelRuntime.getModel(command.model.providerId, command.model.modelId);
-                if (!model) {
-                    throw new Error(`model is unavailable: ${command.model.providerId}/${command.model.modelId}`);
-                }
-                await session.setModel(model);
-                this.#activeModel = { ...command.model };
-                return;
-            }
-            case "set-thinking-level":
-                session.setThinkingLevel(command.thinkingLevel);
-                this.#thinkingLevel = command.thinkingLevel;
-                return;
-            case "new-session":
-                await runtime.newSession();
-                return;
-            case "resume-session":
-                await runtime.switchSession(command.sessionPath);
-                return;
-            case "resize-surface":
-                this.#terminal = { ...command.surface };
-                this.#emitEvent({ type: "terminal-surface", surface: this.#terminal });
-                return;
-            case "shutdown":
-                await this.dispose();
-                return;
-            case "set-setting":
-            case "apply-customization":
-            case "remove-customization":
-                throw new Error("owned UI state commands belong to the owned UI layer, not the Pi engine adapter");
-        }
-    }
-    #bindSession(session) {
-        this.#unsubscribe?.();
-        this.#sessionGeneration += 1;
-        this.#session = session;
-        this.#activeCommandIds = [];
-        this.#completedCommands.clear();
-        this.#sessionCommands = new PiSessionCommandIntegration(session);
-        this.#editor = {
-            text: "",
-            queuedSubmissions: [],
-            selection: null,
-            cursorOffset: 0,
-            historyRevision: this.#editor.historyRevision + 1,
-            submitEnabled: true,
-        };
-        this.#status = { ...this.#status, workingMessage: null, badges: [] };
-        this.#activeModel = readModel(session.model);
-        this.#reconcileActiveModelAvailability();
-        this.#thinkingLevel = readThinkingLevel(session.thinkingLevel);
-        this.#rebuildTranscript(session.messages, "finalized");
-        this.#unsubscribe = session.subscribe(event => this.#handlePiEvent(event));
-        if (this.#extensionUi !== undefined)
-            void this.#bindExtensionUiToSession();
-    }
-    #reconcileActiveModelAvailability() {
-        const modelRuntime = this.#runtime?.services.modelRuntime;
-        if (!modelRuntime) {
-            this.#activeModel = null;
-            return;
-        }
-        const available = modelRuntime.getAvailableSnapshot?.() ?? [];
-        const sessionModel = readModel(this.#session?.model);
-        const authoritative = this.#activeModel ?? sessionModel;
-        if (authoritative === null)
-            return;
-        const remainsAvailable = available.some(model => stringProperty(model, "provider") === authoritative.providerId
-            && stringProperty(model, "id") === authoritative.modelId);
-        this.#activeModel = remainsAvailable ? authoritative : null;
-    }
-    async #bindExtensionUiToSession() {
-        const session = this.#session;
-        const ui = this.#extensionUi;
-        if (session === undefined || ui === undefined || session.bindExtensions === undefined) {
-            this.#extensionBound = false;
-            return;
-        }
-        try {
-            await session.bindExtensions({
-                uiContext: ui,
-                mode: "tui",
-                shutdownHandler: () => this.#extensionShutdown?.(),
-                onError: error => {
-                    const message = isRecord(error) && typeof error.error === "string"
-                        ? error.error
-                        : error instanceof Error ? error.message : String(error);
-                    this.#addDiagnostic("warning", "extension-ui", message, true);
-                    this.#emitView();
-                },
-            });
-            this.#extensionBound = true;
-            this.#emitView();
-        }
-        catch (error) {
-            this.#extensionBound = false;
-            this.#addDiagnostic("error", "extension-ui-bind", error instanceof Error ? error.message : String(error), true);
-            this.#emitView();
-        }
-    }
-    #handlePiEvent(event) {
-        if (!isRecord(event) || typeof event.type !== "string")
-            return;
-        switch (event.type) {
-            case "agent_start":
-                this.#lifecycle = "busy";
-                this.#status = { ...this.#status, workingMessage: "Working..." };
-                this.#emitEvent({ type: "session-lifecycle", lifecycle: "busy", reason: null });
-                this.#emitEvent({ type: "status", status: this.#status });
-                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}`,
-                    });
-                }
-                return;
-            }
-            case "message_end":
-                this.#upsertMessageBlock(event.message, "finalized");
-                return;
-            case "turn_end":
-                this.#upsertMessageBlock(event.message, "finalized");
-                if (Array.isArray(event.toolResults)) {
-                    for (const result of event.toolResults)
-                        this.#upsertMessageBlock(result, "finalized");
-                }
-                return;
-            case "tool_execution_start":
-            case "tool_execution_update":
-            case "tool_execution_end":
-                this.#upsertToolExecutionBlock(event);
-                return;
-            case "agent_settled":
-            case "agent_end": {
-                if (event.type === "agent_end" && event.willRetry === true)
-                    return;
-                const finalMessages = Array.isArray(event.messages) && event.messages.length > 0
-                    ? event.messages
-                    : this.#session?.messages ?? [];
-                if (finalMessages.length > 0)
-                    this.#rebuildTranscript(finalMessages, "finalized");
-                else
-                    this.#transcript = this.#transcript.map(block => block.status === "live" ? { ...block, status: "finalized" } : block);
-                this.#lifecycle = "ready";
-                this.#status = { ...this.#status, workingMessage: null };
-                this.#emitEvent({ type: "session-lifecycle", lifecycle: "ready", reason: null });
-                this.#emitEvent({ type: "status", status: this.#status });
-                this.#emitView();
-                return;
-            }
-            case "queue_update": {
-                const steering = readStringArray(event.steering);
-                const followUp = readStringArray(event.followUp);
-                this.#editor = {
-                    ...this.#editor,
-                    queuedSubmissions: [...steering, ...followUp],
-                    historyRevision: this.#editor.historyRevision + 1,
-                };
-                this.#emitEvent({ type: "editor-state", editor: this.#editor });
-                return;
-            }
-            case "auto_retry_start":
-                this.#lifecycle = "busy";
-                this.#status = { ...this.#status, workingMessage: "Retrying…" };
-                this.#emitEvent({ type: "status", status: this.#status });
-                return;
-            case "auto_retry_end":
-            case "compaction_end":
-                this.#lifecycle = "ready";
-                this.#status = { ...this.#status, workingMessage: null };
-                this.#emitEvent({ type: "status", status: this.#status });
-                return;
-            case "compaction_start":
-                this.#lifecycle = "busy";
-                this.#status = { ...this.#status, workingMessage: "Compacting…" };
-                this.#emitEvent({ type: "status", status: this.#status });
-                return;
-            case "thinking_level_changed":
-                this.#thinkingLevel = readThinkingLevel(event.level);
-                return;
-            default:
-                return;
-        }
-    }
-    #readUsage() {
-        let input = 0;
-        let output = 0;
-        let cacheRead = 0;
-        let cacheWrite = 0;
-        let cost = 0;
-        let latestCacheHitRate = null;
-        let latestPrompt = null;
-        const entries = this.#session?.sessionManager?.getEntries?.()
-            ?? (this.#session?.messages ?? []).map(message => ({ type: "message", message }));
-        for (const entry of entries) {
-            if (!isRecord(entry))
-                continue;
-            const message = entry.type === "message" && isRecord(entry.message) ? entry.message : undefined;
-            const usage = message !== undefined && isRecord(message.usage)
-                ? message.usage
-                : (entry.type === "branch_summary" || entry.type === "compaction") && isRecord(entry.usage) ? entry.usage : undefined;
-            if (usage === undefined)
-                continue;
-            input += finiteNumber(usage.input);
-            output += finiteNumber(usage.output);
-            cacheRead += finiteNumber(usage.cacheRead);
-            cacheWrite += finiteNumber(usage.cacheWrite);
-            cost += isRecord(usage.cost) ? finiteNumber(usage.cost.total) : 0;
-            if (message?.role === "assistant") {
-                latestPrompt = {
-                    input: finiteNumber(usage.input),
-                    cacheRead: finiteNumber(usage.cacheRead),
-                    cacheWrite: finiteNumber(usage.cacheWrite),
-                };
-                const promptTokens = latestPrompt.input + latestPrompt.cacheRead + latestPrompt.cacheWrite;
-                latestCacheHitRate = promptTokens > 0 ? (latestPrompt.cacheRead / promptTokens) * 100 : null;
-            }
-        }
-        const context = this.#session?.getContextUsage?.();
-        const providerId = this.#activeModel?.providerId;
-        const usingSubscription = providerId === "kimi-coding"
-            || (providerId !== undefined && this.#runtime?.services.modelRuntime.isUsingSubscription?.(providerId) === true);
-        return {
-            input,
-            output,
-            cacheRead,
-            cacheWrite,
-            cost,
-            latestCacheHitRate,
-            latestPrompt,
-            contextAvailable: context !== undefined,
-            contextTokens: context?.tokens ?? null,
-            contextWindow: context?.contextWindow ?? 0,
-            contextPercent: context?.percent ?? null,
-            usingSubscription,
-            autoCompactEnabled: this.#runtime?.services.settingsManager?.getCompactionEnabled?.() ?? true,
-        };
-    }
-    #rebuildTranscript(messages, status) {
-        const blocks = [];
-        const blockIndexes = new Map();
-        const occurrences = new Map();
-        for (const [index, message] of messages.entries()) {
-            const key = messageFallbackKey(message, index);
-            const occurrence = occurrences.get(key) ?? 0;
-            occurrences.set(key, occurrence + 1);
-            for (const block of this.#messageBlocks(message, status, index, occurrence)) {
-                const existingIndex = blockIndexes.get(block.id);
-                if (existingIndex === undefined) {
-                    blockIndexes.set(block.id, blocks.length);
-                    blocks.push(block);
-                    continue;
-                }
-                const existing = blocks[existingIndex];
-                if (existing !== undefined) {
-                    blocks[existingIndex] = {
-                        ...block,
-                        payload: {
-                            ...(isRecord(existing.payload) ? existing.payload : {}),
-                            ...(isRecord(block.payload) ? block.payload : {}),
-                        },
-                    };
-                }
-            }
-        }
-        this.#transcript = blocks;
-    }
-    #upsertMessageBlock(message, status) {
-        const blocks = this.#messageBlocks(message, status, this.#transcript.length);
-        const first = blocks[0];
-        for (const block of blocks)
-            this.#upsertTranscriptBlock(block);
-        return first;
-    }
-    #messageBlocks(message, status, fallbackIndex, occurrence) {
-        if (!isRecord(message) || typeof message.role !== "string")
-            return [];
-        const baseId = this.#messageBlockId(message, fallbackIndex, status, occurrence);
-        if (message.role === "user") {
-            return [{
-                    id: baseId,
-                    kind: "user",
-                    status,
-                    revision: this.#nextBlockRevision(baseId),
-                    title: "User",
-                    text: textFromContent(message.content),
-                    payload: { role: "user", imageCount: contentImageCount(message.content) },
-                }];
-        }
-        if (message.role === "bashExecution") {
-            return [{
-                    id: baseId,
-                    kind: "bash",
-                    status,
-                    revision: this.#nextBlockRevision(baseId),
-                    title: stringValue(message.command) ?? "Bash",
-                    text: stringValue(message.output) ?? "",
-                    payload: {
-                        role: "bashExecution",
-                        command: stringValue(message.command) ?? "",
-                        exitCode: typeof message.exitCode === "number" ? message.exitCode : null,
-                        cancelled: message.cancelled === true,
-                        truncated: message.truncated === true,
-                        fullOutputPath: stringValue(message.fullOutputPath) ?? null,
-                        excludeFromContext: message.excludeFromContext === true,
-                    },
-                }];
-        }
-        if (message.role === "custom") {
-            if (message.display === false)
-                return [];
-            return [{
-                    id: baseId,
-                    kind: "custom",
-                    status,
-                    revision: this.#nextBlockRevision(baseId),
-                    title: stringValue(message.customType) ?? "Custom",
-                    text: textFromContent(message.content),
-                    payload: {
-                        role: "custom",
-                        customType: stringValue(message.customType) ?? "custom",
-                        display: true,
-                        details: message.details,
-                        timestamp: typeof message.timestamp === "number" ? message.timestamp : 0,
-                    },
-                }];
-        }
-        if (message.role === "compactionSummary" || message.role === "branchSummary") {
-            return [{
-                    id: baseId,
-                    kind: "compaction",
-                    status,
-                    revision: this.#nextBlockRevision(baseId),
-                    title: message.role === "branchSummary" ? "Branch summary" : "Compaction summary",
-                    text: stringValue(message.summary) ?? "",
-                    payload: {
-                        role: message.role,
-                        tokensBefore: typeof message.tokensBefore === "number" ? message.tokensBefore : 0,
-                        fromId: stringValue(message.fromId) ?? null,
-                        timestamp: typeof message.timestamp === "number" ? message.timestamp : 0,
-                    },
-                }];
-        }
-        if (message.role === "toolResult") {
-            const toolCallId = stringValue(message.toolCallId);
-            const blockId = toolCallId === undefined
-                ? baseId
-                : this.#toolBlockIds.get(toolCallId) ?? `tool-${toolCallId}`;
-            if (toolCallId !== undefined)
-                this.#toolBlockIds.set(toolCallId, blockId);
-            const existing = this.#transcript.find(block => block.id === blockId);
-            const existingPayload = isRecord(existing?.payload) ? existing.payload : undefined;
-            return [{
-                    id: blockId,
-                    kind: "tool-result",
-                    status,
-                    revision: this.#nextBlockRevision(blockId),
-                    title: stringValue(message.toolName) ?? existing?.title ?? "Tool result",
-                    text: textFromContent(message.content),
-                    payload: {
-                        ...(existingPayload ?? {}),
-                        role: "toolResult",
-                        toolCallId: toolCallId ?? null,
-                        toolName: stringValue(message.toolName) ?? stringValue(existingPayload?.toolName) ?? "unknown",
-                        argsComplete: true,
-                        isError: message.isError === true,
-                        details: jsonSummary(message.details),
-                    },
-                }];
-        }
-        if (message.role !== "assistant" || !Array.isArray(message.content))
-            return [];
-        const blocks = [{
-                id: baseId,
-                kind: "assistant",
-                status,
-                revision: this.#nextBlockRevision(baseId),
-                title: "Assistant",
-                text: textFromContent(message.content),
-                payload: {
-                    role: "assistant",
-                    content: assistantContent(message.content),
-                    provider: stringValue(message.provider) ?? null,
-                    model: stringValue(message.model) ?? null,
-                    api: stringValue(message.api) ?? null,
-                    usage: sanitizeJson(message.usage),
-                    stopReason: stringValue(message.stopReason) ?? null,
-                    errorMessage: stringValue(message.errorMessage) ?? null,
-                    timestamp: typeof message.timestamp === "number" ? message.timestamp : 0,
-                },
-            }];
-        for (const item of message.content) {
-            if (!isRecord(item) || item.type !== "toolCall")
-                continue;
-            const toolCallId = stringValue(item.id) ?? `${baseId}:${blocks.length}`;
-            const blockId = this.#toolBlockIds.get(toolCallId) ?? `tool-${toolCallId}`;
-            this.#toolBlockIds.set(toolCallId, blockId);
-            blocks.push({
-                id: blockId,
-                kind: "tool-call",
-                status,
-                revision: this.#nextBlockRevision(blockId),
-                title: stringValue(item.name) ?? "Tool",
-                text: jsonSummary(item.arguments).summary,
-                payload: {
-                    toolCallId,
-                    toolName: stringValue(item.name) ?? "unknown",
-                    arguments: jsonSummary(item.arguments),
-                    argsComplete: status === "finalized",
-                },
-            });
-        }
-        return blocks;
-    }
-    #upsertToolExecutionBlock(event) {
-        const toolCallId = stringValue(event.toolCallId);
-        if (!toolCallId)
-            return;
-        const blockId = this.#toolBlockIds.get(toolCallId) ?? `tool-${toolCallId}`;
-        this.#toolBlockIds.set(toolCallId, blockId);
-        const ended = event.type === "tool_execution_end";
-        const source = ended ? event.result : event.partialResult;
-        this.#upsertTranscriptBlock({
-            id: blockId,
-            kind: ended ? "tool-result" : "tool-call",
-            status: ended ? "finalized" : "live",
-            revision: this.#nextBlockRevision(blockId),
-            title: stringValue(event.toolName) ?? "Tool",
-            text: textFromContent(isRecord(source) ? source.content : source),
-            payload: {
-                toolCallId,
-                toolName: stringValue(event.toolName) ?? "unknown",
-                arguments: jsonSummary(event.args),
-                result: jsonSummary(source),
-                partialResult: event.type === "tool_execution_update",
-                argsComplete: ended,
-                isError: event.isError === true,
-            },
-        });
-    }
-    #upsertTranscriptBlock(block) {
-        const index = this.#transcript.findIndex(existing => existing.id === block.id);
-        if (index >= 0)
-            this.#transcript[index] = block;
-        else
-            this.#transcript.push(block);
-        this.#emitEvent({ type: "transcript-block", block });
-    }
-    #messageBlockId(message, fallbackIndex, status, occurrence) {
-        const existing = this.#messageBlockIds.get(message);
-        if (existing)
-            return existing;
-        const fallback = messageFallbackKey(message, fallbackIndex);
-        const cached = this.#messageFallbackIds.get(fallback) ?? [];
-        let id;
-        if (occurrence !== undefined) {
-            id = cached[occurrence];
-            if (id === undefined) {
-                id = `${fallback}-${occurrence}`;
-                cached[occurrence] = id;
-            }
-        }
-        else {
-            id = [...cached].reverse().find(candidate => this.#transcript.some(block => block.id === candidate && block.status === "live"));
-            if (id === undefined && status === "finalized")
-                id = cached.at(-1);
-            if (id === undefined) {
-                id = `${fallback}-${cached.length}`;
-                cached.push(id);
-            }
-        }
-        this.#messageFallbackIds.set(fallback, cached);
-        this.#messageBlockIds.set(message, id);
-        return id;
-    }
-    #nextBlockRevision(id) {
-        const existing = this.#transcript.find(block => block.id === id);
-        if (existing)
-            return existing.revision + 1;
-        this.#nextBlockSequence += 1;
-        return this.#nextBlockSequence;
-    }
-    #recordCommand(command, outcome, diagnostic) {
-        const result = this.#finishCommand(command, outcome, diagnostic);
-        this.#completedCommands.set(command.correlationId, result);
-        if (this.#completedCommands.size > 256) {
-            const oldest = this.#completedCommands.keys().next().value;
-            if (oldest)
-                this.#completedCommands.delete(oldest);
-        }
-        return result;
-    }
-    #finishCommand(command, outcome, diagnostic) {
-        this.#activeCommandIds = this.#activeCommandIds.filter(id => id !== command.correlationId);
-        this.#emitEvent({
-            type: "command-outcome",
-            correlationId: command.correlationId,
-            outcome,
-            diagnostic,
-        });
-        return { outcome, diagnostic };
-    }
-    #addDiagnostic(severity, code, message, recoverable) {
-        const diagnostic = this.#recordDiagnostic(severity, code, message, recoverable);
-        this.#emitEvent({ type: "diagnostic", diagnostic });
-    }
-    #emitView() {
-        this.#viewRevision += 1;
-        this.#emitEvent({ type: "session-view", view: this.view() });
-    }
-    #emitEvent(value) {
-        const event = this.#event(value);
-        if (event.type !== "session-view")
-            this.#viewRevision += 1;
-        this.#enqueueEvent(event);
-    }
-    #enqueueEvent(event) {
-        const capacity = 1_024;
-        if (this.#eventQueue.length >= capacity) {
-            const coalescible = this.#eventQueue.findIndex(queued => queued.type === "session-view"
-                || queued.type === "status"
-                || queued.type === "editor-state"
-                || queued.type === "transcript-block");
-            if (coalescible >= 0)
-                this.#eventQueue.splice(coalescible, 1);
-            else
-                this.#eventQueue.shift();
-            this.#droppedEventCount += 1;
-            if (this.#droppedEventCount === 1 || this.#droppedEventCount % 128 === 0) {
-                this.#recordDiagnostic("warning", "event-backpressure", `owned UI coalesced ${this.#droppedEventCount} engine events under backpressure`, true);
-            }
-        }
-        this.#eventQueue.push(event);
-        this.#eventQueueProcessing ??= Promise.resolve().then(() => this.#processEventQueue());
-    }
-    async #processEventQueue() {
-        try {
-            while (this.#eventQueue.length > 0) {
-                const event = this.#eventQueue.shift();
-                if (!event)
-                    continue;
-                for (const listener of this.#listeners) {
-                    try {
-                        listener(event);
-                    }
-                    catch (error) {
-                        this.#recordDiagnostic("warning", "event-listener", error instanceof Error ? error.message : String(error), true);
-                    }
-                }
-            }
-        }
-        finally {
-            this.#eventQueueProcessing = undefined;
-            if (this.#eventQueue.length > 0) {
-                this.#eventQueueProcessing = Promise.resolve().then(() => this.#processEventQueue());
-            }
-        }
-    }
-    #recordDiagnostic(severity, code, message, recoverable) {
-        const diagnostic = {
-            sequence: this.#diagnostics.length,
-            code,
-            severity,
-            message,
-            recoverable,
-        };
-        this.#diagnostics.push(diagnostic);
-        if (this.#diagnostics.length > 100)
-            this.#diagnostics.shift();
-        this.#status = {
-            ...this.#status,
-            diagnostics: [...this.#status.diagnostics, message].slice(-8),
-        };
-        return diagnostic;
-    }
-    #event(value) {
-        this.#sequence += 1;
-        return { ...value, sessionId: this.#sessionId, sequence: this.#sequence };
-    }
-}
-export async function createPiEngineAdapter(options = {}) {
-    const adapter = new PiEngineAdapter(options);
-    await adapter.start();
-    return adapter;
-}
-async function createDefaultPiRuntime(input) {
-    return createPiRuntimeIntegration({ cwd: input.cwd, agentDir: input.agentDir });
-}
-async function checkDefaultPiPackageUpdates(cwd, agentDir, settingsManager) {
-    const packageManager = new DefaultPackageManager({ cwd, agentDir, settingsManager });
-    const updates = await packageManager.checkForAvailableUpdates();
-    return updates.map(update => update.displayName);
-}
-function pinnedSessionInfoPresentation(value, sessionName, entries, modelRuntime) {
-    const stats = isRecord(value) ? value : {};
-    const tokens = dynamicObject(stats, "tokens");
-    return {
-        kind: "session-info",
-        ...(sessionName === undefined ? {} : { sessionName }),
-        stats: {
-            ...(stringProperty(stats, "sessionFile") === undefined ? {} : { sessionFile: stringProperty(stats, "sessionFile") }),
-            sessionId: stringProperty(stats, "sessionId") ?? "unknown",
-            userMessages: finiteNumber(stats.userMessages),
-            assistantMessages: finiteNumber(stats.assistantMessages),
-            toolCalls: finiteNumber(stats.toolCalls),
-            toolResults: finiteNumber(stats.toolResults),
-            totalMessages: finiteNumber(stats.totalMessages),
-            tokens: {
-                input: finiteNumber(tokens.input),
-                output: finiteNumber(tokens.output),
-                cacheRead: finiteNumber(tokens.cacheRead),
-                cacheWrite: finiteNumber(tokens.cacheWrite),
-                total: finiteNumber(tokens.total),
-            },
-            cost: finiteNumber(stats.cost),
-        },
-        cacheWaste: pinnedCacheWaste(entries, modelRuntime),
-        usageBreakdown: pinnedUsageCostBreakdown(entries),
-    };
-}
-function pinnedUsageCostBreakdown(entries) {
-    const totals = new Map();
-    for (const entry of entries) {
-        if (!isRecord(entry))
-            continue;
-        let key;
-        let usage;
-        const message = dynamicObject(entry, "message");
-        if (entry.type === "message" && message.role === "assistant") {
-            const provider = stringProperty(message, "provider");
-            const model = stringProperty(message, "responseModel") ?? stringProperty(message, "model");
-            if (provider && model)
-                key = `${provider}/${model}`;
-            usage = dynamicObject(message, "usage");
-        }
-        else if (entry.type === "message" && message.role === "toolResult" && isRecord(message.usage)) {
-            key = "Tools/summaries";
-            usage = message.usage;
-        }
-        else if ((entry.type === "branch_summary" || entry.type === "compaction") && isRecord(entry.usage)) {
-            key = "Tools/summaries";
-            usage = entry.usage;
-        }
-        if (!key || !usage)
-            continue;
-        const cost = finiteNumber(dynamicObject(usage, "cost").total);
-        const tokens = finiteNumber(usage.input) + finiteNumber(usage.output)
-            + finiteNumber(usage.cacheRead) + finiteNumber(usage.cacheWrite);
-        const current = totals.get(key) ?? { cost: 0, tokens: 0 };
-        current.cost += cost;
-        current.tokens += tokens;
-        totals.set(key, current);
-    }
-    return [...totals].map(([key, total]) => ({ key, ...total }))
-        .filter(entry => entry.cost > 0 || entry.tokens > 0)
-        .sort((a, b) => b.cost - a.cost);
-}
-function pinnedCacheWaste(entries, modelRuntime) {
-    let previous;
-    const totals = { missedTokens: 0, missedCost: 0, missCount: 0 };
-    for (const entry of entries) {
-        if (!isRecord(entry))
-            continue;
-        if (entry.type === "compaction" || entry.type === "branch_summary") {
-            previous = undefined;
-            continue;
-        }
-        const message = dynamicObject(entry, "message");
-        if (entry.type !== "message" || message.role !== "assistant")
-            continue;
-        const usage = dynamicObject(message, "usage");
-        const input = finiteNumber(usage.input);
-        const cacheRead = finiteNumber(usage.cacheRead);
-        const cacheWrite = finiteNumber(usage.cacheWrite);
-        const promptTokens = input + cacheRead + cacheWrite;
-        if (previous && promptTokens > 0 && (cacheRead + cacheWrite > 0 || previous.reportedCache)) {
-            const missedTokens = Math.min(previous.promptTokens, promptTokens) - cacheRead;
-            if (missedTokens > 1024) {
-                const cost = dynamicObject(usage, "cost");
-                const paidTokens = input + cacheWrite;
-                const paidRate = paidTokens > 0 ? (finiteNumber(cost.input) + finiteNumber(cost.cacheWrite)) / paidTokens : 0;
-                const provider = stringProperty(message, "provider") ?? "";
-                const modelId = stringProperty(message, "model") ?? "";
-                const model = modelRuntime.getModel(provider, modelId);
-                const modelCost = dynamicObject(dynamicObject(model, "cost"));
-                const readRate = cacheRead > 0
-                    ? finiteNumber(cost.cacheRead) / cacheRead
-                    : finiteNumber(modelCost.cacheRead) / 1_000_000;
-                totals.missedTokens += missedTokens;
-                totals.missedCost += missedTokens * Math.max(0, paidRate - readRate);
-                totals.missCount += 1;
-            }
-        }
-        if (promptTokens > 0) {
-            const provider = stringProperty(message, "provider") ?? "";
-            const model = stringProperty(message, "model") ?? "";
-            previous = {
-                promptTokens,
-                modelKey: `${provider}/${model}`,
-                timestamp: finiteNumber(message.timestamp),
-                reportedCache: (previous?.reportedCache ?? false) || cacheRead + cacheWrite > 0,
-            };
-        }
-    }
-    return totals;
-}
-function defaultWorkflowHost() {
-    return {
-        copyText: copyToClipboard,
-        async runCommand(command, arguments_) {
-            const result = await execFileAsync(command, [...arguments_], { encoding: "utf8" });
-            return { stdout: result.stdout, stderr: result.stderr };
-        },
-        readChangelog: async () => "No changelog entries found.",
-    };
-}
-function workflowLoginNotification(event) {
-    if (!isRecord(event))
-        return undefined;
-    if (event.type === "auth_url") {
-        const url = stringProperty(event, "url");
-        if (!url)
-            return undefined;
-        const instructions = stringProperty(event, "instructions");
-        return { type: "auth_url", url, ...(instructions === undefined ? {} : { instructions }) };
-    }
-    if (event.type === "device_code") {
-        const verificationUri = stringProperty(event, "verificationUri");
-        const userCode = stringProperty(event, "userCode");
-        return verificationUri && userCode ? { type: "device_code", verificationUri, userCode } : undefined;
-    }
-    const message = stringProperty(event, "message");
-    if (!message)
-        return undefined;
-    if (event.type === "info") {
-        const links = Array.isArray(event.links) ? event.links.filter(isRecord).flatMap(link => {
-            const url = stringProperty(link, "url");
-            if (!url)
-                return [];
-            const label = stringProperty(link, "label");
-            return [{ ...(label === undefined ? {} : { label }), url }];
-        }) : [];
-        return { type: "info", message, ...(links.length === 0 ? {} : { links }) };
-    }
-    return { type: event.type === "waiting" ? "waiting" : "progress", message };
-}
-function workflowResult(command, outcome, message, detail) {
-    return { command, outcome, message, ...(detail === undefined ? {} : { detail }) };
-}
-function workflowConfirmation(command, message) {
-    return {
-        command,
-        outcome: "requires-confirmation",
-        message,
-        selectorTitle: "Confirm",
-        options: [
-            { id: "yes", label: "Yes" },
-            { id: "no", label: "No" },
-        ],
-    };
-}
-function workflowOptions(value, idKey, labelKey) {
-    if (!Array.isArray(value))
-        return [];
-    return value.filter(isRecord).flatMap(item => {
-        const id = stringProperty(item, idKey);
-        if (!id)
-            return [];
-        return [{ id, label: stringProperty(item, labelKey) ?? id }];
-    });
-}
-function sessionInfoOptions(value) {
-    return value.filter(isRecord).flatMap(info => {
-        const path = stringProperty(info, "path");
-        if (!path)
-            return [];
-        const modified = info.modified instanceof Date ? info.modified.toISOString() : stringProperty(info, "modified") ?? "unknown time";
-        const messageCount = typeof info.messageCount === "number" ? info.messageCount : 0;
-        return [{
-                id: path,
-                label: stringProperty(info, "name") ?? stringProperty(info, "firstMessage") ?? stringProperty(info, "id") ?? path,
-                description: `${messageCount} messages · ${modified}`,
-            }];
-    });
-}
-function assertPiExtensionUiContext(value) {
-    assertOwnedUiExtensionUiPort(value);
-}
-function dynamicObject(value, key) {
-    const candidate = key === undefined ? value : isRecord(value) ? value[key] : undefined;
-    return isRecord(candidate) ? candidate : {};
-}
-function requireCapability(capability, name) {
-    if (typeof capability !== "function")
-        throw new Error(`Pi workflow capability is unavailable: ${name}`);
-    return capability;
-}
-function pathArgument(value) {
-    if (!value)
-        return undefined;
-    const quote = value[0];
-    if (quote === '"' || quote === "'") {
-        const closing = value.indexOf(quote, 1);
-        return closing < 0 ? undefined : value.slice(1, closing);
-    }
-    return value.split(/\s/, 1)[0] || undefined;
-}
-function settingKeyForCallback(callback) {
-    const keys = {
-        onAutoCompactChange: "autoCompact", onShowImagesChange: "showImages", onImageWidthCellsChange: "imageWidthCells",
-        onAutoResizeImagesChange: "autoResizeImages", onBlockImagesChange: "blockImages", onEnableSkillCommandsChange: "enableSkillCommands",
-        onSteeringModeChange: "steeringMode", onFollowUpModeChange: "followUpMode", onTransportChange: "transport",
-        onHttpIdleTimeoutMsChange: "httpIdleTimeoutMs", onThemeChange: "theme", onThemePreview: "theme",
-        onHideThinkingBlockChange: "hideThinkingBlock", onMermaidRenderingModeChange: "mermaidRenderingMode",
-        onShowCacheMissNoticesChange: "showCacheMissNotices", onCollapseChangelogChange: "collapseChangelog",
-        onEnableInstallTelemetryChange: "enableInstallTelemetry", onQuietStartupChange: "quietStartup",
-        onDefaultProjectTrustChange: "defaultProjectTrust", onDoubleEscapeActionChange: "doubleEscapeAction",
-        onTreeFilterModeChange: "treeFilterMode", onShowHardwareCursorChange: "showHardwareCursor",
-        onEditorPaddingXChange: "editorPaddingX", onOutputPadChange: "outputPad", onAutocompleteMaxVisibleChange: "autocompleteMaxVisible",
-        onClearOnShrinkChange: "clearOnShrink", onShowTerminalProgressChange: "showTerminalProgress", onTuiModeChange: "tuiMode",
-        onFullscreenExitOutputChange: "fullscreenExitOutput", onFullscreenScrollbarChange: "fullscreenScrollbar", onWarningsChange: "warnings",
-    };
-    return keys[callback] ?? null;
-}
-function agentJsonValue(value) {
-    if (value === null || typeof value === "string" || typeof value === "boolean" || (typeof value === "number" && Number.isFinite(value)))
-        return value;
-    if (Array.isArray(value))
-        return value.map(agentJsonValue);
-    if (isRecord(value))
-        return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined).map(([key, item]) => [key, agentJsonValue(item)]));
-    throw new TypeError("setting value must be JSON serializable");
-}
-function isThinkingLevel(value) {
-    return typeof value === "string" && ["off", "minimal", "low", "medium", "high", "xhigh"].includes(value);
-}
-function settingLabel(callback) {
-    return callback
-        .replace(/^on/, "")
-        .replace(/Change$|Preview$|Cancel$/, "")
-        .replace(/([a-z])([A-Z])/g, "$1 $2")
-        .replace(/^./, character => character.toUpperCase());
-}
-function pinnedHotkeySummary() {
-    return [
-        "Enter: send message · Alt+Enter: queue follow-up",
-        "Escape: cancel/abort · Ctrl+C: clear/exit · Ctrl+D: exit when empty",
-        "Shift+Tab: cycle thinking · Ctrl+P/Shift+Ctrl+P: cycle models · Ctrl+L: select model",
-        "Ctrl+O: expand tools · Ctrl+T: toggle thinking · Ctrl+X: copy message",
-        "Alt+Up: restore queued messages · /: commands · !/!!: bash",
-    ].join("\n");
-}
-function scopedModelRecords(modelRuntime) {
-    return modelRuntime.getAvailableSnapshot().map(model => ({
-        descriptor: { provider: model.provider, id: model.id, name: model.name ?? model.id },
-        model,
-    }));
-}
-function scopedModelReference(value) {
-    if (!isRecord(value) || !isRecord(value.model))
-        return undefined;
-    const provider = stringValue(value.model.provider);
-    const id = stringValue(value.model.id);
-    return provider && id ? `${provider}/${id}` : undefined;
-}
-function resolveConfiguredModelIds(patterns, models) {
-    const references = models.map(item => `${item.descriptor.provider}/${item.descriptor.id}`);
-    const resolved = [];
-    for (const pattern of patterns) {
-        const thinkingSuffix = /:(?:off|minimal|low|medium|high|xhigh)$/.exec(pattern);
-        const modelPattern = thinkingSuffix === null ? pattern : pattern.slice(0, -thinkingSuffix[0].length);
-        const matcher = wildcardMatcher(modelPattern);
-        const matches = references.filter((reference, index) => matcher.test(reference) || matcher.test(models[index]?.descriptor.id ?? ""));
-        if (matches.length === 0) {
-            resolved.push(pattern);
-        }
-        else {
-            for (const match of matches)
-                if (!resolved.includes(match))
-                    resolved.push(match);
-        }
-    }
-    return resolved;
-}
-function wildcardMatcher(pattern) {
-    let source = "";
-    for (const character of pattern) {
-        if (character === "*")
-            source += ".*";
-        else if (character === "?")
-            source += ".";
-        else
-            source += character.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
-    }
-    return new RegExp(`^${source}$`, "i");
-}
-function readModel(value) {
-    if (!isRecord(value))
-        return null;
-    const providerId = stringValue(value.provider) ?? stringValue(value.providerId);
-    const modelId = stringValue(value.id) ?? stringValue(value.modelId);
-    if (!providerId || !modelId)
-        return null;
-    return {
-        providerId,
-        modelId,
-        displayName: stringValue(value.name) ?? modelId,
-    };
-}
-function readThinkingLevel(value) {
-    return value === "off" || value === "minimal" || value === "low" || value === "medium"
-        || value === "high" || value === "xhigh"
-        ? value
-        : "medium";
-}
-function readStringArray(value) {
-    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
-}
-function stringValue(value) {
-    return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-function messageFallbackKey(message, fallbackIndex) {
-    if (!isRecord(message))
-        return `message-unknown-${fallbackIndex}`;
-    const timestamp = typeof message.timestamp === "number" && Number.isSafeInteger(message.timestamp)
-        ? message.timestamp
-        : `index-${fallbackIndex}`;
-    return `message-${stringValue(message.role) ?? "unknown"}-${timestamp}`;
-}
-function extensionResourceDiagnostic(index, sourcePath, diagnostic) {
-    return {
-        kind: "extension",
-        id: `extension-diagnostic-${index}`,
-        sourcePath,
-        resolvedPath: null,
-        loaded: false,
-        hidden: false,
-        diagnostic,
-    };
-}
-function collectionResult(value, key) {
-    if (!isRecord(value))
-        return { values: [], diagnostics: [] };
-    const diagnostics = unknownArray(value.diagnostics).map(diagnostic => {
-        if (typeof diagnostic === "string")
-            return diagnostic;
-        if (isRecord(diagnostic)) {
-            const message = stringProperty(diagnostic, "message") ?? String(diagnostic);
-            const path = stringProperty(diagnostic, "path");
-            return path ? `${path}: ${message}` : message;
-        }
-        return String(diagnostic);
-    });
-    return { values: unknownArray(value[key]), diagnostics };
-}
-function unknownArray(value) {
-    return Array.isArray(value) ? value : [];
-}
-function stringProperty(value, key) {
-    if (!isRecord(value))
-        return undefined;
-    const item = value[key];
-    return typeof item === "string" && item.length > 0 ? item : undefined;
-}
-function compactResourceLabel(path) {
-    const segments = path.replaceAll("\\", "/").split("/").filter(Boolean);
-    return segments.at(-1) ?? path;
-}
-function textFromContent(content) {
-    if (typeof content === "string")
-        return content;
-    if (!Array.isArray(content))
-        return "";
-    return content
-        .map(item => isRecord(item) && item.type === "text" ? stringValue(item.text) ?? "" : "")
-        .filter(text => text.length > 0)
-        .join("\n");
-}
-function assistantContent(content) {
-    const result = [];
-    for (const item of content) {
-        if (!isRecord(item))
-            continue;
-        if (item.type === "text")
-            result.push({ type: "text", text: stringValue(item.text) ?? "" });
-        else if (item.type === "thinking") {
-            result.push({
-                type: "thinking",
-                thinking: stringValue(item.thinking) ?? "",
-                ...(item.redacted === true ? { redacted: true } : {}),
-            });
-        }
-        else if (item.type === "toolCall") {
-            result.push({
-                type: "toolCall",
-                id: stringValue(item.id) ?? "",
-                name: stringValue(item.name) ?? "unknown",
-                arguments: sanitizeJson(item.arguments),
-            });
-        }
-    }
-    return result;
-}
-function contentImageCount(content) {
-    return Array.isArray(content)
-        ? content.filter(item => isRecord(item) && item.type === "image").length
-        : 0;
-}
-function jsonSummary(value) {
-    const json = sanitizeJson(value);
-    let summary = "";
-    try {
-        summary = JSON.stringify(json);
-    }
-    catch {
-        summary = String(value);
-    }
-    if (summary.length > 512)
-        summary = `${summary.slice(0, 509)}...`;
-    return { summary, json };
-}
-function sanitizeJson(value, depth = 0) {
-    if (typeof value === "bigint")
-        return value.toString();
-    if (value === null || ["string", "number", "boolean"].includes(typeof value))
-        return value;
-    if (depth >= 8)
-        return "[truncated]";
-    if (Array.isArray(value))
-        return value.slice(0, 100).map(item => sanitizeJson(item, depth + 1));
-    if (isRecord(value)) {
-        const output = {};
-        for (const [key, item] of Object.entries(value).slice(0, 100)) {
-            output[key] = sanitizeJson(item, depth + 1);
-        }
-        return output;
-    }
-    return String(value);
-}
-async function readGitBranch(cwd) {
-    try {
-        const { stdout } = await execFileAsync("git", ["branch", "--show-current"], { cwd, windowsHide: true });
-        const branch = stdout.trim();
-        return branch.length > 0 ? branch : null;
-    }
-    catch {
-        return null;
-    }
-}
-function finiteNumber(value) {
-    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null;
-}