@timurproko/a1 0.1.8-dev.472 → 0.1.8-dev.508

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

@@ -1,80 +1,23 @@
-import { execFile } from "node:child_process";
-import { existsSync, realpathSync } from "node:fs";
-import { mkdir, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { promisify } from "node:util";
-import { PRODUCT_IDENTITY } from "../../../product-identity.js";
-import { configureOwnedHttpDispatcher } from "./http-dispatcher.js";
-import { readPinnedCommandChangelog } from "./changelog.js";
-import { toolRenderingInput } from "./tool-rendering.js";
-import { TranscriptImageAssets } from "./transcript-image-assets.js";
-import { copyToClipboard, CredentialSynchronizationError, DefaultPackageManager, getAgentDir, ProjectTrustStore, SessionManager, VERSION, } from "../startup-public.js";
-import { OWNED_UI_EXTENSION_CONTRACT_VERSION, OWNED_UI_EXTENSION_RENDER_CALLBACKS, OWNED_UI_EXTENSION_UI_CALLBACKS, OWNED_UI_EXTENSION_UI_PROPERTIES, CONTEXTUAL_PROMPT_SUGGESTION_INSTRUCTION, acceptsTranscriptUpdate, transcriptToolState, assertOwnedUiCommand, assertOwnedUiExtensionUiPort, assertOwnedUiPromptSuggestionRequest, assertOwnedUiPromptSuggestionResult, assertOwnedUiSnapshot, normalizePromptSuggestionCandidate, } from "../../../contracts/owned-ui/index.js";
-import { PINNED_PI_SETTINGS_CALLBACKS, PINNED_PI_WORKFLOW_COMMAND_NAMES, } from "./workflows.js";
-import { createPiRuntimeIntegration } from "./runtime-integration.js";
-import { PiSessionCommandIntegration } from "./session-integration.js";
-import { observeCompactionProgress } from "./compaction-progress.js";
-import { PiSettingsIntegration } from "./settings-integration.js";
-import { PendingEngineDelivery } from "./pending-delivery.js";
+import { PiTranscriptProjection } from "./transcript-projection.js";
+import { isRecord, readModel, readStringArray, readThinkingLevel, stringProperty } from "./message-values.js";
+import { getAgentDir } from "../startup-public.js";
+import { assertOwnedUiSnapshot, } from "../../../contracts/owned-ui/index.js";
+import { PiCommandDispatch } from "./command-dispatch.js";
+import { PiEventDelivery } from "./event-delivery.js";
+import { PiExtensionUiBinding } from "./extension-ui-binding.js";
+import { PiPromptSuggestions } from "./prompt-suggestions.js";
+import { PiResourceCatalog } from "./resource-catalog.js";
+import { PiEngineRuntime } from "./session-runtime.js";
+import { PiEngineSettings } from "./settings-port.js";
+import { PiSessionEvents } from "./session-events.js";
+import { readUsageView } from "./usage-view.js";
+import { PiWorkflowContexts } from "./workflow-contexts.js";
+import { PiWorkflowRunner } from "./workflow-runner.js";
+import { defaultWorkflowHost } from "./workflow-support.js";
 /** Explicit flush failure when required delivery was interrupted rather than completed. */
 export class EngineDeliveryError extends Error {
     constructor() { super("Engine delivery did not complete"); this.name = "EngineDeliveryError"; }
 }
-const execFileAsync = promisify(execFile);
-/**
- * Engine events delivered before the queue hands the event loop a turn. Small enough
- * that a streaming burst never holds input, large enough that an ordinary turn is one
- * batch.
- */
-// Performance: deliver at most one engine event per event-loop turn. Transcript updates can
-// be expensive in long sessions; a larger synchronous batch starves terminal
-// input and makes an in-progress mouse selection appear frozen.
-const EVENT_DELIVERY_BATCH = 1;
-const AUTH_REFRESH_TIMEOUT_MS = 15_000;
-// Provenance: Pi 0.84.2 core/model-resolver.ts defaultModelPerProvider.
-const PINNED_DEFAULT_MODEL_BY_PROVIDER = Object.freeze({
-    "amazon-bedrock": "us.anthropic.claude-opus-4-6-v1",
-    "ant-ling": "Ring-2.6-1T",
-    anthropic: "claude-opus-4-8",
-    openai: "gpt-5.5",
-    "azure-openai-responses": "gpt-5.4",
-    "openai-codex": "gpt-5.5",
-    radius: "auto",
-    nvidia: "nvidia/nemotron-3-super-120b-a12b",
-    deepseek: "deepseek-v4-pro",
-    google: "gemini-3.1-pro-preview",
-    "google-vertex": "gemini-3.1-pro-preview",
-    "github-copilot": "gpt-5.4",
-    openrouter: "moonshotai/kimi-k2.6",
-    "vercel-ai-gateway": "zai/glm-5.1",
-    xai: "grok-4.5",
-    groq: "openai/gpt-oss-120b",
-    cerebras: "zai-glm-4.7",
-    zai: "glm-5.1",
-    "zai-coding-cn": "glm-5.1",
-    mistral: "devstral-medium-latest",
-    minimax: "MiniMax-M2.7",
-    "minimax-cn": "MiniMax-M2.7",
-    moonshotai: "kimi-k2.6",
-    "moonshotai-cn": "kimi-k2.6",
-    huggingface: "moonshotai/Kimi-K2.6",
-    fireworks: "accounts/fireworks/models/kimi-k2p6",
-    together: "moonshotai/Kimi-K2.6",
-    baseten: "zai-org/GLM-5.2",
-    opencode: "kimi-k2.6",
-    "opencode-go": "kimi-k2.6",
-    "kimi-coding": "kimi-for-coding",
-    "cloudflare-workers-ai": "@cf/moonshotai/kimi-k2.6",
-    "cloudflare-ai-gateway": "workers-ai/@cf/moonshotai/kimi-k2.6",
-    "qwen-token-plan": "qwen3.7-max",
-    "qwen-token-plan-cn": "qwen3.7-max",
-    "qwen-token-plan-individual": "qwen3.8-max",
-    xiaomi: "mimo-v2.5-pro",
-    "xiaomi-token-plan-cn": "mimo-v2.5-pro",
-    "xiaomi-token-plan-ams": "mimo-v2.5-pro",
-    "xiaomi-token-plan-sgp": "mimo-v2.5-pro",
-});
 const DEFAULT_SURFACE = {
     columns: 100,
     rows: 32,
@@ -83,22 +26,16 @@ const DEFAULT_SURFACE = {
 };
 /** Owns the pinned Pi session lifecycle and translates its events into the neutral agent-engine contract. */
 export class PiEngineAdapter {
-    #runtimeFactory;
-    #checkPackageUpdates;
-    #cwd;
     #agentDir;
     #sessionId;
-    #sessionPath;
-    #sessionSelection;
-    #sessionForkPrompt;
     #workflowHost;
-    #clipboardWriter;
+    #engine;
     #workflowInteraction;
-    #listeners = new Map();
-    #runtime;
-    #session;
-    #unsubscribe;
-    #sequence = 0;
+    #contexts;
+    #workflows;
+    #resources;
+    #settings;
+    #suggestions;
     #viewRevision = 0;
     #lifecycle = "starting";
     #editor = {
@@ -109,8 +46,6 @@ export class PiEngineAdapter {
         historyRevision: 0,
         submitEnabled: false,
     };
-    #sessionGeneration = 0;
-    #sessionBindingGeneration = 0;
     #status = {
         title: "Pi",
         workingMessage: null,
@@ -120,62 +55,161 @@ export class PiEngineAdapter {
     #terminal = DEFAULT_SURFACE;
     #activeModel = null;
     #thinkingLevel = "medium";
-    #activeCommandIds = [];
-    #completedCommands = new Map();
-    #transcript = [];
-    #transcriptIndex = new Map();
-    #transcriptSnapshot;
-    #messageBlockIds = new WeakMap();
-    #messageFallbackIds = new Map();
-    #toolBlockIds = new Map();
-    #transcriptImageAssets = new TranscriptImageAssets();
+    #projection = new PiTranscriptProjection({
+        retryAttempt: () => this.#engine.session?.retryAttempt ?? 0,
+        blockChanged: block => this.#emitEvent({ type: "transcript-block", block }),
+    });
     #usageCache;
-    #nextBlockSequence = 0;
     #diagnostics = [];
-    #eventQueue = new PendingEngineDelivery(event => this.#transcriptImageAssets.retainEvent(event));
-    #eventQueueProcessing;
-    #overload;
-    #overloads = 0;
-    #deliveryFailed = false;
+    // Invariant: every port closes over adapter state read at call time, so delivery is built before a session binds.
+    #delivery = new PiEventDelivery({
+        sessionId: () => this.#sessionId,
+        sessionGeneration: () => this.#engine.generation,
+        transcriptBlock: id => this.#projection.block(id),
+        retainEvent: event => this.#projection.assets.retainEvent(event),
+        isPendingCommand: correlationId => this.#commands.isPending(correlationId),
+        cancelForOverload: () => this.#cancelForOverload(),
+        reconcileOverload: cancelled => this.#reconcileOverload(cancelled),
+        listenerFailed: message => { this.#recordDiagnostic("warning", "event-listener", message, true); },
+    });
     #admissionStopped = false;
     #runningCommands = 0;
-    #invalidatedEvents = 0;
-    #pendingCommands = new Map();
-    #reservedOutcomes = new Map();
-    #pendingWorkflows = new Set();
-    #agentRunActive = false;
-    #agentRunSequence = 0;
-    #assistantResponseSequence = 0;
-    #statusKind = null;
-    #sessionCommands;
-    #compactionProgress = null;
-    #gitBranch = null;
-    #extensionUi;
-    #extensionShutdown;
-    #extensionBound = false;
+    #commands;
+    #events = new PiSessionEvents(this.#projection, {
+        sessionGeneration: () => this.#engine.generation,
+        sessionMessages: () => this.#engine.session?.messages ?? [],
+        activeModel: () => this.#activeModel,
+        replaceTranscript: blocks => { this.#setTranscript(blocks); },
+        emit: value => { this.#emitEvent(value); },
+        emitView: () => { this.#emitView(); },
+        enterWork: message => {
+            const wasBusy = this.#lifecycle === "busy";
+            this.#lifecycle = "busy";
+            this.#status = { ...this.#status, workingMessage: message, workingProgress: null };
+            if (!wasBusy)
+                this.#emitEvent({ type: "session-lifecycle", lifecycle: "busy", reason: null });
+            this.#emitEvent({ type: "status", status: this.#status });
+        },
+        leaveWork: () => {
+            this.#lifecycle = "ready";
+            this.#status = { ...this.#status, workingMessage: null, workingProgress: null };
+            this.#emitEvent({ type: "session-lifecycle", lifecycle: "ready", reason: null });
+            this.#emitEvent({ type: "status", status: this.#status });
+        },
+        workProgress: percent => {
+            if (this.#status.workingProgress === percent)
+                return;
+            this.#status = { ...this.#status, workingProgress: percent };
+            this.#emitEvent({ type: "status", status: this.#status });
+        },
+        queueChanged: queuedSubmissions => {
+            this.#editor = { ...this.#editor, queuedSubmissions: [...queuedSubmissions], historyRevision: this.#editor.historyRevision + 1 };
+            this.#emitEvent({ type: "editor-state", editor: this.#editor });
+        },
+        thinkingLevelChanged: level => { this.#thinkingLevel = level; },
+        usageInvalidated: () => { this.#usageCache = undefined; },
+        compactionStarted: () => { this.#engine.compactionStarted(); },
+        compactionEnded: () => { this.#engine.compactionEnded(); },
+        deliverQueuedAfterCompaction: () => { this.#engine.deliverQueuedAfterCompaction(); },
+    });
+    #extensions = new PiExtensionUiBinding({
+        session: () => this.#engine.session,
+        diagnostic: (severity, code, message, recoverable) => { this.#addDiagnostic(severity, code, message, recoverable); },
+        emitView: () => { this.#emitView(); },
+    });
     #disposed = false;
-    #settingsProductMode;
-    #projectTrustPrompt;
-    #settingsIntegration;
-    #settingsIntegrationManager;
-    #availableThemes;
     constructor(options = {}) {
-        this.#cwd = options.cwd ?? process.cwd();
         this.#agentDir = options.agentDir ?? getAgentDir();
         this.#sessionId = options.sessionId ?? "owned-session-1";
-        this.#sessionPath = options.sessionPath;
-        this.#sessionSelection = options.sessionSelection;
-        this.#sessionForkPrompt = options.sessionForkPrompt;
-        this.#runtimeFactory = options.createRuntime ?? createDefaultPiRuntime;
-        this.#checkPackageUpdates = options.checkPackageUpdates
-            ?? (options.createRuntime
-                ? async () => []
-                : settingsManager => checkDefaultPiPackageUpdates(this.#cwd, this.#agentDir, settingsManager));
         this.#workflowHost = options.workflowHost ?? defaultWorkflowHost();
-        this.#availableThemes = options.availableThemes ?? null;
-        this.#settingsProductMode = options.settingsProductMode ?? "bare";
-        this.#projectTrustPrompt = options.projectTrustPrompt;
         this.#workflowInteraction = { prompt: async () => null, notify() { } };
+        this.#engine = new PiEngineRuntime({
+            cwd: options.cwd ?? process.cwd(),
+            agentDir: this.#agentDir,
+            sessionId: this.#sessionId,
+            sessionPath: options.sessionPath,
+            sessionSelection: options.sessionSelection,
+            sessionForkPrompt: options.sessionForkPrompt,
+            projectTrustPrompt: options.projectTrustPrompt,
+            createRuntime: options.createRuntime,
+            checkPackageUpdates: options.checkPackageUpdates,
+            host: this.#workflowHost,
+        }, {
+            disposed: () => this.#disposed,
+            started: runtime => {
+                this.#terminal = {
+                    ...this.#terminal,
+                    hardwareCursor: runtime.services.settingsManager?.getShowHardwareCursor?.() ?? this.#terminal.hardwareCursor,
+                };
+            },
+            rebindBlocked: () => this.#delivery.overloaded || this.#admissionStopped || this.#disposed,
+            sessionReplacing: () => { this.#commands.cancelPending(["new-session", "resume-session"]); },
+            sessionReplaced: session => { this.#sessionReplaced(session); },
+            rebound: () => { this.#emitView(); },
+            event: event => { this.#events.handle(event); },
+            compactionProgress: percent => { this.#events.compactionProgress(percent); },
+            diagnostic: (severity, code, message, recoverable) => { this.#addDiagnostic(severity, code, message, recoverable); },
+            emitView: () => { this.#emitView(); },
+        });
+        this.#contexts = new PiWorkflowContexts({ agentDir: this.#agentDir }, {
+            cwd: () => this.#engine.cwd,
+            session: () => this.#engine.session,
+            runtime: () => this.#engine.runtime,
+            disposed: () => this.#disposed,
+            activeModel: () => this.#activeModel,
+            emitView: () => { this.#emitView(); },
+        });
+        this.#workflows = new PiWorkflowRunner({ agentDir: this.#agentDir, host: this.#workflowHost, contexts: this.#contexts }, {
+            session: () => this.#engine.session,
+            runtime: () => this.#engine.runtime,
+            disposed: () => this.#disposed,
+            sessionGeneration: () => this.#engine.generation,
+            interaction: () => this.#workflowInteraction,
+            admissionStopped: () => this.#delivery.overloaded || this.#admissionStopped || this.#disposed,
+            pendingCommandCount: () => this.#commands.pendingCount,
+            beginRunning: () => { this.#runningCommands++; },
+            endRunning: () => { this.#runningCommands--; },
+            activeModel: () => this.#activeModel,
+            setActiveModel: model => { this.#activeModel = model; },
+            thinkingLevel: () => this.#thinkingLevel,
+            setThinkingLevel: level => { this.#thinkingLevel = level; },
+            emitView: () => { this.#emitView(); },
+            reconcileActiveModelAvailability: () => { this.#reconcileActiveModelAvailability(); },
+            bindExtensionUiToSession: () => this.#extensions.rebind(),
+            applyPinnedSetting: selection => this.#settings.applyPinnedSetting(selection),
+            snapshot: () => this.snapshot(),
+            dispose: () => this.dispose(),
+        });
+        this.#commands = new PiCommandDispatch({
+            sessionId: () => this.#sessionId,
+            notRunning: () => this.#disposed || !this.#engine.runtime || !this.#engine.session,
+            admissionStopped: () => this.#delivery.overloaded || this.#admissionStopped,
+            pendingWorkflowCount: () => this.#workflows.pendingCount,
+            sessionGeneration: () => this.#engine.generation,
+            beginRunning: () => { this.#runningCommands++; },
+            endRunning: () => { this.#runningCommands--; },
+            perform: command => this.#perform(command),
+            emit: value => { this.#emitEvent(value); },
+            emitView: () => { this.#emitView(); },
+            diagnostic: (severity, code, message, recoverable) => { this.#addDiagnostic(severity, code, message, recoverable); },
+        });
+        this.#resources = new PiResourceCatalog({ contexts: this.#contexts }, {
+            session: () => this.#engine.session,
+            runtime: () => this.#engine.runtime,
+        });
+        this.#settings = new PiEngineSettings({ availableThemes: options.availableThemes ?? null, productMode: options.settingsProductMode ?? "bare" }, {
+            runtime: () => this.#engine.runtime,
+            requireSession: () => this.#requireWorkflowSession(),
+            thinkingLevelChanged: level => { this.#thinkingLevel = level; this.#emitView(); },
+            emitView: () => { this.#emitView(); },
+        });
+        this.#suggestions = new PiPromptSuggestions({
+            session: () => this.#engine.session,
+            runtime: () => this.#engine.runtime,
+            activeModel: () => this.#activeModel,
+            identity: () => ({ sessionId: this.#sessionId, sessionGeneration: this.#engine.generation, runSequence: this.#events.runSequence, responseSequence: this.#events.responseSequence }),
+            unavailable: () => this.#disposed || this.#delivery.overloaded || this.#admissionStopped,
+        });
     }
     setWorkflowInteractionHost(interaction) {
         this.#workflowInteraction = interaction;
@@ -184,855 +218,170 @@ export class PiEngineAdapter {
         return this.#sessionId;
     }
     get sessionGeneration() {
-        return this.#sessionGeneration;
+        return this.#engine.generation;
     }
     /** Actual session replacements, excluding delivery-only invalidation of callbacks. */
-    get sessionBindingGeneration() { return this.#sessionBindingGeneration; }
+    get sessionBindingGeneration() { return this.#engine.bindingGeneration; }
     get cwd() {
-        return this.#runtime?.cwd ?? this.#cwd;
+        return this.#engine.cwd;
     }
     get agentDir() {
         return this.#agentDir;
     }
     resolveTranscriptImage(assetId) {
-        return this.#transcriptImageAssets.resolve(assetId);
+        return this.#projection.assets.resolve(assetId);
     }
     currentSessionFile() {
-        const value = this.#session?.sessionManager?.getSessionFile?.();
-        return typeof value === "string" && value.length > 0 ? value : null;
+        return this.#engine.currentSessionFile();
     }
     currentSessionResumeMetadata() {
-        const manager = this.#session?.sessionManager;
-        if (manager === undefined
-            || typeof manager.isPersisted !== "function"
-            || typeof manager.getSessionId !== "function"
-            || typeof manager.getSessionDir !== "function"
-            || typeof manager.usesDefaultSessionDir !== "function"
-            || manager.isPersisted() !== true
-            || !existsSync(this.currentSessionFile() ?? ""))
-            return null;
-        const sessionId = manager.getSessionId();
-        const sessionDir = manager.getSessionDir();
-        if (!sessionId || !sessionDir)
-            return null;
-        return { sessionId, sessionDir, usesDefaultSessionDir: manager.usesDefaultSessionDir() };
+        return this.#engine.currentSessionResumeMetadata();
     }
     get disposed() {
         return this.#disposed;
     }
     suggestionReasoningPolicy() {
-        const session = this.#session;
-        if (!session?.model)
-            return "unavailable";
-        if (!session.model.reasoning)
-            return "ordinary";
-        // Performance: the run's own level keeps the provider's thinking parameters, and the cached prefix, identical.
-        return readSuggestionReasoning(session.thinkingLevel);
-    }
-    async generate(request) {
-        assertOwnedUiPromptSuggestionRequest(request);
-        const identity = request.identity;
-        const session = this.#session;
-        const runtime = this.#runtime;
-        const activeModel = this.#activeModel;
-        if (this.#disposed || this.#overload !== undefined || this.#admissionStopped || session === undefined || runtime === undefined || request.signal.aborted
-            || identity.sessionId !== this.#sessionId
-            || identity.sessionGeneration !== this.#sessionGeneration
-            || identity.runSequence !== this.#agentRunSequence
-            || identity.responseSequence !== this.#assistantResponseSequence
-            || activeModel === null
-            || identity.model.providerId !== activeModel.providerId
-            || identity.model.modelId !== activeModel.modelId) {
-            return { identity, outcome: request.signal.aborted ? "cancelled" : "unavailable", text: null };
-        }
-        const model = session.model;
-        const agent = session.agent;
-        const agentState = agent.state;
-        const policy = this.suggestionReasoningPolicy();
-        if (model === undefined || policy === "unavailable" || typeof runtime.services.modelRuntime.completeSimple !== "function") {
-            return { identity, outcome: "unavailable", text: null };
-        }
-        // Performance: mirror the primary loop's request shape so the provider serves the conversation prefix
-        // from the run's prompt cache. `onResponse` stays out: extensions must not see a suggestion as a response.
-        const reasoning = policy === "ordinary" || policy === "off" ? undefined : policy;
-        let response;
-        try {
-            const transformed = typeof agent.transformContext === "function"
-                ? await agent.transformContext(agentState.messages, request.signal)
-                : agentState.messages;
-            const messages = typeof agent.convertToLlm === "function"
-                ? await agent.convertToLlm(transformed)
-                : transformed.filter(message => message.role === "user" || message.role === "assistant" || message.role === "toolResult");
-            response = await runtime.services.modelRuntime.completeSimple(model, {
-                systemPrompt: agentState.systemPrompt,
-                messages: [
-                    ...messages,
-                    { role: "user", content: CONTEXTUAL_PROMPT_SUGGESTION_INSTRUCTION, timestamp: Date.now() },
-                ],
-                tools: agentState.tools,
-            }, {
-                signal: request.signal,
-                ...(reasoning === undefined ? {} : { reasoning }),
-                ...(agent.sessionId === undefined ? {} : { sessionId: agent.sessionId }),
-                ...(agent.thinkingBudgets === undefined ? {} : { thinkingBudgets: agent.thinkingBudgets }),
-                ...(agent.transport === undefined ? {} : { transport: agent.transport }),
-                ...(agent.onPayload === undefined ? {} : { onPayload: agent.onPayload }),
-            });
-        }
-        catch {
-            return { identity, outcome: request.signal.aborted ? "cancelled" : "provider-failure", text: null };
-        }
-        if (request.signal.aborted || (isRecord(response) && response.stopReason === "aborted")) {
-            return { identity, outcome: "cancelled", text: null };
-        }
-        if (!isRecord(response) || stringValue(response.errorMessage) !== undefined || response.stopReason === "error") {
-            return { identity, outcome: "provider-failure", text: null };
-        }
-        const content = Array.isArray(response.content) ? response.content : [];
-        if (response.stopReason === "length" || content.some(block => isRecord(block) && block.type === "toolCall")) {
-            return { identity, outcome: "rejected", text: null };
-        }
-        // Security: validate all text, not just the first block of a multi-part response.
-        const rawText = content.filter(block => isRecord(block) && block.type === "text")
-            .map(block => stringValue(block.text) ?? "").join("\n");
-        const text = normalizePromptSuggestionCandidate(rawText);
-        const result = text === null
-            ? { identity, outcome: rawText.trim() ? "rejected" : "empty", text: null }
-            : { identity, outcome: "candidate", text };
-        assertOwnedUiPromptSuggestionResult(result);
-        return result;
+        return this.#suggestions.reasoningPolicy();
+    }
+    generate(request) {
+        return this.#suggestions.generate(request);
     }
     async start() {
-        if (this.#runtime)
+        if (this.#engine.started)
             return this.view();
-        const runtime = await this.#runtimeFactory({
-            cwd: this.#cwd,
-            agentDir: this.#agentDir,
-            sessionId: this.#sessionId,
-            ...(this.#sessionPath === undefined ? {} : { sessionPath: this.#sessionPath }),
-            ...(this.#sessionSelection === undefined ? {} : { sessionSelection: this.#sessionSelection }),
-            ...(this.#sessionForkPrompt === undefined ? {} : { sessionForkPrompt: this.#sessionForkPrompt }),
-            ...(this.#projectTrustPrompt === undefined ? {} : { projectTrustPrompt: this.#projectTrustPrompt }),
-        }).catch(error => {
+        await this.#engine.start().catch(error => {
             this.#lifecycle = "failed";
             this.#addDiagnostic("error", "engine-startup", error instanceof Error ? error.message : String(error), false);
             throw error;
         });
-        this.#runtime = runtime;
-        this.#cwd = runtime.cwd ?? this.#cwd;
-        this.#gitBranch = await readGitBranch(this.#cwd);
-        this.#terminal = {
-            ...this.#terminal,
-            hardwareCursor: runtime.services.settingsManager?.getShowHardwareCursor?.() ?? this.#terminal.hardwareCursor,
-        };
-        runtime.setRebindSession(async (session) => {
-            if (this.#overload !== undefined || this.#admissionStopped || this.#disposed)
-                return;
-            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);
-        await this.#announceChangelog(runtime.services.settingsManager);
         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);
+        void this.#engine.announcePackageUpdates();
         return this.view();
     }
-    async #announceChangelog(settingsManager) {
-        if (!settingsManager || typeof settingsManager.getLastChangelogVersion !== "function"
-            || typeof settingsManager.setLastChangelogVersion !== "function")
-            return;
-        if ((this.#session?.messages.length ?? 0) > 0)
-            return;
-        const lastVersion = settingsManager.getLastChangelogVersion();
-        if (lastVersion === VERSION)
-            return;
-        if (!lastVersion) {
-            settingsManager.setLastChangelogVersion(VERSION);
-            await settingsManager.flush();
-            return;
-        }
-        const markdown = await this.#workflowHost.readChangelog(lastVersion).catch(() => "");
-        if (markdown.trim().length > 0) {
-            this.#addDiagnostic("info", settingsManager.getCollapseChangelog() ? "changelog-collapsed" : "changelog-expanded", markdown, true);
-            settingsManager.setLastChangelogVersion(VERSION);
-            await settingsManager.flush();
-        }
-    }
-    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 ${PRODUCT_IDENTITY.commandName} pi update --extensions\nPackages:\n${packages}`, true);
-        this.#emitView();
-    }
     onEvent(listener) {
-        const initial = this.#event({ type: "session-view", view: this.view() });
-        this.#listeners.set(listener, initial.sequence);
-        listener(initial);
-        return () => this.#listeners.delete(listener);
+        return this.#delivery.subscribe(listener, this.#delivery.stamp({ type: "session-view", view: this.view() }));
     }
     /** Developer-only pressure evidence; never mirrored into visible diagnostic/status arrays. */
     deliveryDiagnostics() {
-        return { ...this.#eventQueue.diagnostics(), overloads: this.#overloads, recovering: this.#overload !== undefined,
-            pendingCommands: this.#pendingCommands.size + this.#pendingWorkflows.size, reservedOutcomes: this.#reservedOutcomes.size, invalidatedEvents: this.#invalidatedEvents };
+        return { ...this.#delivery.diagnostics(), pendingCommands: this.#commands.pendingCount + this.#workflows.pendingCount };
     }
     async flushEvents() {
-        const failed = this.#deliveryFailed;
-        while (this.#eventQueueProcessing)
-            await this.#eventQueueProcessing;
-        if (failed || this.#deliveryFailed || this.#disposed && this.#lifecycle !== "stopped") {
-            this.#deliveryFailed = false;
+        const failed = this.#delivery.failed;
+        await this.#delivery.settle();
+        if (failed || this.#delivery.failed || this.#disposed && this.#lifecycle !== "stopped") {
+            this.#delivery.clearFailure();
             throw new EngineDeliveryError();
         }
     }
     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;
+        return this.#resources.nonVisualResources();
     }
     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,
-                    sourceInfo: extensionSourceSummary(extension.sourceInfo),
-                    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;
+        return this.#resources.extensionResources();
     }
     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)) {
-            const registered = extensionCommands.filter(isRecord);
-            for (const command of registered) {
-                const name = stringProperty(command, "invocationName") ?? stringProperty(command, "name");
-                if (!name || usedNames.has(name) || isPiPrefixedCompatibilityAlias(command, registered))
-                    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)) {
-                const scoped = Array.isArray(session.scopedModels) && session.scopedModels.length > 0;
-                return workflowResult("model", "completed", scoped ? "Only one model in scope" : "Only one model available", undefined, "status");
-            }
-            const model = readModel(result.model);
-            if (model)
-                this.#activeModel = model;
-            if (result.thinkingLevel !== undefined)
-                this.#thinkingLevel = readThinkingLevel(result.thinkingLevel);
-            this.#emitView();
-            const modelName = stringProperty(result.model, "name") ?? stringProperty(result.model, "id") ?? "model";
-            const reasoning = result.model.reasoning === true;
-            const thinking = this.#thinkingLevel;
-            const suffix = reasoning && thinking !== "off" ? ` (thinking: ${thinking})` : "";
-            return workflowResult("model", "completed", `Switched to ${modelName}${suffix}`, undefined, "status");
-        }
-        catch (error) {
-            return workflowResult("model", "failed", error instanceof Error ? error.message : String(error));
-        }
+        return this.#resources.workflowAutocompleteCommands();
     }
-    /**
-     * 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();
+    visualExtensionSupport() {
+        return this.#extensions.support();
     }
-    /** Settings port for the live runtime, or null before the runtime is available. */
-    settingsPort() {
-        const settings = this.#runtime?.services.settingsManager;
-        if (!settings || typeof settings.getCompactionEnabled !== "function")
-            return null;
-        if (this.#settingsIntegration === undefined || this.#settingsIntegrationManager !== settings) {
-            this.#settingsIntegrationManager = settings;
-            configureOwnedHttpDispatcher(settings.getHttpIdleTimeoutMs());
-            this.#settingsIntegration = new PiSettingsIntegration(settings, {
-                ...(this.#availableThemes === null ? {} : { themes: this.#availableThemes }),
-                thinkingLevels: () => {
-                    const levels = this.#runtime?.session?.getAvailableThinkingLevels?.();
-                    return Array.isArray(levels) ? levels.map(level => String(level)) : [];
-                },
-                productMode: this.#settingsProductMode,
-            });
-            this.#settingsIntegration.bindOwner("shell", {
-                enableSkillCommands: { apply: value => {
-                        if (typeof value !== "boolean")
-                            throw new TypeError("Skill commands value is invalid");
-                        settings.setEnableSkillCommands(value);
-                    } },
-                doubleEscapeAction: { apply: value => {
-                        if (value !== "tree" && value !== "fork" && value !== "none")
-                            throw new TypeError("Double-Escape action is invalid");
-                        settings.setDoubleEscapeAction(value);
-                    } },
-                treeFilterMode: { apply: value => {
-                        if (value !== "default" && value !== "no-tools" && value !== "user-only" && value !== "labeled-only" && value !== "all")
-                            throw new TypeError("Tree filter mode is invalid");
-                        settings.setTreeFilterMode(value);
-                    } },
-                showCacheMissNotices: { apply: value => {
-                        if (typeof value !== "boolean")
-                            throw new TypeError("Cache-miss notice setting is invalid");
-                        settings.setShowCacheMissNotices(value);
-                    } },
-            });
-            this.#settingsIntegration.bindOwner("startup", {
-                // Invariant: deferred application is the owner operation: the next preflight reads
-                // the persisted default before constructing project-backed services.
-                defaultProjectTrust: { apply() { } },
-                collapseChangelog: { apply() { } },
-            });
-            this.#settingsIntegration.bindOwner("agent", {
-                autoCompact: { apply: value => {
-                        if (typeof value !== "boolean")
-                            throw new TypeError("Auto compact value is invalid");
-                        this.#requireWorkflowSession().setAutoCompactionEnabled(value);
-                    } },
-                autoResizeImages: { apply: value => {
-                        if (typeof value !== "boolean")
-                            throw new TypeError("Auto-resize images value is invalid");
-                        settings.setImageAutoResize(value);
-                    } },
-                blockImages: { apply: value => {
-                        if (typeof value !== "boolean")
-                            throw new TypeError("Block images value is invalid");
-                        settings.setBlockImages(value);
-                    } },
-                steeringMode: { apply: value => {
-                        if (value !== "all" && value !== "one-at-a-time")
-                            throw new TypeError("Steering mode is invalid");
-                        this.#requireWorkflowSession().setSteeringMode(value);
-                    } },
-                followUpMode: { apply: value => {
-                        if (value !== "all" && value !== "one-at-a-time")
-                            throw new TypeError("Follow-up mode is invalid");
-                        this.#requireWorkflowSession().setFollowUpMode(value);
-                    } },
-                transport: { apply: value => {
-                        if (value !== "sse" && value !== "websocket" && value !== "websocket-cached" && value !== "auto")
-                            throw new TypeError("Transport is invalid");
-                        this.#requireWorkflowSession().agent.transport = value;
-                    } },
-                httpIdleTimeoutMs: { apply: value => {
-                        if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)
-                            throw new TypeError("HTTP idle timeout is invalid");
-                        // Invariant: provider streaming reads the manager per request; global fetch uses
-                        // the matching owned dispatcher and zero maps to disabled semantics.
-                        configureOwnedHttpDispatcher(value);
-                        settings.setHttpIdleTimeoutMs(value);
-                    } },
-                thinkingLevel: { apply: value => {
-                        if (!isThinkingLevel(value))
-                            throw new TypeError("Thinking level is invalid");
-                        this.#requireWorkflowSession().setThinkingLevel(value);
-                        this.#thinkingLevel = readThinkingLevel(this.#requireWorkflowSession().thinkingLevel);
-                        this.#emitView();
-                    } },
-                warnings: { apply: value => {
-                        if (!isRecord(value) || Object.values(value).some(flag => typeof flag !== "boolean"))
-                            throw new TypeError("Warnings setting is invalid");
-                        settings.setWarnings(value);
-                    } },
-            });
-        }
-        return this.#settingsIntegration;
+    bindExtensionUi(ui, shutdown) {
+        return this.#extensions.bind(ui, shutdown);
     }
-    /** Which settings surface this adapter serves; hidden-in-bare effects are unbindable in bare mode. */
-    get settingsProductMode() {
-        return this.#settingsProductMode;
+    unbindExtensionUi() {
+        return this.#extensions.unbind();
     }
-    bindSettingsOwner(owner, handlers) {
-        const settings = this.settingsPort();
-        if (settings === null)
-            return () => { };
-        return settings.bindOwner(owner, handlers);
+    async cycleModelWorkflow(direction) {
+        return this.#workflows.cycleModelWorkflow(direction);
     }
     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 : [],
-        };
+        return this.#contexts.pinnedModelSelectorContext();
     }
     pinnedProjectTrustContext() {
-        const runtime = this.#runtime;
-        if (!runtime)
-            throw new Error("engine runtime is unavailable");
-        const cwd = resolve(this.#cwd);
-        let trustPath = cwd;
-        try {
-            trustPath = realpathSync(cwd);
-        }
-        catch {
-            // Compatibility: pinned Pi retains the resolved path when real-path lookup fails.
-        }
-        // Security: trust the target's parent, not the parent containing a directory alias.
-        const parent = dirname(trustPath);
-        const trustStore = new ProjectTrustStore(this.#agentDir);
-        const trustOptions = [
-            { label: "Trust", trusted: true, updates: [{ path: trustPath, decision: true }], savedPath: trustPath },
-            ...(parent === trustPath ? [] : [{
-                    label: `Trust parent folder (${parent})`,
-                    trusted: true,
-                    updates: [{ path: parent, decision: true }, { path: trustPath, decision: null }],
-                    savedPath: parent,
-                }]),
-            { label: "Do not trust", trusted: false, updates: [{ path: trustPath, decision: false }], savedPath: trustPath },
-        ];
-        return {
-            cwd,
-            savedDecision: trustStore.getEntry(cwd),
-            projectTrusted: runtime.services.settingsManager?.isProjectTrusted?.() === true,
-            trustOptions,
-        };
+        return this.#contexts.pinnedProjectTrustContext();
     }
     persistProjectTrust(updates) {
-        new ProjectTrustStore(this.#agentDir).setMany([...updates]);
+        this.#contexts.persistProjectTrust(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);
-            },
-        };
+        return this.#contexts.pinnedSessionSelectorContext();
     }
     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,
-        };
+        return this.#contexts.pinnedScopedModelsContext();
     }
     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();
+        this.#contexts.updateScopedModels(enabledModelIds);
     }
     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" };
+        this.#contexts.persistScopedModels(enabledModelIds);
+    }
+    refreshScopedModels(signal) {
+        return this.#contexts.refreshScopedModels(signal);
     }
     pinnedLoginOptions(authType) {
-        return this.#loginOptions(authType);
+        return this.#contexts.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 };
+        return this.#contexts.pinnedLoginMethodOptions(providerReference);
     }
     pinnedAmbientAuthentication(selection) {
-        if (!selection.startsWith("api_key:"))
-            return null;
-        const providerId = selection.slice("api_key:".length);
-        const provider = this.#runtime?.services.modelRuntime.getProvider?.(providerId);
-        const method = dynamicObject(dynamicObject(provider, "auth"), "apiKey");
-        if (!method || typeof method.login === "function")
-            return null;
-        const providerName = stringProperty(provider, "name") ?? providerId;
-        return { providerId, providerName, title: `${providerName} setup`, message: `${stringProperty(method, "name") ?? "Authentication"} is configured outside pi.` };
+        return this.#contexts.pinnedAmbientAuthentication(selection);
     }
     pinnedLogoutOptions() {
-        return this.#logoutOptions();
+        return this.#contexts.logoutOptions();
     }
     pinnedForkOptions() {
-        const session = this.#requireWorkflowSession();
-        const messages = requireCapability(session.getUserMessagesForForking, "getUserMessagesForForking").call(session);
-        return workflowOptions(messages, "entryId", "text");
+        return this.#contexts.pinnedForkOptions();
     }
     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);
-            },
-        };
+        return this.#contexts.pinnedTreeSelectorContext();
+    }
+    /** Bind the owned UI's clipboard lifecycle without changing the comparison host. True means acknowledged delivery. */
+    bindClipboardWriter(writer) {
+        return this.#workflows.bindClipboardWriter(writer);
+    }
+    /** Workflow and tree copying share the active owner's write fence and delivery acknowledgment. */
+    copyWorkflowText(text) {
+        return this.#workflows.copyWorkflowText(text);
+    }
+    abortBashWorkflow() {
+        this.#workflows.abortBashWorkflow();
+    }
+    executeBashWorkflow(command, excludeFromContext) {
+        return this.#workflows.executeBashWorkflow(command, excludeFromContext);
+    }
+    reloadBlockedResult() {
+        return this.#workflows.reloadBlockedResult();
+    }
+    executeWorkflow(request) {
+        return this.#workflows.executeWorkflow(request);
+    }
+    /**
+     * 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.#settings.configuredTheme();
+    }
+    /** Settings port for the live runtime, or null before the runtime is available. */
+    settingsPort() {
+        return this.#settings.settingsPort();
+    }
+    /** Which settings surface this adapter serves; hidden-in-bare effects are unbindable in bare mode. */
+    get settingsProductMode() {
+        return this.#settings.productMode;
+    }
+    bindSettingsOwner(owner, handlers) {
+        return this.#settings.bindSettingsOwner(owner, handlers);
     }
     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 }),
-        };
+        return this.#settings.pinnedSettingsSnapshot();
+    }
+    applyPinnedSettingValue(callback, value) {
+        return this.#settings.applyPinnedSettingValue(callback, value);
     }
     pinnedMessageRenderer(customType) {
         return this.#requireWorkflowSession().extensionRunner?.getMessageRenderer?.(customType);
@@ -1044,121 +393,38 @@ export class PiEngineAdapter {
     pinnedToolDefinition(toolName) {
         return this.#requireWorkflowSession().extensionRunner?.getToolDefinition?.(toolName);
     }
-    /** Bind the owned UI's clipboard lifecycle without changing the comparison host. True means acknowledged delivery. */
-    bindClipboardWriter(writer) {
-        const previous = this.#clipboardWriter;
-        this.#clipboardWriter = writer;
-        return () => { if (this.#clipboardWriter === writer)
-            this.#clipboardWriter = previous; };
-    }
-    /** Workflow and tree copying share the active owner's write fence and delivery acknowledgment. */
-    async copyWorkflowText(text) {
-        if (this.#clipboardWriter !== undefined)
-            return this.#clipboardWriter(text);
-        await this.#workflowHost.copyText(text);
-        return true;
-    }
     clearQueuedWorkflows() {
         const session = this.#requireWorkflowSession();
         const result = session.clearQueue?.();
-        this.#sessionCommands?.forgetQueuedImages();
+        this.#engine.sessionCommands?.forgetQueuedImages();
         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,
-        };
-    }
-    async applyPinnedSettingValue(callback, value) {
-        try {
-            return await this.#applyPinnedSetting(callback, value, true);
-        }
-        catch (error) {
-            return workflowResult("settings", "failed", error instanceof Error ? error.message : String(error));
-        }
-    }
-    reloadBlockedResult() {
-        const session = this.#requireWorkflowSession();
-        if (session.isStreaming)
-            return workflowResult("reload", "failed", "Wait for the current response to finish before reloading.", undefined, "warning");
-        if (session.isCompacting)
-            return workflowResult("reload", "failed", "Wait for compaction to finish before reloading.", undefined, "warning");
-        return null;
-    }
-    async executeWorkflow(request) {
-        const cancelled = workflowResult(request.command, "cancelled", "", undefined, "silent");
-        if (this.#overload !== undefined || this.#admissionStopped || this.#disposed
-            || this.#pendingCommands.size + this.#pendingWorkflows.size >= 32)
-            return cancelled;
-        let cancel;
-        const cancellation = new Promise(resolve => { cancel = () => resolve(cancelled); });
-        const pending = { command: request.command, cancel };
-        this.#pendingWorkflows.add(pending);
-        this.#runningCommands++;
-        const operation = this.#runWorkflow(request).finally(() => { this.#runningCommands--; });
-        try {
-            return await Promise.race([operation, cancellation]);
-        }
-        finally {
-            this.#pendingWorkflows.delete(pending);
-        }
-    }
-    async #runWorkflow(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: ${errorMessage(error, "Unknown error")}`
-                : request.command === "import"
-                    ? `Failed to import session: ${message}`
-                    : request.command === "new"
-                        ? `Failed to create session: ${message}`
-                        : request.command === "resume"
-                            ? `Failed to resume session: ${message}`
-                            : request.command === "reload" ? `Reload failed: ${message}` : message;
-            return workflowResult(request.command, "failed", contextualMessage);
-        }
-    }
     view() {
         return {
             contractVersion: 1,
             sessionId: this.#sessionId,
             revision: this.#viewRevision,
             lifecycle: this.#lifecycle,
-            transcript: this.#transcriptSnapshot ??= Object.freeze([...this.#transcript]),
+            transcript: this.#projection.snapshot(),
             editor: { ...this.#editor, queuedSubmissions: [...this.#editor.queuedSubmissions] },
             status: {
                 ...this.#status,
                 diagnostics: [...this.#status.diagnostics],
                 badges: [...this.#status.badges],
-                usage: this.#usageCache ??= this.#readUsage(),
+                usage: this.#usageCache ??= readUsageView(this.#engine.session, this.#engine.runtime, this.#activeModel),
                 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,
+                    branch: this.#engine.gitBranch,
+                    sessionName: this.#engine.session?.sessionManager?.getSessionName() ?? null,
+                    availableProviderCount: new Set(this.#engine.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],
+            activeCommandIds: [...this.#commands.activeCommandIds],
             dialog: null,
             overlay: null,
             customizations: [],
@@ -1170,99 +436,27 @@ export class PiEngineAdapter {
             contractVersion: 1,
             snapshotId: `snapshot-${this.#viewRevision}`,
             sessionId: this.#sessionId,
-            sequence: this.#sequence,
+            sequence: this.#delivery.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");
-        }
-        // Invariant: the bounded out-of-band cancellation path has one slot per admitted command.
-        if (this.#overload !== undefined || this.#admissionStopped || this.#pendingCommands.size + this.#pendingWorkflows.size >= 32)
-            return { outcome: "rejected", diagnostic: null };
-        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);
-        const generation = this.#sessionGeneration;
-        let cancelled = false;
-        const cancellation = new Promise(resolve => {
-            this.#pendingCommands.set(command.correlationId, { type: command.type, cancel: () => {
-                    if (cancelled)
-                        return;
-                    cancelled = true;
-                    resolve(this.#recordCommand(command, "failed", null));
-                } });
-        });
-        this.#emitEvent({ type: "command-outcome", correlationId: command.correlationId, outcome: "accepted", diagnostic: null });
-        const operation = async () => {
-            try {
-                if (cancelled)
-                    return { outcome: "failed", diagnostic: null };
-                this.#runningCommands++;
-                try {
-                    await this.#perform(command);
-                }
-                finally {
-                    this.#runningCommands--;
-                }
-                if (cancelled)
-                    return { outcome: "failed", diagnostic: null };
-                if (generation === this.#sessionGeneration)
-                    this.#emitView();
-                if (cancelled)
-                    return { outcome: "failed", diagnostic: null };
-                return this.#recordCommand(command, "completed", null);
-            }
-            catch (error) {
-                if (cancelled)
-                    return { outcome: "failed", diagnostic: null };
-                const diagnostic = error instanceof Error ? error.message : String(error);
-                this.#addDiagnostic("error", "engine-command", diagnostic, true);
-                if (generation === this.#sessionGeneration)
-                    this.#emitView();
-                return this.#recordCommand(command, "failed", diagnostic);
-            }
-        };
-        try {
-            return await Promise.race([operation(), cancellation]);
-        }
-        finally {
-            this.#pendingCommands.delete(command.correlationId);
-        }
+    execute(command) {
+        return this.#commands.execute(command);
     }
     async dispose() {
         if (this.#disposed)
             return;
         this.#disposed = true;
-        for (const pending of this.#pendingCommands.values())
-            if (pending.type !== "shutdown")
-                pending.cancel();
+        this.#commands.cancelPending(["shutdown"]);
         // Compatibility: /quit owns normal disposal and must report its actual completion, not cancel itself.
-        for (const pending of this.#pendingWorkflows)
-            if (pending.command !== "quit")
-                pending.cancel();
-        this.#transcriptImageAssets.clear();
-        this.#extensionBound = false;
-        this.#extensionUi = undefined;
-        this.#extensionShutdown = undefined;
+        this.#workflows.cancelPending("quit");
+        this.#projection.assets.clear();
+        await this.#extensions.unbind();
         this.#lifecycle = "stopping";
         this.#emitEvent({ type: "session-lifecycle", lifecycle: "stopping", reason: null });
-        this.#unsubscribe?.();
-        this.#unsubscribe = undefined;
-        this.#compactionProgress?.dispose();
-        this.#compactionProgress = null;
-        await this.#runtime?.dispose();
+        await this.#engine.dispose();
         this.#lifecycle = "stopped";
         this.#emitEvent({ type: "session-lifecycle", lifecycle: "stopped", reason: null });
         this.#emitView();
@@ -1274,716 +468,45 @@ export class PiEngineAdapter {
                 throw error;
         }
     }
-    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 await this.#applyPinnedSetting(selection);
-            }
-            case "model": {
-                const reference = selection ?? argument;
-                if (!reference)
-                    return workflowResult(request.command, "failed", "Model requires the owned model controller");
-                const scopedModels = Array.isArray(session.scopedModels)
-                    ? session.scopedModels.map(item => item.model)
-                    : [];
-                let availableModels = scopedModels.length > 0
-                    ? scopedModels
-                    : [...(runtime.services.modelRuntime.getAvailableSnapshot?.() ?? [])];
-                let model = findExactWorkflowModel(reference, availableModels);
-                const messages = [];
-                const generation = this.#sessionGeneration;
-                const current = () => !this.#disposed && generation === this.#sessionGeneration;
-                const publish = (message) => {
-                    if (!current())
-                        return;
-                    if (this.#workflowInteraction.publish)
-                        this.#workflowInteraction.publish(message);
-                    else
-                        messages.push(message);
-                };
-                if (model === undefined && scopedModels.length === 0) {
-                    publish({ kind: "status", message: "Refreshing model catalogs…" });
-                    const controller = new AbortController();
-                    let timedOut = false;
-                    const timeout = setTimeout(() => {
-                        timedOut = true;
-                        controller.abort();
-                    }, AUTH_REFRESH_TIMEOUT_MS);
-                    try {
-                        const refreshed = await runtime.services.modelRuntime.refresh?.({ signal: controller.signal });
-                        if (isRecord(refreshed) && refreshed.aborted === true && timedOut) {
-                            publish({ kind: "warning", message: "Model refresh timed out; searching cached models." });
-                        }
-                        else if (isRecord(refreshed) && refreshed.errors instanceof Map && refreshed.errors.size > 0) {
-                            publish({ kind: "warning", message: `Could not refresh ${[...refreshed.errors.keys()].join(", ")}; searching cached models.` });
-                        }
-                    }
-                    catch (error) {
-                        publish({
-                            kind: "warning",
-                            message: timedOut
-                                ? "Model refresh timed out; searching cached models."
-                                : `Could not refresh model catalogs: ${error instanceof Error ? error.message : String(error)}`,
-                        });
-                    }
-                    finally {
-                        clearTimeout(timeout);
-                    }
-                    availableModels = [...(runtime.services.modelRuntime.getAvailableSnapshot?.() ?? [])];
-                    model = findExactWorkflowModel(reference, availableModels);
-                }
-                if (!current())
-                    return workflowResult(request.command, "cancelled", "Model selection cancelled", undefined, "silent");
-                if (model === undefined) {
-                    return {
-                        ...workflowResult(request.command, "requires-selection", "Select a model", reference, "silent"),
-                        ...(messages.length === 0 ? {} : { messages: Object.freeze(messages) }),
-                    };
-                }
-                try {
-                    await session.setModel(model);
-                }
-                catch (error) {
-                    if (!current())
-                        return workflowResult(request.command, "cancelled", "Model selection cancelled", undefined, "silent");
-                    const failure = { kind: "error", message: error instanceof Error ? error.message : String(error) };
-                    return workflowResult(request.command, "failed", failure.message, undefined, "error", messages.length === 0 ? undefined : [...messages, failure]);
-                }
-                if (!current())
-                    return workflowResult(request.command, "cancelled", "Model selection cancelled", undefined, "silent");
-                const providerId = stringProperty(model, "provider") ?? "unknown";
-                const modelId = stringProperty(model, "id") ?? reference;
-                this.#activeModel = { providerId, modelId, displayName: stringProperty(model, "name") ?? modelId };
-                this.#emitView();
-                const resultMessage = { kind: "status", message: `Model: ${modelId}` };
-                return messages.length === 0
-                    ? workflowResult(request.command, "completed", resultMessage.message)
-                    : workflowResult(request.command, "completed", resultMessage.message, undefined, "status", [...messages, resultMessage]);
-            }
-            case "scoped-models": {
-                if (!selection)
-                    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", undefined, "status");
-                try {
-                    const result = await requireCapability(runtime.importFromJsonl, "importFromJsonl").call(runtime, path, request.cwdOverride);
-                    if (isRecord(result) && result.cancelled === true)
-                        return workflowResult(request.command, "cancelled", "Import cancelled", undefined, "status");
-                    return workflowResult(request.command, "completed", `Session imported from: ${path}`);
-                }
-                catch (error) {
-                    const issue = isRecord(error) && isRecord(error.issue) ? error.issue : undefined;
-                    const fallbackCwd = issue === undefined ? undefined : stringProperty(issue, "fallbackCwd");
-                    if (fallbackCwd !== undefined && request.cwdOverride === undefined) {
-                        const sessionCwd = stringProperty(issue, "sessionCwd") ?? "the session working directory";
-                        return workflowConfirmation(request.command, `cwd from session file does not exist\n${sessionCwd}\n\ncontinue in current cwd\n${fallbackCwd}`, fallbackCwd);
-                    }
-                    throw error;
-                }
-            }
-            case "share": {
-                const signal = request.signal;
-                if (signal?.aborted)
-                    return workflowResult(request.command, "cancelled", "Share cancelled", undefined, "status");
-                try {
-                    await this.#workflowHost.runCommand("gh", ["auth", "status"], signal === undefined ? undefined : { signal });
-                }
-                catch (error) {
-                    if (signal?.aborted || isAbortError(error))
-                        return workflowResult(request.command, "cancelled", "Share cancelled", undefined, "status");
-                    const message = commandMissing(error)
-                        ? "GitHub CLI (gh) is not installed. Install it from https://cli.github.com/"
-                        : "GitHub CLI is not logged in. Run 'gh auth login' first.";
-                    return workflowResult(request.command, "failed", message);
-                }
-                const temporary = join(tmpdir(), `${PRODUCT_IDENTITY.filesystem.temporaryPrefix}pi-session-${process.pid}.html`);
-                try {
-                    try {
-                        await requireCapability(session.exportToHtml, "exportToHtml").call(session, temporary);
-                    }
-                    catch (error) {
-                        return workflowResult(request.command, "failed", `Failed to export session: ${errorMessage(error, "Unknown error")}`);
-                    }
-                    if (signal?.aborted)
-                        return workflowResult(request.command, "cancelled", "Share cancelled", undefined, "status");
-                    let gist;
-                    try {
-                        gist = await this.#workflowHost.runCommand("gh", ["gist", "create", "--public=false", temporary], signal === undefined ? undefined : { signal });
-                    }
-                    catch (error) {
-                        if (signal?.aborted || isAbortError(error))
-                            return workflowResult(request.command, "cancelled", "Share cancelled", undefined, "status");
-                        return workflowResult(request.command, "failed", `Failed to create gist: ${shareCommandFailureDetail(error)}`);
+    #requireWorkflowSession() {
+        if (this.#disposed || !this.#engine.runtime || !this.#engine.session)
+            throw new Error("engine adapter is not running");
+        return this.#engine.session;
+    }
+    async #perform(command) {
+        const runtime = this.#engine.runtime;
+        const session = this.#engine.session;
+        const generation = this.#engine.generation;
+        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.#engine.sessionCommands?.execute(command.type === "prompt" || command.type === "steer" || command.type === "follow-up"
+                    ? {
+                        type: command.type,
+                        text: command.text,
+                        ...(command.images === undefined ? {} : { images: [...command.images] }),
                     }
-                    if (signal?.aborted)
-                        return workflowResult(request.command, "cancelled", "Share cancelled", undefined, "status");
-                    const gistUrl = gist.stdout.trim();
-                    const gistId = gistUrl.split("/").at(-1);
-                    if (!gistId)
-                        return workflowResult(request.command, "failed", "Failed to parse gist ID from gh output");
-                    return workflowResult(request.command, "completed", `Share URL: ${shareViewerUrl(gistId)}`, gistUrl);
-                }
-                finally {
-                    await rm(temporary, { force: true });
+                    : { 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 "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.");
-                const acknowledged = await this.copyWorkflowText(text);
-                return workflowResult(request.command, "completed", acknowledged ? "Copied last agent message to clipboard" : "Submitted 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>", undefined, "warning");
+            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}`);
                 }
-                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", undefined, "silent");
-                return workflowResult(request.command, "completed", "Forked to new session");
-            }
-            case "clone": {
-                const manager = session.sessionManager;
-                const leaf = manager?.getLeafId?.();
-                if (typeof leaf !== "string")
-                    return workflowResult(request.command, "completed", "Nothing to clone yet", undefined, "status");
-                const result = await requireCapability(runtime.fork, "fork").call(runtime, leaf, { position: "at" });
-                if (isRecord(result) && result.cancelled === true)
-                    return workflowResult(request.command, "cancelled", "Clone cancelled", undefined, "silent");
-                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", undefined, "status");
-                if (isRecord(result) && result.cancelled === true)
-                    return workflowResult(request.command, "cancelled", "Navigation cancelled", undefined, "status");
-                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;
-                const previousModel = session.model;
-                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", undefined, "silent");
-                    }
-                    const detail = error instanceof Error ? error.message : String(error);
-                    const actionLabel = authType === "api_key" ? `Saved API key for ${providerName}` : `Logged in to ${providerName}`;
-                    const message = error instanceof CredentialSynchronizationError
-                        ? `${actionLabel}, but local model state could not be synchronized: ${detail}`
-                        : authType === "api_key"
-                            ? `Failed to save API key for ${providerName}: ${detail}`
-                            : `Failed to login to ${providerName}: ${detail}`;
-                    return workflowResult(request.command, "failed", message);
-                }
-                finally {
-                    this.#workflowInteraction.finishLogin?.();
-                }
-                return await this.#completeProviderAuthentication(providerId, providerName, authType, previousModel);
-            }
-            case "logout": {
-                if (!selection)
-                    return workflowResult(request.command, "failed", "Logout requires the owned authentication controller");
-                const [credentialType = "oauth", providerId = selection] = selection.includes(":") ? selection.split(":", 2) : ["oauth", selection];
-                const modelRuntime = runtime.services.modelRuntime;
-                const provider = modelRuntime.getProvider?.(providerId);
-                const providerName = stringProperty(provider, "name") ?? providerId;
-                try {
-                    await requireCapability(modelRuntime.logout, "logout").call(modelRuntime, providerId, { signal: AbortSignal.timeout(15_000) });
-                }
-                catch (error) {
-                    const detail = error instanceof Error ? error.message : String(error);
-                    const message = error instanceof CredentialSynchronizationError
-                        ? `Credentials removed for ${providerName}, but local model state could not be synchronized: ${detail}`
-                        : `Logout failed: ${detail}`;
-                    return workflowResult(request.command, "failed", message);
-                }
-                this.#reconcileActiveModelAvailability();
-                this.#emitView();
-                return workflowResult(request.command, "completed", credentialType === "api_key"
-                    ? `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", undefined, "silent");
-                return workflowResult(request.command, "completed", "✓ New session started", undefined, "accent");
-            }
-            case "compact": {
-                try {
-                    await session.compact(argument || undefined);
-                    return workflowResult(request.command, "completed", "Compaction requested", undefined, "silent");
-                }
-                catch (error) {
-                    return workflowResult(request.command, "failed", error instanceof Error ? error.message : String(error), undefined, "silent");
-                }
-            }
-            case "resume": {
-                if (!selection && !argument)
-                    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", undefined, "silent");
-                    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", undefined, "status");
-                    const result = await runtime.switchSession(sessionPath, { cwdOverride: fallbackCwd });
-                    if (isRecord(result) && result.cancelled === true)
-                        return workflowResult(request.command, "cancelled", "Resume cancelled", undefined, "silent");
-                    return workflowResult(request.command, "completed", "Resumed session in current cwd");
-                }
-            }
-            case "reload": {
-                const blocked = this.reloadBlockedResult();
-                if (blocked)
-                    return blocked;
-                await requireCapability(session.reload, "reload").call(session);
-                await this.#bindExtensionUiToSession();
-                const message = "Reloaded keybindings, extensions, skills, prompts, themes, and context files";
-                const modelError = runtime.services.modelRuntime.getError?.();
-                return workflowResult(request.command, "completed", message, undefined, "status", modelError ? [
-                    { kind: "error", message: `models.json error: ${modelError}` },
-                    { kind: "status", message },
-                ] : undefined);
-            }
-            case "quit": {
-                await this.dispose();
-                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");
-        }
-    }
-    async #completeProviderAuthentication(providerId, providerName, authType, previousModel) {
-        const session = this.#requireWorkflowSession();
-        const modelRuntime = this.#runtime?.services.modelRuntime;
-        if (!modelRuntime)
-            throw new Error("engine runtime is unavailable");
-        const actionLabel = authType === "oauth" ? `Logged in to ${providerName}` : `Saved API key for ${providerName}`;
-        let selectedModelId;
-        let selectionError;
-        if (isUnknownModel(previousModel)) {
-            const available = modelRuntime.getAvailableSnapshot?.() ?? [];
-            const providerModels = available.filter(model => stringProperty(model, "provider") === providerId);
-            const defaultModelId = PINNED_DEFAULT_MODEL_BY_PROVIDER[providerId];
-            if (defaultModelId === undefined) {
-                selectionError = `${actionLabel}, but no default model is configured for provider "${providerId}". Use /model to select a model.`;
-            }
-            else if (providerModels.length === 0) {
-                selectionError = `${actionLabel}, but no models are available for that provider. Use /model to select a model.`;
-            }
-            else {
-                const selectedModel = providerModels.find(model => stringProperty(model, "id") === defaultModelId);
-                if (selectedModel === undefined) {
-                    selectionError = `${actionLabel}, but its default model "${defaultModelId}" is not available. Use /model to select a model.`;
-                }
-                else {
-                    try {
-                        await session.setModel(selectedModel);
-                        selectedModelId = stringProperty(selectedModel, "id") ?? defaultModelId;
-                        this.#activeModel = {
-                            providerId,
-                            modelId: selectedModelId,
-                            displayName: stringProperty(selectedModel, "name") ?? selectedModelId,
-                        };
-                    }
-                    catch (error) {
-                        selectionError = `${actionLabel}, but selecting its default model failed: ${error instanceof Error ? error.message : String(error)}. Use /model to select a model.`;
-                    }
-                }
-            }
-        }
-        this.#reconcileActiveModelAvailability();
-        this.#emitView();
-        const status = `${actionLabel}.${selectedModelId ? ` Selected ${selectedModelId}.` : ""} Credentials saved to ${join(this.#agentDir, "auth.json")}`;
-        const messages = [
-            { kind: "status", message: status },
-            ...(selectionError === undefined ? [] : [{ kind: "error", message: selectionError }]),
-        ];
-        this.#scheduleAuthenticatedProviderRefresh(providerId, actionLabel);
-        return workflowResult("login", "completed", status, undefined, "status", messages);
-    }
-    #scheduleAuthenticatedProviderRefresh(providerId, actionLabel) {
-        const runtime = this.#runtime;
-        const refresh = runtime?.services.modelRuntime.refresh;
-        if (!runtime || typeof refresh !== "function")
-            return;
-        const generation = this.#sessionGeneration;
-        const publish = this.#workflowInteraction.publish;
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), AUTH_REFRESH_TIMEOUT_MS);
-        // Compatibility: post-authentication refresh starts on the next turn so its notices follow the saved-credential status.
-        void new Promise(resolve => setTimeout(resolve, 0))
-            .then(() => refresh.call(runtime.services.modelRuntime, { providers: [providerId], signal: controller.signal }))
-            .then(result => {
-            if (this.#disposed || this.#sessionGeneration !== generation)
-                return;
-            if (isRecord(result) && result.aborted === true) {
-                publish?.({ kind: "warning", message: `${actionLabel}, but its model catalog refresh timed out; using cached models.` });
-            }
-            else if (isRecord(result) && result.errors instanceof Map && result.errors.size > 0) {
-                publish?.({ kind: "warning", message: `${actionLabel}, but its model catalog could not be refreshed; using cached models.` });
-            }
-            this.#reconcileActiveModelAvailability();
-            this.#emitView();
-        })
-            .catch(error => {
-            if (this.#disposed || this.#sessionGeneration !== generation)
-                return;
-            publish?.({
-                kind: "warning",
-                message: controller.signal.aborted
-                    ? `${actionLabel}, but its model catalog refresh timed out; using cached models.`
-                    : `${actionLabel}, but its model catalog could not be refreshed: ${error instanceof Error ? error.message : String(error)}`,
-            });
-        })
-            .finally(() => clearTimeout(timeout));
-    }
-    #requireWorkflowSession() {
-        if (this.#disposed || !this.#runtime || !this.#session)
-            throw new Error("engine adapter is not running");
-        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));
-    }
-    async #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 port = this.settingsPort();
-        if (port === null)
-            return workflowResult("settings", "failed", "Settings are unavailable");
-        const key = settingKeyForCallback(callback);
-        if (key === null)
-            return workflowResult("settings", "failed", `${settingLabel(callback)} is unavailable in this runtime`);
-        const result = await port.writeSetting(key, agentJsonValue(selectedValue));
-        if (result.status === "failed" || result.status === "unavailable") {
-            return workflowResult("settings", "failed", result.failure ?? result.limitationReason ?? `${settingLabel(callback)} is unavailable`);
-        }
-        this.#emitView();
-        const suffix = result.status === "deferred" ? ` (${result.application})` : "";
-        return workflowResult("settings", "completed", `${settingLabel(callback)}: ${String(selectedValue)}${suffix}`);
-    }
-    async #perform(command) {
-        const runtime = this.#runtime;
-        const session = this.#session;
-        const generation = this.#sessionGeneration;
-        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,
-                        ...(command.images === undefined ? {} : { images: [...command.images] }),
-                    }
-                    : { type: command.type });
-                if (!result || result.outcome === "rejected" || result.outcome === "failed") {
-                    throw new Error(command.type === "retry" ? "no previous prompt is available to retry" : `Pi session command failed: ${command.type}`);
-                }
-                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);
-                if (generation === this.#sessionGeneration && this.#overload === undefined && !this.#admissionStopped)
-                    this.#activeModel = { ...command.model };
-                return;
+                await session.setModel(model);
+                if (generation === this.#engine.generation && !this.#delivery.overloaded && !this.#admissionStopped)
+                    this.#activeModel = { ...command.model };
+                return;
             }
             case "set-thinking-level":
                 session.setThinkingLevel(command.thinkingLevel);
@@ -2008,24 +531,10 @@ export class PiEngineAdapter {
                 throw new Error("owned UI state commands belong to the owned UI layer, not the Pi engine adapter");
         }
     }
-    #bindSession(session) {
-        this.#unsubscribe?.();
-        for (const pending of this.#pendingCommands.values()) {
-            if (pending.type !== "new-session" && pending.type !== "resume-session")
-                pending.cancel();
-        }
-        this.#sessionGeneration += 1;
-        this.#sessionBindingGeneration += 1;
-        this.#invalidatedEvents += this.#eventQueue.discardObsolete(this.#sessionGeneration);
-        this.#session = session;
-        this.#activeCommandIds = [];
-        this.#completedCommands.clear();
-        this.#sessionCommands = new PiSessionCommandIntegration(session);
-        this.#compactionProgress?.dispose();
-        this.#compactionProgress = observeCompactionProgress(session, percent => {
-            if (this.#session === session && !this.#disposed)
-                this.#publishCompactionProgress(percent);
-        });
+    // Invariant: the runtime already advanced the generation and subscribed; this rebuilds what the view derives from a session.
+    #sessionReplaced(session) {
+        this.#delivery.discardObsolete(this.#engine.generation);
+        this.#commands.reset();
         this.#editor = {
             text: "",
             queuedSubmissions: [],
@@ -2035,33 +544,25 @@ export class PiEngineAdapter {
             submitEnabled: true,
         };
         this.#status = { ...this.#status, workingMessage: null, workingProgress: null, badges: [] };
-        this.#statusKind = null;
-        this.#agentRunActive = false;
-        this.#agentRunSequence = 0;
-        this.#assistantResponseSequence = 0;
+        this.#events.reset();
         this.#activeModel = readModel(session.model);
         this.#reconcileActiveModelAvailability();
         this.#thinkingLevel = readThinkingLevel(session.thinkingLevel);
-        this.#transcriptImageAssets.clear();
+        this.#projection.assets.clear();
         // Invariant: a new binding cannot inherit arguments/results from a reused invocation id.
         this.#setTranscript([]);
-        this.#rebuildTranscript(session.messages, "finalized");
-        const generation = this.#sessionGeneration;
-        this.#unsubscribe = session.subscribe(event => {
-            if (generation === this.#sessionGeneration && !this.#disposed)
-                this.#handlePiEvent(event);
-        });
-        if (this.#extensionUi !== undefined)
-            void this.#bindExtensionUiToSession();
+        this.#setTranscript(this.#projection.rebuild(session.messages, "finalized"));
+        if (this.#extensions.attached)
+            void this.#extensions.rebind();
     }
     #reconcileActiveModelAvailability() {
-        const modelRuntime = this.#runtime?.services.modelRuntime;
+        const modelRuntime = this.#engine.runtime?.services.modelRuntime;
         if (!modelRuntime) {
             this.#activeModel = null;
             return;
         }
         const available = modelRuntime.getAvailableSnapshot?.() ?? [];
-        const sessionModel = readModel(this.#session?.model);
+        const sessionModel = readModel(this.#engine.session?.model);
         const authoritative = this.#activeModel ?? sessionModel;
         if (authoritative === null)
             return;
@@ -2069,694 +570,13 @@ export class PiEngineAdapter {
             && 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();
-        }
-    }
-    // Performance: replacing the transcript rebuilds its index so block lookup stays constant-time.
     #setTranscript(blocks) {
         // Invariant: lazy delivery snapshots must freeze before their authoritative source can be removed.
-        if (!this.#eventQueue.seal()) {
-            this.#beginOverload();
-            return;
-        }
-        for (const block of blocks)
-            this.#transcriptImageAssets.retain(block);
-        for (const block of this.#transcript)
-            this.#transcriptImageAssets.release(block);
-        this.#transcript = blocks;
-        this.#transcriptIndex.clear();
-        for (const [index, block] of blocks.entries())
-            this.#transcriptIndex.set(block.id, index);
-        this.#transcriptImageAssets.discardUnowned();
-        this.#transcriptSnapshot = undefined;
-    }
-    #transcriptBlock(id) {
-        const index = this.#transcriptIndex.get(id);
-        return index === undefined ? undefined : this.#transcript[index];
-    }
-    // Invariant: the named work state is the only state a matching end may clear.
-    #enterWorkState(kind, message) {
-        const wasBusy = this.#lifecycle === "busy";
-        this.#statusKind = kind;
-        this.#lifecycle = "busy";
-        this.#status = { ...this.#status, workingMessage: message, workingProgress: null };
-        if (!wasBusy)
-            this.#emitEvent({ type: "session-lifecycle", lifecycle: "busy", reason: null });
-        this.#emitEvent({ type: "status", status: this.#status });
-    }
-    // Invariant: ending retry or compaction cannot clear a different active work state.
-    #endWorkState(kind) {
-        if (this.#statusKind !== kind)
-            return;
-        if (this.#agentRunActive) {
-            this.#enterWorkState("working", "Working");
-            return;
-        }
-        this.#leaveWorkStates();
-    }
-    #leaveWorkStates() {
-        this.#statusKind = null;
-        this.#lifecycle = "ready";
-        this.#status = { ...this.#status, workingMessage: null, workingProgress: null };
-        this.#emitEvent({ type: "session-lifecycle", lifecycle: "ready", reason: null });
-        this.#emitEvent({ type: "status", status: this.#status });
-    }
-    // Invariant: progress belongs to the compaction state only and is published when the integer changes.
-    #publishCompactionProgress(percent) {
-        if (this.#statusKind !== "compaction" || this.#status.workingProgress === percent)
-            return;
-        this.#status = { ...this.#status, workingProgress: percent };
-        this.#emitEvent({ type: "status", status: this.#status });
-    }
-    // Rationale: a manual compaction ends with an idle session, so the engine would never consume
-    // the messages queued during it; automatic compaction returns to a run or a pending prompt.
-    #deliverQueuedAfterCompaction() {
-        const commands = this.#sessionCommands;
-        const generation = this.#sessionGeneration;
-        if (commands === undefined)
+        if (!this.#delivery.seal()) {
+            this.#delivery.beginOverload();
             return;
-        const report = (error) => {
-            if (generation !== this.#sessionGeneration || this.#disposed)
-                return;
-            this.#addDiagnostic("error", "engine-command", `Queued input could not be sent after compaction: ${error instanceof Error ? error.message : String(error)}`, true);
-            this.#emitView();
-        };
-        commands.deliverQueuedAfterCompaction(report).catch(report);
-    }
-    #handlePiEvent(event) {
-        try {
-            this.#applyPiEvent(event);
-        }
-        finally {
-            this.#transcriptImageAssets.discardUnowned();
-        }
-    }
-    #applyPiEvent(event) {
-        if (!isRecord(event) || typeof event.type !== "string")
-            return;
-        // Invariant: usage moves at message and lifecycle boundaries, not with stream chunks, so the
-        // two streaming event kinds keep the memo and everything else drops it.
-        if (event.type !== "message_update" && event.type !== "tool_execution_update")
-            this.#usageCache = undefined;
-        switch (event.type) {
-            case "agent_start":
-                this.#agentRunActive = true;
-                this.#agentRunSequence += 1;
-                this.#emitEvent({ type: "agent-run-started" });
-                this.#enterWorkState("working", "Working");
-                return;
-            case "message_start":
-                this.#upsertMessageBlock(event.message, "live");
-                return;
-            case "message_update": {
-                const delta = isRecord(event.assistantMessageEvent) && typeof event.assistantMessageEvent.delta === "string"
-                    ? event.assistantMessageEvent.delta
-                    : undefined;
-                // Invariant: the delta is folded in before the block is stored, so a chunk is one update to
-                // one block rather than a store without the delta followed by a store with it.
-                const blocks = this.#messageBlocks(event.message, "live", this.#transcript.length);
-                for (const [index, block] of blocks.entries()) {
-                    this.#upsertTranscriptBlock(index === 0 && delta !== undefined && !block.text.endsWith(delta)
-                        ? { ...block, text: `${block.text}${delta}` }
-                        : block);
-                }
-                return;
-            }
-            case "message_end":
-                this.#upsertMessageBlock(event.message, "finalized");
-                this.#settleFailedDeclarations(event.message);
-                // Compatibility: preserve the same semantic boundary v2 counted. Transcript block
-                // finalization is intentionally not a substitute: rebuilds, retries,
-                // thinking parts, and tool rows can all finalize independently.
-                if (isRecord(event.message) && event.message.role === "assistant") {
-                    this.#assistantResponseSequence += 1;
-                    const content = Array.isArray(event.message.content) ? event.message.content : [];
-                    const stopReason = stringValue(event.message.stopReason) ?? null;
-                    const toolContinuation = stopReason === "toolUse"
-                        || content.some(item => isRecord(item) && item.type === "toolCall");
-                    const successful = stringValue(event.message.errorMessage) === undefined
-                        && stopReason !== "error"
-                        && stopReason !== "aborted"
-                        && textFromContent(content).trim().length > 0;
-                    this.#emitEvent({
-                        type: "assistant-message-completed",
-                        sessionGeneration: this.#sessionGeneration,
-                        runSequence: this.#agentRunSequence,
-                        responseSequence: this.#assistantResponseSequence,
-                        model: this.#activeModel,
-                        assistantMessageCount: this.#transcript.filter(block => block.kind === "assistant").length,
-                        successful,
-                        stopReason,
-                        toolContinuation,
-                    });
-                }
-                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_end": {
-                this.#upsertToolExecutionBlock(event);
-                return;
-            }
-            case "tool_execution_update":
-                this.#upsertToolExecutionBlock(event);
-                return;
-            case "agent_settled":
-            case "agent_end": {
-                if (event.type === "agent_end" && event.willRetry === true)
-                    return;
-                // Protocol: agent_end is run-local; only settlement reads the complete session scope.
-                const finalMessages = event.type === "agent_settled"
-                    ? this.#session?.messages ?? []
-                    : Array.isArray(event.messages) ? event.messages : [];
-                if (event.type === "agent_end")
-                    this.#mergeRunTranscript(finalMessages);
-                else if (finalMessages.length > 0)
-                    this.#rebuildTranscript(finalMessages, "finalized");
-                // Invariant: missing final messages must not erase accumulated content or invent tool outcomes.
-                if (finalMessages.length === 0)
-                    this.#setTranscript(this.#transcript.map(block => block.status === "live" && transcriptToolState(block) === undefined
-                        ? { ...block, status: "finalized", revision: block.revision + 1 } : block));
-                // Compatibility: ending a turn leaves the working state, as the recorded pinned baseline does, but
-                // it leaves only that state: a compaction or retry being shown outlives the turn
-                // that ended under it. Settlement ends the run, and with it every state — the
-                // engine ends a turn for each continuation it makes and settles once.
-                if (event.type === "agent_settled") {
-                    this.#agentRunActive = false;
-                    this.#leaveWorkStates();
-                }
-                else if (this.#statusKind === null || this.#statusKind === "working") {
-                    this.#leaveWorkStates();
-                }
-                this.#emitView();
-                if (event.type === "agent_settled") {
-                    const assistants = finalMessages.filter(message => isRecord(message) && message.role === "assistant");
-                    const lastAssistant = assistants.at(-1);
-                    const successful = lastAssistant !== undefined
-                        && stringValue(lastAssistant.errorMessage) === undefined
-                        && stringValue(lastAssistant.stopReason) !== "error"
-                        && stringValue(lastAssistant.stopReason) !== "aborted";
-                    this.#emitEvent({
-                        type: "agent-run-settled",
-                        sessionGeneration: this.#sessionGeneration,
-                        runSequence: this.#agentRunSequence,
-                        responseSequence: this.#assistantResponseSequence,
-                        model: this.#activeModel,
-                        assistantMessageCount: assistants.length,
-                        successful,
-                    });
-                }
-                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.#enterWorkState("retry", "Retrying");
-                return;
-            case "auto_retry_end":
-                this.#endWorkState("retry");
-                return;
-            case "compaction_start":
-                this.#enterWorkState("compaction", "Compacting");
-                this.#compactionProgress?.begin();
-                return;
-            case "compaction_end":
-                this.#compactionProgress?.end();
-                this.#endWorkState("compaction");
-                if (event.reason === "manual")
-                    this.#deliverQueuedAfterCompaction();
-                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,
-        };
-    }
-    // Invariant: run-local completion may restate messages, but never owns transcript membership.
-    #mergeRunTranscript(messages) {
-        const positions = new Map();
-        const sessionOccurrences = new Map();
-        for (const [index, message] of (this.#session?.messages ?? []).entries()) {
-            const key = messageFallbackKey(message, index);
-            const occurrence = sessionOccurrences.get(key) ?? 0;
-            sessionOccurrences.set(key, occurrence + 1);
-            positions.set(message, { index, occurrence });
-        }
-        const runOccurrences = new Map();
-        for (const [index, message] of messages.entries()) {
-            const key = messageFallbackKey(message, index);
-            const occurrence = runOccurrences.get(key) ?? 0;
-            runOccurrences.set(key, occurrence + 1);
-            const position = positions.get(message) ?? { index, occurrence };
-            for (const block of this.#messageBlocks(message, "finalized", position.index, position.occurrence)) {
-                this.#upsertTranscriptBlock(block);
-            }
-            this.#settleFailedDeclarations(message);
-        }
-    }
-    // Invariant: full replacement is reserved for session-authoritative scope (bind/settlement).
-    #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, id => blocks[blockIndexes.get(id) ?? -1] ?? this.#transcriptBlock(id))) {
-                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 : {}),
-                        },
-                    };
-                }
-            }
-        }
-        // Performance: an authoritative rebuild restates most of what is already there. Reusing the block
-        // that already says it keeps its revision, and with it the rows the shell rendered for
-        // it — otherwise every turn that ends re-renders the whole session.
-        this.#setTranscript(blocks.map(block => {
-            const existing = this.#transcriptBlock(block.id);
-            const next = existing === undefined ? block : retainCompletedArguments(existing, block);
-            return existing !== undefined && sameBlockContent(existing, next) ? existing : next;
-        }));
-    }
-    #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, currentBlock = id => this.#transcriptBlock(id)) {
-        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),
-                    imageReferences: this.#imageReferences(message.content, "user"),
-                    payload: {
-                        role: "user",
-                        imageCount: contentImageCount(message.content),
-                        timestamp: typeof message.timestamp === "number" && Number.isFinite(message.timestamp) ? message.timestamp : null,
-                    },
-                }];
-        }
-        if (message.role === "bashExecution") {
-            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 = currentBlock(blockId);
-            const existingPayload = isRecord(existing?.payload) ? existing.payload : undefined;
-            const payload = {
-                role: "toolResult", toolCallId: toolCallId ?? null,
-                toolName: stringValue(message.toolName) ?? stringValue(existingPayload?.toolName) ?? "unknown",
-                argsComplete: true, partialResult: status === "live", isError: message.isError === true,
-            };
-            const rendering = toolRenderingInput({ args: undefined, previousArgs: existing?.toolRendering,
-                result: message, payload, image: part => this.#imageReferences([part], "tool-result")[0] });
-            return [{
-                    id: blockId,
-                    kind: "tool-result",
-                    status,
-                    toolState: { argsComplete: true, execution: status === "live" ? "running" : message.isError === true ? "failed" : "succeeded" },
-                    revision: this.#nextBlockRevision(blockId),
-                    title: stringValue(message.toolName) ?? existing?.title ?? "Tool result",
-                    ...rendering,
-                    payload,
-                }];
-        }
-        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);
-            const failure = status === "finalized" ? this.#declarationFailure(message) : undefined;
-            const payload = { toolCallId, toolName: stringValue(item.name) ?? "unknown",
-                argsComplete: failure === undefined && status === "finalized",
-                ...(failure === undefined ? {} : { isError: true }) };
-            const rendering = toolRenderingInput({ args: item.arguments, payload,
-                ...(failure === undefined ? {} : { result: { content: [{ type: "text", text: failure.text }] } }),
-                image: () => undefined });
-            blocks.push({
-                id: blockId,
-                kind: failure === undefined ? "tool-call" : "tool-result",
-                status: failure === undefined ? "live" : "finalized",
-                toolState: {
-                    argsComplete: failure === undefined && status === "finalized",
-                    execution: failure?.execution ?? "pending",
-                },
-                revision: this.#nextBlockRevision(blockId),
-                title: stringValue(item.name) ?? "Tool",
-                ...rendering,
-                text: failure?.text ?? jsonSummary(item.arguments).summary,
-                payload,
-            });
-        }
-        return blocks;
-    }
-    #declarationFailure(message) {
-        // Provenance: pinned interactive-mode message_end and history reconstruction settle pending tools.
-        if (message.role !== "assistant")
-            return undefined;
-        if (message.stopReason === "aborted") {
-            const attempts = this.#session?.retryAttempt ?? 0;
-            return { execution: "aborted", text: attempts > 0
-                    ? `Aborted after ${attempts} retry attempt${attempts > 1 ? "s" : ""}` : "Operation aborted" };
-        }
-        return message.stopReason === "error"
-            ? { execution: "failed", text: stringValue(message.errorMessage) || "Error" } : undefined;
-    }
-    #settleFailedDeclarations(message) {
-        if (!isRecord(message))
-            return;
-        const failure = this.#declarationFailure(message);
-        if (failure === undefined)
-            return;
-        for (const block of this.#transcript) {
-            const state = transcriptToolState(block);
-            if (state === undefined || state.execution !== "pending" && state.execution !== "running")
-                continue;
-            const payload = { ...(isRecord(block.payload) ? block.payload : {}), partialResult: false, isError: true };
-            this.#upsertTranscriptBlock({
-                ...block, kind: "tool-result", status: "finalized", revision: block.revision + 1,
-                ...toolRenderingInput({ args: undefined, previousArgs: block.toolRendering, payload,
-                    result: { content: [{ type: "text", text: failure.text }] }, image: () => undefined }),
-                toolState: { ...state, execution: failure.execution }, payload,
-            });
-        }
-    }
-    #imageReferences(content, source) {
-        if (!Array.isArray(content))
-            return [];
-        const references = [];
-        for (const item of content) {
-            if (references.length >= 16)
-                break;
-            const reference = this.#transcriptImageAssets.reference(item, source);
-            if (reference !== undefined)
-                references.push(reference);
-        }
-        return references;
-    }
-    #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 existing = this.#transcriptBlock(blockId);
-        const state = existing === undefined ? undefined : transcriptToolState(existing);
-        // Invariant: duplicate starts cannot blank accumulated output; late events cannot reopen a settled invocation.
-        if (state !== undefined && (state.execution !== "pending" && state.execution !== "running"
-            || event.type === "tool_execution_start" && state.execution === "running"))
-            return;
-        const source = ended ? event.result : event.partialResult;
-        const payload = { toolCallId, toolName: stringValue(event.toolName) ?? "unknown",
-            partialResult: event.type === "tool_execution_update", argsComplete: true, isError: event.isError === true };
-        const rendering = toolRenderingInput({ args: event.args, previousArgs: existing?.toolRendering, result: source,
-            payload, image: part => this.#imageReferences([part], "tool-result")[0] });
-        this.#upsertTranscriptBlock({
-            id: blockId,
-            kind: ended ? "tool-result" : "tool-call",
-            status: ended ? "finalized" : "live",
-            toolState: { argsComplete: true, execution: ended ? event.isError === true ? "failed" : "succeeded" : "running" },
-            revision: this.#nextBlockRevision(blockId),
-            title: stringValue(event.toolName) ?? "Tool",
-            ...rendering,
-            payload,
-        });
-    }
-    #upsertTranscriptBlock(block) {
-        const index = this.#transcriptIndex.get(block.id);
-        if (index !== undefined) {
-            const existing = this.#transcript[index];
-            // Invariant: argument completion is not execution finality; stale phases still stay rejected.
-            if (existing !== undefined && !acceptsTranscriptUpdate(existing, block))
-                return;
-            if (existing !== undefined)
-                block = retainCompletedArguments(existing, block);
-            // Performance: nothing is emitted for a block that repeats itself, and keeping the
-            // revision keeps the rows it already rendered.
-            if (existing !== undefined && sameBlockContent(existing, block))
-                return;
-            this.#transcriptImageAssets.retain(block);
-            if (existing !== undefined)
-                this.#transcriptImageAssets.release(existing);
-            this.#transcript[index] = block;
-        }
-        else {
-            this.#transcriptImageAssets.retain(block);
-            this.#transcriptIndex.set(block.id, this.#transcript.length);
-            this.#transcript.push(block);
-        }
-        this.#transcriptSnapshot = undefined;
-        this.#emitEvent({ type: "transcript-block", block });
-    }
-    #messageBlockId(message, fallbackIndex, status, occurrence) {
-        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.#transcriptBlock(candidate)?.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.#transcriptBlock(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 };
+        this.#projection.replace(blocks);
     }
     #addDiagnostic(severity, code, message, recoverable) {
         const diagnostic = this.#recordDiagnostic(severity, code, message, recoverable);
@@ -2768,138 +588,40 @@ export class PiEngineAdapter {
         this.#emitEvent({ type: "session-view", view: this.view() });
     }
     #emitEvent(value) {
-        const event = this.#event(value);
-        if (event.type !== "session-view")
+        if (value.type !== "session-view")
             this.#viewRevision += 1;
-        this.#enqueueEvent(event);
-    }
-    #enqueueEvent(event) {
-        if (this.#overload !== undefined) {
-            if (event.type === "command-outcome" && event.outcome !== "accepted" && this.#pendingCommands.has(event.correlationId)) {
-                this.#reservedOutcomes.set(event.correlationId, { outcome: event.outcome, diagnostic: event.diagnostic });
-            }
-            return;
-        }
-        if (!this.#eventQueue.push(event, this.#sessionGeneration, event.type === "transcript-block"
-            ? this.#blockReconciliation(event.block.id, event.sequence) : undefined)) {
-            this.#beginOverload();
-            if (event.type === "command-outcome" && event.outcome !== "accepted" && this.#pendingCommands.has(event.correlationId)
-                && !this.#reservedOutcomes.has(event.correlationId)) {
-                this.#reservedOutcomes.set(event.correlationId, { outcome: event.outcome, diagnostic: event.diagnostic });
-            }
-        }
-        this.#eventQueueProcessing ??= Promise.resolve().then(() => this.#processEventQueue());
-    }
-    // Performance: capture only identity, not the complete block/event retained by an earlier revision.
-    #blockReconciliation(id, sequence) {
-        return () => ({ type: "transcript-block", sessionId: this.#sessionId, sequence, block: this.#transcriptBlock(id) });
-    }
-    #beginOverload() {
-        if (this.#overload !== undefined)
-            return;
-        this.#overloads = Math.min(Number.MAX_SAFE_INTEGER, this.#overloads + 1);
-        this.#deliveryFailed = true;
-        // Concurrency: reserve before cancellation; outcomes produced reentrantly must not enter the saturated queue.
-        this.#overload = Promise.resolve(false);
-        for (const pending of this.#pendingCommands.values())
-            pending.cancel();
-        for (const pending of this.#pendingWorkflows)
-            pending.cancel();
-        const session = this.#session;
-        this.#overload = new Promise(resolve => {
-            const timer = setTimeout(() => resolve(false), 2000);
-            void Promise.resolve().then(() => session?.abort()).then(() => {
-                clearTimeout(timer);
-                resolve(true);
-            }, () => { clearTimeout(timer); resolve(false); });
-        });
+        this.#delivery.emit(value);
     }
-    #deliver(event) {
-        for (const [listener, subscribedAt] of this.#listeners) {
-            if (event.sequence <= subscribedAt)
-                continue;
-            try {
-                listener(event);
-            }
-            catch (error) {
-                this.#deliveryFailed = true;
-                this.#recordDiagnostic("warning", "event-listener", error instanceof Error ? error.message : String(error), true);
-            }
-        }
+    // Concurrency: cancellation runs synchronously so the overload reservation already guards reentrant outcomes.
+    #cancelForOverload() {
+        this.#commands.cancelPending();
+        this.#workflows.cancelPending();
+        const session = this.#engine.session;
+        return Promise.resolve().then(() => session?.abort()).then(() => undefined);
     }
-    async #reconcileOverload() {
-        const cancelled = await this.#overload;
+    async #reconcileOverload(cancelled) {
         const canResume = cancelled === true && this.#runningCommands === 0;
         this.#admissionStopped = !canResume;
-        this.#unsubscribe?.();
-        this.#unsubscribe = undefined;
-        this.#compactionProgress?.dispose();
-        this.#compactionProgress = null;
-        ++this.#sessionGeneration;
-        this.#agentRunActive = false;
-        this.#statusKind = null;
+        this.#engine.suspend();
+        this.#events.abandonRun();
         this.#status = { ...this.#status, workingMessage: null, workingProgress: null };
         this.#lifecycle = this.#disposed ? "stopped" : canResume ? "ready" : "failed";
         this.#editor = { ...this.#editor, submitEnabled: canResume && !this.#disposed };
         this.#viewRevision += 1;
         // Invariant: overload publishes one authoritative view; settle tool phases before finalizing other live blocks.
-        this.#settleFailedDeclarations({ role: "assistant", stopReason: cancelled ? "aborted" : "error",
+        this.#projection.settleFailedDeclarations({ role: "assistant", stopReason: cancelled ? "aborted" : "error",
             errorMessage: "Tool result unavailable after UI delivery overload" });
-        this.#setTranscript(this.#transcript.map(block => block.status === "live" ? { ...block, status: "finalized", revision: block.revision + 1 } : block));
-        for (const [correlationId, result] of this.#reservedOutcomes) {
-            this.#deliver(this.#event({ type: "command-outcome", correlationId, ...result }));
+        this.#setTranscript(this.#projection.blocks.map(block => block.status === "live" ? { ...block, status: "finalized", revision: block.revision + 1 } : block));
+        for (const [correlationId, result] of this.#delivery.takeReservedOutcomes()) {
+            this.#delivery.deliverNow(this.#delivery.stamp({ type: "command-outcome", correlationId, ...result }));
             await new Promise(resolve => setImmediate(resolve));
         }
-        this.#reservedOutcomes.clear();
         // Invariant: one out-of-band authoritative reconciliation, not an emergency transcript/event log.
-        this.#deliver(this.#event({ type: "session-view", view: this.view() }));
+        this.#delivery.deliverNow(this.#delivery.stamp({ type: "session-view", view: this.view() }));
         if (this.#disposed)
-            this.#deliver(this.#event({ type: "session-lifecycle", lifecycle: "stopped", reason: null }));
-        if (canResume && !this.#disposed && this.#session !== undefined) {
-            const generation = this.#sessionGeneration;
-            this.#unsubscribe = this.#session.subscribe(event => {
-                if (generation === this.#sessionGeneration && !this.#disposed)
-                    this.#handlePiEvent(event);
-            });
-        }
-        this.#overload = undefined;
-    }
-    async #processEventQueue() {
-        try {
-            let deliveredSinceYield = 0;
-            while (this.#eventQueue.size > 0) {
-                const pending = this.#eventQueue.shift();
-                if (pending === undefined)
-                    continue;
-                if (pending.generation !== this.#sessionGeneration && pending.event.type !== "command-outcome") {
-                    this.#invalidatedEvents = Math.min(Number.MAX_SAFE_INTEGER, this.#invalidatedEvents + 1);
-                    pending.release?.();
-                    continue;
-                }
-                try {
-                    this.#deliver(pending.event);
-                }
-                finally {
-                    pending.release?.();
-                }
-                deliveredSinceYield += 1;
-                // Concurrency: a microtask chain runs to exhaustion before the loop turns, so a streaming
-                // burst would hold typed input, pointer reports, and timed indicators until it
-                // drained. Yielding on a macrotask hands those their turn between batches.
-                if (deliveredSinceYield >= EVENT_DELIVERY_BATCH && this.#eventQueue.size > 0) {
-                    deliveredSinceYield = 0;
-                    await new Promise(resolve => { setImmediate(resolve); });
-                }
-            }
-            if (this.#overload !== undefined)
-                await this.#reconcileOverload();
-        }
-        finally {
-            this.#eventQueueProcessing = undefined;
-            if (this.#eventQueue.size > 0) {
-                this.#eventQueueProcessing = Promise.resolve().then(() => this.#processEventQueue());
-            }
-        }
+            this.#delivery.deliverNow(this.#delivery.stamp({ type: "session-lifecycle", lifecycle: "stopped", reason: null }));
+        if (canResume && !this.#disposed)
+            this.#engine.resume();
     }
     #recordDiagnostic(severity, code, message, recoverable) {
         const diagnostic = {
@@ -2918,619 +640,9 @@ export class PiEngineAdapter {
         };
         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,
-        ...(input.sessionPath === undefined ? {} : { sessionPath: input.sessionPath }),
-        ...(input.sessionSelection === undefined ? {} : { sessionSelection: input.sessionSelection }),
-        ...(input.sessionForkPrompt === undefined ? {} : { sessionForkPrompt: input.sessionForkPrompt }),
-        ...(input.projectTrustPrompt === undefined ? {} : { projectTrustPrompt: input.projectTrustPrompt }),
-    });
-}
-async function checkDefaultPiPackageUpdates(cwd, agentDir, settingsManager) {
-    const packageManager = new DefaultPackageManager({ cwd, agentDir, settingsManager });
-    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_, options) {
-            const result = await execFileAsync(command, [...arguments_], { encoding: "utf8", signal: options?.signal });
-            return { stdout: result.stdout, stderr: result.stderr };
-        },
-        readChangelog: readPinnedCommandChangelog,
-    };
-}
-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, messageKind, messages) {
-    return {
-        command,
-        outcome,
-        message,
-        ...(detail === undefined ? {} : { detail }),
-        ...(messageKind === undefined ? {} : { messageKind }),
-        ...(messages === undefined ? {} : { messages: Object.freeze([...messages]) }),
-    };
-}
-function workflowConfirmation(command, message, detail) {
-    return {
-        command,
-        outcome: "requires-confirmation",
-        message,
-        ...(detail === undefined ? {} : { detail }),
-        selectorTitle: "Confirm",
-        options: [
-            { id: "yes", label: "Yes" },
-            { id: "no", label: "No" },
-        ],
-    };
-}
-function errorMessage(error, fallback) {
-    return error instanceof Error ? error.message : fallback;
-}
-function shareCommandFailureDetail(error) {
-    // Compatibility: Pi reports a failed child's stderr, not execFile's command wrapper.
-    if (isRecord(error) && (typeof error.code === "number" || typeof error.signal === "string") && typeof error.stderr === "string") {
-        return error.stderr.trim() || "Unknown error";
-    }
-    return errorMessage(error, "Unknown error");
-}
-function commandMissing(error) {
-    return isRecord(error) && error.code === "ENOENT";
-}
-function isAbortError(error) {
-    return isRecord(error) && (error.name === "AbortError" || error.code === "ABORT_ERR");
-}
-function shareViewerUrl(gistId) {
-    const baseUrl = process.env.PI_SHARE_VIEWER_URL || "https://pi.dev/session/";
-    return `${baseUrl}#${gistId}`;
-}
-function workflowOptions(value, idKey, labelKey) {
-    if (!Array.isArray(value))
-        return [];
-    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", onThinkingLevelChange: "thinkingLevel", 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 readSuggestionReasoning(value) {
-    return value === "minimal" || value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max"
-        ? value
-        : "off";
-}
-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,
-        sourceInfo: null,
-        loaded: false,
-        hidden: false,
-        diagnostic,
-    };
-}
-function extensionSourceSummary(value) {
-    if (!isRecord(value))
-        return null;
-    const source = stringProperty(value, "source");
-    const scope = value.scope;
-    const origin = value.origin;
-    const baseDir = value.baseDir;
-    if (!source
-        || (scope !== "user" && scope !== "project" && scope !== "temporary")
-        || (origin !== "package" && origin !== "top-level")
-        || (baseDir !== undefined && typeof baseDir !== "string"))
-        return null;
-    return { source, scope, origin, baseDir: baseDir ?? null };
-}
-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 isUnknownModel(value) {
-    return isRecord(value)
-        && value.provider === "unknown"
-        && value.id === "unknown"
-        && value.api === "unknown";
-}
-function findExactWorkflowModel(reference, models) {
-    const normalized = reference.trim().toLowerCase();
-    const canonical = models.filter(model => {
-        const provider = stringProperty(model, "provider");
-        const id = stringProperty(model, "id");
-        return provider !== undefined && id !== undefined && `${provider}/${id}`.toLowerCase() === normalized;
-    });
-    if (canonical.length === 1)
-        return canonical[0];
-    const bare = models.filter(model => stringProperty(model, "id")?.toLowerCase() === normalized);
-    return bare.length === 1 ? bare[0] : undefined;
-}
-/**
- * Some ecosystem extensions retain a `pi-<name>` slash-command alias beside
- * their unprefixed command. A1 presents the product-neutral command once while
- * leaving Pi's runner free to accept the compatibility alias when typed.
- */
-function isPiPrefixedCompatibilityAlias(command, commands) {
-    const name = stringProperty(command, "name");
-    if (!name?.startsWith("pi-") || name.length === 3)
-        return false;
-    const canonicalName = name.slice(3);
-    const description = stringProperty(command, "description");
-    const sourcePath = extensionCommandSourcePath(command);
-    return commands.some(candidate => candidate !== command
-        && stringProperty(candidate, "name") === canonicalName
-        && stringProperty(candidate, "description") === description
-        && extensionCommandSourcePath(candidate) === sourcePath);
-}
-function extensionCommandSourcePath(command) {
-    return isRecord(command) ? stringProperty(command.sourceInfo, "path") : undefined;
-}
-function compactResourceLabel(path) {
-    const segments = path.replaceAll("\\", "/").split("/").filter(Boolean);
-    return segments.at(-1) ?? path;
-}
-/** A later error may restate a declaration, but cannot make completed arguments incomplete. */
-function retainCompletedArguments(current, next) {
-    if (current.toolState?.argsComplete !== true || next.toolState === undefined || next.toolState.argsComplete)
-        return next;
-    return { ...next, toolState: { ...next.toolState, argsComplete: true },
-        ...(next.toolRendering === undefined || current.toolRendering === undefined ? {} : {
-            toolRendering: { ...next.toolRendering, arguments: current.toolRendering.arguments },
-        }),
-        payload: { ...(isRecord(next.payload) ? next.payload : {}), argsComplete: true } };
-}
-/**
- * Whether two blocks say the same thing. A block that says what it already said is not a
- * new revision: the shell renders a block once per revision, so bumping one it did not
- * need re-renders it for nothing.
- */
-function sameBlockContent(left, right) {
-    return left.kind === right.kind
-        && left.status === right.status
-        && left.title === right.title
-        && left.text === right.text
-        && sameValue(left.toolState, right.toolState)
-        && sameValue(left.toolRendering, right.toolRendering)
-        && sameValue(left.payload, right.payload)
-        && sameValue(left.imageReferences ?? [], right.imageReferences ?? []);
-}
-function sameValue(left, right) {
-    if (left === right)
-        return true;
-    if (typeof left !== typeof right || left === null || right === null)
-        return false;
-    if (Array.isArray(left) || Array.isArray(right)) {
-        if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length)
-            return false;
-        return left.every((value, index) => sameValue(value, right[index]));
-    }
-    if (typeof left !== "object")
-        return false;
-    const leftKeys = Object.keys(left);
-    const rightRecord = right;
-    if (leftKeys.length !== Object.keys(rightRecord).length)
-        return false;
-    return leftKeys.every(key => Object.hasOwn(rightRecord, key) && sameValue(left[key], rightRecord[key]));
-}
-function textFromContent(content) {
-    if (typeof content === "string")
-        return content;
-    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;
-}