@sammorrowdrums/mcpi 0.70.8 → 0.85.0-bootstrap.0

package/dist/core/agent-session.js

@@ -13,19 +13,24 @@
  * Modes use this class and add their own I/O layer on top.
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { basename, dirname, resolve } from "node:path";
-import { isContextOverflow, modelsAreEqual, resetApiProviders, supportsXhigh } from "@sammorrowdrums/mcpi-ai";
-import { theme } from "../modes/interactive/theme/theme.js";
+import { basename, dirname } from "node:path";
+import { contentText } from "@sammorrowdrums/mcpi-ai";
+import { clampThinkingLevel, cleanupSessionResources, getSupportedThinkingLevels, isContextOverflow, isRecoverableLength, isRetryableAssistantError, modelsAreEqual, resetApiProviders, streamSimple, } from "@sammorrowdrums/mcpi-ai/compat";
+import { getThemeByName, theme } from "../modes/interactive/theme/theme.js";
 import { stripFrontmatter } from "../utils/frontmatter.js";
+import { resolvePath } from "../utils/paths.js";
 import { sleep } from "../utils/sleep.js";
+import { normalizeToolResultImages } from "../utils/tool-result-images.js";
 import { formatNoApiKeyFoundMessage, formatNoModelSelectedMessage } from "./auth-guidance.js";
 import { executeBashWithOperations } from "./bash-executor.js";
-import { calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, generateBranchSummary, prepareCompaction, shouldCompact, } from "./compaction/index.js";
+import { calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, estimateTokens, generateBranchSummary, prepareCompaction, shouldCompact, } from "./compaction/index.js";
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
+import { applyEnvOverlay } from "./env-overlay.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
 import { ExtensionRunner, wrapRegisteredTools, } from "./extensions/index.js";
 import { emitSessionShutdownEvent } from "./extensions/runner.js";
+import { ModelRegistry } from "./model-registry.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
 import { CURRENT_SESSION_VERSION, getLatestCompactionEntry } from "./session-manager.js";
 import { createSyntheticSourceInfo } from "./source-info.js";
@@ -33,6 +38,7 @@ import { buildSystemPrompt } from "./system-prompt.js";
 import { createLocalBashOperations } from "./tools/bash.js";
 import { createAllToolDefinitions } from "./tools/index.js";
 import { createToolDefinitionFromAgentTool } from "./tools/tool-definition-wrapper.js";
+import { addUsageToTotals, createUsageTotals } from "./usage-totals.js";
 /**
  * Parse a skill block from message text.
  * Returns null if the text doesn't contain a skill block.
@@ -49,12 +55,25 @@ export function parseSkillBlock(text) {
     };
 }
 // ============================================================================
+// Types
+// ============================================================================
+function withoutDeletedHeaders(headers) {
+    return headers
+        ? Object.fromEntries(Object.entries(headers).filter((entry) => entry[1] !== null))
+        : undefined;
+}
+function estimateMessagesTokens(messages) {
+    let tokens = 0;
+    for (const message of messages) {
+        tokens += estimateTokens(message);
+    }
+    return tokens;
+}
+// ============================================================================
 // Constants
 // ============================================================================
 /** Standard thinking levels */
 const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high"];
-/** Thinking levels including xhigh (for supported models) */
-const THINKING_LEVELS_WITH_XHIGH = ["off", "minimal", "low", "medium", "high", "xhigh"];
 // ============================================================================
 // AgentSession Class
 // ============================================================================
@@ -66,7 +85,9 @@ export class AgentSession {
     // Event subscription state
     _unsubscribeAgent;
     _eventListeners = [];
-    _agentEventQueue = Promise.resolve();
+    _isAgentRunActive = false;
+    _idleWaitPromise;
+    _resolveIdleWait;
     /** Tracks pending steering messages for UI display. Removed when delivered. */
     _steeringMessages = [];
     /** Tracks pending follow-up messages for UI display. Removed when delivered. */
@@ -82,10 +103,8 @@ export class AgentSession {
     // Retry state
     _retryAbortController = undefined;
     _retryAttempt = 0;
-    _retryPromise = undefined;
-    _retryResolve = undefined;
     // Bash execution state
-    _bashAbortController = undefined;
+    _bashAbortControllers = new Set();
     _pendingBashMessages = [];
     // Extension system
     _extensionRunner;
@@ -97,15 +116,17 @@ export class AgentSession {
     _extensionRunnerRef;
     _initialActiveToolNames;
     _allowedToolNames;
+    _excludedToolNames;
     _baseToolsOverride;
     _sessionStartEvent;
     _extensionUIContext;
+    _extensionMode = "print";
     _extensionCommandContextActions;
+    _extensionAbortHandler;
     _extensionShutdownHandler;
     _extensionErrorListener;
     _extensionErrorUnsubscriber;
-    // Model registry for API key resolution
-    _modelRegistry;
+    _modelRuntime;
     // Tool registry for extension getTools/setTools
     _toolRegistry = new Map();
     _toolDefinitions = new Map();
@@ -114,6 +135,7 @@ export class AgentSession {
     // Base system prompt (without extension appends) - used to apply fresh appends each turn
     _baseSystemPrompt = "";
     _baseSystemPromptOptions;
+    _systemPromptOverride;
     constructor(config) {
         this.agent = config.agent;
         this.sessionManager = config.sessionManager;
@@ -122,37 +144,48 @@ export class AgentSession {
         this._resourceLoader = config.resourceLoader;
         this._customTools = config.customTools ?? [];
         this._cwd = config.cwd;
-        this._modelRegistry = config.modelRegistry;
+        this._modelRuntime = config.modelRuntime;
         this._extensionRunnerRef = config.extensionRunnerRef;
         this._initialActiveToolNames = config.initialActiveToolNames;
         this._allowedToolNames = config.allowedToolNames ? new Set(config.allowedToolNames) : undefined;
+        this._excludedToolNames = config.excludedToolNames ? new Set(config.excludedToolNames) : undefined;
         this._baseToolsOverride = config.baseToolsOverride;
         this._sessionStartEvent = config.sessionStartEvent ?? { type: "session_start", reason: "startup" };
         // Always subscribe to agent events for internal handling
         // (session persistence, extensions, auto-compaction, retry logic)
         this._unsubscribeAgent = this.agent.subscribe(this._handleAgentEvent);
         this._installAgentToolHooks();
+        this._installAgentNextTurnRefresh();
         this._buildRuntime({
             activeToolNames: this._initialActiveToolNames,
             includeAllExtensionTools: true,
         });
     }
-    /** Model registry for API key resolution and model discovery */
-    get modelRegistry() {
-        return this._modelRegistry;
+    get modelRuntime() {
+        return this._modelRuntime;
     }
     async _getRequiredRequestAuth(model) {
-        const result = await this._modelRegistry.getApiKeyAndHeaders(model);
-        if (!result.ok) {
-            if (result.error.startsWith("No API key found")) {
+        let result;
+        try {
+            result = await this._modelRuntime.getAuth(model);
+        }
+        catch (error) {
+            const cause = error instanceof Error ? error.cause : undefined;
+            if (cause instanceof Error && cause.message === "authHeader requires a resolved API key") {
                 throw new Error(formatNoApiKeyFoundMessage(model.provider));
             }
-            throw new Error(result.error);
+            throw error;
         }
-        if (result.apiKey) {
-            return { apiKey: result.apiKey, headers: result.headers };
+        if (result && (result.auth.apiKey || result.auth.headers)) {
+            const requestModel = result.auth.baseUrl ? { ...model, baseUrl: result.auth.baseUrl } : model;
+            return {
+                model: requestModel,
+                apiKey: result.auth.apiKey,
+                headers: withoutDeletedHeaders(result.auth.headers),
+                env: result.env,
+            };
         }
-        const isOAuth = this._modelRegistry.isUsingOAuth(model);
+        const isOAuth = this._modelRuntime.isUsingOAuth(model.provider);
         if (isOAuth) {
             throw new Error(`Authentication failed for "${model.provider}". ` +
                 `Credentials may have expired or network is unavailable. ` +
@@ -160,6 +193,26 @@ export class AgentSession {
         }
         throw new Error(formatNoApiKeyFoundMessage(model.provider));
     }
+    async _getSummarizationRequestAuth(model) {
+        if (this.agent.streamFunction === streamSimple) {
+            return this._getRequiredRequestAuth(model);
+        }
+        try {
+            const result = await this._modelRuntime.getAuth(model);
+            if (!result)
+                return { model };
+            const requestModel = result.auth.baseUrl ? { ...model, baseUrl: result.auth.baseUrl } : model;
+            return {
+                model: requestModel,
+                apiKey: result.auth.apiKey,
+                headers: withoutDeletedHeaders(result.auth.headers),
+                env: result.env,
+            };
+        }
+        catch {
+            return { model };
+        }
+    }
     /**
      * Install tool hooks once on the Agent instance.
      *
@@ -169,14 +222,11 @@ export class AgentSession {
      * happens here instead of in wrappers.
      */
     _installAgentToolHooks() {
-        // Resolve deferred tools from the registry when not in context tools array
-        this.agent.resolveTool = (name) => this._toolRegistry.get(name);
         this.agent.beforeToolCall = async ({ toolCall, args }) => {
             const runner = this._extensionRunner;
             if (!runner.hasHandlers("tool_call")) {
                 return undefined;
             }
-            await this._agentEventQueue;
             try {
                 return await runner.emitToolCall({
                     type: "tool_call",
@@ -194,25 +244,51 @@ export class AgentSession {
         };
         this.agent.afterToolCall = async ({ toolCall, args, result, isError }) => {
             const runner = this._extensionRunner;
-            if (!runner.hasHandlers("tool_result")) {
-                return undefined;
-            }
-            const hookResult = await runner.emitToolResult({
-                type: "tool_result",
-                toolName: toolCall.name,
-                toolCallId: toolCall.id,
-                input: args,
-                content: result.content,
-                details: result.details,
-                isError,
+            const hookResult = runner.hasHandlers("tool_result")
+                ? await runner.emitToolResult({
+                    type: "tool_result",
+                    toolName: toolCall.name,
+                    toolCallId: toolCall.id,
+                    input: args,
+                    content: result.content,
+                    details: result.details,
+                    isError,
+                    usage: result.usage,
+                })
+                : undefined;
+            const content = hookResult?.content ?? result.content ?? [];
+            // Runs after the extension hook so images injected or replaced by extensions are normalized too.
+            const normalizedContent = await normalizeToolResultImages(content, {
+                autoResizeImages: this.settingsManager.getImageAutoResize(),
             });
-            if (!hookResult) {
+            if (!hookResult && normalizedContent === content) {
                 return undefined;
             }
             return {
-                content: hookResult.content,
-                details: hookResult.details,
-                isError: hookResult.isError ?? isError,
+                content: normalizedContent,
+                details: hookResult?.details,
+                isError: hookResult?.isError ?? isError,
+                usage: hookResult?.usage,
+            };
+        };
+    }
+    _installAgentNextTurnRefresh() {
+        const previousPrepareNextTurnWithContext = this.agent.prepareNextTurnWithContext ??
+            (this.agent.prepareNextTurn
+                ? async (_turn, signal) => await this.agent.prepareNextTurn?.(signal)
+                : undefined);
+        this.agent.prepareNextTurnWithContext = async (turn, signal) => {
+            const previousSnapshot = await previousPrepareNextTurnWithContext?.(turn, signal);
+            const previousContext = previousSnapshot?.context ?? turn.context;
+            return {
+                ...previousSnapshot,
+                context: {
+                    ...previousContext,
+                    systemPrompt: this._systemPromptOverride ?? this._baseSystemPrompt,
+                    tools: this.agent.state.tools.slice(),
+                },
+                model: this.agent.state.model,
+                thinkingLevel: this.agent.state.thinkingLevel,
             };
         };
     }
@@ -232,51 +308,42 @@ export class AgentSession {
             followUp: [...this._followUpMessages],
         });
     }
-    // Track last assistant message for auto-compaction check
-    _lastAssistantMessage = undefined;
-    /** Internal handler for agent events - shared by subscribe and reconnect */
-    _handleAgentEvent = (event) => {
-        // Create retry promise synchronously before queueing async processing.
-        // Agent.emit() calls this handler synchronously, and prompt() calls waitForRetry()
-        // as soon as agent.prompt() resolves. If _retryPromise is created only inside
-        // _processAgentEvent, slow earlier queued events can delay agent_end processing
-        // and waitForRetry() can miss the in-flight retry.
-        this._createRetryPromiseForAgentEnd(event);
-        this._agentEventQueue = this._agentEventQueue.then(() => this._processAgentEvent(event), () => this._processAgentEvent(event));
-        // Keep queue alive if an event handler fails
-        this._agentEventQueue.catch(() => { });
-    };
-    _createRetryPromiseForAgentEnd(event) {
-        if (event.type !== "agent_end" || this._retryPromise) {
-            return;
-        }
-        const settings = this.settingsManager.getRetrySettings();
-        if (!settings.enabled) {
-            return;
+    _getIdleWaitPromise() {
+        if (!this._idleWaitPromise) {
+            this._idleWaitPromise = new Promise((resolve) => {
+                this._resolveIdleWait = resolve;
+            });
         }
-        const lastAssistant = this._findLastAssistantInMessages(event.messages);
-        if (!lastAssistant || !this._isRetryableError(lastAssistant)) {
+        return this._idleWaitPromise;
+    }
+    _resolveIdleWaitIfIdle() {
+        if (this._isAgentRunActive || !this._resolveIdleWait) {
             return;
         }
-        this._retryPromise = new Promise((resolve) => {
-            this._retryResolve = resolve;
-        });
+        const resolve = this._resolveIdleWait;
+        this._idleWaitPromise = undefined;
+        this._resolveIdleWait = undefined;
+        resolve();
     }
-    _findLastAssistantInMessages(messages) {
-        for (let i = messages.length - 1; i >= 0; i--) {
-            const message = messages[i];
-            if (message.role === "assistant") {
-                return message;
-            }
+    async _emitAgentSettled() {
+        this._isAgentRunActive = false;
+        try {
+            await this._extensionRunner.emit({ type: "agent_settled" });
+            this._emit({ type: "agent_settled" });
+        }
+        finally {
+            this._resolveIdleWaitIfIdle();
         }
-        return undefined;
     }
-    async _processAgentEvent(event) {
+    // Track last assistant message for auto-compaction check
+    _lastAssistantMessage = undefined;
+    /** Internal handler for agent events - shared by subscribe and reconnect */
+    _handleAgentEvent = async (event) => {
         // When a user message starts, check if it's from either queue and remove it BEFORE emitting
         // This ensures the UI sees the updated queue state
         if (event.type === "message_start" && event.message.role === "user") {
             this._overflowRecoveryAttempted = false;
-            const messageText = this._getUserMessageText(event.message);
+            const messageText = contentText(event.message.content, "");
             if (messageText) {
                 // Check steering queue first
                 const steeringIndex = this._steeringMessages.indexOf(messageText);
@@ -297,7 +364,7 @@ export class AgentSession {
         // Emit to extensions first
         await this._emitExtensionEvent(event);
         // Notify all listeners
-        this._emit(event);
+        this._emit(event.type === "agent_end" ? { ...event, willRetry: this._willRetryAfterAgentEnd(event) } : event);
         // Handle session persistence
         if (event.type === "message_end") {
             // Check if this is a custom message from extensions
@@ -316,7 +383,7 @@ export class AgentSession {
             if (event.message.role === "assistant") {
                 this._lastAssistantMessage = event.message;
                 const assistantMsg = event.message;
-                if (assistantMsg.stopReason !== "error") {
+                if (assistantMsg.stopReason !== "error" && assistantMsg.stopReason !== "length") {
                     this._overflowRecoveryAttempted = false;
                 }
                 // Reset retry counter immediately on successful assistant response
@@ -331,37 +398,19 @@ export class AgentSession {
                 }
             }
         }
-        // Check auto-retry and auto-compaction after agent completes
-        if (event.type === "agent_end" && this._lastAssistantMessage) {
-            const msg = this._lastAssistantMessage;
-            this._lastAssistantMessage = undefined;
-            // Check for retryable errors first (overloaded, rate limit, server errors)
-            if (this._isRetryableError(msg)) {
-                const didRetry = await this._handleRetryableError(msg);
-                if (didRetry)
-                    return; // Retry was initiated, don't proceed to compaction
-            }
-            this._resolveRetry();
-            await this._checkCompaction(msg);
+    };
+    _willRetryAfterAgentEnd(event) {
+        const settings = this.settingsManager.getRetrySettings();
+        if (!settings.enabled || this._retryAttempt >= settings.maxRetries) {
+            return false;
         }
-    }
-    /** Resolve the pending retry promise */
-    _resolveRetry() {
-        if (this._retryResolve) {
-            this._retryResolve();
-            this._retryResolve = undefined;
-            this._retryPromise = undefined;
+        for (let i = event.messages.length - 1; i >= 0; i--) {
+            const message = event.messages[i];
+            if (message.role === "assistant") {
+                return this._isRetryableError(message);
+            }
         }
-    }
-    /** Extract text content from a message */
-    _getUserMessageText(message) {
-        if (message.role !== "user")
-            return "";
-        const content = message.content;
-        if (typeof content === "string")
-            return content;
-        const textBlocks = content.filter((c) => c.type === "text");
-        return textBlocks.map((c) => c.text).join("");
+        return false;
     }
     /** Find the last assistant message in agent state (including aborted ones) */
     _findLastAssistantMessage() {
@@ -374,6 +423,20 @@ export class AgentSession {
         }
         return undefined;
     }
+    _replaceMessageInPlace(target, replacement) {
+        // Agent-core stores the finalized message object in its state before emitting message_end.
+        // SessionManager persistence happens later in _handleAgentEvent() with event.message.
+        // Mutating this object in place keeps agent state, later turn/agent events, listeners,
+        // and the eventual SessionManager.appendMessage(event.message) persistence in sync.
+        if (target === replacement) {
+            return;
+        }
+        const targetRecord = target;
+        for (const key of Object.keys(targetRecord)) {
+            delete targetRecord[key];
+        }
+        Object.assign(targetRecord, replacement);
+    }
     /** Emit extension events based on agent events */
     async _emitExtensionEvent(event) {
         if (event.type === "agent_start") {
@@ -421,7 +484,19 @@ export class AgentSession {
                 type: "message_end",
                 message: event.message,
             };
-            await this._extensionRunner.emit(extensionEvent);
+            const replacement = await this._extensionRunner.emitMessageEnd(extensionEvent);
+            if (replacement) {
+                // Untyped extension handlers can return messages with null/missing content;
+                // normalize so it never enters agent state or session history.
+                const normalized = (replacement.role === "user" ||
+                    replacement.role === "assistant" ||
+                    replacement.role === "toolResult" ||
+                    replacement.role === "custom") &&
+                    replacement.content == null
+                    ? { ...replacement, content: [] }
+                    : replacement;
+                this._replaceMessageInPlace(event.message, normalized);
+            }
         }
         else if (event.type === "tool_execution_start") {
             const extensionEvent = {
@@ -468,34 +543,32 @@ export class AgentSession {
             }
         };
     }
-    /**
-     * Temporarily disconnect from agent events.
-     * User listeners are preserved and will receive events again after resubscribe().
-     * Used internally during operations that need to pause event processing.
-     */
+    /** Disconnect from agent events during disposal. */
     _disconnectFromAgent() {
         if (this._unsubscribeAgent) {
             this._unsubscribeAgent();
             this._unsubscribeAgent = undefined;
         }
     }
-    /**
-     * Reconnect to agent events after _disconnectFromAgent().
-     * Preserves all existing listeners.
-     */
-    _reconnectToAgent() {
-        if (this._unsubscribeAgent)
-            return; // Already connected
-        this._unsubscribeAgent = this.agent.subscribe(this._handleAgentEvent);
-    }
     /**
      * Remove all listeners and disconnect from agent.
      * Call this when completely done with the session.
      */
     dispose() {
+        try {
+            this.abortRetry();
+            this.abortCompaction();
+            this.abortBranchSummary();
+            this.abortBash();
+            this.agent.abort();
+        }
+        catch {
+            // Dispose must succeed even if an abort hook throws.
+        }
         this._extensionRunner.invalidate("This extension ctx is stale after session replacement or reload. Do not use a captured pi or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload().");
         this._disconnectFromAgent();
         this._eventListeners = [];
+        cleanupSessionResources(this.sessionId);
     }
     // =========================================================================
     // Read-only State Access
@@ -512,9 +585,13 @@ export class AgentSession {
     get thinkingLevel() {
         return this.agent.state.thinkingLevel;
     }
-    /** Whether agent is currently streaming a response */
+    /** Whether the session is currently processing an agent run or post-run continuation. */
     get isStreaming() {
-        return this.agent.state.isStreaming;
+        return this._isAgentRunActive;
+    }
+    /** Whether the session has no active agent run, retry, auto-compaction, or queued continuation. */
+    get isIdle() {
+        return !this._isAgentRunActive;
     }
     /** Current effective system prompt (includes any per-turn extension modifications) */
     get systemPrompt() {
@@ -532,13 +609,14 @@ export class AgentSession {
         return this.agent.state.tools.map((t) => t.name);
     }
     /**
-     * Get all configured tools with name, description, parameter schema, and source metadata.
+     * Get all configured tools with name, description, parameter schema, prompt guidelines, and source metadata.
      */
     getAllTools() {
         return Array.from(this._toolDefinitions.values()).map(({ definition, sourceInfo }) => ({
             name: definition.name,
             description: definition.description,
             parameters: definition.parameters,
+            promptGuidelines: definition.promptGuidelines,
             sourceInfo,
         }));
     }
@@ -553,22 +631,18 @@ export class AgentSession {
      */
     setActiveToolsByName(toolNames) {
         const tools = [];
-        const promptToolNames = [];
+        const validToolNames = [];
         for (const name of toolNames) {
             const tool = this._toolRegistry.get(name);
             if (tool) {
                 tools.push(tool);
-                if (!tool.deferred) {
-                    promptToolNames.push(name);
-                }
+                validToolNames.push(name);
             }
         }
         this.agent.state.tools = tools;
-        // Rebuild base system prompt — deferred tools are excluded from the
-        // prompt but stay in the tools array with defer_loading for providers
-        // that support it (Anthropic). This preserves prompt cache.
-        this._baseSystemPrompt = this._rebuildSystemPrompt(promptToolNames);
-        this.agent.state.systemPrompt = this._baseSystemPrompt;
+        // Rebuild base system prompt with new tool set
+        this._baseSystemPrompt = this._rebuildSystemPrompt(validToolNames);
+        this.agent.state.systemPrompt = this._systemPromptOverride ?? this._baseSystemPrompt;
     }
     /** Whether compaction or branch summarization is currently running */
     get isCompacting() {
@@ -668,6 +742,45 @@ export class AgentSession {
     // =========================================================================
     // Prompting
     // =========================================================================
+    async _runAgentPrompt(messages) {
+        this._isAgentRunActive = true;
+        try {
+            await this.agent.prompt(messages);
+            while (await this._handlePostAgentRun()) {
+                await this.agent.continue();
+            }
+        }
+        finally {
+            this._systemPromptOverride = undefined;
+            this._flushPendingBashMessages();
+            await this._emitAgentSettled();
+        }
+    }
+    async _handlePostAgentRun() {
+        const msg = this._lastAssistantMessage;
+        this._lastAssistantMessage = undefined;
+        if (!msg) {
+            return false;
+        }
+        if (this._isRetryableError(msg) && (await this._prepareRetry(msg))) {
+            return true;
+        }
+        if (msg.stopReason === "error" && this._retryAttempt > 0) {
+            this._emit({
+                type: "auto_retry_end",
+                success: false,
+                attempt: this._retryAttempt,
+                finalError: msg.errorMessage,
+            });
+            this._retryAttempt = 0;
+        }
+        if (await this._checkCompaction(msg)) {
+            return true;
+        }
+        // The agent loop drains both queues before emitting agent_end. Any messages
+        // here were queued by agent_end extension handlers and need a continuation.
+        return this.agent.hasQueuedMessages();
+    }
     /**
      * Send a prompt to the agent.
      * - Handles extension commands (registered via pi.registerCommand) immediately, even during streaming
@@ -692,11 +805,14 @@ export class AgentSession {
                     return;
                 }
             }
+            if (this._compactionAbortController !== undefined) {
+                throw new Error("Cannot submit a prompt while compaction is in progress. Wait for compaction to finish and retry.");
+            }
             // Emit input event for extension interception (before skill/template expansion)
             let currentText = text;
             let currentImages = options?.images;
             if (this._extensionRunner.hasHandlers("input")) {
-                const inputResult = await this._extensionRunner.emitInput(currentText, currentImages, options?.source ?? "interactive");
+                const inputResult = await this._extensionRunner.emitInput(currentText, currentImages, options?.source ?? "interactive", this.isStreaming ? options?.streamingBehavior : undefined);
                 if (inputResult.action === "handled") {
                     preflightResult?.(true);
                     return;
@@ -732,8 +848,10 @@ export class AgentSession {
             if (!this.model) {
                 throw new Error(formatNoModelSelectedMessage());
             }
-            if (!this._modelRegistry.hasConfiguredAuth(this.model)) {
-                const isOAuth = this._modelRegistry.isUsingOAuth(this.model);
+            const hasConfiguredAuth = this._modelRuntime.hasConfiguredAuth(this.model.provider) ||
+                (await this._modelRuntime.checkAuth(this.model.provider)) !== undefined;
+            if (!hasConfiguredAuth) {
+                const isOAuth = this._modelRuntime.isUsingOAuth(this.model.provider);
                 if (isOAuth) {
                     throw new Error(`Authentication failed for "${this.model.provider}". ` +
                         `Credentials may have expired or network is unavailable. ` +
@@ -741,7 +859,8 @@ export class AgentSession {
                 }
                 throw new Error(formatNoApiKeyFoundMessage(this.model.provider));
             }
-            // Check if we need to compact before sending (catches aborted responses)
+            // Check if we need to compact before sending (catches aborted responses).
+            // The user's new prompt is sent below, so do not call agent.continue() here.
             const lastAssistant = this._findLastAssistantMessage();
             if (lastAssistant) {
                 await this._checkCompaction(lastAssistant, false);
@@ -771,7 +890,8 @@ export class AgentSession {
                     messages.push({
                         role: "custom",
                         customType: msg.customType,
-                        content: msg.content,
+                        // Untyped extensions can pass null/missing content; normalize at ingestion.
+                        content: msg.content ?? [],
                         display: msg.display,
                         details: msg.details,
                         timestamp: Date.now(),
@@ -779,11 +899,13 @@ export class AgentSession {
                 }
             }
             // Apply extension-modified system prompt, or reset to base
-            if (result?.systemPrompt) {
+            if (result?.systemPrompt !== undefined) {
+                this._systemPromptOverride = result.systemPrompt;
                 this.agent.state.systemPrompt = result.systemPrompt;
             }
             else {
                 // Ensure we're using the base prompt (in case previous turn had modifications)
+                this._systemPromptOverride = undefined;
                 this.agent.state.systemPrompt = this._baseSystemPrompt;
             }
         }
@@ -795,8 +917,7 @@ export class AgentSession {
             return;
         }
         preflightResult?.(true);
-        await this.agent.prompt(messages);
-        await this.waitForRetry();
+        await this._runAgentPrompt(messages);
     }
     /**
      * Try to execute an extension command. Returns true if command was found and executed.
@@ -949,7 +1070,8 @@ export class AgentSession {
         const appMessage = {
             role: "custom",
             customType: message.customType,
-            content: message.content,
+            // Untyped extensions can pass null/missing content; normalize at ingestion.
+            content: message.content ?? [],
             display: message.display,
             details: message.details,
             timestamp: Date.now(),
@@ -957,7 +1079,7 @@ export class AgentSession {
         if (options?.deliverAs === "nextTurn") {
             this._pendingNextTurnMessages.push(appMessage);
         }
-        else if (this.isStreaming) {
+        else if (this.isStreaming && options?.triggerTurn !== false) {
             if (options?.deliverAs === "followUp") {
                 this.agent.followUp(appMessage);
             }
@@ -966,7 +1088,7 @@ export class AgentSession {
             }
         }
         else if (options?.triggerTurn) {
-            await this.agent.prompt(appMessage);
+            await this._runAgentPrompt(appMessage);
         }
         else {
             this.agent.state.messages.push(appMessage);
@@ -981,6 +1103,7 @@ export class AgentSession {
      *
      * @param content User message content (string or content array)
      * @param options.deliverAs Delivery mode when streaming: "steer" or "followUp"
+     * @param options.expandPromptTemplates Whether to dispatch extension commands and expand skill commands and prompt templates. Default: false.
      */
     async sendUserMessage(content, options) {
         // Normalize content to text string + optional images
@@ -1004,9 +1127,8 @@ export class AgentSession {
             if (images.length === 0)
                 images = undefined;
         }
-        // Use prompt() with expandPromptTemplates: false to skip command handling and template expansion
         await this.prompt(text, {
-            expandPromptTemplates: false,
+            expandPromptTemplates: options?.expandPromptTemplates ?? false,
             streamingBehavior: options?.deliverAs,
             images,
             source: "extension",
@@ -1047,7 +1169,13 @@ export class AgentSession {
     async abort() {
         this.abortRetry();
         this.agent.abort();
-        await this.agent.waitForIdle();
+        await this.waitForIdle();
+    }
+    async waitForIdle() {
+        if (this.isIdle) {
+            return;
+        }
+        await this._getIdleWaitPromise();
     }
     // =========================================================================
     // Model Management
@@ -1068,7 +1196,7 @@ export class AgentSession {
      * @throws Error if no auth is configured for the model
      */
     async setModel(model) {
-        if (!this._modelRegistry.hasConfiguredAuth(model)) {
+        if (!(await this._modelRuntime.checkAuth(model.provider))) {
             throw new Error(`No API key for ${model.provider}/${model.id}`);
         }
         const previousModel = this.model;
@@ -1093,7 +1221,8 @@ export class AgentSession {
         return this._cycleAvailableModel(direction);
     }
     async _cycleScopedModel(direction) {
-        const scopedModels = this._scopedModels.filter((scoped) => this._modelRegistry.hasConfiguredAuth(scoped.model));
+        const availableIds = new Set(this._modelRuntime.getAvailableSnapshot().map((model) => `${model.provider}\0${model.id}`));
+        const scopedModels = this._scopedModels.filter((scoped) => availableIds.has(`${scoped.model.provider}\0${scoped.model.id}`));
         if (scopedModels.length <= 1)
             return undefined;
         const currentModel = this.model;
@@ -1117,7 +1246,7 @@ export class AgentSession {
         return { model: next.model, thinkingLevel: this.thinkingLevel, isScoped: true };
     }
     async _cycleAvailableModel(direction) {
-        const availableModels = await this._modelRegistry.getAvailable();
+        const availableModels = this._modelRuntime.getAvailableSnapshot();
         if (availableModels.length <= 1)
             return undefined;
         const currentModel = this.model;
@@ -1148,13 +1277,20 @@ export class AgentSession {
         const availableLevels = this.getAvailableThinkingLevels();
         const effectiveLevel = availableLevels.includes(level) ? level : this._clampThinkingLevel(level, availableLevels);
         // Only persist if actually changing
-        const isChanging = effectiveLevel !== this.agent.state.thinkingLevel;
+        const previousLevel = this.agent.state.thinkingLevel;
+        const isChanging = effectiveLevel !== previousLevel;
         this.agent.state.thinkingLevel = effectiveLevel;
         if (isChanging) {
             this.sessionManager.appendThinkingLevelChange(effectiveLevel);
             if (this.supportsThinking() || effectiveLevel !== "off") {
                 this.settingsManager.setDefaultThinkingLevel(effectiveLevel);
             }
+            this._emit({ type: "thinking_level_changed", level: effectiveLevel });
+            void this._extensionRunner.emit({
+                type: "thinking_level_select",
+                level: effectiveLevel,
+                previousLevel,
+            });
         }
     }
     /**
@@ -1176,15 +1312,9 @@ export class AgentSession {
      * The provider will clamp to what the specific model supports internally.
      */
     getAvailableThinkingLevels() {
-        if (!this.supportsThinking())
-            return ["off"];
-        return this.supportsXhighThinking() ? THINKING_LEVELS_WITH_XHIGH : THINKING_LEVELS;
-    }
-    /**
-     * Check if current model supports xhigh thinking level.
-     */
-    supportsXhighThinking() {
-        return this.model ? supportsXhigh(this.model) : false;
+        if (!this.model)
+            return THINKING_LEVELS;
+        return getSupportedThinkingLevels(this.model);
     }
     /**
      * Check if current model supports thinking/reasoning.
@@ -1201,28 +1331,16 @@ export class AgentSession {
         }
         return this.thinkingLevel;
     }
-    _clampThinkingLevel(level, availableLevels) {
-        const ordered = THINKING_LEVELS_WITH_XHIGH;
-        const available = new Set(availableLevels);
-        const requestedIndex = ordered.indexOf(level);
-        if (requestedIndex === -1) {
-            return availableLevels[0] ?? "off";
-        }
-        for (let i = requestedIndex; i < ordered.length; i++) {
-            const candidate = ordered[i];
-            if (available.has(candidate))
-                return candidate;
-        }
-        for (let i = requestedIndex - 1; i >= 0; i--) {
-            const candidate = ordered[i];
-            if (available.has(candidate))
-                return candidate;
-        }
-        return availableLevels[0] ?? "off";
+    _clampThinkingLevel(level, _availableLevels) {
+        return this.model ? clampThinkingLevel(this.model, level) : "off";
     }
     // =========================================================================
     // Queue Mode Management
     // =========================================================================
+    syncQueueModesFromSettings() {
+        this.agent.steeringMode = this.settingsManager.getSteeringMode();
+        this.agent.followUpMode = this.settingsManager.getFollowUpMode();
+    }
     /**
      * Set steering message mode.
      * Saves to settings.
@@ -1248,7 +1366,6 @@ export class AgentSession {
      * @param customInstructions Optional instructions for the compaction summary
      */
     async compact(customInstructions) {
-        this._disconnectFromAgent();
         await this.abort();
         this._compactionAbortController = new AbortController();
         this._emit({ type: "compaction_start", reason: "manual" });
@@ -1256,7 +1373,7 @@ export class AgentSession {
             if (!this.model) {
                 throw new Error(formatNoModelSelectedMessage());
             }
-            const { apiKey, headers } = await this._getRequiredRequestAuth(this.model);
+            const { model: requestModel, apiKey, headers, env } = await this._getSummarizationRequestAuth(this.model);
             const pathEntries = this.sessionManager.getBranch();
             const settings = this.settingsManager.getCompactionSettings();
             const preparation = prepareCompaction(pathEntries, settings);
@@ -1276,6 +1393,8 @@ export class AgentSession {
                     preparation,
                     branchEntries: pathEntries,
                     customInstructions,
+                    reason: "manual",
+                    willRetry: false,
                     signal: this._compactionAbortController.signal,
                 }));
                 if (result?.cancel) {
@@ -1289,29 +1408,33 @@ export class AgentSession {
             let summary;
             let firstKeptEntryId;
             let tokensBefore;
+            let usage;
             let details;
             if (extensionCompaction) {
                 // Extension provided compaction content
                 summary = extensionCompaction.summary;
                 firstKeptEntryId = extensionCompaction.firstKeptEntryId;
                 tokensBefore = extensionCompaction.tokensBefore;
+                usage = extensionCompaction.usage;
                 details = extensionCompaction.details;
             }
             else {
                 // Generate compaction result
-                const result = await compact(preparation, this.model, apiKey, headers, customInstructions, this._compactionAbortController.signal, this.thinkingLevel);
+                const result = await compact(preparation, requestModel, apiKey, headers, customInstructions, this._compactionAbortController.signal, this.thinkingLevel, this.agent.streamFunction, env, this.settingsManager.getRetrySettings(), this._summarizationRetryCallbacks({ source: "compaction", reason: "manual" }));
                 summary = result.summary;
                 firstKeptEntryId = result.firstKeptEntryId;
                 tokensBefore = result.tokensBefore;
+                usage = result.usage;
                 details = result.details;
             }
             if (this._compactionAbortController.signal.aborted) {
                 throw new Error("Compaction cancelled");
             }
-            this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension);
+            this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension, usage);
             const newEntries = this.sessionManager.getEntries();
             const sessionContext = this.sessionManager.buildSessionContext();
             this.agent.state.messages = sessionContext.messages;
+            const estimatedTokensAfter = estimateMessagesTokens(sessionContext.messages);
             // Get the saved compaction entry for the extension event
             const savedCompactionEntry = newEntries.find((e) => e.type === "compaction" && e.summary === summary);
             if (this._extensionRunner && savedCompactionEntry) {
@@ -1319,14 +1442,20 @@ export class AgentSession {
                     type: "session_compact",
                     compactionEntry: savedCompactionEntry,
                     fromExtension,
+                    reason: "manual",
+                    willRetry: false,
                 });
             }
             const compactionResult = {
                 summary,
                 firstKeptEntryId,
                 tokensBefore,
+                estimatedTokensAfter,
+                usage,
                 details,
             };
+            // compaction_end listeners may submit queued prompts, so expose idle state before notifying them.
+            this._compactionAbortController = undefined;
             this._emit({
                 type: "compaction_end",
                 reason: "manual",
@@ -1339,6 +1468,7 @@ export class AgentSession {
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             const aborted = message === "Compaction cancelled" || (error instanceof Error && error.name === "AbortError");
+            this._compactionAbortController = undefined;
             this._emit({
                 type: "compaction_end",
                 reason: "manual",
@@ -1351,7 +1481,6 @@ export class AgentSession {
         }
         finally {
             this._compactionAbortController = undefined;
-            this._reconnectToAgent();
         }
     }
     /**
@@ -1372,7 +1501,8 @@ export class AgentSession {
      * Called after agent_end and before prompt submission.
      *
      * Two cases:
-     * 1. Overflow: LLM returned context overflow error, remove error message from agent state, compact, auto-retry
+     * 1. Recoverable failure: LLM returned context overflow or stopped below its desired output limit;
+     *    remove the assistant message, compact, and auto-retry once
      * 2. Threshold: Context over threshold, compact, NO auto-retry (user continues manually)
      *
      * @param assistantMessage The assistant message to check
@@ -1381,10 +1511,10 @@ export class AgentSession {
     async _checkCompaction(assistantMessage, skipAbortedCheck = true) {
         const settings = this.settingsManager.getCompactionSettings();
         if (!settings.enabled)
-            return;
+            return false;
         // Skip if message was aborted (user cancelled) - unless skipAbortedCheck is false
         if (skipAbortedCheck && assistantMessage.stopReason === "aborted")
-            return;
+            return false;
         const contextWindow = this.model?.contextWindow ?? 0;
         // Skip overflow check if the message came from a different model.
         // This handles the case where user switched from a smaller-context model (e.g. opus)
@@ -1397,10 +1527,19 @@ export class AgentSession {
         const compactionEntry = getLatestCompactionEntry(this.sessionManager.getBranch());
         const assistantIsFromBeforeCompaction = compactionEntry !== null && assistantMessage.timestamp <= new Date(compactionEntry.timestamp).getTime();
         if (assistantIsFromBeforeCompaction) {
-            return;
+            return false;
         }
-        // Case 1: Overflow - LLM returned context overflow error
-        if (sameModel && isContextOverflow(assistantMessage, contextWindow)) {
+        // Case 1: Recoverable failure. Explicit/silent context overflow still uses context metadata.
+        // A length stop is recoverable when output ended below the model's original desired limit,
+        // independent of the configured context size or any context-clamped provider request limit.
+        // A successful response over the configured window should compact but must not retry: the
+        // assistant answer already completed and agent.continue() cannot continue from an assistant.
+        const recoverableLength = sameModel && isRecoverableLength(assistantMessage, this.model?.maxTokens ?? 0);
+        if (sameModel && (isContextOverflow(assistantMessage, contextWindow) || recoverableLength)) {
+            const willRetry = assistantMessage.stopReason !== "stop";
+            if (!willRetry) {
+                return await this._runAutoCompaction("overflow", false);
+            }
             if (this._overflowRecoveryAttempted) {
                 this._emit({
                     type: "compaction_end",
@@ -1410,27 +1549,28 @@ export class AgentSession {
                     willRetry: false,
                     errorMessage: "Context overflow recovery failed after one compact-and-retry attempt. Try reducing context or switching to a larger-context model.",
                 });
-                return;
+                return false;
             }
             this._overflowRecoveryAttempted = true;
-            // Remove the error message from agent state (it IS saved to session for history,
-            // but we don't want it in context for the retry)
+            // Remove the failed or truncated message from agent state. It remains in session history,
+            // but must not be included in the compact-and-retry context.
             const messages = this.agent.state.messages;
             if (messages.length > 0 && messages[messages.length - 1].role === "assistant") {
                 this.agent.state.messages = messages.slice(0, -1);
             }
-            await this._runAutoCompaction("overflow", true);
-            return;
+            return await this._runAutoCompaction("overflow", willRetry);
         }
         // Case 2: Threshold - context is getting large
-        // For error messages (no usage data), estimate from last successful response.
-        // This ensures sessions that hit persistent API errors (e.g. 529) can still compact.
+        // For error messages or all-zero usage messages, estimate from the last valid response.
+        // This ensures sessions that hit persistent API errors (e.g. 529) or malformed zero-usage
+        // responses can still compact and do not reset context accounting.
         let contextTokens;
-        if (assistantMessage.stopReason === "error") {
+        const directContextTokens = assistantMessage.usage ? calculateContextTokens(assistantMessage.usage) : 0;
+        if (assistantMessage.stopReason === "error" || directContextTokens === 0) {
             const messages = this.agent.state.messages;
             const estimate = estimateContextTokens(messages);
             if (estimate.lastUsageIndex === null)
-                return; // No usage data at all
+                return false; // No usage data at all
             // Verify the usage source is post-compaction. Kept pre-compaction messages
             // have stale usage reflecting the old (larger) context and would falsely
             // trigger compaction right after one just finished.
@@ -1438,59 +1578,37 @@ export class AgentSession {
             if (compactionEntry &&
                 usageMsg.role === "assistant" &&
                 usageMsg.timestamp <= new Date(compactionEntry.timestamp).getTime()) {
-                return;
+                return false;
             }
             contextTokens = estimate.tokens;
         }
         else {
-            contextTokens = calculateContextTokens(assistantMessage.usage);
+            contextTokens = directContextTokens;
         }
         if (shouldCompact(contextTokens, contextWindow, settings)) {
-            await this._runAutoCompaction("threshold", false);
+            return await this._runAutoCompaction("threshold", false);
         }
+        return false;
     }
     /**
      * Internal: Run auto-compaction with events.
      */
     async _runAutoCompaction(reason, willRetry) {
         const settings = this.settingsManager.getCompactionSettings();
-        this._emit({ type: "compaction_start", reason });
-        this._autoCompactionAbortController = new AbortController();
+        let started = false;
         try {
             if (!this.model) {
-                this._emit({
-                    type: "compaction_end",
-                    reason,
-                    result: undefined,
-                    aborted: false,
-                    willRetry: false,
-                });
-                return;
-            }
-            const authResult = await this._modelRegistry.getApiKeyAndHeaders(this.model);
-            if (!authResult.ok || !authResult.apiKey) {
-                this._emit({
-                    type: "compaction_end",
-                    reason,
-                    result: undefined,
-                    aborted: false,
-                    willRetry: false,
-                });
-                return;
+                return false;
             }
-            const { apiKey, headers } = authResult;
+            const { model: requestModel, apiKey, headers, env } = await this._getSummarizationRequestAuth(this.model);
             const pathEntries = this.sessionManager.getBranch();
             const preparation = prepareCompaction(pathEntries, settings);
             if (!preparation) {
-                this._emit({
-                    type: "compaction_end",
-                    reason,
-                    result: undefined,
-                    aborted: false,
-                    willRetry: false,
-                });
-                return;
+                return false;
             }
+            this._emit({ type: "compaction_start", reason });
+            this._autoCompactionAbortController = new AbortController();
+            started = true;
             let extensionCompaction;
             let fromExtension = false;
             if (this._extensionRunner.hasHandlers("session_before_compact")) {
@@ -1499,6 +1617,8 @@ export class AgentSession {
                     preparation,
                     branchEntries: pathEntries,
                     customInstructions: undefined,
+                    reason,
+                    willRetry,
                     signal: this._autoCompactionAbortController.signal,
                 }));
                 if (extensionResult?.cancel) {
@@ -1509,7 +1629,7 @@ export class AgentSession {
                         aborted: true,
                         willRetry: false,
                     });
-                    return;
+                    return false;
                 }
                 if (extensionResult?.compaction) {
                     extensionCompaction = extensionResult.compaction;
@@ -1519,20 +1639,23 @@ export class AgentSession {
             let summary;
             let firstKeptEntryId;
             let tokensBefore;
+            let usage;
             let details;
             if (extensionCompaction) {
                 // Extension provided compaction content
                 summary = extensionCompaction.summary;
                 firstKeptEntryId = extensionCompaction.firstKeptEntryId;
                 tokensBefore = extensionCompaction.tokensBefore;
+                usage = extensionCompaction.usage;
                 details = extensionCompaction.details;
             }
             else {
                 // Generate compaction result
-                const compactResult = await compact(preparation, this.model, apiKey, headers, undefined, this._autoCompactionAbortController.signal, this.thinkingLevel);
+                const compactResult = await compact(preparation, requestModel, apiKey, headers, undefined, this._autoCompactionAbortController.signal, this.thinkingLevel, this.agent.streamFunction, env, this.settingsManager.getRetrySettings(), this._summarizationRetryCallbacks({ source: "compaction", reason }));
                 summary = compactResult.summary;
                 firstKeptEntryId = compactResult.firstKeptEntryId;
                 tokensBefore = compactResult.tokensBefore;
+                usage = compactResult.usage;
                 details = compactResult.details;
             }
             if (this._autoCompactionAbortController.signal.aborted) {
@@ -1543,12 +1666,13 @@ export class AgentSession {
                     aborted: true,
                     willRetry: false,
                 });
-                return;
+                return false;
             }
-            this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension);
+            this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension, usage);
             const newEntries = this.sessionManager.getEntries();
             const sessionContext = this.sessionManager.buildSessionContext();
             this.agent.state.messages = sessionContext.messages;
+            const estimatedTokensAfter = estimateMessagesTokens(sessionContext.messages);
             // Get the saved compaction entry for the extension event
             const savedCompactionEntry = newEntries.find((e) => e.type === "compaction" && e.summary === summary);
             if (this._extensionRunner && savedCompactionEntry) {
@@ -1556,45 +1680,50 @@ export class AgentSession {
                     type: "session_compact",
                     compactionEntry: savedCompactionEntry,
                     fromExtension,
+                    reason,
+                    willRetry,
                 });
             }
             const result = {
                 summary,
                 firstKeptEntryId,
                 tokensBefore,
+                estimatedTokensAfter,
+                usage,
                 details,
             };
             this._emit({ type: "compaction_end", reason, result, aborted: false, willRetry });
             if (willRetry) {
                 const messages = this.agent.state.messages;
                 const lastMsg = messages[messages.length - 1];
-                if (lastMsg?.role === "assistant" && lastMsg.stopReason === "error") {
+                // The overflow response was persisted on message_end before _checkCompaction() removed it
+                // from agent state. Rebuilding state from the new compaction can restore that kept entry,
+                // leaving an assistant as the final message. agent.continue() rejects that state, so remove
+                // the retriable error or truncated-length response again before continuing the interrupted turn.
+                if (lastMsg?.role === "assistant" && (lastMsg.stopReason === "error" || lastMsg.stopReason === "length")) {
                     this.agent.state.messages = messages.slice(0, -1);
                 }
-                setTimeout(() => {
-                    this.agent.continue().catch(() => { });
-                }, 100);
-            }
-            else if (this.agent.hasQueuedMessages()) {
-                // Auto-compaction can complete while follow-up/steering/custom messages are waiting.
-                // Kick the loop so queued messages are actually delivered.
-                setTimeout(() => {
-                    this.agent.continue().catch(() => { });
-                }, 100);
+                return true;
             }
+            // Auto-compaction can complete while follow-up/steering/custom messages are waiting.
+            // Continue once so queued messages are delivered.
+            return this.agent.hasQueuedMessages();
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : "compaction failed";
-            this._emit({
-                type: "compaction_end",
-                reason,
-                result: undefined,
-                aborted: false,
-                willRetry: false,
-                errorMessage: reason === "overflow"
-                    ? `Context overflow recovery failed: ${errorMessage}`
-                    : `Auto-compaction failed: ${errorMessage}`,
-            });
+            if (started) {
+                this._emit({
+                    type: "compaction_end",
+                    reason,
+                    result: undefined,
+                    aborted: false,
+                    willRetry: false,
+                    errorMessage: reason === "overflow"
+                        ? `Context overflow recovery failed: ${errorMessage}`
+                        : `Auto-compaction failed: ${errorMessage}`,
+                });
+            }
+            return false;
         }
         finally {
             this._autoCompactionAbortController = undefined;
@@ -1614,9 +1743,15 @@ export class AgentSession {
         if (bindings.uiContext !== undefined) {
             this._extensionUIContext = bindings.uiContext;
         }
+        if (bindings.mode !== undefined) {
+            this._extensionMode = bindings.mode;
+        }
         if (bindings.commandContextActions !== undefined) {
             this._extensionCommandContextActions = bindings.commandContextActions;
         }
+        if (bindings.abortHandler !== undefined) {
+            this._extensionAbortHandler = bindings.abortHandler;
+        }
         if (bindings.shutdownHandler !== undefined) {
             this._extensionShutdownHandler = bindings.shutdownHandler;
         }
@@ -1641,8 +1776,7 @@ export class AgentSession {
             themePaths: this.buildExtensionResourcePaths(themePaths),
         };
         this._resourceLoader.extendResources(extensionPaths);
-        const promptToolNames = this.getActiveToolNames().filter((name) => !this._toolRegistry.get(name)?.deferred);
-        this._baseSystemPrompt = this._rebuildSystemPrompt(promptToolNames);
+        this._baseSystemPrompt = this._rebuildSystemPrompt(this.getActiveToolNames());
         this.agent.state.systemPrompt = this._baseSystemPrompt;
     }
     buildExtensionResourcePaths(entries) {
@@ -1669,7 +1803,7 @@ export class AgentSession {
         return `extension:${name}`;
     }
     _applyExtensionBindings(runner) {
-        runner.setUIContext(this._extensionUIContext);
+        runner.setUIContext(this._extensionUIContext, this._extensionMode);
         runner.bindCommandContext(this._extensionCommandContextActions);
         this._extensionErrorUnsubscriber?.();
         this._extensionErrorUnsubscriber = this._extensionErrorListener
@@ -1681,7 +1815,7 @@ export class AgentSession {
         if (!currentModel) {
             return;
         }
-        const refreshedModel = this._modelRegistry.find(currentModel.provider, currentModel.id);
+        const refreshedModel = this._modelRuntime.getModel(currentModel.provider, currentModel.id);
         if (!refreshedModel || refreshedModel === currentModel) {
             return;
         }
@@ -1729,10 +1863,14 @@ export class AgentSession {
                 });
             },
             appendEntry: (customType, data) => {
-                this.sessionManager.appendCustomEntry(customType, data);
+                const entryId = this.sessionManager.appendCustomEntry(customType, data);
+                const entry = this.sessionManager.getEntry(entryId);
+                if (entry) {
+                    this._emit({ type: "entry_appended", entry });
+                }
             },
             setSessionName: (name) => {
-                this.sessionManager.appendSessionInfo(name);
+                this.setSessionName(name);
             },
             getSessionName: () => {
                 return this.sessionManager.getSessionName();
@@ -1746,7 +1884,7 @@ export class AgentSession {
             refreshTools: () => this._refreshToolRegistry(),
             getCommands,
             setModel: async (model) => {
-                if (!this.modelRegistry.hasConfiguredAuth(model))
+                if (!this._modelRuntime.hasConfiguredAuth(model.provider))
                     return false;
                 await this.setModel(model);
                 return true;
@@ -1755,9 +1893,17 @@ export class AgentSession {
             setThinkingLevel: (level) => this.setThinkingLevel(level),
         }, {
             getModel: () => this.model,
-            isIdle: () => !this.isStreaming,
+            getScopedModels: () => this._scopedModels,
+            isIdle: () => this.isIdle,
+            isProjectTrusted: () => this.settingsManager.isProjectTrusted(),
             getSignal: () => this.agent.signal,
-            abort: () => this.abort(),
+            abort: () => {
+                if (this._extensionAbortHandler) {
+                    this._extensionAbortHandler();
+                    return;
+                }
+                void this.abort();
+            },
             hasPendingMessages: () => this.pendingMessageCount > 0,
             shutdown: () => {
                 this._extensionShutdownHandler?.();
@@ -1776,13 +1922,18 @@ export class AgentSession {
                 })();
             },
             getSystemPrompt: () => this.systemPrompt,
+            getSystemPromptOptions: () => this._baseSystemPromptOptions,
         }, {
             registerProvider: (name, config) => {
-                this._modelRegistry.registerProvider(name, config);
+                this._modelRuntime.registerProvider(name, config);
+                this._refreshCurrentModelFromRegistry();
+            },
+            registerNativeProvider: (provider) => {
+                this._modelRuntime.registerNativeProvider(provider);
                 this._refreshCurrentModelFromRegistry();
             },
             unregisterProvider: (name) => {
-                this._modelRegistry.unregisterProvider(name);
+                this._modelRuntime.unregisterProvider(name);
                 this._refreshCurrentModelFromRegistry();
             },
         });
@@ -1791,7 +1942,8 @@ export class AgentSession {
         const previousRegistryNames = new Set(this._toolRegistry.keys());
         const previousActiveToolNames = this.getActiveToolNames();
         const allowedToolNames = this._allowedToolNames;
-        const isAllowedTool = (name) => !allowedToolNames || allowedToolNames.has(name);
+        const excludedToolNames = this._excludedToolNames;
+        const isAllowedTool = (name) => (!allowedToolNames || allowedToolNames.has(name)) && !excludedToolNames?.has(name);
         const registeredTools = this._extensionRunner.getAllRegisteredTools();
         const allCustomTools = [
             ...registeredTools,
@@ -1874,7 +2026,16 @@ export class AgentSession {
             ]))
             : createAllToolDefinitions(this._cwd, {
                 read: { autoResizeImages },
-                bash: { commandPrefix: shellCommandPrefix, shellPath },
+                bash: {
+                    commandPrefix: shellCommandPrefix,
+                    shellPath,
+                    // Read the runner at spawn time so extension reload swaps in the new
+                    // session environment without rebuilding the tool.
+                    spawnHook: (context) => ({
+                        ...context,
+                        env: applyEnvOverlay(context.env, this._extensionRunner.getSessionEnv()),
+                    }),
+                },
             });
         this._baseToolDefinitions = new Map(Object.entries(baseToolDefinitions).map(([name, tool]) => [name, tool]));
         const extensionsResult = this._resourceLoader.getExtensions();
@@ -1883,7 +2044,7 @@ export class AgentSession {
                 extensionsResult.runtime.flagValues.set(name, value);
             }
         }
-        this._extensionRunner = new ExtensionRunner(extensionsResult.extensions, extensionsResult.runtime, this._cwd, this.sessionManager, this._modelRegistry);
+        this._extensionRunner = new ExtensionRunner(extensionsResult.extensions, extensionsResult.runtime, this._cwd, this.sessionManager, new ModelRegistry(this._modelRuntime));
         if (this._extensionRunnerRef) {
             this._extensionRunnerRef.current = this._extensionRunner;
         }
@@ -1898,10 +2059,13 @@ export class AgentSession {
             includeAllExtensionTools: options.includeAllExtensionTools,
         });
     }
-    async reload() {
-        const previousFlagValues = this._extensionRunner.getFlagValues();
-        await emitSessionShutdownEvent(this._extensionRunner, { type: "session_shutdown", reason: "reload" });
+    async reload(options) {
+        const oldRunner = this._extensionRunner;
+        const previousFlagValues = oldRunner.getFlagValues();
+        await emitSessionShutdownEvent(oldRunner, { type: "session_shutdown", reason: "reload" });
+        oldRunner.invalidate();
         await this.settingsManager.reload();
+        this.syncQueueModesFromSettings();
         resetApiProviders();
         await this._resourceLoader.reload();
         this._buildRuntime({
@@ -1914,6 +2078,7 @@ export class AgentSession {
             this._extensionShutdownHandler ||
             this._extensionErrorListener;
         if (hasBindings) {
+            await options?.beforeSessionStart?.();
             await this._extensionRunner.emit({ type: "session_start", reason: "reload" });
             await this.extendResourcesFromExtensions("reload");
         }
@@ -1926,44 +2091,52 @@ export class AgentSession {
      * Context overflow errors are NOT retryable (handled by compaction instead).
      */
     _isRetryableError(message) {
-        if (message.stopReason !== "error" || !message.errorMessage)
-            return false;
-        // Context overflow is handled by compaction, not retry
-        const contextWindow = this.model?.contextWindow ?? 0;
-        if (isContextOverflow(message, contextWindow))
+        // Context overflow is handled by compaction, not retry.
+        if (isContextOverflow(message, this.model?.contextWindow ?? 0))
             return false;
-        const err = message.errorMessage;
-        // Match: overloaded_error, provider returned error, rate limit, 429, 500, 502, 503, 504, service unavailable, network/connection errors (including connection lost), fetch failed, request ended without sending chunks, HTTP/2 closed before response, terminated, retry delay exceeded
-        return /overloaded|provider.?returned.?error|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server.?error|internal.?error|network.?error|connection.?error|connection.?refused|connection.?lost|other side closed|fetch failed|upstream.?connect|reset before headers|socket hang up|ended without|http2 request did not get a response|timed? out|timeout|terminated|retry delay/i.test(err);
+        return isRetryableAssistantError(message);
     }
     /**
-     * Handle retryable errors with exponential backoff.
-     * @returns true if retry was initiated, false if max retries exceeded or disabled
+     * Retry policy + callbacks shared by compaction and branch-summary summarization calls.
+     * Uses the same `settings.retry` budget/backoff as agent-turn retries so a single transient
+     * stream drop no longer fails the whole operation. `source` carries the context
+     * the TUI needs to render the retry and recreate the underlying indicator.
      */
-    async _handleRetryableError(message) {
+    _summarizationRetryCallbacks(source) {
+        return {
+            onRetryScheduled: (attempt, maxAttempts, delayMs, errorMessage) => {
+                this._emit({
+                    type: "summarization_retry_scheduled",
+                    attempt,
+                    maxAttempts,
+                    delayMs,
+                    errorMessage,
+                });
+            },
+            onRetryAttemptStart: () => {
+                this._emit({
+                    type: "summarization_retry_attempt_start",
+                    ...source,
+                });
+            },
+            onRetryFinished: () => {
+                this._emit({ type: "summarization_retry_finished" });
+            },
+        };
+    }
+    /**
+     * Prepare a retryable error for continuation with exponential backoff.
+     * @returns true if the caller should continue the agent, false otherwise
+     */
+    async _prepareRetry(message) {
         const settings = this.settingsManager.getRetrySettings();
         if (!settings.enabled) {
-            this._resolveRetry();
             return false;
         }
-        // Retry promise is created synchronously in _handleAgentEvent for agent_end.
-        // Keep a defensive fallback here in case a future refactor bypasses that path.
-        if (!this._retryPromise) {
-            this._retryPromise = new Promise((resolve) => {
-                this._retryResolve = resolve;
-            });
-        }
         this._retryAttempt++;
         if (this._retryAttempt > settings.maxRetries) {
-            // Max retries exceeded, emit final failure and reset
-            this._emit({
-                type: "auto_retry_end",
-                success: false,
-                attempt: this._retryAttempt - 1,
-                finalError: message.errorMessage,
-            });
-            this._retryAttempt = 0;
-            this._resolveRetry(); // Resolve so waitForRetry() completes
+            // Preserve the completed attempt count so post-run handling can emit the final failure.
+            this._retryAttempt--;
             return false;
         }
         const delayMs = settings.baseDelayMs * 2 ** (this._retryAttempt - 1);
@@ -1988,23 +2161,17 @@ export class AgentSession {
             // Aborted during sleep - emit end event so UI can clean up
             const attempt = this._retryAttempt;
             this._retryAttempt = 0;
-            this._retryAbortController = undefined;
             this._emit({
                 type: "auto_retry_end",
                 success: false,
                 attempt,
                 finalError: "Retry cancelled",
             });
-            this._resolveRetry();
             return false;
         }
-        this._retryAbortController = undefined;
-        // Retry via continue() - use setTimeout to break out of event handler chain
-        setTimeout(() => {
-            this.agent.continue().catch(() => {
-                // Retry failed - will be caught by next agent_end
-            });
-        }, 0);
+        finally {
+            this._retryAbortController = undefined;
+        }
         return true;
     }
     /**
@@ -2012,23 +2179,10 @@ export class AgentSession {
      */
     abortRetry() {
         this._retryAbortController?.abort();
-        // Note: _retryAttempt is reset in the catch block of _autoRetry
-        this._resolveRetry();
-    }
-    /**
-     * Wait for any in-progress retry to complete.
-     * Returns immediately if no retry is in progress.
-     */
-    async waitForRetry() {
-        if (!this._retryPromise) {
-            return;
-        }
-        await this._retryPromise;
-        await this.agent.waitForIdle();
     }
     /** Whether auto-retry is currently in progress */
     get isRetrying() {
-        return this._retryPromise !== undefined;
+        return this._retryAbortController !== undefined;
     }
     /** Whether auto-retry is enabled */
     get autoRetryEnabled() {
@@ -2049,24 +2203,29 @@ export class AgentSession {
      * @param command The bash command to execute
      * @param onChunk Optional streaming callback for output
      * @param options.excludeFromContext If true, command output won't be sent to LLM (!! prefix)
+     * @param options.id Optional identifier included in bash execution update events
      * @param options.operations Custom BashOperations for remote execution
      */
     async executeBash(command, onChunk, options) {
-        this._bashAbortController = new AbortController();
+        const abortController = new AbortController();
+        this._bashAbortControllers.add(abortController);
         // Apply command prefix if configured (e.g., "shopt -s expand_aliases" for alias support)
         const prefix = this.settingsManager.getShellCommandPrefix();
         const shellPath = this.settingsManager.getShellPath();
         const resolvedCommand = prefix ? `${prefix}\n${command}` : command;
         try {
             const result = await executeBashWithOperations(resolvedCommand, this.sessionManager.getCwd(), options?.operations ?? createLocalBashOperations({ shellPath }), {
-                onChunk,
-                signal: this._bashAbortController.signal,
+                onChunk: (delta) => {
+                    onChunk?.(delta);
+                    this._emit({ type: "bash_execution_update", id: options?.id, delta });
+                },
+                signal: abortController.signal,
             });
             this.recordBashResult(command, result, options);
             return result;
         }
         finally {
-            this._bashAbortController = undefined;
+            this._bashAbortControllers.delete(abortController);
         }
     }
     /**
@@ -2101,11 +2260,13 @@ export class AgentSession {
      * Cancel running bash command.
      */
     abortBash() {
-        this._bashAbortController?.abort();
+        for (const abortController of [...this._bashAbortControllers]) {
+            abortController.abort();
+        }
     }
     /** Whether a bash command is currently running */
     get isBashRunning() {
-        return this._bashAbortController !== undefined;
+        return this._bashAbortControllers.size > 0;
     }
     /** Whether there are pending bash messages waiting to be flushed */
     get hasPendingBashMessages() {
@@ -2134,6 +2295,9 @@ export class AgentSession {
      */
     setSessionName(name) {
         this.sessionManager.appendSessionInfo(name);
+        const event = { type: "session_info_changed", name: this.sessionManager.getSessionName() };
+        this._emit(event);
+        void this._extensionRunner.emit(event);
     }
     // =========================================================================
     // Tree Navigation
@@ -2150,6 +2314,9 @@ export class AgentSession {
      * @returns Result with editorText (if user message) and cancelled status
      */
     async navigateTree(targetId, options = {}) {
+        if (this.isStreaming) {
+            throw new Error("Wait for the current response to finish before navigating the session tree.");
+        }
         const oldLeafId = this.sessionManager.getLeafId();
         // No-op if already at target
         if (targetId === oldLeafId) {
@@ -2181,127 +2348,131 @@ export class AgentSession {
         };
         // Set up abort controller for summarization
         this._branchSummaryAbortController = new AbortController();
-        let extensionSummary;
-        let fromExtension = false;
-        // Emit session_before_tree event
-        if (this._extensionRunner.hasHandlers("session_before_tree")) {
-            const result = (await this._extensionRunner.emit({
-                type: "session_before_tree",
-                preparation,
-                signal: this._branchSummaryAbortController.signal,
-            }));
-            if (result?.cancel) {
-                return { cancelled: true };
-            }
-            if (result?.summary && options.summarize) {
-                extensionSummary = result.summary;
-                fromExtension = true;
-            }
-            // Allow extensions to override instructions and label
-            if (result?.customInstructions !== undefined) {
-                customInstructions = result.customInstructions;
-            }
-            if (result?.replaceInstructions !== undefined) {
-                replaceInstructions = result.replaceInstructions;
-            }
-            if (result?.label !== undefined) {
-                label = result.label;
-            }
-        }
-        // Run default summarizer if needed
-        let summaryText;
-        let summaryDetails;
-        if (options.summarize && entriesToSummarize.length > 0 && !extensionSummary) {
-            const model = this.model;
-            const { apiKey, headers } = await this._getRequiredRequestAuth(model);
-            const branchSummarySettings = this.settingsManager.getBranchSummarySettings();
-            const result = await generateBranchSummary(entriesToSummarize, {
-                model,
-                apiKey,
-                headers,
-                signal: this._branchSummaryAbortController.signal,
-                customInstructions,
-                replaceInstructions,
-                reserveTokens: branchSummarySettings.reserveTokens,
-            });
-            this._branchSummaryAbortController = undefined;
-            if (result.aborted) {
-                return { cancelled: true, aborted: true };
+        try {
+            let extensionSummary;
+            let fromExtension = false;
+            // Emit session_before_tree event
+            if (this._extensionRunner.hasHandlers("session_before_tree")) {
+                const result = (await this._extensionRunner.emit({
+                    type: "session_before_tree",
+                    preparation,
+                    signal: this._branchSummaryAbortController.signal,
+                }));
+                if (result?.cancel) {
+                    return { cancelled: true };
+                }
+                if (result?.summary && options.summarize) {
+                    extensionSummary = result.summary;
+                    fromExtension = true;
+                }
+                // Allow extensions to override instructions and label
+                if (result?.customInstructions !== undefined) {
+                    customInstructions = result.customInstructions;
+                }
+                if (result?.replaceInstructions !== undefined) {
+                    replaceInstructions = result.replaceInstructions;
+                }
+                if (result?.label !== undefined) {
+                    label = result.label;
+                }
+            }
+            // Run default summarizer if needed
+            let summaryText;
+            let summaryDetails;
+            let summaryUsage;
+            if (options.summarize && entriesToSummarize.length > 0 && !extensionSummary) {
+                const model = this.model;
+                const { model: requestModel, apiKey, headers, env } = await this._getSummarizationRequestAuth(model);
+                const branchSummarySettings = this.settingsManager.getBranchSummarySettings();
+                const result = await generateBranchSummary(entriesToSummarize, {
+                    model: requestModel,
+                    apiKey,
+                    headers,
+                    env,
+                    signal: this._branchSummaryAbortController.signal,
+                    customInstructions,
+                    replaceInstructions,
+                    reserveTokens: branchSummarySettings.reserveTokens,
+                    streamFn: this.agent.streamFunction,
+                    retry: this.settingsManager.getRetrySettings(),
+                    callbacks: this._summarizationRetryCallbacks({ source: "branchSummary" }),
+                });
+                if (result.aborted) {
+                    return { cancelled: true, aborted: true };
+                }
+                if (result.error) {
+                    throw new Error(result.error);
+                }
+                summaryText = result.summary;
+                summaryUsage = result.usage;
+                summaryDetails = {
+                    readFiles: result.readFiles || [],
+                    modifiedFiles: result.modifiedFiles || [],
+                };
+            }
+            else if (extensionSummary) {
+                summaryText = extensionSummary.summary;
+                summaryDetails = extensionSummary.details;
+                summaryUsage = extensionSummary.usage;
+            }
+            // Determine the new leaf position based on target type
+            let newLeafId;
+            let editorText;
+            if (targetEntry.type === "message" && targetEntry.message.role === "user") {
+                // User message: leaf = parent (null if root), text goes to editor
+                newLeafId = targetEntry.parentId;
+                editorText = contentText(targetEntry.message.content, "");
+            }
+            else if (targetEntry.type === "custom_message") {
+                // Custom message: leaf = parent (null if root), text goes to editor
+                newLeafId = targetEntry.parentId;
+                editorText = contentText(targetEntry.content, "");
             }
-            if (result.error) {
-                throw new Error(result.error);
+            else {
+                // Non-user message: leaf = selected node
+                newLeafId = targetId;
+            }
+            // Switch leaf (with or without summary)
+            // Summary is attached at the navigation target position (newLeafId), not the old branch
+            let summaryEntry;
+            if (summaryText) {
+                // Create summary at target position (can be null for root)
+                const summaryId = this.sessionManager.branchWithSummary(newLeafId, summaryText, summaryDetails, fromExtension, summaryUsage);
+                summaryEntry = this.sessionManager.getEntry(summaryId);
+                // Attach label to the summary entry
+                if (label) {
+                    this.sessionManager.appendLabelChange(summaryId, label);
+                }
             }
-            summaryText = result.summary;
-            summaryDetails = {
-                readFiles: result.readFiles || [],
-                modifiedFiles: result.modifiedFiles || [],
-            };
-        }
-        else if (extensionSummary) {
-            summaryText = extensionSummary.summary;
-            summaryDetails = extensionSummary.details;
-        }
-        // Determine the new leaf position based on target type
-        let newLeafId;
-        let editorText;
-        if (targetEntry.type === "message" && targetEntry.message.role === "user") {
-            // User message: leaf = parent (null if root), text goes to editor
-            newLeafId = targetEntry.parentId;
-            editorText = this._extractUserMessageText(targetEntry.message.content);
-        }
-        else if (targetEntry.type === "custom_message") {
-            // Custom message: leaf = parent (null if root), text goes to editor
-            newLeafId = targetEntry.parentId;
-            editorText =
-                typeof targetEntry.content === "string"
-                    ? targetEntry.content
-                    : targetEntry.content
-                        .filter((c) => c.type === "text")
-                        .map((c) => c.text)
-                        .join("");
-        }
-        else {
-            // Non-user message: leaf = selected node
-            newLeafId = targetId;
-        }
-        // Switch leaf (with or without summary)
-        // Summary is attached at the navigation target position (newLeafId), not the old branch
-        let summaryEntry;
-        if (summaryText) {
-            // Create summary at target position (can be null for root)
-            const summaryId = this.sessionManager.branchWithSummary(newLeafId, summaryText, summaryDetails, fromExtension);
-            summaryEntry = this.sessionManager.getEntry(summaryId);
-            // Attach label to the summary entry
-            if (label) {
-                this.sessionManager.appendLabelChange(summaryId, label);
+            else if (newLeafId === null) {
+                // No summary, navigating to root - reset leaf
+                this.sessionManager.resetLeaf();
             }
+            else {
+                // No summary, navigating to non-root
+                this.sessionManager.branch(newLeafId);
+            }
+            // Attach label to target entry when not summarizing (no summary entry to label)
+            if (label && !summaryText) {
+                this.sessionManager.appendLabelChange(targetId, label);
+            }
+            // Update agent state
+            const sessionContext = this.sessionManager.buildSessionContext();
+            this.agent.state.messages = sessionContext.messages;
+            // Emit session_tree event
+            await this._extensionRunner.emit({
+                type: "session_tree",
+                newLeafId: this.sessionManager.getLeafId(),
+                oldLeafId,
+                summaryEntry,
+                fromExtension: summaryText ? fromExtension : undefined,
+            });
+            // Emit to custom tools
+            return { editorText, cancelled: false, summaryEntry };
         }
-        else if (newLeafId === null) {
-            // No summary, navigating to root - reset leaf
-            this.sessionManager.resetLeaf();
-        }
-        else {
-            // No summary, navigating to non-root
-            this.sessionManager.branch(newLeafId);
-        }
-        // Attach label to target entry when not summarizing (no summary entry to label)
-        if (label && !summaryText) {
-            this.sessionManager.appendLabelChange(targetId, label);
+        finally {
+            this._branchSummaryAbortController = undefined;
         }
-        // Update agent state
-        const sessionContext = this.sessionManager.buildSessionContext();
-        this.agent.state.messages = sessionContext.messages;
-        // Emit session_tree event
-        await this._extensionRunner.emit({
-            type: "session_tree",
-            newLeafId: this.sessionManager.getLeafId(),
-            oldLeafId,
-            summaryEntry,
-            fromExtension: summaryText ? fromExtension : undefined,
-        });
-        // Emit to custom tools
-        this._branchSummaryAbortController = undefined;
-        return { editorText, cancelled: false, summaryEntry };
     }
     /**
      * Get all user messages from session for fork selector.
@@ -2314,47 +2485,49 @@ export class AgentSession {
                 continue;
             if (entry.message.role !== "user")
                 continue;
-            const text = this._extractUserMessageText(entry.message.content);
+            const text = contentText(entry.message.content, "");
             if (text) {
                 result.push({ entryId: entry.id, text });
             }
         }
         return result;
     }
-    _extractUserMessageText(content) {
-        if (typeof content === "string")
-            return content;
-        if (Array.isArray(content)) {
-            return content
-                .filter((c) => c.type === "text")
-                .map((c) => c.text)
-                .join("");
-        }
-        return "";
-    }
     /**
-     * Get session statistics.
+     * Get session statistics. Aggregates over ALL session entries (including
+     * history that was compacted away), so token/cost totals reflect what was
+     * actually billed across the session.
      */
     getSessionStats() {
-        const state = this.state;
-        const userMessages = state.messages.filter((m) => m.role === "user").length;
-        const assistantMessages = state.messages.filter((m) => m.role === "assistant").length;
-        const toolResults = state.messages.filter((m) => m.role === "toolResult").length;
+        let userMessages = 0;
+        let assistantMessages = 0;
+        let toolResults = 0;
+        let totalMessages = 0;
         let toolCalls = 0;
-        let totalInput = 0;
-        let totalOutput = 0;
-        let totalCacheRead = 0;
-        let totalCacheWrite = 0;
-        let totalCost = 0;
-        for (const message of state.messages) {
-            if (message.role === "assistant") {
+        const usageTotals = createUsageTotals();
+        for (const entry of this.sessionManager.getEntries()) {
+            if ((entry.type === "branch_summary" || entry.type === "compaction") && entry.usage) {
+                addUsageToTotals(usageTotals, entry.usage);
+            }
+            if (entry.type !== "message")
+                continue;
+            totalMessages++;
+            const message = entry.message;
+            if (message.role === "user") {
+                userMessages++;
+            }
+            else if (message.role === "toolResult") {
+                toolResults++;
+                if (message.usage) {
+                    addUsageToTotals(usageTotals, message.usage);
+                }
+            }
+            else if (message.role === "assistant") {
+                assistantMessages++;
                 const assistantMsg = message;
-                toolCalls += assistantMsg.content.filter((c) => c.type === "toolCall").length;
-                totalInput += assistantMsg.usage.input;
-                totalOutput += assistantMsg.usage.output;
-                totalCacheRead += assistantMsg.usage.cacheRead;
-                totalCacheWrite += assistantMsg.usage.cacheWrite;
-                totalCost += assistantMsg.usage.cost.total;
+                if (Array.isArray(assistantMsg.content)) {
+                    toolCalls += assistantMsg.content.filter((c) => c.type === "toolCall").length;
+                }
+                addUsageToTotals(usageTotals, assistantMsg.usage);
             }
         }
         return {
@@ -2364,15 +2537,15 @@ export class AgentSession {
             assistantMessages,
             toolCalls,
             toolResults,
-            totalMessages: state.messages.length,
+            totalMessages,
             tokens: {
-                input: totalInput,
-                output: totalOutput,
-                cacheRead: totalCacheRead,
-                cacheWrite: totalCacheWrite,
-                total: totalInput + totalOutput + totalCacheRead + totalCacheWrite,
+                input: usageTotals.input,
+                output: usageTotals.output,
+                cacheRead: usageTotals.cacheRead,
+                cacheWrite: usageTotals.cacheWrite,
+                total: usageTotals.input + usageTotals.output + usageTotals.cacheRead + usageTotals.cacheWrite,
             },
-            cost: totalCost,
+            cost: usageTotals.cost,
             contextUsage: this.getContextUsage(),
         };
     }
@@ -2400,8 +2573,8 @@ export class AgentSession {
                         const contextTokens = calculateContextTokens(assistant.usage);
                         if (contextTokens > 0) {
                             hasPostCompactionUsage = true;
+                            break;
                         }
-                        break;
                     }
                 }
             }
@@ -2420,10 +2593,11 @@ export class AgentSession {
     /**
      * Export session to HTML.
      * @param outputPath Optional output path (defaults to session directory)
+     * @param options Optional export presentation settings
      * @returns Path to exported file
      */
-    async exportToHtml(outputPath) {
-        const themeName = this.settingsManager.getTheme();
+    async exportToHtml(outputPath, options = {}) {
+        const themeName = [options.themeName, this.settingsManager.getTheme()].find((candidate) => candidate !== undefined && getThemeByName(candidate) !== undefined);
         // Create tool renderer if we have an extension runner (for custom tool HTML rendering)
         const toolRenderer = createToolHtmlRenderer({
             getToolDefinition: (name) => this.getToolDefinition(name),
@@ -2443,7 +2617,7 @@ export class AgentSession {
      * @returns The resolved output file path.
      */
     exportToJsonl(outputPath) {
-        const filePath = resolve(outputPath ?? `session-${new Date().toISOString().replace(/[:.]/g, "-")}.jsonl`);
+        const filePath = resolvePath(outputPath ?? `session-${new Date().toISOString().replace(/[:.]/g, "-")}.jsonl`, process.cwd());
         const dir = dirname(filePath);
         if (!existsSync(dir)) {
             mkdirSync(dir, { recursive: true });