@bastani/atomic 0.8.31-alpha.4 → 0.9.0-alpha.1

package/dist/core/agent-session.js

@@ -1,192 +1,56 @@
 /**
  * AgentSession - Core abstraction for agent lifecycle and session management.
  *
- * This class is shared between all run modes (interactive, print, rpc).
- * It encapsulates:
- * - Agent state access
- * - Event subscription with automatic session persistence
- * - Model and thinking level management
- * - Compaction (manual and auto)
- * - Bash execution
- * - Session switching and branching
- *
- * Modes use this class and add their own I/O layer on top.
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { basename, dirname } from "node:path";
-import { clampThinkingLevel, cleanupSessionResources, getSupportedThinkingLevels, isContextOverflow, modelsAreEqual, resetApiProviders, } from "@earendil-works/pi-ai";
-import { 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 { ATOMIC_GUIDE_COMMAND_NAME, ATOMIC_GUIDE_HELP_CHOICES, atomicGuideModeForChoice, getAtomicGuideMessage, isAtomicGuideHelpChoice, normalizeAtomicGuideMode, } from "./atomic-guide-command.js";
-import { formatAuthStorageLoadFailedMessage, formatNoApiKeyFoundMessage, formatNoModelSelectedMessage, formatUnresolvedModelMessage, } from "./auth-guidance.js";
-import { executeBashWithOperations } from "./bash-executor.js";
-import { calculateContextTokens, collectEntriesForBranchSummary, contextCompact as runContextCompact, estimateContextTokens, generateBranchSummary, prepareContextCompaction, shouldCompact, validateContextDeletionRequest, } from "./compaction/index.js";
-import { getEffectiveInputBudget, getModelDefaultContextWindow, getSupportedContextWindows, selectContextWindow } from "./context-window.js";
-import { formatCopilotProviderError, parseCopilotPromptLimitError } from "./copilot-errors.js";
-import { DEFAULT_THINKING_LEVEL } from "./defaults.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 { expandPromptTemplate } from "./prompt-templates.js";
-import { CURRENT_SESSION_VERSION, getLatestCompactionBoundaryEntry } from "./session-manager.js";
-import { createSyntheticSourceInfo } from "./source-info.js";
-import { buildSystemPrompt } from "./system-prompt.js";
-import { createLocalBashOperations } from "./tools/bash.js";
-import { evaluateBashCommandPolicy, formatBashCommandPolicyRejection, } from "./tools/bash-policy.js";
-import { createAllToolDefinitions, defaultToolNames } from "./tools/index.js";
-import { redirectOversizedToolResult } from "./tools/oversized-tool-result.js";
-import { createToolDefinitionFromAgentTool } from "./tools/tool-definition-wrapper.js";
-import { isCopilotGeminiModel } from "./copilot-gemini-payload-sanitizer.js";
-import { normalizeToolArgumentsForModel } from "./copilot-gemini-tool-arguments.js";
-function deepFreeze(value) {
-    if (value && typeof value === "object") {
-        Object.freeze(value);
-        for (const nested of Object.values(value)) {
-            deepFreeze(nested);
-        }
-    }
-    return value;
-}
-/**
- * Parse a skill block from message text.
- * Returns null if the text doesn't contain a skill block.
+ * The historical import path is preserved here as a facade. Responsibilities are
+ * implemented in sibling modules by lifecycle area so each authored source file
+ * stays below the repository file-length gate.
  */
-export function parseSkillBlock(text) {
-    const prefix = '<skill name="';
-    if (!text.startsWith(prefix))
-        return null;
-    const nameEnd = text.indexOf('" location="', prefix.length);
-    if (nameEnd === -1)
-        return null;
-    const name = text.slice(prefix.length, nameEnd);
-    if (!name)
-        return null;
-    const locationStart = nameEnd + '" location="'.length;
-    const locationEnd = text.indexOf('">\n', locationStart);
-    if (locationEnd === -1)
-        return null;
-    const location = text.slice(locationStart, locationEnd);
-    if (!location)
-        return null;
-    const contentStart = locationEnd + '">\n'.length;
-    const closing = "\n</skill>";
-    const contentEnd = text.indexOf(closing, contentStart);
-    if (contentEnd === -1)
-        return null;
-    const afterClosing = text.slice(contentEnd + closing.length);
-    if (afterClosing !== "" && !afterClosing.startsWith("\n\n"))
-        return null;
-    return {
-        name,
-        location,
-        content: text.slice(contentStart, contentEnd),
-        userMessage: afterClosing ? afterClosing.slice(2).trim() || undefined : undefined,
-    };
-}
-const COPILOT_CONTEXT_WINDOW_SELECTION_OPTIONS = { allowCopilotLongContextFallback: true };
-function drainAgentMessageQueue(queue) {
-    if (!queue)
-        return [];
-    const drained = [];
-    while (queue.hasItems()) {
-        drained.push(...queue.drain());
-    }
-    return drained;
-}
-function normalizeInterruptAbortMessage(value) {
-    const trimmed = value?.trim();
-    return trimmed && trimmed.length > 0 ? trimmed : undefined;
-}
-function isGenericAbortText(value) {
-    const normalized = value.trim().toLowerCase().replace(/[.!]+$/, "");
-    return (normalized === "operation aborted" ||
-        normalized === "the operation was aborted" ||
-        normalized === "request was aborted" ||
-        normalized === "this operation was aborted" ||
-        normalized === "extension custom ui aborted");
-}
-function isSingleGenericAbortTextContent(content) {
-    return (Array.isArray(content) &&
-        content.length === 1 &&
-        typeof content[0] === "object" &&
-        content[0] !== null &&
-        content[0].type === "text" &&
-        typeof content[0].text === "string" &&
-        isGenericAbortText(content[0].text));
-}
-function replacementAbortContent(text) {
-    return [{ type: "text", text }];
-}
-// ============================================================================
-// Constants
-// ============================================================================
-/** Standard thinking levels */
-const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high"];
-function customMessageExcludesContext(message) {
-    return message.excludeFromContext === true;
-}
-// ============================================================================
-// AgentSession Class
-// ============================================================================
+import { installAgentSessionAccessors } from "./agent-session-accessors.js";
+import { agentSessionAutoCompactionMethods } from "./agent-session-auto-compaction.js";
+import { agentSessionBashMethods } from "./agent-session-bash.js";
+import { agentSessionCompactionMethods } from "./agent-session-compaction.js";
+import { agentSessionEventsMethods } from "./agent-session-events.js";
+import { agentSessionExportMethods } from "./agent-session-export.js";
+import { agentSessionExtensionBindingsMethods } from "./agent-session-extension-bindings.js";
+import { agentSessionMessageQueueMethods } from "./agent-session-message-queue.js";
+import { agentSessionModelsMethods } from "./agent-session-models.js";
+import { agentSessionPromptMethods } from "./agent-session-prompt.js";
+import { agentSessionRetryMethods } from "./agent-session-retry.js";
+import { agentSessionStateMethods } from "./agent-session-state.js";
+import { agentSessionToolHooksMethods } from "./agent-session-tool-hooks.js";
+import { agentSessionToolRegistryMethods } from "./agent-session-tool-registry.js";
+import { agentSessionTreeMethods } from "./agent-session-tree.js";
+export { parseSkillBlock } from "./agent-session-skill-block.js";
 export class AgentSession {
     constructor(config) {
         this._eventListeners = [];
         this._agentEventQueue = Promise.resolve();
-        /** Tracks pending steering messages for UI display. Removed when delivered. */
         this._steeringMessages = [];
-        /** Tracks pending follow-up messages for UI display. Removed when delivered. */
         this._followUpMessages = [];
-        /** Serializes interrupt custom-message delivery so only one immediate prompt runs at a time. */
         this._interruptDeliveryQueue = Promise.resolve();
-        /** Number of interrupt custom messages enqueued or currently delivering. */
         this._pendingInterruptDeliveries = 0;
-        /** Queues held out of pi-agent-core while an interrupt sequence is active. */
         this._activeInterruptQueueHold = undefined;
-        /** Replacement text for generic abort results produced by an interrupt-delivered custom message. */
         this._activeInterruptAbortMessage = undefined;
-        /** Messages queued to be included with the next user prompt as context ("asides"). */
         this._pendingNextTurnMessages = [];
-        // Compaction state
         this._compactionAbortController = undefined;
         this._autoCompactionAbortController = undefined;
         this._overflowRecoveryAttempted = false;
-        // Branch summarization state
         this._branchSummaryAbortController = undefined;
-        // Retry state
         this._retryAbortController = undefined;
         this._retryAttempt = 0;
         this._retryPromise = undefined;
         this._retryResolve = undefined;
-        // Bash execution state
         this._bashAbortController = undefined;
         this._pendingBashMessages = [];
         this._turnIndex = 0;
         this._baseToolDefinitions = new Map();
         this._extensionMode = "print";
-        // Tool registry for extension getTools/setTools
         this._toolRegistry = new Map();
         this._toolDefinitions = new Map();
         this._toolPromptSnippets = new Map();
         this._toolPromptGuidelines = new Map();
-        // Base system prompt (without extension appends) - used to apply fresh appends each turn
         this._baseSystemPrompt = "";
-        // Track last assistant message for auto-compaction check
         this._lastAssistantMessage = undefined;
-        /** Internal handler for agent events - shared by subscribe and reconnect */
-        this._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(() => { });
-        };
         this.agent = config.agent;
         this.sessionManager = config.sessionManager;
         this.settingsManager = config.settingsManager;
@@ -203,3006 +67,16 @@ export class AgentSession {
         this._baseToolsOverride = config.baseToolsOverride;
         this._sessionStartEvent = config.sessionStartEvent ?? { type: "session_start", reason: "startup" };
         this._orchestrationContext = config.orchestrationContext;
-        // 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._buildRuntime({
+        const internals = this;
+        internals._handleAgentEvent = internals._handleAgentEvent.bind(this);
+        this._unsubscribeAgent = this.agent.subscribe(internals._handleAgentEvent);
+        internals._installAgentToolHooks();
+        internals._buildRuntime({
             activeToolNames: this._initialActiveToolNames,
             includeAllExtensionTools: true,
         });
     }
-    /** Orchestration context for this session, when owned by a workflow/subagent runtime. */
-    get orchestrationContext() {
-        return this._orchestrationContext;
-    }
-    /** Model registry for API key resolution and model discovery */
-    get modelRegistry() {
-        return this._modelRegistry;
-    }
-    async _getRequiredRequestAuth(model) {
-        const result = await this._modelRegistry.getApiKeyAndHeaders(model);
-        if (!result.ok) {
-            if (result.error.startsWith("No API key found")) {
-                throw new Error(formatNoApiKeyFoundMessage(model.provider));
-            }
-            throw new Error(result.error);
-        }
-        if (result.apiKey) {
-            return { apiKey: result.apiKey, headers: result.headers };
-        }
-        const isOAuth = this._modelRegistry.isUsingOAuth(model);
-        if (isOAuth) {
-            throw new Error(`Authentication failed for "${model.provider}". ` +
-                `Credentials may have expired or network is unavailable. ` +
-                `Run '/login ${model.provider}' to re-authenticate.`);
-        }
-        throw new Error(formatNoApiKeyFoundMessage(model.provider));
-    }
-    /**
-     * Install tool hooks once on the Agent instance.
-     *
-     * The callbacks read `this._extensionRunner` at execution time, so extension reload swaps in the
-     * new runner without reinstalling hooks. Extension-specific tool wrappers are still used to adapt
-     * registered tool execution to the extension context. Tool call and tool result interception now
-     * happens here instead of in wrappers.
-     */
-    _installAgentToolHooks() {
-        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",
-                    toolName: toolCall.name,
-                    toolCallId: toolCall.id,
-                    input: args,
-                });
-            }
-            catch (err) {
-                if (err instanceof Error) {
-                    throw err;
-                }
-                throw new Error(`Extension failed, blocking execution: ${String(err)}`);
-            }
-        };
-        this.agent.afterToolCall = async ({ toolCall, args, result, isError }) => {
-            const runner = this._extensionRunner;
-            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,
-                })
-                : undefined;
-            const extensionReplacement = hookResult
-                ? {
-                    content: hookResult.content,
-                    details: hookResult.details,
-                    isError: hookResult.isError ?? isError,
-                }
-                : undefined;
-            const finalResult = hookResult
-                ? {
-                    content: hookResult.content ?? result.content,
-                    // Preserve original details when an extension hook rewrites only content;
-                    // the redirect check only replaces model-visible content blocks.
-                    details: hookResult.details ?? result.details,
-                }
-                : result;
-            const finalIsError = hookResult?.isError ?? isError;
-            const redirectReplacement = await redirectOversizedToolResult({
-                toolName: toolCall.name,
-                toolCallId: toolCall.id,
-                result: finalResult,
-                isError: finalIsError,
-                sessionId: this.sessionManager.getSessionId(),
-                sessionDir: this.sessionManager.getSessionDir() || undefined,
-                maxResultSizeChars: this.getToolDefinition(toolCall.name)?.maxResultSizeChars,
-            });
-            return redirectReplacement ?? extensionReplacement;
-        };
-    }
-    // =========================================================================
-    // Event Subscription
-    // =========================================================================
-    /** Emit an event to all listeners */
-    _emit(event) {
-        for (const l of this._eventListeners) {
-            l(event);
-        }
-    }
-    _emitQueueUpdate() {
-        this._emit({
-            type: "queue_update",
-            steering: [...this._steeringMessages],
-            followUp: [...this._followUpMessages],
-        });
-    }
-    _createRetryPromiseForAgentEnd(event) {
-        if (event.type !== "agent_end" || this._retryPromise) {
-            return;
-        }
-        const settings = this.settingsManager.getRetrySettings();
-        if (!settings.enabled) {
-            return;
-        }
-        const lastAssistant = this._findLastAssistantInMessages(event.messages);
-        if (!lastAssistant || !this._isRetryableError(lastAssistant)) {
-            return;
-        }
-        this._retryPromise = new Promise((resolve) => {
-            this._retryResolve = resolve;
-        });
-    }
-    _findLastAssistantInMessages(messages) {
-        for (let i = messages.length - 1; i >= 0; i--) {
-            const message = messages[i];
-            if (message.role === "assistant") {
-                return message;
-            }
-        }
-        return undefined;
-    }
-    async _processAgentEvent(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);
-            if (messageText) {
-                // Check steering queue first
-                const steeringIndex = this._steeringMessages.indexOf(messageText);
-                if (steeringIndex !== -1) {
-                    this._steeringMessages.splice(steeringIndex, 1);
-                    this._emitQueueUpdate();
-                }
-                else {
-                    // Check follow-up queue
-                    const followUpIndex = this._followUpMessages.indexOf(messageText);
-                    if (followUpIndex !== -1) {
-                        this._followUpMessages.splice(followUpIndex, 1);
-                        this._emitQueueUpdate();
-                    }
-                }
-            }
-        }
-        this._applyInterruptAbortMessage(event);
-        this._applyProviderErrorGuidance(event);
-        // Emit to extensions first
-        await this._emitExtensionEvent(event);
-        // Notify all listeners
-        this._emit(event);
-        // Handle session persistence
-        if (event.type === "message_end") {
-            // Check if this is a custom message from extensions
-            if (event.message.role === "custom") {
-                // Persist as CustomMessageEntry
-                this.sessionManager.appendCustomMessageEntry(event.message.customType, event.message.content, event.message.display, event.message.details, customMessageExcludesContext(event.message));
-            }
-            else if (event.message.role === "user" ||
-                event.message.role === "assistant" ||
-                event.message.role === "toolResult") {
-                if (event.message.role === "assistant") {
-                    this._normalizePersistedGeminiToolArgs(event.message);
-                }
-                // Regular LLM message - persist as SessionMessageEntry
-                this.sessionManager.appendMessage(event.message);
-            }
-            // Other message types (bashExecution, branchSummary) are persisted elsewhere
-            // Track assistant message for auto-compaction (checked on agent_end)
-            if (event.message.role === "assistant") {
-                this._lastAssistantMessage = event.message;
-                const assistantMsg = event.message;
-                // Treat degenerate empty completions (no content, zero output tokens) as
-                // failures alongside stopReason === "error". Otherwise an empty turn that
-                // stops with reason "stop" would reset the retry counter on every attempt,
-                // causing unbounded retries instead of honoring maxRetries.
-                const assistantFailed = assistantMsg.stopReason === "error" || this._isEmptyCompletion(assistantMsg);
-                if (!assistantFailed) {
-                    this._overflowRecoveryAttempted = false;
-                }
-                // Reset retry counter immediately on successful assistant response
-                // This prevents accumulation across multiple LLM calls within a turn
-                if (!assistantFailed && this._retryAttempt > 0) {
-                    this._emit({
-                        type: "auto_retry_end",
-                        success: true,
-                        attempt: this._retryAttempt,
-                    });
-                    this._retryAttempt = 0;
-                }
-            }
-        }
-        // 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,
-            // transient provider finish_reason errors, or degenerate empty completions)
-            const retryableError = this._isRetryableError(msg);
-            const emptyCompletion = !retryableError && this._isEmptyCompletion(msg);
-            if (retryableError || emptyCompletion) {
-                if (emptyCompletion && !msg.errorMessage) {
-                    // Surface a clear reason in the retry banner; empty completions carry no
-                    // provider error message of their own.
-                    msg.errorMessage = "Provider returned an empty completion";
-                }
-                const didRetry = await this._handleRetryableError(msg);
-                if (didRetry)
-                    return; // Retry was initiated, don't proceed to compaction
-            }
-            this._resolveRetry();
-            await this._checkCompaction(msg);
-        }
-    }
-    _applyInterruptAbortMessage(event) {
-        const abortMessage = this._activeInterruptAbortMessage;
-        if (!abortMessage)
-            return;
-        if (event.type === "tool_execution_end" && event.isError && isSingleGenericAbortTextContent(event.result.content)) {
-            event.result.content = replacementAbortContent(abortMessage);
-            return;
-        }
-        if (event.type !== "message_start" && event.type !== "message_end")
-            return;
-        if (event.message.role === "toolResult" && event.message.isError && isSingleGenericAbortTextContent(event.message.content)) {
-            event.message.content = replacementAbortContent(abortMessage);
-            return;
-        }
-        if (event.message.role === "assistant") {
-            const assistantMessage = event.message;
-            if (assistantMessage.stopReason === "aborted") {
-                assistantMessage.errorMessage = abortMessage;
-            }
-        }
-    }
-    _applyProviderErrorGuidance(event) {
-        if (event.type !== "message_start" && event.type !== "message_update" && event.type !== "message_end")
-            return;
-        if (event.message.role !== "assistant")
-            return;
-        const assistantMessage = event.message;
-        if (assistantMessage.stopReason !== "error" || !assistantMessage.errorMessage)
-            return;
-        assistantMessage.errorMessage = formatCopilotProviderError(assistantMessage.provider, assistantMessage.errorMessage);
-    }
-    /** Resolve the pending retry promise */
-    _resolveRetry() {
-        if (this._retryResolve) {
-            this._retryResolve();
-            this._retryResolve = undefined;
-            this._retryPromise = undefined;
-        }
-    }
-    /** 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("");
-    }
-    /** Find the last assistant message in agent state (including aborted ones) */
-    _findLastAssistantMessage() {
-        const messages = this.agent.state.messages;
-        for (let i = messages.length - 1; i >= 0; i--) {
-            const msg = messages[i];
-            if (msg.role === "assistant") {
-                return msg;
-            }
-        }
-        return undefined;
-    }
-    _replaceMessageInPlace(target, replacement) {
-        // Agent-core stores the finalized message object in its state before emitting message_end.
-        // SessionManager persistence happens later in _processAgentEvent() 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") {
-            this._turnIndex = 0;
-            await this._extensionRunner.emit({ type: "agent_start" });
-        }
-        else if (event.type === "agent_end") {
-            await this._extensionRunner.emit({ type: "agent_end", messages: event.messages });
-        }
-        else if (event.type === "turn_start") {
-            const extensionEvent = {
-                type: "turn_start",
-                turnIndex: this._turnIndex,
-                timestamp: Date.now(),
-            };
-            await this._extensionRunner.emit(extensionEvent);
-        }
-        else if (event.type === "turn_end") {
-            const extensionEvent = {
-                type: "turn_end",
-                turnIndex: this._turnIndex,
-                message: event.message,
-                toolResults: event.toolResults,
-            };
-            await this._extensionRunner.emit(extensionEvent);
-            this._turnIndex++;
-        }
-        else if (event.type === "message_start") {
-            const extensionEvent = {
-                type: "message_start",
-                message: event.message,
-            };
-            await this._extensionRunner.emit(extensionEvent);
-        }
-        else if (event.type === "message_update") {
-            const extensionEvent = {
-                type: "message_update",
-                message: event.message,
-                assistantMessageEvent: event.assistantMessageEvent,
-            };
-            await this._extensionRunner.emit(extensionEvent);
-        }
-        else if (event.type === "message_end") {
-            const extensionEvent = {
-                type: "message_end",
-                message: event.message,
-            };
-            const replacement = await this._extensionRunner.emitMessageEnd(extensionEvent);
-            if (replacement) {
-                this._replaceMessageInPlace(event.message, replacement);
-            }
-        }
-        else if (event.type === "tool_execution_start") {
-            const extensionEvent = {
-                type: "tool_execution_start",
-                toolCallId: event.toolCallId,
-                toolName: event.toolName,
-                args: event.args,
-            };
-            await this._extensionRunner.emit(extensionEvent);
-        }
-        else if (event.type === "tool_execution_update") {
-            const extensionEvent = {
-                type: "tool_execution_update",
-                toolCallId: event.toolCallId,
-                toolName: event.toolName,
-                args: event.args,
-                partialResult: event.partialResult,
-            };
-            await this._extensionRunner.emit(extensionEvent);
-        }
-        else if (event.type === "tool_execution_end") {
-            const extensionEvent = {
-                type: "tool_execution_end",
-                toolCallId: event.toolCallId,
-                toolName: event.toolName,
-                result: event.result,
-                isError: event.isError,
-            };
-            await this._extensionRunner.emit(extensionEvent);
-        }
-    }
-    /**
-     * Subscribe to agent events.
-     * Session persistence is handled internally (saves messages on message_end).
-     * Multiple listeners can be added. Returns unsubscribe function for this listener.
-     */
-    subscribe(listener) {
-        this._eventListeners.push(listener);
-        // Return unsubscribe function for this specific listener
-        return () => {
-            const index = this._eventListeners.indexOf(listener);
-            if (index !== -1) {
-                this._eventListeners.splice(index, 1);
-            }
-        };
-    }
-    /**
-     * 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.
-     */
-    _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() {
-        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
-    // =========================================================================
-    /** Full agent state */
-    get state() {
-        return this.agent.state;
-    }
-    /** Current model (may be undefined if not yet selected) */
-    get model() {
-        return this.agent.state.model;
-    }
-    /** Current thinking level */
-    get thinkingLevel() {
-        return this.agent.state.thinkingLevel;
-    }
-    /** Whether agent is currently streaming a response */
-    get isStreaming() {
-        return this.agent.state.isStreaming;
-    }
-    /** Current effective system prompt (includes any per-turn extension modifications) */
-    get systemPrompt() {
-        return this.agent.state.systemPrompt;
-    }
-    /** Current retry attempt (0 if not retrying) */
-    get retryAttempt() {
-        return this._retryAttempt;
-    }
-    /**
-     * Get the names of currently active tools.
-     * Returns the names of tools currently set on the agent.
-     */
-    getActiveToolNames() {
-        return this.agent.state.tools.map((t) => t.name);
-    }
-    /**
-     * Get all configured tools with name, description, parameter schema, 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,
-        }));
-    }
-    getToolDefinition(name) {
-        return this._toolDefinitions.get(name)?.definition;
-    }
-    /**
-     * Set active tools by name.
-     * Only tools in the registry can be enabled. Unknown tool names are ignored.
-     * Also rebuilds the system prompt to reflect the new tool set.
-     * Changes take effect on the next agent turn.
-     */
-    setActiveToolsByName(toolNames) {
-        const tools = [];
-        const validToolNames = [];
-        for (const name of toolNames) {
-            const tool = this._toolRegistry.get(name);
-            if (tool) {
-                tools.push(tool);
-                validToolNames.push(name);
-            }
-        }
-        this.agent.state.tools = tools;
-        // Rebuild base system prompt with new tool set
-        this._baseSystemPrompt = this._rebuildSystemPrompt(validToolNames);
-        this.agent.state.systemPrompt = this._baseSystemPrompt;
-    }
-    /** Whether compaction or branch summarization is currently running */
-    get isCompacting() {
-        return (this._autoCompactionAbortController !== undefined ||
-            this._compactionAbortController !== undefined ||
-            this._branchSummaryAbortController !== undefined);
-    }
-    /** All messages including custom types like BashExecutionMessage */
-    get messages() {
-        return this.agent.state.messages;
-    }
-    /** Current steering mode */
-    get steeringMode() {
-        return this.agent.steeringMode;
-    }
-    /** Current follow-up mode */
-    get followUpMode() {
-        return this.agent.followUpMode;
-    }
-    /** Current session file path, or undefined if sessions are disabled */
-    get sessionFile() {
-        return this.sessionManager.getSessionFile();
-    }
-    /** Current session ID */
-    get sessionId() {
-        return this.sessionManager.getSessionId();
-    }
-    /** Current session display name, if set */
-    get sessionName() {
-        return this.sessionManager.getSessionName();
-    }
-    /** Scoped models for cycling (from --models flag) */
-    get scopedModels() {
-        return this._scopedModels;
-    }
-    /** Update scoped models for cycling */
-    setScopedModels(scopedModels) {
-        this._scopedModels = scopedModels;
-    }
-    /** File-based prompt templates */
-    get promptTemplates() {
-        return this._resourceLoader.getPrompts().prompts;
-    }
-    _normalizePromptSnippet(text) {
-        if (!text)
-            return undefined;
-        const oneLine = text
-            .replace(/[\r\n]+/g, " ")
-            .replace(/\s+/g, " ")
-            .trim();
-        return oneLine.length > 0 ? oneLine : undefined;
-    }
-    _normalizePromptGuidelines(guidelines) {
-        if (!guidelines || guidelines.length === 0) {
-            return [];
-        }
-        const unique = new Set();
-        for (const guideline of guidelines) {
-            const normalized = guideline.trim();
-            if (normalized.length > 0) {
-                unique.add(normalized);
-            }
-        }
-        return Array.from(unique);
-    }
-    _rebuildSystemPrompt(toolNames) {
-        const validToolNames = toolNames.filter((name) => this._toolRegistry.has(name));
-        const toolSnippets = {};
-        const promptGuidelines = [];
-        for (const name of validToolNames) {
-            const snippet = this._toolPromptSnippets.get(name);
-            if (snippet) {
-                toolSnippets[name] = snippet;
-            }
-            const toolGuidelines = this._toolPromptGuidelines.get(name);
-            if (toolGuidelines) {
-                promptGuidelines.push(...toolGuidelines);
-            }
-        }
-        const loaderSystemPrompt = this._resourceLoader.getSystemPrompt();
-        const loaderAppendSystemPrompt = this._resourceLoader.getAppendSystemPrompt();
-        const appendSystemPrompt = loaderAppendSystemPrompt.length > 0 ? loaderAppendSystemPrompt.join("\n\n") : undefined;
-        const loadedSkills = this._resourceLoader.getSkills().skills;
-        const loadedContextFiles = this._resourceLoader.getAgentsFiles().agentsFiles;
-        this._baseSystemPromptOptions = {
-            cwd: this._cwd,
-            selectedModel: this.model,
-            selectedThinkingLevel: this.thinkingLevel,
-            skills: loadedSkills,
-            contextFiles: loadedContextFiles,
-            customPrompt: loaderSystemPrompt,
-            appendSystemPrompt,
-            selectedTools: validToolNames,
-            excludedTools: this._excludedToolNames ? Array.from(this._excludedToolNames) : undefined,
-            toolSnippets,
-            promptGuidelines,
-        };
-        return buildSystemPrompt(this._baseSystemPromptOptions);
-    }
-    _refreshBaseSystemPromptFromActiveTools() {
-        this._baseSystemPrompt = this._rebuildSystemPrompt(this.getActiveToolNames());
-        this.agent.state.systemPrompt = this._baseSystemPrompt;
-    }
-    // =========================================================================
-    // Prompting
-    // =========================================================================
-    /**
-     * Send a prompt to the agent.
-     * - Handles extension commands (registered via pi.registerCommand) immediately, even during streaming
-     * - Expands file-based prompt templates by default
-     * - During streaming, queues via steer() or followUp() based on streamingBehavior option
-     * - Validates model and API key before sending (when not streaming)
-     * @throws Error if streaming and no streamingBehavior specified
-     * @throws Error if no model selected or no API key available (when not streaming)
-     */
-    async prompt(text, options) {
-        const expandPromptTemplates = options?.expandPromptTemplates ?? true;
-        const preflightResult = options?.preflightResult;
-        let messages;
-        try {
-            // Handle slash commands first (execute immediately, even during streaming).
-            // Builtin and extension commands manage their own LLM interaction via custom messages.
-            if (expandPromptTemplates && text.startsWith("/")) {
-                const handledBuiltin = await this._tryExecuteBuiltinSlashCommand(text);
-                if (handledBuiltin) {
-                    preflightResult?.(true);
-                    return;
-                }
-                const handledExtension = await this._tryExecuteExtensionCommand(text);
-                if (handledExtension) {
-                    preflightResult?.(true);
-                    return;
-                }
-            }
-            // 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", this.isStreaming ? options?.streamingBehavior : undefined);
-                if (inputResult.action === "handled") {
-                    preflightResult?.(true);
-                    return;
-                }
-                if (inputResult.action === "transform") {
-                    currentText = inputResult.text;
-                    currentImages = inputResult.images ?? currentImages;
-                }
-            }
-            // Expand skill commands (/skill:name args) and prompt templates (/template args)
-            let expandedText = currentText;
-            if (expandPromptTemplates) {
-                expandedText = this._expandSkillCommand(expandedText);
-                expandedText = expandPromptTemplate(expandedText, [...this.promptTemplates]);
-            }
-            // If streaming, queue via steer() or followUp() based on option
-            if (this.isStreaming) {
-                if (!options?.streamingBehavior) {
-                    throw new Error("Agent is already processing. Specify streamingBehavior ('steer' or 'followUp') to queue the message.");
-                }
-                if (options.streamingBehavior === "followUp") {
-                    await this._queueFollowUp(expandedText, currentImages);
-                }
-                else {
-                    await this._queueSteer(expandedText, currentImages);
-                }
-                preflightResult?.(true);
-                return;
-            }
-            // Flush any pending bash messages before the new prompt
-            this._flushPendingBashMessages();
-            // Validate model
-            if (!this.model) {
-                throw new Error(formatNoModelSelectedMessage());
-            }
-            // Defensive guard: a model that never resolved to a real provider
-            // (for example an unknown/unresolved model id that reached this path
-            // as a bare string) has no `provider`, which would otherwise fail deep
-            // in auth resolution as the confusing "No API key found for undefined".
-            // Surface a clear, accurate "unknown model" error instead.
-            const resolvedProvider = this.model.provider;
-            if (typeof resolvedProvider !== "string" || resolvedProvider.length === 0) {
-                throw new Error(formatUnresolvedModelMessage(this.model));
-            }
-            if (!this._modelRegistry.hasConfiguredAuth(this.model)) {
-                // A failed credential-store load (for example auth.json briefly locked
-                // by a concurrent process, or invalid JSON) leaves an empty in-memory
-                // credential set. That would otherwise be misreported here as
-                // "No API key found" even though the credentials exist on disk. Surface
-                // the real load failure instead so configured providers are not falsely
-                // reported as unauthenticated (issue #1431).
-                const authLoadError = this._modelRegistry.authStorage.getLoadError();
-                if (authLoadError) {
-                    throw new Error(formatAuthStorageLoadFailedMessage(this.model.provider, authLoadError), { cause: authLoadError });
-                }
-                const isOAuth = this._modelRegistry.isUsingOAuth(this.model);
-                if (isOAuth) {
-                    throw new Error(`Authentication failed for "${this.model.provider}". ` +
-                        `Credentials may have expired or network is unavailable. ` +
-                        `Run '/login ${this.model.provider}' to re-authenticate.`);
-                }
-                throw new Error(formatNoApiKeyFoundMessage(this.model.provider));
-            }
-            // Check if we need to compact before sending (catches aborted responses)
-            const lastAssistant = this._findLastAssistantMessage();
-            if (lastAssistant) {
-                await this._checkCompaction(lastAssistant, false);
-            }
-            // Build messages array (custom message if any, then user message)
-            messages = [];
-            // Add user message
-            const userContent = [{ type: "text", text: expandedText }];
-            if (currentImages) {
-                userContent.push(...currentImages);
-            }
-            messages.push({
-                role: "user",
-                content: userContent,
-                timestamp: Date.now(),
-            });
-            // Inject any pending "nextTurn" messages as context alongside the user message
-            for (const msg of this._pendingNextTurnMessages) {
-                messages.push(msg);
-            }
-            this._pendingNextTurnMessages = [];
-            // Emit before_agent_start extension event
-            const result = await this._extensionRunner.emitBeforeAgentStart(expandedText, currentImages, this._baseSystemPrompt, this._baseSystemPromptOptions);
-            // Add all custom messages from extensions
-            if (result?.messages) {
-                for (const msg of result.messages) {
-                    messages.push({
-                        role: "custom",
-                        customType: msg.customType,
-                        content: msg.content,
-                        display: msg.display,
-                        details: msg.details,
-                        timestamp: Date.now(),
-                    });
-                }
-            }
-            // Apply extension-modified system prompt, or reset to base
-            if (result?.systemPrompt) {
-                this.agent.state.systemPrompt = result.systemPrompt;
-            }
-            else {
-                // Ensure we're using the base prompt (in case previous turn had modifications)
-                this.agent.state.systemPrompt = this._baseSystemPrompt;
-            }
-        }
-        catch (error) {
-            preflightResult?.(false);
-            throw error;
-        }
-        if (!messages) {
-            return;
-        }
-        preflightResult?.(true);
-        await this._runAgentPrompt(messages);
-    }
-    async _runAgentPrompt(messages) {
-        await this.agent.prompt(messages);
-        await this.waitForRetry();
-        await this._continueQueuedAgentMessages();
-    }
-    async _continueQueuedAgentMessages() {
-        await this._agentEventQueue;
-        while (this.agent.hasQueuedMessages()) {
-            await this.agent.continue();
-            await this.waitForRetry();
-            await this._agentEventQueue;
-        }
-    }
-    /**
-     * Try to execute a built-in slash command. Returns true if command was found and executed.
-     */
-    async _tryExecuteBuiltinSlashCommand(text) {
-        const spaceIndex = text.indexOf(" ");
-        const commandName = spaceIndex === -1 ? text.slice(1) : text.slice(1, spaceIndex);
-        if (commandName !== ATOMIC_GUIDE_COMMAND_NAME)
-            return false;
-        const args = spaceIndex === -1 ? "" : text.slice(spaceIndex + 1);
-        const mode = normalizeAtomicGuideMode(args);
-        if (mode === "help" && this._extensionUIContext) {
-            const choice = await this._extensionUIContext.select("Atomic. Select where to start:", [
-                ...ATOMIC_GUIDE_HELP_CHOICES,
-            ]);
-            if (!choice || !isAtomicGuideHelpChoice(choice))
-                return true;
-            await this.sendCustomMessage({
-                customType: "atomic",
-                content: getAtomicGuideMessage(atomicGuideModeForChoice(choice), this._cwd),
-                display: true,
-            }, { triggerTurn: false });
-            return true;
-        }
-        await this.sendCustomMessage({
-            customType: "atomic",
-            content: getAtomicGuideMessage(mode, this._cwd),
-            display: true,
-        }, { triggerTurn: false });
-        return true;
-    }
-    /**
-     * Try to execute an extension command. Returns true if command was found and executed.
-     */
-    async _tryExecuteExtensionCommand(text) {
-        // Parse command name and args
-        const spaceIndex = text.indexOf(" ");
-        const commandName = spaceIndex === -1 ? text.slice(1) : text.slice(1, spaceIndex);
-        const args = spaceIndex === -1 ? "" : text.slice(spaceIndex + 1);
-        const command = this._extensionRunner.getCommand(commandName);
-        if (!command)
-            return false;
-        // Get command context from extension runner (includes session control methods)
-        const ctx = this._extensionRunner.createCommandContext();
-        try {
-            await command.handler(args, ctx);
-            return true;
-        }
-        catch (err) {
-            // Emit error via extension runner
-            this._extensionRunner.emitError({
-                extensionPath: `command:${commandName}`,
-                event: "command",
-                error: err instanceof Error ? err.message : String(err),
-            });
-            return true;
-        }
-    }
-    /**
-     * Expand skill commands (/skill:name args) to their full content.
-     * Returns the expanded text, or the original text if not a skill command or skill not found.
-     * Emits errors via extension runner if file read fails.
-     */
-    _expandSkillCommand(text) {
-        if (!text.startsWith("/skill:"))
-            return text;
-        const spaceIndex = text.indexOf(" ");
-        const skillName = spaceIndex === -1 ? text.slice(7) : text.slice(7, spaceIndex);
-        const args = spaceIndex === -1 ? "" : text.slice(spaceIndex + 1).trim();
-        const skill = this.resourceLoader.getSkills().skills.find((s) => s.name === skillName);
-        if (!skill)
-            return text; // Unknown skill, pass through
-        try {
-            const content = readFileSync(skill.filePath, "utf-8");
-            const body = stripFrontmatter(content).trim();
-            const skillBlock = `<skill name="${skill.name}" location="${skill.filePath}">\nReferences are relative to ${skill.baseDir}.\n\n${body}\n</skill>`;
-            return args ? `${skillBlock}\n\n${args}` : skillBlock;
-        }
-        catch (err) {
-            // Emit error like extension commands do
-            this._extensionRunner.emitError({
-                extensionPath: skill.filePath,
-                event: "skill_expansion",
-                error: err instanceof Error ? err.message : String(err),
-            });
-            return text; // Return original on error
-        }
-    }
-    /**
-     * Queue a steering message while the agent is running.
-     * Delivered after the current assistant turn finishes executing its tool calls,
-     * before the next LLM call.
-     * Expands skill commands and prompt templates. Errors on extension commands.
-     * @param images Optional image attachments to include with the message
-     * @throws Error if text is an extension command
-     */
-    async steer(text, images) {
-        // Check for extension commands (cannot be queued)
-        if (text.startsWith("/")) {
-            this._throwIfExtensionCommand(text);
-        }
-        // Expand skill commands and prompt templates
-        let expandedText = this._expandSkillCommand(text);
-        expandedText = expandPromptTemplate(expandedText, [...this.promptTemplates]);
-        await this._queueSteer(expandedText, images);
-    }
-    /**
-     * Queue a follow-up message to be processed after the agent finishes.
-     * Delivered only when agent has no more tool calls or steering messages.
-     * Expands skill commands and prompt templates. Errors on extension commands.
-     * @param images Optional image attachments to include with the message
-     * @throws Error if text is an extension command
-     */
-    async followUp(text, images) {
-        // Check for extension commands (cannot be queued)
-        if (text.startsWith("/")) {
-            this._throwIfExtensionCommand(text);
-        }
-        // Expand skill commands and prompt templates
-        let expandedText = this._expandSkillCommand(text);
-        expandedText = expandPromptTemplate(expandedText, [...this.promptTemplates]);
-        await this._queueFollowUp(expandedText, images);
-    }
-    /**
-     * Internal: Queue a steering message (already expanded, no extension command check).
-     */
-    async _queueSteer(text, images) {
-        this._steeringMessages.push(text);
-        this._emitQueueUpdate();
-        const content = [{ type: "text", text }];
-        if (images) {
-            content.push(...images);
-        }
-        this._queueAgentMessage({
-            role: "user",
-            content,
-            timestamp: Date.now(),
-        }, "steer");
-    }
-    /**
-     * Internal: Queue a follow-up message (already expanded, no extension command check).
-     */
-    async _queueFollowUp(text, images) {
-        this._followUpMessages.push(text);
-        this._emitQueueUpdate();
-        const content = [{ type: "text", text }];
-        if (images) {
-            content.push(...images);
-        }
-        this._queueAgentMessage({
-            role: "user",
-            content,
-            timestamp: Date.now(),
-        }, "followUp");
-    }
-    /**
-     * Throw an error if the text is an extension command.
-     */
-    _throwIfExtensionCommand(text) {
-        const spaceIndex = text.indexOf(" ");
-        const commandName = spaceIndex === -1 ? text.slice(1) : text.slice(1, spaceIndex);
-        const command = this._extensionRunner.getCommand(commandName);
-        if (command) {
-            throw new Error(`Extension command "/${commandName}" cannot be queued. Use prompt() or execute the command when not streaming.`);
-        }
-    }
-    /**
-     * Send a custom message to the session. Creates a CustomMessageEntry.
-     *
-     * Handles five cases:
-     * - Streaming + interrupt trigger: aborts the active run and starts an immediate custom-message turn
-     * - Streaming + explicit display-only context exclusion: appends to state/session, no turn and no queue
-     * - Streaming otherwise: queues message, processed when loop pulls from queue
-     * - Not streaming + triggerTurn: appends to state/session, starts new turn
-     * - Not streaming + no trigger: appends to state/session, no turn
-     *
-     * @param message Custom message with customType, content, display, details
-     * @param options.triggerTurn If true and not streaming, triggers a new LLM turn
-     * @param options.deliverAs Delivery mode: "steer", "followUp", "nextTurn", or "interrupt"
-     */
-    async sendCustomMessage(message, options) {
-        const appMessage = {
-            role: "custom",
-            customType: message.customType,
-            content: message.content,
-            display: message.display,
-            details: message.details,
-            timestamp: Date.now(),
-            ...(options?.excludeFromContext === true ? { excludeFromContext: true } : {}),
-        };
-        if (options?.deliverAs === "nextTurn") {
-            this._pendingNextTurnMessages.push(appMessage);
-        }
-        else if (options?.deliverAs === "interrupt" && options.triggerTurn) {
-            await this._enqueueInterruptCustomMessage(appMessage, options);
-        }
-        else if (this.isStreaming && options?.excludeFromContext === true && options.triggerTurn !== true && options.deliverAs === undefined) {
-            this._appendCustomMessage(appMessage);
-        }
-        else if (this.isStreaming) {
-            this._queueAgentMessage(appMessage, options?.deliverAs === "followUp" ? "followUp" : "steer");
-        }
-        else if (options?.triggerTurn) {
-            await this._runAgentPrompt(appMessage);
-        }
-        else {
-            this._appendCustomMessage(appMessage);
-        }
-    }
-    _appendCustomMessage(message) {
-        this.agent.state.messages.push(message);
-        this.sessionManager.appendCustomMessageEntry(message.customType, message.content, message.display, message.details, customMessageExcludesContext(message));
-        this._emit({ type: "message_start", message });
-        this._emit({ type: "message_end", message });
-    }
-    _enqueueInterruptCustomMessage(message, options) {
-        this._pendingInterruptDeliveries += 1;
-        // Establish the hold synchronously when the interrupt is enqueued, not when
-        // the serialized delivery callback later starts. Callers commonly fire and
-        // forget sendCustomMessage(), then queue additional steer/follow-up messages
-        // before the promise chain gets a microtask; those messages must be captured
-        // in the active interrupt hold instead of pi-agent-core's live queues.
-        this._ensureActiveInterruptQueueHold();
-        const delivery = this._interruptDeliveryQueue.then(async () => {
-            try {
-                await this._sendInterruptCustomMessageNow(message, options);
-            }
-            finally {
-                this._pendingInterruptDeliveries -= 1;
-                if (this._pendingInterruptDeliveries === 0) {
-                    this._restoreAndClearActiveInterruptQueueHold();
-                }
-            }
-        });
-        this._interruptDeliveryQueue = delivery.catch(() => undefined);
-        return delivery;
-    }
-    async _sendInterruptCustomMessageNow(message, options) {
-        this.abortRetry();
-        this._ensureActiveInterruptQueueHold();
-        if (this.isStreaming) {
-            const previousAbortMessage = this._activeInterruptAbortMessage;
-            this._activeInterruptAbortMessage = normalizeInterruptAbortMessage(options?.interruptAbortMessage);
-            try {
-                this.agent.abort();
-                await this.agent.waitForIdle();
-                await this._agentEventQueue;
-            }
-            finally {
-                this._activeInterruptAbortMessage = previousAbortMessage;
-            }
-        }
-        await this.agent.prompt(message);
-    }
-    _ensureActiveInterruptQueueHold() {
-        if (this._activeInterruptQueueHold !== undefined) {
-            return this._activeInterruptQueueHold;
-        }
-        const drained = this._drainQueuedAgentMessages();
-        this._activeInterruptQueueHold = {
-            steering: [...drained.steering],
-            followUp: [...drained.followUp],
-        };
-        return this._activeInterruptQueueHold;
-    }
-    _restoreAndClearActiveInterruptQueueHold() {
-        const hold = this._activeInterruptQueueHold;
-        if (hold === undefined) {
-            return;
-        }
-        const currentCoreQueues = this._drainQueuedAgentMessages();
-        this._restoreQueuedAgentMessages({
-            steering: [...hold.steering, ...currentCoreQueues.steering],
-            followUp: [...hold.followUp, ...currentCoreQueues.followUp],
-        });
-        this._activeInterruptQueueHold = undefined;
-    }
-    _queueAgentMessage(message, delivery) {
-        const hold = this._activeInterruptQueueHold;
-        if (hold !== undefined) {
-            if (delivery === "followUp") {
-                hold.followUp.push(message);
-            }
-            else {
-                hold.steering.push(message);
-            }
-            return;
-        }
-        if (delivery === "followUp") {
-            this.agent.followUp(message);
-        }
-        else {
-            this.agent.steer(message);
-        }
-    }
-    _drainQueuedAgentMessages() {
-        // pi-agent-core exposes public clear methods but no public drain/restore pair.
-        // Interrupts need to prevent the aborting run from consuming queued steer/follow-up
-        // messages while still preserving those queues for a later turn.
-        const agentWithQueues = this.agent;
-        return {
-            steering: drainAgentMessageQueue(agentWithQueues.steeringQueue),
-            followUp: drainAgentMessageQueue(agentWithQueues.followUpQueue),
-        };
-    }
-    _restoreQueuedAgentMessages(queues) {
-        for (const message of queues.steering) {
-            this.agent.steer(message);
-        }
-        for (const message of queues.followUp) {
-            this.agent.followUp(message);
-        }
-    }
-    /**
-     * Send a user message to the agent. Always triggers a turn.
-     * When the agent is streaming, use deliverAs to specify how to queue the message.
-     *
-     * @param content User message content (string or content array)
-     * @param options.deliverAs Delivery mode when streaming: "steer" or "followUp"
-     */
-    async sendUserMessage(content, options) {
-        // Normalize content to text string + optional images
-        let text;
-        let images;
-        if (typeof content === "string") {
-            text = content;
-        }
-        else {
-            const textParts = [];
-            images = [];
-            for (const part of content) {
-                if (part.type === "text") {
-                    textParts.push(part.text);
-                }
-                else {
-                    images.push(part);
-                }
-            }
-            text = textParts.join("\n");
-            if (images.length === 0)
-                images = undefined;
-        }
-        // Use prompt() with expandPromptTemplates: false to skip command handling and template expansion
-        await this.prompt(text, {
-            expandPromptTemplates: false,
-            streamingBehavior: options?.deliverAs,
-            images,
-            source: "extension",
-        });
-    }
-    /**
-     * Clear all queued messages and return them.
-     * Useful for restoring to editor when user aborts.
-     * @returns Object with steering and followUp arrays
-     */
-    clearQueue() {
-        const steering = [...this._steeringMessages];
-        const followUp = [...this._followUpMessages];
-        this._steeringMessages = [];
-        this._followUpMessages = [];
-        this.agent.clearAllQueues();
-        if (this._activeInterruptQueueHold !== undefined) {
-            this._activeInterruptQueueHold.steering.length = 0;
-            this._activeInterruptQueueHold.followUp.length = 0;
-        }
-        this._emitQueueUpdate();
-        return { steering, followUp };
-    }
-    /** Number of pending messages (includes both steering and follow-up) */
-    get pendingMessageCount() {
-        return this._steeringMessages.length + this._followUpMessages.length;
-    }
-    /** Get pending steering messages (read-only) */
-    getSteeringMessages() {
-        return this._steeringMessages;
-    }
-    /** Get pending follow-up messages (read-only) */
-    getFollowUpMessages() {
-        return this._followUpMessages;
-    }
-    get resourceLoader() {
-        return this._resourceLoader;
-    }
-    /**
-     * Abort current operation and wait for agent to become idle.
-     */
-    async abort() {
-        this.abortRetry();
-        this.agent.abort();
-        await this.agent.waitForIdle();
-    }
-    // =========================================================================
-    // Model Management
-    // =========================================================================
-    _emitModelChanged(nextModel, previousModel, source) {
-        if (modelsAreEqual(previousModel, nextModel))
-            return;
-        this._emit({
-            type: "model_changed",
-            model: nextModel,
-            previousModel,
-            source,
-        });
-    }
-    async _emitModelSelect(nextModel, previousModel, source) {
-        if (modelsAreEqual(previousModel, nextModel))
-            return;
-        await this._extensionRunner.emit({
-            type: "model_select",
-            model: nextModel,
-            previousModel,
-            source,
-        });
-    }
-    /**
-     * Set model directly.
-     * Validates that auth is configured, saves to session and settings.
-     * @throws Error if no auth is configured for the model
-     */
-    async setModel(model) {
-        if (!this._modelRegistry.hasConfiguredAuth(model)) {
-            throw new Error(`No API key for ${model.provider}/${model.id}`);
-        }
-        const previousModel = this.model;
-        const thinkingLevel = this._getThinkingLevelForModelSwitch();
-        const nextModel = this._withContextWindowForModelSwitch(model);
-        this.agent.state.model = nextModel;
-        this.sessionManager.appendModelChange(nextModel.provider, nextModel.id);
-        this._appendContextWindowChangeIfChanged(previousModel, nextModel);
-        this.settingsManager.setDefaultModelAndProvider(nextModel.provider, nextModel.id);
-        // Re-clamp thinking level for new model's capabilities
-        this.setThinkingLevel(thinkingLevel);
-        this._refreshBaseSystemPromptFromActiveTools();
-        this._emitModelChanged(nextModel, previousModel, "set");
-        await this._emitModelSelect(nextModel, previousModel, "set");
-    }
-    /**
-     * Cycle to next/previous model.
-     * Uses scoped models (from --models flag) if available, otherwise all available models.
-     * @param direction - "forward" (default) or "backward"
-     * @returns The new model info, or undefined if only one model available
-     */
-    async cycleModel(direction = "forward") {
-        if (this._scopedModels.length > 0) {
-            return this._cycleScopedModel(direction);
-        }
-        return this._cycleAvailableModel(direction);
-    }
-    async _cycleScopedModel(direction) {
-        const scopedModels = this._scopedModels.filter((scoped) => this._modelRegistry.hasConfiguredAuth(scoped.model));
-        if (scopedModels.length <= 1)
-            return undefined;
-        const currentModel = this.model;
-        let currentIndex = scopedModels.findIndex((sm) => modelsAreEqual(sm.model, currentModel));
-        if (currentIndex === -1)
-            currentIndex = 0;
-        const len = scopedModels.length;
-        const nextIndex = direction === "forward" ? (currentIndex + 1) % len : (currentIndex - 1 + len) % len;
-        const next = scopedModels[nextIndex];
-        const thinkingLevel = this._getThinkingLevelForModelSwitch(next.thinkingLevel);
-        const nextModel = this._withContextWindowForModelSwitch(next.model);
-        // Apply model
-        this.agent.state.model = nextModel;
-        this.sessionManager.appendModelChange(nextModel.provider, nextModel.id);
-        this._appendContextWindowChangeIfChanged(currentModel, nextModel);
-        this.settingsManager.setDefaultModelAndProvider(nextModel.provider, nextModel.id);
-        // Apply thinking level.
-        // - Explicit scoped model thinking level overrides current session level
-        // - Undefined scoped model thinking level inherits the current session preference
-        // setThinkingLevel clamps to model capabilities.
-        this.setThinkingLevel(thinkingLevel);
-        this._refreshBaseSystemPromptFromActiveTools();
-        this._emitModelChanged(nextModel, currentModel, "cycle");
-        await this._emitModelSelect(nextModel, currentModel, "cycle");
-        return { model: nextModel, thinkingLevel: this.thinkingLevel, isScoped: true };
-    }
-    async _cycleAvailableModel(direction) {
-        const availableModels = await this._modelRegistry.getAvailable();
-        if (availableModels.length <= 1)
-            return undefined;
-        const currentModel = this.model;
-        let currentIndex = availableModels.findIndex((m) => modelsAreEqual(m, currentModel));
-        if (currentIndex === -1)
-            currentIndex = 0;
-        const len = availableModels.length;
-        const nextIndex = direction === "forward" ? (currentIndex + 1) % len : (currentIndex - 1 + len) % len;
-        const selectedModel = this._withContextWindowForModelSwitch(availableModels[nextIndex]);
-        const thinkingLevel = this._getThinkingLevelForModelSwitch();
-        this.agent.state.model = selectedModel;
-        this.sessionManager.appendModelChange(selectedModel.provider, selectedModel.id);
-        this._appendContextWindowChangeIfChanged(currentModel, selectedModel);
-        this.settingsManager.setDefaultModelAndProvider(selectedModel.provider, selectedModel.id);
-        // Re-clamp thinking level for new model's capabilities
-        this.setThinkingLevel(thinkingLevel);
-        this._refreshBaseSystemPromptFromActiveTools();
-        this._emitModelChanged(selectedModel, currentModel, "cycle");
-        await this._emitModelSelect(selectedModel, currentModel, "cycle");
-        return { model: selectedModel, thinkingLevel: this.thinkingLevel, isScoped: false };
-    }
-    // =========================================================================
-    // Thinking Level Management
-    // =========================================================================
-    /**
-     * Set thinking level.
-     * Clamps to model capabilities based on available thinking levels.
-     * Saves to session and settings only if the level actually changes.
-     */
-    setThinkingLevel(level) {
-        const availableLevels = this.getAvailableThinkingLevels();
-        const effectiveLevel = availableLevels.includes(level) ? level : this._clampThinkingLevel(level, availableLevels);
-        // Only persist if actually changing
-        const previousLevel = this.agent.state.thinkingLevel;
-        const isChanging = effectiveLevel !== previousLevel;
-        this.agent.state.thinkingLevel = effectiveLevel;
-        if (isChanging) {
-            this.sessionManager.appendThinkingLevelChange(effectiveLevel);
-            this._refreshBaseSystemPromptFromActiveTools();
-            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,
-            });
-        }
-    }
-    /**
-     * Cycle to next thinking level.
-     * @returns New level, or undefined if model doesn't support thinking
-     */
-    cycleThinkingLevel() {
-        if (!this.supportsThinking())
-            return undefined;
-        const levels = this.getAvailableThinkingLevels();
-        const currentIndex = levels.indexOf(this.thinkingLevel);
-        const nextIndex = (currentIndex + 1) % levels.length;
-        const nextLevel = levels[nextIndex];
-        this.setThinkingLevel(nextLevel);
-        return nextLevel;
-    }
-    /**
-     * Get available thinking levels for current model.
-     * The provider will clamp to what the specific model supports internally.
-     */
-    getAvailableThinkingLevels() {
-        if (!this.model)
-            return THINKING_LEVELS;
-        return getSupportedThinkingLevels(this.model);
-    }
-    /**
-     * Check if current model supports thinking/reasoning.
-     */
-    supportsThinking() {
-        return !!this.model?.reasoning;
-    }
-    _getThinkingLevelForModelSwitch(explicitLevel) {
-        if (explicitLevel !== undefined) {
-            return explicitLevel;
-        }
-        if (!this.supportsThinking()) {
-            return this.settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL;
-        }
-        return this.thinkingLevel;
-    }
-    _clampThinkingLevel(level, _availableLevels) {
-        return this.model ? clampThinkingLevel(this.model, level) : "off";
-    }
-    // =========================================================================
-    // Context Window Management
-    // =========================================================================
-    getAvailableContextWindows() {
-        return this.model ? getSupportedContextWindows(this.model) : [];
-    }
-    supportsContextWindowSelection() {
-        return this.getAvailableContextWindows().length > 1;
-    }
-    setContextWindow(contextWindow, options = {}) {
-        if (!this.model) {
-            throw new Error("No model selected");
-        }
-        const selected = selectContextWindow(this.model, contextWindow, COPILOT_CONTEXT_WINDOW_SELECTION_OPTIONS);
-        if ("error" in selected) {
-            throw new Error(selected.error);
-        }
-        const previousContextWindow = this.model.contextWindow;
-        const isChanging = previousContextWindow !== selected.contextWindow;
-        this.agent.state.model = selected.model;
-        if (isChanging) {
-            this.sessionManager.appendContextWindowChange(selected.contextWindow);
-            this._emit({ type: "context_window_changed", contextWindow: selected.contextWindow });
-        }
-        if (options.persistDefault === true) {
-            this.settingsManager.setDefaultContextWindowForModel(selected.model.provider, selected.model.id, selected.contextWindow);
-        }
-    }
-    _withContextWindowForModelSwitch(model) {
-        // A source model's scalar contextWindow can be its natural default (for example a 1m-default
-        // model). Do not treat that alone as an opt-in to larger windows on a 400k-default target.
-        const settingsDefaultContextWindow = this._getSettingsContextWindowRequestForModel(model)?.contextWindow;
-        const candidates = [];
-        const targetDefaultContextWindow = getModelDefaultContextWindow(model);
-        if (model.contextWindow !== targetDefaultContextWindow) {
-            // Preserve an explicit context-window selection already applied to the target model
-            // (for example a caller passing selectContextWindow(target, 1m).model).
-            candidates.push(model.contextWindow);
-        }
-        const currentModel = this.model;
-        if (currentModel && this._shouldCarryCurrentContextWindowForModelSwitch(currentModel, settingsDefaultContextWindow)) {
-            candidates.push(currentModel.contextWindow);
-        }
-        if (settingsDefaultContextWindow !== undefined) {
-            candidates.push(settingsDefaultContextWindow);
-        }
-        candidates.push(targetDefaultContextWindow);
-        for (const candidate of candidates) {
-            const selected = selectContextWindow(model, candidate, COPILOT_CONTEXT_WINDOW_SELECTION_OPTIONS);
-            if (!("error" in selected))
-                return selected.model;
-        }
-        return model;
-    }
-    _shouldCarryCurrentContextWindowForModelSwitch(currentModel, settingsDefaultContextWindow) {
-        if (currentModel.contextWindow !== getModelDefaultContextWindow(currentModel)) {
-            return true;
-        }
-        if (this.sessionManager.getBranch().some((entry) => entry.type === "context_window_change")) {
-            return true;
-        }
-        return (settingsDefaultContextWindow !== undefined &&
-            currentModel.contextWindow === settingsDefaultContextWindow &&
-            getSupportedContextWindows(currentModel).includes(settingsDefaultContextWindow));
-    }
-    _getSettingsContextWindowRequestForModel(model) {
-        const modelContextWindow = this.settingsManager.getDefaultContextWindowForModel(model.provider, model.id);
-        if (modelContextWindow !== undefined) {
-            return { contextWindow: modelContextWindow, source: "model-settings" };
-        }
-        const globalContextWindow = this.settingsManager.getDefaultContextWindow();
-        return globalContextWindow === undefined
-            ? undefined
-            : { contextWindow: globalContextWindow, source: "global-settings" };
-    }
-    _getContextWindowReplayForModel(model, requestedContextWindow, source) {
-        if (requestedContextWindow !== undefined) {
-            const selected = selectContextWindow(model, requestedContextWindow, COPILOT_CONTEXT_WINDOW_SELECTION_OPTIONS);
-            if (!("error" in selected)) {
-                return { model: selected.model, contextWindow: selected.contextWindow, wouldWarn: false };
-            }
-            return this._getDefaultContextWindowReplayForModel(model, source !== "global-settings");
-        }
-        return this._getDefaultContextWindowReplayForModel(model, false);
-    }
-    _getDefaultContextWindowReplayForModel(model, wouldWarn) {
-        const defaultContextWindow = getModelDefaultContextWindow(model);
-        const selected = selectContextWindow(model, defaultContextWindow, COPILOT_CONTEXT_WINDOW_SELECTION_OPTIONS);
-        if (!("error" in selected)) {
-            return { model: selected.model, contextWindow: selected.contextWindow, wouldWarn };
-        }
-        return {
-            model: { ...model, contextWindow: defaultContextWindow, defaultContextWindow },
-            contextWindow: defaultContextWindow,
-            wouldWarn,
-        };
-    }
-    _getResumeContextWindowReplayForModel(model) {
-        const sessionContext = this.sessionManager.buildSessionContext();
-        if (sessionContext.contextWindow !== undefined) {
-            return this._getContextWindowReplayForModel(model, sessionContext.contextWindow, "session");
-        }
-        const settingsContextWindow = this._getSettingsContextWindowRequestForModel(model);
-        return this._getContextWindowReplayForModel(model, settingsContextWindow?.contextWindow, settingsContextWindow?.source);
-    }
-    _applyContextWindowReplay(contextWindow) {
-        if (!this.model)
-            return;
-        const previousContextWindow = this.model.contextWindow;
-        const settingsContextWindow = this._getSettingsContextWindowRequestForModel(this.model);
-        const requestedContextWindow = contextWindow ?? settingsContextWindow?.contextWindow;
-        const source = contextWindow !== undefined ? "session" : settingsContextWindow?.source;
-        const replay = this._getContextWindowReplayForModel(this.model, requestedContextWindow, source);
-        this.agent.state.model = replay.model;
-        if (previousContextWindow !== replay.contextWindow) {
-            this._emit({ type: "context_window_changed", contextWindow: replay.contextWindow });
-        }
-    }
-    _appendContextWindowChangeIfChanged(previousModel, nextModel) {
-        const replay = this._getResumeContextWindowReplayForModel(nextModel);
-        if (!replay.wouldWarn && nextModel.contextWindow === replay.contextWindow)
-            return;
-        this.sessionManager.appendContextWindowChange(nextModel.contextWindow);
-        if (previousModel?.contextWindow !== nextModel.contextWindow) {
-            this._emit({ type: "context_window_changed", contextWindow: nextModel.contextWindow });
-        }
-    }
-    // =========================================================================
-    // Queue Mode Management
-    // =========================================================================
-    /**
-     * Set steering message mode.
-     * Saves to settings.
-     */
-    setSteeringMode(mode) {
-        this.agent.steeringMode = mode;
-        this.settingsManager.setSteeringMode(mode);
-    }
-    /**
-     * Set follow-up message mode.
-     * Saves to settings.
-     */
-    setFollowUpMode(mode) {
-        this.agent.followUpMode = mode;
-        this.settingsManager.setFollowUpMode(mode);
-    }
-    // =========================================================================
-    // Compaction
-    // =========================================================================
-    /**
-     * Apply validated logical deletions and rebuild active agent context.
-     * Retained transcript entries/content blocks stay verbatim.
-     */
-    async _applyContextVerbatimCompaction(options) {
-        if (!this.model) {
-            throw new Error(formatNoModelSelectedMessage());
-        }
-        // Capture the narrowed model now (control-flow narrowing holds immediately after the
-        // guard) so the lazy planner-fallback closure below can use a non-undefined model.
-        const model = this.model;
-        const compactionThinkingLevel = this.thinkingLevel;
-        const pathEntries = this.sessionManager.getBranch();
-        const settings = this.settingsManager.getCompactionSettings();
-        const preparation = prepareContextCompaction(pathEntries, settings, {
-            ...(options.compression_ratio === undefined ? {} : { compression_ratio: options.compression_ratio }),
-            ...(options.preserve_recent === undefined ? {} : { preserve_recent: options.preserve_recent }),
-            ...(options.query === undefined ? {} : { query: options.query }),
-        });
-        if (!preparation) {
-            return undefined;
-        }
-        const parameters = preparation.parameters;
-        // Planner fallback used when no extension supplies a deletionRequest. Auth is resolved
-        // lazily here so extension-provided deletion requests keep working offline. Returns
-        // undefined when auth is unavailable (auto-mode resolvers), signaling a no-op compaction.
-        const runPlanner = async () => {
-            const auth = await options.resolvePlannerAuth();
-            if (!auth)
-                return undefined;
-            return runContextCompact(preparation, model, auth.apiKey, auth.headers, options.abortController.signal, compactionThinkingLevel);
-        };
-        // Emit session_before_compact to allow extensions to cancel or provide a deletion request.
-        // This happens BEFORE any auth resolution so local extension deletion requests work
-        // without configured API credentials.
-        let fromExtension = false;
-        let validated;
-        if (this._extensionRunner.hasHandlers("session_before_compact")) {
-            // Deep-clone the preparation only when a before-compact handler actually exists. Extensions
-            // receive an isolated, frozen snapshot so they cannot mutate protection metadata
-            // (protectedEntryIds, entry .protected flags, etc.) on the internal preparation used for
-            // validation. Building it lazily avoids deep-cloning the transcript — largest exactly when
-            // compaction fires — on the common no-extension path.
-            let extensionPreparation;
-            try {
-                extensionPreparation = deepFreeze(structuredClone(preparation));
-            }
-            catch (error) {
-                // structuredClone only throws if an entry carries a non-cloneable value (a function or a
-                // class instance). Transcript entries are plain data today, so this guards a latent
-                // invariant: surface a clear error instead of letting a raw DataCloneError abort an
-                // otherwise-viable compaction.
-                throw new Error(`Failed to snapshot transcript for compaction extensions: ${error instanceof Error ? error.message : String(error)}`);
-            }
-            const hookResult = (await this._extensionRunner.emit({
-                type: "session_before_compact",
-                reason: options.reason,
-                parameters,
-                preparation: extensionPreparation,
-                branchEntries: pathEntries,
-                signal: options.abortController.signal,
-            }));
-            if (hookResult?.cancel) {
-                throw new Error("Compaction cancelled");
-            }
-            if (hookResult?.deletionRequest) {
-                const extensionDeletionRequest = hookResult.deletionRequest;
-                // Reject empty deletion requests before any side effects (backup, append, rebuild).
-                if (!Array.isArray(extensionDeletionRequest.deletions) || extensionDeletionRequest.deletions.length === 0) {
-                    throw new Error("No safe context deletions proposed by extension");
-                }
-                // Validate against the internal transcript snapshot, not the extension-facing clone.
-                // Auth is NOT resolved here — local extension deletion requests work offline.
-                validated = validateContextDeletionRequest(extensionDeletionRequest, preparation.transcript);
-                // Reject if reconciliation reduced deletions to zero.
-                if (validated.deletedTargets.length === 0) {
-                    throw new Error("No safe context deletions proposed by extension");
-                }
-                fromExtension = true;
-            }
-        }
-        // Planner fallback shared by both paths: no before-compact handler at all, or a handler that
-        // observed without supplying a deletionRequest. Resolves auth lazily; undefined means auth is
-        // unavailable (auto-mode resolvers), so compaction is a no-op.
-        if (!validated) {
-            const plannerResult = await runPlanner();
-            if (!plannerResult) {
-                return undefined;
-            }
-            validated = plannerResult;
-        }
-        if (options.abortController.signal.aborted) {
-            throw new Error("Compaction cancelled");
-        }
-        const backupPath = this.sessionManager.writeBackupSnapshot(options.backupLabel);
-        const compactionEntryId = this.sessionManager.appendContextCompaction(validated.deletedTargets, validated.protectedEntryIds, validated.stats, backupPath);
-        const sessionContext = this.sessionManager.buildSessionContext();
-        this.agent.state.messages = sessionContext.messages;
-        const result = {
-            ...validated,
-            promptVersion: 1,
-            parameters,
-            ...(backupPath ? { backupPath } : {}),
-        };
-        // Emit session_compact so extensions can observe the validated result. This is a pure
-        // observation hook fired AFTER the compaction has been committed (backup written,
-        // context_compaction entry persisted, active context rebuilt). A misbehaving observer must
-        // never turn a successful, already-persisted compaction into a reported failure, so any
-        // throw is routed to the non-fatal extension-error channel and compaction still reports
-        // success.
-        const contextCompactionEntry = this.sessionManager.getEntry(compactionEntryId);
-        try {
-            await this._extensionRunner.emit({
-                type: "session_compact",
-                reason: options.reason,
-                parameters,
-                result,
-                contextCompactionEntry,
-                fromExtension,
-            });
-        }
-        catch (error) {
-            this._extensionRunner.emitError({
-                extensionPath: "<session_compact>",
-                event: "session_compact",
-                error: error instanceof Error ? error.message : String(error),
-                stack: error instanceof Error ? error.stack : undefined,
-            });
-        }
-        return result;
-    }
-    /**
-     * Manually compact the session context using deletion-only verbatim context compaction.
-     * Aborts current agent operation first.
-     */
-    async compact(options = {}) {
-        this._disconnectFromAgent();
-        await this.abort();
-        this._compactionAbortController = new AbortController();
-        this._emit({ type: "compaction_start", reason: "manual" });
-        try {
-            if (!this.model) {
-                throw new Error(formatNoModelSelectedMessage());
-            }
-            // Auth is resolved lazily: only called when the planner fallback is needed.
-            // Extensions that provide a deletionRequest work without configured credentials.
-            const model = this.model;
-            const result = await this._applyContextVerbatimCompaction({
-                resolvePlannerAuth: () => this._getRequiredRequestAuth(model),
-                abortController: this._compactionAbortController,
-                backupLabel: "compact",
-                reason: "manual",
-                ...(options.compression_ratio === undefined ? {} : { compression_ratio: options.compression_ratio }),
-                ...(options.preserve_recent === undefined ? {} : { preserve_recent: options.preserve_recent }),
-                ...(options.query === undefined ? {} : { query: options.query }),
-            });
-            if (!result) {
-                throw new Error("Nothing to compact (session too small)");
-            }
-            this._emit({
-                type: "compaction_end",
-                reason: "manual",
-                result,
-                aborted: false,
-                willRetry: false,
-            });
-            return result;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            const aborted = message === "Compaction cancelled" || (error instanceof Error && error.name === "AbortError");
-            this._emit({
-                type: "compaction_end",
-                reason: "manual",
-                result: undefined,
-                aborted,
-                willRetry: false,
-                errorMessage: aborted ? undefined : `Compaction failed: ${message}`,
-            });
-            throw error;
-        }
-        finally {
-            this._compactionAbortController = undefined;
-            this._reconnectToAgent();
-        }
-    }
-    /**
-     * Manually compact the session context by applying validated logical deletions.
-     * Retained transcript entries/content blocks stay verbatim; no user prompt text is accepted.
-     */
-    async contextCompact() {
-        this._disconnectFromAgent();
-        await this.abort();
-        this._compactionAbortController = new AbortController();
-        this._emit({ type: "context_compaction_start", reason: "manual" });
-        try {
-            if (!this.model) {
-                throw new Error(formatNoModelSelectedMessage());
-            }
-            // Auth is resolved lazily: only called when the planner fallback is needed.
-            // Extensions that provide a deletionRequest work without configured credentials.
-            const model = this.model;
-            const result = await this._applyContextVerbatimCompaction({
-                resolvePlannerAuth: () => this._getRequiredRequestAuth(model),
-                abortController: this._compactionAbortController,
-                backupLabel: "context-compact",
-                reason: "manual",
-            });
-            if (!result) {
-                throw new Error("Nothing to context-compact (session too small)");
-            }
-            this._emit({
-                type: "context_compaction_end",
-                reason: "manual",
-                result,
-                aborted: false,
-                willRetry: false,
-            });
-            return result;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            const aborted = message === "Compaction cancelled" || (error instanceof Error && error.name === "AbortError");
-            this._emit({
-                type: "context_compaction_end",
-                reason: "manual",
-                result: undefined,
-                aborted,
-                willRetry: false,
-                errorMessage: aborted ? undefined : `Context compaction failed: ${message}`,
-            });
-            throw error;
-        }
-        finally {
-            this._compactionAbortController = undefined;
-            this._reconnectToAgent();
-        }
-    }
-    /**
-     * Cancel in-progress compaction (manual or auto).
-     */
-    abortCompaction() {
-        this._compactionAbortController?.abort();
-        this._autoCompactionAbortController?.abort();
-    }
-    /**
-     * Cancel in-progress branch summarization.
-     */
-    abortBranchSummary() {
-        this._branchSummaryAbortController?.abort();
-    }
-    /**
-     * Check if compaction is needed and run it.
-     * 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
-     * 2. Threshold: Context over threshold, compact, resume queued active-turn work if present; otherwise wait for user
-     *
-     * @param assistantMessage The assistant message to check
-     * @param skipAbortedCheck If false, include aborted messages (for pre-prompt check). Default: true
-     */
-    async _checkCompaction(assistantMessage, skipAbortedCheck = true) {
-        const settings = this.settingsManager.getCompactionSettings();
-        if (!settings.enabled)
-            return;
-        // Skip if message was aborted (user cancelled) - unless skipAbortedCheck is false
-        if (skipAbortedCheck && assistantMessage.stopReason === "aborted")
-            return;
-        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)
-        // to a larger-context model (e.g. codex) - the overflow error from the old model
-        // shouldn't trigger compaction for the new model.
-        const sameModel = this.model && assistantMessage.provider === this.model.provider && assistantMessage.model === this.model.id;
-        // Skip compaction checks if this assistant message is older than the latest
-        // compaction boundary. This prevents a stale pre-compaction usage/error
-        // from retriggering compaction on the first prompt after compaction.
-        const compactionBoundaryEntry = getLatestCompactionBoundaryEntry(this.sessionManager.getBranch());
-        const assistantIsFromBeforeCompactionBoundary = compactionBoundaryEntry !== null &&
-            assistantMessage.timestamp <= new Date(compactionBoundaryEntry.timestamp).getTime();
-        if (assistantIsFromBeforeCompactionBoundary) {
-            return;
-        }
-        // Case 1: Overflow - LLM returned context overflow error
-        // When Copilot rejects a 1m client-budget prompt at a lower server cap (for example
-        // because long-context/usage-based billing entitlement is missing), leave the friendly
-        // error visible instead of auto-compacting down to a smaller server tier silently.
-        if (sameModel && this._isCopilotServerCapBelowSelectedContextWindow(assistantMessage)) {
-            return;
-        }
-        if (sameModel && isContextOverflow(assistantMessage, contextWindow)) {
-            if (this._overflowRecoveryAttempted) {
-                this._emit({
-                    type: "compaction_end",
-                    reason: "overflow",
-                    result: undefined,
-                    aborted: false,
-                    willRetry: false,
-                    errorMessage: "Context overflow recovery failed after one compact-and-retry attempt. Try reducing context or switching to a larger-context model.",
-                });
-                return;
-            }
-            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)
-            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;
-        }
-        // 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.
-        let contextTokens;
-        if (assistantMessage.stopReason === "error") {
-            const messages = this.agent.state.messages;
-            const estimate = estimateContextTokens(messages);
-            if (estimate.lastUsageIndex === null)
-                return; // 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.
-            const usageMsg = messages[estimate.lastUsageIndex];
-            if (compactionBoundaryEntry &&
-                usageMsg.role === "assistant" &&
-                usageMsg.timestamp <= new Date(compactionBoundaryEntry.timestamp).getTime()) {
-                return;
-            }
-            contextTokens = estimate.tokens;
-        }
-        else {
-            contextTokens = calculateContextTokens(assistantMessage.usage);
-        }
-        // Compact against the effective input budget (the hard prompt cap for providers like Copilot
-        // that advertise a larger total window) so we compact before overrunning the server-side limit
-        // rather than relying on reactive overflow recovery near the cap.
-        const compactionBudget = this.model ? getEffectiveInputBudget(this.model) : contextWindow;
-        if (shouldCompact(contextTokens, compactionBudget, settings)) {
-            await this._runAutoCompaction("threshold", false);
-        }
-    }
-    _isCopilotServerCapBelowSelectedContextWindow(assistantMessage) {
-        if (!this.model || this.model.provider !== "github-copilot" || !assistantMessage.errorMessage)
-            return false;
-        const promptLimitError = parseCopilotPromptLimitError(assistantMessage.errorMessage);
-        // Compare against the effective input budget (the model's real prompt cap), not the displayed
-        // total window. A rejection at the prompt cap is a normal overflow we should compact-and-retry;
-        // only a rejection *below* the cap (e.g. a missing long-context entitlement dropping the account
-        // to a lower server tier) keeps the friendly error visible instead of silently compacting down.
-        return promptLimitError !== undefined && getEffectiveInputBudget(this.model) > promptLimitError.limitTokens;
-    }
-    /**
-     * Internal: remove the trailing overflow error from retry context if it is still present.
-     */
-    _dropTrailingOverflowAssistantErrorIfPresent() {
-        const messages = this.agent.state.messages;
-        const lastMsg = messages[messages.length - 1];
-        if (lastMsg?.role === "assistant" && lastMsg.stopReason === "error") {
-            this.agent.state.messages = messages.slice(0, -1);
-        }
-    }
-    /**
-     * Internal: schedule a live post-event continuation probe after compaction_end listeners can flush queues.
-     */
-    _schedulePostAutoCompactionContinuationProbe(reason, willRetry) {
-        setTimeout(() => {
-            if (this.isCompacting || this.isStreaming) {
-                return;
-            }
-            if (reason === "overflow" && willRetry) {
-                this._resumeAfterAutoCompaction();
-                return;
-            }
-            if (!this.agent.hasQueuedMessages()) {
-                return;
-            }
-            this._resumeAfterAutoCompaction();
-        }, 100);
-    }
-    /**
-     * Internal: resume generation after successful auto-compaction only when active work remains.
-     */
-    _resumeAfterAutoCompaction() {
-        this.agent.continue().catch(() => { });
-    }
-    /**
-     * Internal: Run auto-compaction with events.
-     */
-    async _runAutoCompaction(reason, willRetry) {
-        this._emit({ type: "compaction_start", reason });
-        this._autoCompactionAbortController = new AbortController();
-        try {
-            if (!this.model) {
-                this._emit({
-                    type: "compaction_end",
-                    reason,
-                    result: undefined,
-                    aborted: false,
-                    willRetry: false,
-                });
-                return;
-            }
-            // Auth is resolved lazily: only called when the planner fallback is needed.
-            // This allows extension-provided deletion requests to run before auth is checked,
-            // enabling local extension compaction even when API credentials are unavailable.
-            // Auto-mode resolver returns undefined (rather than throwing) when auth is missing,
-            // so compaction silently no-ops if the planner would be needed but credentials are absent.
-            const model = this.model;
-            const result = await this._applyContextVerbatimCompaction({
-                resolvePlannerAuth: async () => {
-                    const authResult = await this._modelRegistry.getApiKeyAndHeaders(model);
-                    if (!authResult.ok || !authResult.apiKey) {
-                        return undefined;
-                    }
-                    return { apiKey: authResult.apiKey, headers: authResult.headers };
-                },
-                abortController: this._autoCompactionAbortController,
-                backupLabel: reason === "overflow" ? "overflow-auto-compact" : "auto-compact",
-                reason,
-            });
-            if (!result) {
-                this._emit({
-                    type: "compaction_end",
-                    reason,
-                    result: undefined,
-                    aborted: false,
-                    willRetry: false,
-                });
-                return;
-            }
-            if (reason === "overflow" && willRetry) {
-                this._dropTrailingOverflowAssistantErrorIfPresent();
-            }
-            this._emit({ type: "compaction_end", reason, result, aborted: false, willRetry });
-            this._schedulePostAutoCompactionContinuationProbe(reason, willRetry);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : "compaction failed";
-            const aborted = errorMessage === "Compaction cancelled" || (error instanceof Error && error.name === "AbortError");
-            this._emit({
-                type: "compaction_end",
-                reason,
-                result: undefined,
-                aborted,
-                willRetry: false,
-                errorMessage: aborted
-                    ? undefined
-                    : reason === "overflow"
-                        ? `Context overflow recovery failed: ${errorMessage}`
-                        : `Auto-compaction failed: ${errorMessage}`,
-            });
-        }
-        finally {
-            this._autoCompactionAbortController = undefined;
-        }
-    }
-    /**
-     * Toggle auto-compaction setting.
-     */
-    setAutoCompactionEnabled(enabled) {
-        this.settingsManager.setCompactionEnabled(enabled);
-    }
-    /** Whether auto-compaction is enabled */
-    get autoCompactionEnabled() {
-        return this.settingsManager.getCompactionEnabled();
-    }
-    async bindExtensions(bindings) {
-        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.shutdownHandler !== undefined) {
-            this._extensionShutdownHandler = bindings.shutdownHandler;
-        }
-        if (bindings.onError !== undefined) {
-            this._extensionErrorListener = bindings.onError;
-        }
-        this._applyExtensionBindings(this._extensionRunner);
-        await this._extensionRunner.emit(this._sessionStartEvent);
-        await this.extendResourcesFromExtensions(this._sessionStartEvent.reason === "reload" ? "reload" : "startup");
-    }
-    async extendResourcesFromExtensions(reason) {
-        if (!this._extensionRunner.hasHandlers("resources_discover")) {
-            return;
-        }
-        const { skillPaths, promptPaths, themePaths } = await this._extensionRunner.emitResourcesDiscover(this._cwd, reason);
-        if (skillPaths.length === 0 && promptPaths.length === 0 && themePaths.length === 0) {
-            return;
-        }
-        const extensionPaths = {
-            skillPaths: this.buildExtensionResourcePaths(skillPaths),
-            promptPaths: this.buildExtensionResourcePaths(promptPaths),
-            themePaths: this.buildExtensionResourcePaths(themePaths),
-        };
-        this._resourceLoader.extendResources(extensionPaths);
-        this._baseSystemPrompt = this._rebuildSystemPrompt(this.getActiveToolNames());
-        this.agent.state.systemPrompt = this._baseSystemPrompt;
-    }
-    buildExtensionResourcePaths(entries) {
-        return entries.map((entry) => {
-            const source = this.getExtensionSourceLabel(entry.extensionPath);
-            const baseDir = entry.extensionPath.startsWith("<") ? undefined : dirname(entry.extensionPath);
-            return {
-                path: entry.path,
-                metadata: {
-                    source,
-                    scope: "temporary",
-                    origin: "top-level",
-                    baseDir,
-                },
-            };
-        });
-    }
-    getExtensionSourceLabel(extensionPath) {
-        if (extensionPath.startsWith("<")) {
-            return `extension:${extensionPath.replace(/[<>]/g, "")}`;
-        }
-        const base = basename(extensionPath);
-        const name = base.replace(/\.(ts|js)$/, "");
-        return `extension:${name}`;
-    }
-    _applyExtensionBindings(runner) {
-        runner.setUIContext(this._extensionUIContext, this._extensionMode);
-        runner.bindCommandContext(this._extensionCommandContextActions);
-        this._extensionErrorUnsubscriber?.();
-        this._extensionErrorUnsubscriber = this._extensionErrorListener
-            ? runner.onError(this._extensionErrorListener)
-            : undefined;
-    }
-    _refreshCurrentModelFromRegistry() {
-        const currentModel = this.model;
-        if (!currentModel) {
-            return;
-        }
-        const refreshedModel = this._modelRegistry.find(currentModel.provider, currentModel.id);
-        if (!refreshedModel || refreshedModel === currentModel) {
-            return;
-        }
-        const replay = this._getResumeContextWindowReplayForModel(refreshedModel);
-        this.agent.state.model = replay.model;
-        if (currentModel.contextWindow !== replay.contextWindow) {
-            this._emit({ type: "context_window_changed", contextWindow: replay.contextWindow });
-        }
-        this._refreshBaseSystemPromptFromActiveTools();
-    }
-    _bindExtensionCore(runner) {
-        const getCommands = () => {
-            const extensionCommands = runner.getRegisteredCommands().map((command) => ({
-                name: command.invocationName,
-                description: command.description,
-                source: "extension",
-                sourceInfo: command.sourceInfo,
-            }));
-            const templates = this.promptTemplates.map((template) => ({
-                name: template.name,
-                description: template.description,
-                source: "prompt",
-                sourceInfo: template.sourceInfo,
-            }));
-            const skills = this._resourceLoader.getSkills().skills.map((skill) => ({
-                name: `skill:${skill.name}`,
-                description: skill.description,
-                source: "skill",
-                sourceInfo: skill.sourceInfo,
-            }));
-            return [...extensionCommands, ...templates, ...skills];
-        };
-        runner.bindCore({
-            sendMessage: (message, options) => {
-                this.sendCustomMessage(message, options).catch((err) => {
-                    runner.emitError({
-                        extensionPath: "<runtime>",
-                        event: "send_message",
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                });
-            },
-            sendUserMessage: (content, options) => {
-                this.sendUserMessage(content, options).catch((err) => {
-                    runner.emitError({
-                        extensionPath: "<runtime>",
-                        event: "send_user_message",
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                });
-            },
-            appendEntry: (customType, data) => {
-                this.sessionManager.appendCustomEntry(customType, data);
-            },
-            setSessionName: (name) => {
-                this.setSessionName(name);
-            },
-            getSessionName: () => {
-                return this.sessionManager.getSessionName();
-            },
-            setLabel: (entryId, label) => {
-                this.sessionManager.appendLabelChange(entryId, label);
-            },
-            getActiveTools: () => this.getActiveToolNames(),
-            getAllTools: () => this.getAllTools(),
-            setActiveTools: (toolNames) => this.setActiveToolsByName(toolNames),
-            refreshTools: () => this._refreshToolRegistry(),
-            getCommands,
-            setModel: async (model) => {
-                if (!this.modelRegistry.hasConfiguredAuth(model))
-                    return false;
-                await this.setModel(model);
-                return true;
-            },
-            getThinkingLevel: () => this.thinkingLevel,
-            setThinkingLevel: (level) => this.setThinkingLevel(level),
-        }, {
-            getModel: () => this.model,
-            isIdle: () => !this.isStreaming,
-            isProjectTrusted: () => this.settingsManager.isProjectTrusted(),
-            getSignal: () => this.agent.signal,
-            abort: () => this.abort(),
-            hasPendingMessages: () => this.pendingMessageCount > 0,
-            shutdown: () => {
-                this._extensionShutdownHandler?.();
-            },
-            getContextUsage: () => this.getContextUsage(),
-            compact: (options) => {
-                void (async () => {
-                    try {
-                        const result = await this.compact({
-                            ...(options?.compression_ratio === undefined ? {} : { compression_ratio: options.compression_ratio }),
-                            ...(options?.preserve_recent === undefined ? {} : { preserve_recent: options.preserve_recent }),
-                            ...(options?.query === undefined ? {} : { query: options.query }),
-                        });
-                        options?.onComplete?.(result);
-                    }
-                    catch (error) {
-                        const err = error instanceof Error ? error : new Error(String(error));
-                        options?.onError?.(err);
-                    }
-                })();
-            },
-            getSystemPrompt: () => this.systemPrompt,
-            getSystemPromptOptions: () => this._baseSystemPromptOptions,
-        }, {
-            registerProvider: (name, config) => {
-                this._modelRegistry.registerProvider(name, config);
-                this._refreshCurrentModelFromRegistry();
-            },
-            unregisterProvider: (name) => {
-                this._modelRegistry.unregisterProvider(name);
-                this._refreshCurrentModelFromRegistry();
-            },
-        });
-    }
-    _refreshToolRegistry(options) {
-        const previousRegistryNames = new Set(this._toolRegistry.keys());
-        const previousActiveToolNames = this.getActiveToolNames();
-        const allowedToolNames = this._allowedToolNames;
-        const excludedToolNames = this._excludedToolNames;
-        const isExposedTool = (name) => {
-            if (allowedToolNames && !allowedToolNames.has(name)) {
-                return false;
-            }
-            if (excludedToolNames?.has(name)) {
-                return false;
-            }
-            return true;
-        };
-        const registeredTools = this._extensionRunner.getAllRegisteredTools();
-        const allCustomTools = [
-            ...registeredTools,
-            ...this._customTools.map((definition) => ({
-                definition,
-                sourceInfo: createSyntheticSourceInfo(`<sdk:${definition.name}>`, { source: "sdk" }),
-            })),
-        ].filter((tool) => isExposedTool(tool.definition.name));
-        const definitionRegistry = new Map(Array.from(this._baseToolDefinitions.entries())
-            .filter(([name]) => isExposedTool(name))
-            .map(([name, definition]) => [
-            name,
-            {
-                definition,
-                sourceInfo: createSyntheticSourceInfo(`<builtin:${name}>`, { source: "builtin" }),
-            },
-        ]));
-        for (const tool of allCustomTools) {
-            definitionRegistry.set(tool.definition.name, {
-                definition: tool.definition,
-                sourceInfo: tool.sourceInfo,
-            });
-        }
-        this._toolDefinitions = definitionRegistry;
-        this._toolPromptSnippets = new Map(Array.from(definitionRegistry.values())
-            .map(({ definition }) => {
-            const snippet = this._normalizePromptSnippet(definition.promptSnippet);
-            return snippet ? [definition.name, snippet] : undefined;
-        })
-            .filter((entry) => entry !== undefined));
-        this._toolPromptGuidelines = new Map(Array.from(definitionRegistry.values())
-            .map(({ definition }) => {
-            const guidelines = this._normalizePromptGuidelines(definition.promptGuidelines);
-            return guidelines.length > 0 ? [definition.name, guidelines] : undefined;
-        })
-            .filter((entry) => entry !== undefined));
-        const runner = this._extensionRunner;
-        const wrappedExtensionTools = wrapRegisteredTools(allCustomTools, runner);
-        const wrappedBuiltInTools = wrapRegisteredTools(Array.from(this._baseToolDefinitions.values())
-            .filter((definition) => isExposedTool(definition.name))
-            .map((definition) => ({
-            definition,
-            sourceInfo: createSyntheticSourceInfo(`<builtin:${definition.name}>`, { source: "builtin" }),
-        })), runner);
-        const toolRegistry = new Map(wrappedBuiltInTools.map((tool) => [tool.name, tool]));
-        for (const tool of wrappedExtensionTools) {
-            toolRegistry.set(tool.name, tool);
-        }
-        // GitHub Copilot Gemini serializes array/object tool-call arguments as
-        // flattened `name[index]` keys (confirmed on the raw CAPI wire). Reconstruct
-        // them into proper arrays/objects before per-tool preparation and schema
-        // validation, so tool calls (notably structured_output) don't fail and loop.
-        // Gated to Copilot Gemini at call time via this.model; a no-op otherwise.
-        // `prepareArguments` is a plain function field (no `this` binding), and the
-        // `{ ...tool }` spread assumes AgentTools are plain objects — matching the
-        // existing tool-definition-wrapper pattern; a class-instance tool would lose
-        // prototype members here.
-        this._toolRegistry = new Map(Array.from(toolRegistry, ([name, tool]) => {
-            const basePrepareArguments = tool.prepareArguments;
-            const prepareArguments = (args) => {
-                const normalized = normalizeToolArgumentsForModel(args, this.model, tool.parameters);
-                return basePrepareArguments ? basePrepareArguments(normalized) : normalized;
-            };
-            return [name, { ...tool, prepareArguments }];
-        }));
-        const nextActiveToolNames = (options?.activeToolNames ? [...options.activeToolNames] : [...previousActiveToolNames]).filter((name) => isExposedTool(name));
-        if (allowedToolNames) {
-            for (const toolName of this._toolRegistry.keys()) {
-                if (allowedToolNames.has(toolName)) {
-                    nextActiveToolNames.push(toolName);
-                }
-            }
-        }
-        else if (options?.includeAllExtensionTools) {
-            for (const tool of wrappedExtensionTools) {
-                nextActiveToolNames.push(tool.name);
-            }
-        }
-        else if (!options?.activeToolNames) {
-            for (const toolName of this._toolRegistry.keys()) {
-                if (!previousRegistryNames.has(toolName)) {
-                    nextActiveToolNames.push(toolName);
-                }
-            }
-        }
-        this.setActiveToolsByName([...new Set(nextActiveToolNames)]);
-    }
-    _buildRuntime(options) {
-        const autoResizeImages = this.settingsManager.getImageAutoResize();
-        const shellCommandPrefix = this.settingsManager.getShellCommandPrefix();
-        const shellPath = this.settingsManager.getShellPath();
-        const baseToolDefinitions = this._baseToolsOverride
-            ? Object.fromEntries(Object.entries(this._baseToolsOverride).map(([name, tool]) => [
-                name,
-                createToolDefinitionFromAgentTool(tool),
-            ]))
-            : createAllToolDefinitions(this._cwd, {
-                read: { autoResizeImages },
-                bash: {
-                    commandPrefix: shellCommandPrefix,
-                    shellPath,
-                    policy: this._bashPolicy,
-                    policyLabel: "session bash policy",
-                },
-            });
-        this._baseToolDefinitions = new Map(Object.entries(baseToolDefinitions).map(([name, tool]) => [name, tool]));
-        const extensionsResult = this._resourceLoader.getExtensions();
-        if (options.flagValues) {
-            for (const [name, value] of options.flagValues) {
-                extensionsResult.runtime.flagValues.set(name, value);
-            }
-        }
-        this._extensionRunner = new ExtensionRunner(extensionsResult.extensions, extensionsResult.runtime, this._cwd, this.sessionManager, this._modelRegistry, this._orchestrationContext);
-        if (this._extensionRunnerRef) {
-            this._extensionRunnerRef.current = this._extensionRunner;
-        }
-        this._bindExtensionCore(this._extensionRunner);
-        this._applyExtensionBindings(this._extensionRunner);
-        const defaultActiveToolNames = this._baseToolsOverride
-            ? Object.keys(this._baseToolsOverride)
-            : [...defaultToolNames];
-        const baseActiveToolNames = options.activeToolNames ?? defaultActiveToolNames;
-        this._refreshToolRegistry({
-            activeToolNames: baseActiveToolNames,
-            includeAllExtensionTools: options.includeAllExtensionTools,
-        });
-    }
-    async reload() {
-        const previousFlagValues = this._extensionRunner.getFlagValues();
-        await emitSessionShutdownEvent(this._extensionRunner, { type: "session_shutdown", reason: "reload" });
-        await this.settingsManager.reload();
-        resetApiProviders();
-        await this._resourceLoader.reload();
-        this._buildRuntime({
-            activeToolNames: this.getActiveToolNames(),
-            flagValues: previousFlagValues,
-            includeAllExtensionTools: true,
-        });
-        const hasBindings = this._extensionUIContext ||
-            this._extensionCommandContextActions ||
-            this._extensionShutdownHandler ||
-            this._extensionErrorListener;
-        if (hasBindings) {
-            await this._extensionRunner.emit({ type: "session_start", reason: "reload" });
-            await this.extendResourcesFromExtensions("reload");
-        }
-    }
-    // =========================================================================
-    // Auto-Retry
-    // =========================================================================
-    /**
-     * Check if an error is retryable (overloaded, rate limit, server errors).
-     * 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))
-            return false;
-        const err = message.errorMessage;
-        // A genuine `content_filter` stop is a deliberate safety block: retrying it
-        // re-issues the same blocked request up to maxRetries times for no benefit.
-        // GitHub Copilot Gemini is the exception — CAPI maps spurious Gemini blocks
-        // (RECITATION/safety on MALFORMED_FUNCTION_CALL etc.) to `content_filter`, so
-        // only treat `content_filter` as retryable for those models.
-        if (isCopilotGeminiModel({ provider: message.provider, api: message.api, id: message.model }) &&
-            /finish.?reason:?\s*content.?filter/i.test(err)) {
-            return true;
-        }
-        // Match: overloaded_error, provider returned error, rate limit, 429, 500, 502, 503, 504, service unavailable, network/connection errors (including connection lost), WebSocket transport closes/errors, fetch failed, premature stream endings, HTTP/2 closed before response, terminated, retry delay exceeded, and a bare/transient provider finish_reason "error" (e.g. github-copilot Gemini's CAPI mapping of MALFORMED_FUNCTION_CALL/OTHER/UNEXPECTED_TOOL_CALL). These are provider-agnostic transient failures.
-        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|websocket.?closed|websocket.?error|other side closed|fetch failed|upstream.?connect|reset before headers|socket hang up|ended without|stream ended before message_stop|http2 request did not get a response|timed? out|timeout|terminated|retry delay|finish.?reason:?\s*error/i.test(err);
-    }
-    /**
-     * For GitHub Copilot Gemini, reconstruct flattened tool-call arguments
-     * (for example `edits[0].newText`) into the nested arrays/objects Gemini
-     * produced before the assistant message is persisted, so saved transcripts
-     * never carry the flattened CAPI wire shape and replays loaded from disk match
-     * the structure Gemini signed. In-place, gated to Copilot Gemini, and a no-op
-     * for well-formed arguments or any other provider/model. The outbound replay
-     * normalizer still heals already-persisted (legacy) sessions on the wire.
-     */
-    _normalizePersistedGeminiToolArgs(message) {
-        const model = this.model;
-        if (!model || !isCopilotGeminiModel(model))
-            return;
-        for (const block of message.content) {
-            if (block.type !== "toolCall")
-                continue;
-            const tool = this._toolRegistry.get(block.name);
-            const normalized = normalizeToolArgumentsForModel(block.arguments, model, tool?.parameters);
-            if (normalized !== block.arguments && normalized !== null && typeof normalized === "object") {
-                block.arguments = normalized;
-            }
-        }
-    }
-    /**
-     * Detect a degenerate empty completion: the provider ended the stream with no
-     * usable content and zero output tokens. Seen with github-copilot Gemini models
-     * that emit finish_reason "stop" (or a tool-use stop) with an empty content array
-     * and 0 output tokens, leaving the turn dead instead of producing the next step.
-     *
-     * These are treated as retryable so the harness re-issues the request rather than
-     * silently stopping mid-task. Guarded tightly (no text, no tool call, no thinking,
-     * and output === 0) so legitimate non-empty turns are never matched.
-     *
-     * Intentionally provider-agnostic (not gated to Copilot Gemini): a degenerate
-     * empty turn is a transient failure for any provider. It is bounded by
-     * `maxRetries` and falls through to normal handling on exhaustion.
-     */
-    _isEmptyCompletion(message) {
-        // Only "completed" stop reasons can be deceptively empty. Real errors are handled
-        // by _isRetryableError; aborted/length turns are intentional outcomes.
-        if (message.stopReason !== "stop" && message.stopReason !== "toolUse")
-            return false;
-        const content = message.content;
-        if (Array.isArray(content)) {
-            const hasContent = content.some((part) => {
-                if (part.type === "text")
-                    return part.text.trim().length > 0;
-                if (part.type === "toolCall")
-                    return true;
-                if (part.type === "thinking")
-                    return part.redacted === true || part.thinking.trim().length > 0;
-                return true; // unknown part types count as content
-            });
-            if (hasContent)
-                return false;
-        }
-        // A turn that produced output tokens but no surfaced content is not "empty"
-        // (e.g. reasoning-only responses); leave those alone. Note: a provider that
-        // fails to report `usage` (output defaults to 0) would make every
-        // content-less turn match here; the dual requirement (empty content AND zero
-        // output) keeps that false-positive risk low in practice.
-        return (message.usage?.output ?? 0) === 0;
-    }
-    /**
-     * Handle retryable errors with exponential backoff.
-     * @returns true if retry was initiated, false if max retries exceeded or disabled
-     */
-    async _handleRetryableError(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
-            return false;
-        }
-        const delayMs = settings.baseDelayMs * 2 ** (this._retryAttempt - 1);
-        this._emit({
-            type: "auto_retry_start",
-            attempt: this._retryAttempt,
-            maxAttempts: settings.maxRetries,
-            delayMs,
-            errorMessage: message.errorMessage || "Unknown error",
-        });
-        // Remove error message from agent state (keep in session for history)
-        const messages = this.agent.state.messages;
-        if (messages.length > 0 && messages[messages.length - 1].role === "assistant") {
-            this.agent.state.messages = messages.slice(0, -1);
-        }
-        // Wait with exponential backoff (abortable)
-        this._retryAbortController = new AbortController();
-        try {
-            await sleep(delayMs, this._retryAbortController.signal);
-        }
-        catch {
-            // 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);
-        return true;
-    }
-    /**
-     * Cancel in-progress retry.
-     */
-    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;
-    }
-    /** Whether auto-retry is enabled */
-    get autoRetryEnabled() {
-        return this.settingsManager.getRetryEnabled();
-    }
-    /**
-     * Toggle auto-retry setting.
-     */
-    setAutoRetryEnabled(enabled) {
-        this.settingsManager.setRetryEnabled(enabled);
-    }
-    // =========================================================================
-    // Bash Execution
-    // =========================================================================
-    /**
-     * Execute a bash command.
-     * Adds result to agent context and session.
-     * @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.operations Custom BashOperations for remote execution
-     */
-    async executeBash(command, onChunk, options) {
-        const policyDecision = evaluateBashCommandPolicy(command, this._bashPolicy);
-        if (!policyDecision.allowed) {
-            throw new Error(formatBashCommandPolicyRejection(policyDecision, "session bash policy"));
-        }
-        this._bashAbortController = new 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,
-            });
-            this.recordBashResult(command, result, options);
-            return result;
-        }
-        finally {
-            this._bashAbortController = undefined;
-        }
-    }
-    /**
-     * Record a bash execution result in session history.
-     * Used by executeBash and by extensions that handle bash execution themselves.
-     */
-    recordBashResult(command, result, options) {
-        const bashMessage = {
-            role: "bashExecution",
-            command,
-            output: result.output,
-            exitCode: result.exitCode,
-            cancelled: result.cancelled,
-            truncated: result.truncated,
-            fullOutputPath: result.fullOutputPath,
-            timestamp: Date.now(),
-            excludeFromContext: options?.excludeFromContext,
-        };
-        // If agent is streaming, defer adding to avoid breaking tool_use/tool_result ordering
-        if (this.isStreaming) {
-            // Queue for later - will be flushed on agent_end
-            this._pendingBashMessages.push(bashMessage);
-        }
-        else {
-            // Add to agent state immediately
-            this.agent.state.messages.push(bashMessage);
-            // Save to session
-            this.sessionManager.appendMessage(bashMessage);
-        }
-    }
-    /**
-     * Cancel running bash command.
-     */
-    abortBash() {
-        this._bashAbortController?.abort();
-    }
-    /** Whether a bash command is currently running */
-    get isBashRunning() {
-        return this._bashAbortController !== undefined;
-    }
-    /** Whether there are pending bash messages waiting to be flushed */
-    get hasPendingBashMessages() {
-        return this._pendingBashMessages.length > 0;
-    }
-    /**
-     * Flush pending bash messages to agent state and session.
-     * Called after agent turn completes to maintain proper message ordering.
-     */
-    _flushPendingBashMessages() {
-        if (this._pendingBashMessages.length === 0)
-            return;
-        for (const bashMessage of this._pendingBashMessages) {
-            // Add to agent state
-            this.agent.state.messages.push(bashMessage);
-            // Save to session
-            this.sessionManager.appendMessage(bashMessage);
-        }
-        this._pendingBashMessages = [];
-    }
-    // =========================================================================
-    // Session Management
-    // =========================================================================
-    /**
-     * Set a display name for the current session.
-     */
-    setSessionName(name) {
-        this.sessionManager.appendSessionInfo(name);
-        this._emit({ type: "session_info_changed", name: this.sessionManager.getSessionName() });
-    }
-    // =========================================================================
-    // Tree Navigation
-    // =========================================================================
-    /**
-     * Navigate to a different node in the session tree.
-     * Unlike fork() which creates a new session file, this stays in the same file.
-     *
-     * @param targetId The entry ID to navigate to
-     * @param options.summarize Whether user wants to summarize abandoned branch
-     * @param options.customInstructions Custom instructions for summarizer
-     * @param options.replaceInstructions If true, customInstructions replaces the default prompt
-     * @param options.label Label to attach to the branch summary entry
-     * @returns Result with editorText (if user message) and cancelled status
-     */
-    async navigateTree(targetId, options = {}) {
-        const oldLeafId = this.sessionManager.getLeafId();
-        // No-op if already at target
-        if (targetId === oldLeafId) {
-            return { cancelled: false };
-        }
-        // Model required for summarization
-        if (options.summarize && !this.model) {
-            throw new Error("No model available for summarization");
-        }
-        const targetEntry = this.sessionManager.getEntry(targetId);
-        if (!targetEntry) {
-            throw new Error(`Entry ${targetId} not found`);
-        }
-        // Collect entries to summarize (from old leaf to common ancestor)
-        const { entries: entriesToSummarize, commonAncestorId } = collectEntriesForBranchSummary(this.sessionManager, oldLeafId, targetId);
-        // Prepare event data - mutable so extensions can override
-        let customInstructions = options.customInstructions;
-        let replaceInstructions = options.replaceInstructions;
-        let label = options.label;
-        const preparation = {
-            targetId,
-            oldLeafId,
-            commonAncestorId,
-            entriesToSummarize,
-            userWantsSummary: options.summarize ?? false,
-            customInstructions,
-            replaceInstructions,
-            label,
-        };
-        // Set up abort controller for summarization
-        this._branchSummaryAbortController = new AbortController();
-        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;
-            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,
-                    streamFn: this.agent.streamFn,
-                });
-                if (result.aborted) {
-                    return { cancelled: true, aborted: true };
-                }
-                if (result.error) {
-                    throw new Error(result.error);
-                }
-                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;
-            this._applyContextWindowReplay(sessionContext.contextWindow);
-            // 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 };
-        }
-        finally {
-            this._branchSummaryAbortController = undefined;
-        }
-    }
-    /**
-     * Get all user messages from session for fork selector.
-     */
-    getUserMessagesForForking() {
-        const entries = this.sessionManager.getEntries();
-        const result = [];
-        for (const entry of entries) {
-            if (entry.type !== "message")
-                continue;
-            if (entry.message.role !== "user")
-                continue;
-            const text = this._extractUserMessageText(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.
-     */
-    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 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 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;
-            }
-        }
-        return {
-            sessionFile: this.sessionFile,
-            sessionId: this.sessionId,
-            userMessages,
-            assistantMessages,
-            toolCalls,
-            toolResults,
-            totalMessages: state.messages.length,
-            tokens: {
-                input: totalInput,
-                output: totalOutput,
-                cacheRead: totalCacheRead,
-                cacheWrite: totalCacheWrite,
-                total: totalInput + totalOutput + totalCacheRead + totalCacheWrite,
-            },
-            cost: totalCost,
-            contextUsage: this.getContextUsage(),
-        };
-    }
-    getContextUsage() {
-        const model = this.model;
-        if (!model)
-            return undefined;
-        const contextWindow = model.contextWindow ?? 0;
-        if (contextWindow <= 0)
-            return undefined;
-        // After compaction, the last assistant usage reflects pre-compaction context size.
-        // We can only trust usage from an assistant that responded after the latest compaction.
-        // If no such assistant exists, context token count is unknown until the next LLM response.
-        const branchEntries = this.sessionManager.getBranch();
-        const latestCompactionBoundary = getLatestCompactionBoundaryEntry(branchEntries);
-        if (latestCompactionBoundary) {
-            // Check if there's a valid assistant usage after the compaction boundary
-            const compactionIndex = branchEntries.lastIndexOf(latestCompactionBoundary);
-            let hasPostCompactionUsage = false;
-            for (let i = branchEntries.length - 1; i > compactionIndex; i--) {
-                const entry = branchEntries[i];
-                if (entry.type === "message" && entry.message.role === "assistant") {
-                    const assistant = entry.message;
-                    if (assistant.stopReason !== "aborted" && assistant.stopReason !== "error") {
-                        const contextTokens = calculateContextTokens(assistant.usage);
-                        if (contextTokens > 0) {
-                            hasPostCompactionUsage = true;
-                        }
-                        break;
-                    }
-                }
-            }
-            if (!hasPostCompactionUsage) {
-                return { tokens: null, contextWindow, percent: null };
-            }
-        }
-        const estimate = estimateContextTokens(this.messages);
-        const percent = (estimate.tokens / contextWindow) * 100;
-        return {
-            tokens: estimate.tokens,
-            contextWindow,
-            percent,
-        };
-    }
-    /**
-     * Export session to HTML.
-     * @param outputPath Optional output path (defaults to session directory)
-     * @returns Path to exported file
-     */
-    async exportToHtml(outputPath) {
-        const themeName = this.settingsManager.getTheme();
-        // Create tool renderer if we have an extension runner (for custom tool HTML rendering)
-        const toolRenderer = createToolHtmlRenderer({
-            getToolDefinition: (name) => this.getToolDefinition(name),
-            theme,
-            cwd: this.sessionManager.getCwd(),
-        });
-        return await exportSessionToHtml(this.sessionManager, this.state, {
-            outputPath,
-            themeName,
-            toolRenderer,
-        });
-    }
-    /**
-     * Export the current session branch to a JSONL file.
-     * Writes the session header followed by all entries on the current branch path.
-     * @param outputPath Target file path. If omitted, generates a timestamped file in cwd.
-     * @returns The resolved output file path.
-     */
-    exportToJsonl(outputPath) {
-        const filePath = resolvePath(outputPath ?? `session-${new Date().toISOString().replace(/[:.]/g, "-")}.jsonl`, process.cwd());
-        const dir = dirname(filePath);
-        if (!existsSync(dir)) {
-            mkdirSync(dir, { recursive: true });
-        }
-        const header = {
-            type: "session",
-            version: CURRENT_SESSION_VERSION,
-            id: this.sessionManager.getSessionId(),
-            timestamp: new Date().toISOString(),
-            cwd: this.sessionManager.getCwd(),
-        };
-        const branchEntries = this.sessionManager.getBranch();
-        const lines = [JSON.stringify(header)];
-        // Re-chain parentIds to form a linear sequence
-        let prevId = null;
-        for (const entry of branchEntries) {
-            const linear = { ...entry, parentId: prevId };
-            lines.push(JSON.stringify(linear));
-            prevId = entry.id;
-        }
-        writeFileSync(filePath, `${lines.join("\n")}\n`);
-        return filePath;
-    }
-    // =========================================================================
-    // Utilities
-    // =========================================================================
-    /**
-     * Get text content of last assistant message.
-     * Useful for /copy command.
-     * @returns Text content, or undefined if no assistant message exists
-     */
-    getLastAssistantText() {
-        const lastAssistant = this.messages
-            .slice()
-            .reverse()
-            .find((m) => {
-            if (m.role !== "assistant")
-                return false;
-            const msg = m;
-            // Skip aborted messages with no content
-            if (msg.stopReason === "aborted" && msg.content.length === 0)
-                return false;
-            return true;
-        });
-        if (!lastAssistant)
-            return undefined;
-        let text = "";
-        for (const content of lastAssistant.content) {
-            if (content.type === "text") {
-                text += content.text;
-            }
-        }
-        return text.trim() || undefined;
-    }
-    // =========================================================================
-    // Extension System
-    // =========================================================================
-    createReplacedSessionContext() {
-        const context = Object.defineProperties({}, Object.getOwnPropertyDescriptors(this._extensionRunner.createCommandContext()));
-        context.sendMessage = (message, options) => this.sendCustomMessage(message, options);
-        context.sendUserMessage = (content, options) => this.sendUserMessage(content, options);
-        return context;
-    }
-    /**
-     * Check if extensions have handlers for a specific event type.
-     */
-    hasExtensionHandlers(eventType) {
-        return this._extensionRunner.hasHandlers(eventType);
-    }
-    /**
-     * Get the extension runner (for setting UI context and error handlers).
-     */
-    get extensionRunner() {
-        return this._extensionRunner;
-    }
 }
+installAgentSessionAccessors(AgentSession.prototype);
+Object.assign(AgentSession.prototype, agentSessionToolHooksMethods, agentSessionEventsMethods, agentSessionStateMethods, agentSessionPromptMethods, agentSessionMessageQueueMethods, agentSessionModelsMethods, agentSessionCompactionMethods, agentSessionAutoCompactionMethods, agentSessionExtensionBindingsMethods, agentSessionToolRegistryMethods, agentSessionRetryMethods, agentSessionBashMethods, agentSessionTreeMethods, agentSessionExportMethods);
 //# sourceMappingURL=agent-session.js.map