shortcutxl 0.2.19 → 0.2.21

package/dist/core/agent-session.js

@@ -12,24 +12,28 @@
  *
  * Modes use this class and add their own I/O layer on top.
  */
-import { isContextOverflow, modelsAreEqual } from '@mariozechner/pi-ai';
+import { isContextOverflow } from '@mariozechner/pi-ai';
 import { readFileSync } from 'node:fs';
 import { basename, dirname } from 'node:path';
 // SHORTCUT PATCH: removed getDocsPath import — login errors no longer reference providers.md
 import { stripFrontmatter } from '../utils/frontmatter.js';
+import { emitExtensionEvent } from './session/extension-emitter.js';
+import { ModelManager } from './session/model-manager.js';
+import { PersistenceHandler } from './session/persistence-handler.js';
+import { QueueTracker } from './session/queue-tracker.js';
+import { ToolRegistry } from './session/tool-registry.js';
+// SHORTCUT PATCH: SessionBash removed — interactive bash is handled directly by modes/
 import { calculateContextTokens, collectEntriesForBranchSummary, estimateContextTokens, generateBranchSummary } from './compaction/index.js';
 import { DEFAULT_THINKING_LEVEL } from './defaults.js';
 import { exportFromFile } from './export-html/index.js';
 import { createToolHtmlRenderer } from './export-html/tool-renderer.js';
-import { ExtensionRunner, wrapRegisteredTools, wrapToolsWithExtensions } from './extensions/index.js';
+import { ExtensionRunner } from './extensions/index.js';
 import { expandPromptTemplate } from './prompt-templates.js';
-import { SessionBash } from './session-bash.js';
 import { checkCompactionNeeded, SessionCompaction } from './session-compaction.js';
 import { getLatestCompactionEntry } from './session-manager.js';
-import { clampThinkingLevel, computeNextModel, cycleThinkingLevel as computeNextThinkingLevel, getAvailableThinkingLevels, supportsThinking, supportsXhighThinking } from './session-models.js';
+import { getAvailableThinkingLevels, supportsThinking, supportsXhighThinking } from './session-models.js';
 import { isRetryableError, SessionRetry } from './session-retry.js';
 import { ALL_BUILTIN_SLASH_COMMAND_NAMES } from './slash-commands.js';
-import { buildSystemPrompt } from './system-prompt.js';
 import { theme } from './theme.js';
 import { createAllTools } from './tools/index.js';
 // ============================================================================
@@ -61,10 +65,8 @@ export class AgentSession {
     _unsubscribeAgent;
     _eventListeners = [];
     _agentEventQueue = Promise.resolve();
-    /** Tracks pending steering messages for UI display. Removed when delivered. */
-    _steeringMessages = [];
-    /** Tracks pending follow-up messages for UI display. Removed when delivered. */
-    _followUpMessages = [];
+    // Event pipeline: queue tracker (owns steering/followUp message display state)
+    _queueTracker = new QueueTracker();
     /** Messages queued to be included with the next user prompt as context ("asides"). */
     _pendingNextTurnMessages = [];
     // Compaction state machine (extracted module)
@@ -73,18 +75,13 @@ export class AgentSession {
     _branchSummaryAbortController = undefined;
     // Retry state machine (extracted module)
     _retry = new SessionRetry();
-    // Bash execution (extracted module)
-    _bash = new SessionBash();
-    // Extension system
+    // Extension system (used by prompt handling, tool registry, lifecycle, bridge — not just events)
     _extensionRunner = undefined;
-    _turnIndex = 0;
-    // Timing state for observability
-    _agentStartTime = 0;
-    _turnStartTime = 0;
-    _toolStartTimes = new Map();
+    // Event pipeline
+    _turnIndex = 0; // shared counter — passed to both extension emitter and persistence
+    _persistence = new PersistenceHandler();
     _resourceLoader;
     _customTools;
-    _baseToolRegistry = new Map();
     _cwd;
     _extensionRunnerRef;
     _prePromptContext;
@@ -99,12 +96,10 @@ export class AgentSession {
     _extensionErrorUnsubscriber;
     // Model registry for API key resolution
     _modelRegistry;
-    // Tool registry for extension getTools/setTools
-    _toolRegistry = new Map();
-    _toolPromptSnippets = new Map();
-    _toolPromptGuidelines = new Map();
-    // Base system prompt (without extension appends) - used to apply fresh appends each turn
-    _baseSystemPrompt = '';
+    // Tool registry — owns tool maps, prompt snippets, system prompt rebuild
+    _tools;
+    // Model manager — model switching, cycling, thinking level
+    _models;
     constructor(config) {
         this.agent = config.agent;
         this.sessionManager = config.sessionManager;
@@ -117,6 +112,9 @@ export class AgentSession {
         this._initialActiveToolNames = config.initialActiveToolNames;
         this._baseToolsOverride = config.baseToolsOverride;
         this._prePromptContext = config.prePromptContext;
+        // Construct extracted modules with stable deps
+        this._tools = new ToolRegistry(this.agent, this._resourceLoader, this._cwd);
+        this._models = new ModelManager(this.agent, this._modelRegistry, this.sessionManager, this.settingsManager);
         // Forward extracted module events to session listeners
         this._retry.onEvent((event) => this._emit(event));
         this._compaction.onEvent((event) => this._emit(event));
@@ -124,8 +122,7 @@ export class AgentSession {
         // (session persistence, extensions, auto-compaction, retry logic)
         this._unsubscribeAgent = this.agent.subscribe(this._handleAgentEvent);
         this._buildRuntime({
-            activeToolNames: this._initialActiveToolNames,
-            includeAllExtensionTools: true
+            activeToolNames: this._initialActiveToolNames
         });
     }
     /** Model registry for API key resolution and model discovery */
@@ -152,12 +149,12 @@ export class AgentSession {
         let i = messages.length - 1;
         while (i >= 0 && messages[i].role === 'toolResult')
             i--;
-        if (i >= 0 && messages[i].role === 'assistant' && messages[i].stopReason === 'error') {
+        if (i >= 0 &&
+            messages[i].role === 'assistant' &&
+            messages[i].stopReason === 'error') {
             this.agent.replaceMessages(messages.slice(0, i));
         }
     }
-    // Track last assistant message for auto-compaction check
-    _lastAssistantMessage = undefined;
     /** Internal handler for agent events - shared by subscribe and reconnect */
     _handleAgentEvent = (event) => {
         // Create retry promise synchronously before queueing async processing.
@@ -189,127 +186,61 @@ export class AgentSession {
         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') {
-            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);
-                }
-                else {
-                    // Check follow-up queue
-                    const followUpIndex = this._followUpMessages.indexOf(messageText);
-                    if (followUpIndex !== -1) {
-                        this._followUpMessages.splice(followUpIndex, 1);
-                    }
-                }
-            }
-        }
-        // Emit to extensions first
-        await this._emitExtensionEvent(event);
-        // Notify all listeners
+        // --- Step 1: Queue tracking (sync) ---
+        this._queueTracker.handle(event);
+        // --- Step 2: Extensions (async — must complete before persistence) ---
+        // Reset turnIndex on agent_start BEFORE the snapshot so extensions see 0.
+        if (event.type === 'agent_start')
+            this._turnIndex = 0;
+        const turnIndex = this._turnIndex;
+        await emitExtensionEvent(this._extensionRunner, event, turnIndex);
+        // --- Step 3: External listeners (sync) ---
         this._emit(event);
-        // --- Timing + session persistence ---
+        // --- Step 4: Persistence (sync — writes timing + messages to SessionManager) ---
         if (event.type === 'agent_start') {
-            this._agentStartTime = Date.now();
-            this._toolStartTimes.clear();
-            // Snapshot system prompt and tool definitions at start of each agent invocation
-            this.sessionManager.appendSystemPrompt(this.systemPrompt);
-            this.sessionManager.appendToolDefinitions(this.agent.state.tools.map((t) => ({
+            this._persistence.startAgent(this.sessionManager, this.systemPrompt, this.agent.state.tools.map((t) => ({
                 name: t.name,
                 description: t.description,
                 parameters: t.parameters
             })));
         }
-        if (event.type === 'turn_start') {
-            this._turnStartTime = Date.now();
-            this.sessionManager.appendTurnStart(this._turnIndex);
-        }
-        if (event.type === 'tool_execution_start') {
-            this._toolStartTimes.set(event.toolCallId, Date.now());
-        }
-        if (event.type === 'tool_execution_end') {
-            // Duration is computed here but consumed when the toolResult message_end arrives.
-            // We keep the start time in the map — it's read in message_end(toolResult) below.
-        }
-        // 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);
-            }
-            else if (event.message.role === 'assistant') {
-                // LLM latency: time from turn start to assistant message complete
-                const durationMs = this._turnStartTime > 0 ? Date.now() - this._turnStartTime : undefined;
-                this.sessionManager.appendMessage(event.message, durationMs);
-            }
-            else if (event.message.role === 'toolResult') {
-                // Tool execution time: from tool_execution_start to now
-                const toolCallId = event.message.toolCallId;
-                let durationMs;
-                if (toolCallId) {
-                    const startTime = this._toolStartTimes.get(toolCallId);
-                    if (startTime) {
-                        durationMs = Date.now() - startTime;
-                        this._toolStartTimes.delete(toolCallId);
-                    }
-                }
-                this.sessionManager.appendMessage(event.message, durationMs);
-            }
-            else if (event.message.role === 'user') {
-                this.sessionManager.appendMessage(event.message);
-            }
-            // Other message types (bashExecution, compactionSummary, branchSummary) are persisted elsewhere
-            // Track assistant message for auto-compaction (checked on agent_end)
-            if (event.message.role === 'assistant') {
-                this._lastAssistantMessage = event.message;
-                // Reset retry counter immediately on successful assistant response
-                // This prevents accumulation across multiple LLM calls within a turn
-                const assistantMsg = event.message;
-                if (assistantMsg.stopReason !== 'error' && this._retry.attempt > 0) {
-                    this._retry.onSuccess();
-                }
-            }
+        else {
+            this._persistence.handle(event, this.sessionManager, turnIndex);
         }
-        if (event.type === 'turn_end') {
-            const durationMs = this._turnStartTime > 0 ? Date.now() - this._turnStartTime : 0;
-            this.sessionManager.appendTurnEnd(this._turnIndex, durationMs);
+        // --- Turn counter (pipeline concern, after all consumers of turnIndex) ---
+        if (event.type === 'turn_end')
             this._turnIndex++;
+        // --- Step 5: Retry success tracking (sync) ---
+        // Reset retry counter on successful assistant response. This is a pipeline
+        // concern, not a persistence concern — it bridges persistence's lastAssistant
+        // tracking with the retry state machine.
+        if (event.type === 'message_end' && event.message.role === 'assistant') {
+            const assistantMsg = event.message;
+            if (assistantMsg.stopReason !== 'error' && this._retry.attempt > 0) {
+                this._retry.onSuccess();
+            }
         }
-        // Check auto-retry and auto-compaction after agent completes
-        if (event.type === 'agent_end' && this._lastAssistantMessage) {
-            const msg = this._lastAssistantMessage;
-            this._lastAssistantMessage = undefined;
-            // Check for retryable errors first (overloaded, rate limit, server errors)
-            if (isRetryableError(msg, this._checkContextOverflow)) {
-                const didRetry = await this._retry.handleRetryableError(msg, this.settingsManager.getRetrySettings(), {
-                    removeLastAssistantMessage: () => this._removeLastErrorGroup(),
-                    continue: () => {
-                        setTimeout(() => {
-                            this.agent.continue().catch(() => { });
-                        }, 0);
-                    }
-                });
-                if (didRetry)
-                    return; // Retry was initiated, don't proceed to compaction
+        // --- Step 6: Post-agent: retry → compaction (async, sequential, conditional) ---
+        if (event.type === 'agent_end') {
+            const lastAssistant = this._persistence.lastAssistantMessage;
+            this._persistence.clearLastAssistant();
+            if (lastAssistant) {
+                if (isRetryableError(lastAssistant, this._checkContextOverflow)) {
+                    const didRetry = await this._retry.handleRetryableError(lastAssistant, this.settingsManager.getRetrySettings(), {
+                        removeLastAssistantMessage: () => this._removeLastErrorGroup(),
+                        continue: () => {
+                            setTimeout(() => {
+                                this.agent.continue().catch(() => { });
+                            }, 0);
+                        }
+                    });
+                    if (didRetry)
+                        return;
+                }
+                await this._triggerCompactionIfNeeded(lastAssistant, true);
             }
-            await this._triggerCompactionIfNeeded(msg, true);
         }
     }
-    /** 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;
@@ -321,87 +252,6 @@ export class AgentSession {
         }
         return undefined;
     }
-    /** Emit extension events based on agent events */
-    async _emitExtensionEvent(event) {
-        if (!this._extensionRunner)
-            return;
-        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);
-            // _turnIndex is incremented in _processAgentEvent after appendTurnEnd
-        }
-        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
-            };
-            await this._extensionRunner.emit(extensionEvent);
-        }
-        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).
@@ -474,10 +324,10 @@ export class AgentSession {
     }
     /**
      * Get the names of currently active tools.
-     * Returns the names of tools currently set on the agent.
+     * Delegates to ToolRegistry (single source of truth).
      */
     getActiveToolNames() {
-        return this.agent.state.tools.map((t) => t.name);
+        return this._tools.getActiveToolNames();
     }
     /**
      * Get all configured tools with name, description, and parameter schema.
@@ -486,11 +336,7 @@ export class AgentSession {
         return this._customTools;
     }
     getAllTools() {
-        return Array.from(this._toolRegistry.values()).map((t) => ({
-            name: t.name,
-            description: t.description,
-            parameters: t.parameters
-        }));
+        return this._tools.getAllTools();
     }
     /**
      * Set active tools by name.
@@ -499,24 +345,11 @@ export class AgentSession {
      * 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.setTools(tools);
-        // Rebuild base system prompt with new tool set
-        this._baseSystemPrompt = this._rebuildSystemPrompt(validToolNames);
-        this.agent.setSystemPrompt(this._baseSystemPrompt);
+        this._tools.setActiveToolsByName(toolNames);
     }
     // SHORTCUT PATCH: allow switching system prompt mid-session (for mode switching)
     setBaseSystemPrompt(prompt) {
-        this._baseSystemPrompt = prompt;
-        this.agent.setSystemPrompt(prompt);
+        this._tools.overrideBaseSystemPrompt(prompt);
     }
     /** Whether compaction (manual or auto) is currently running */
     get isCompacting() {
@@ -550,58 +383,6 @@ export class AgentSession {
     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;
-        return buildSystemPrompt({
-            cwd: this._cwd,
-            skills: loadedSkills,
-            contextFiles: loadedContextFiles,
-            customPrompt: loaderSystemPrompt,
-            appendSystemPrompt,
-            selectedTools: validToolNames,
-            toolSnippets,
-            promptGuidelines
-        });
-    }
     // =========================================================================
     // Prompting
     // =========================================================================
@@ -657,8 +438,6 @@ export class AgentSession {
             }
             return;
         }
-        // Flush any pending bash messages before the new prompt
-        this._flushPendingBashMessages();
         // Validate model
         if (!this.model) {
             throw new LoginRequiredError();
@@ -708,7 +487,7 @@ export class AgentSession {
         this._pendingNextTurnMessages = [];
         // Emit before_agent_start extension event
         if (this._extensionRunner) {
-            const result = await this._extensionRunner.emitBeforeAgentStart(expandedText, currentImages, this._baseSystemPrompt);
+            const result = await this._extensionRunner.emitBeforeAgentStart(expandedText, currentImages, this._tools.baseSystemPrompt);
             // Add all custom messages from extensions
             if (result?.messages) {
                 for (const msg of result.messages) {
@@ -728,7 +507,7 @@ export class AgentSession {
             }
             else {
                 // Ensure we're using the base prompt (in case previous turn had modifications)
-                this.agent.setSystemPrompt(this._baseSystemPrompt);
+                this.agent.setSystemPrompt(this._tools.baseSystemPrompt);
             }
         }
         await this.agent.prompt(messages);
@@ -831,7 +610,7 @@ export class AgentSession {
      * Internal: Queue a steering message (already expanded, no extension command check).
      */
     async _queueSteer(text, images) {
-        this._steeringMessages.push(text);
+        this._queueTracker.pushSteering(text);
         const content = [{ type: 'text', text }];
         if (images) {
             content.push(...images);
@@ -846,7 +625,7 @@ export class AgentSession {
      * Internal: Queue a follow-up message (already expanded, no extension command check).
      */
     async _queueFollowUp(text, images) {
-        this._followUpMessages.push(text);
+        this._queueTracker.pushFollowUp(text);
         const content = [{ type: 'text', text }];
         if (images) {
             content.push(...images);
@@ -955,24 +734,21 @@ export class AgentSession {
      * @returns Object with steering and followUp arrays
      */
     clearQueue() {
-        const steering = [...this._steeringMessages];
-        const followUp = [...this._followUpMessages];
-        this._steeringMessages = [];
-        this._followUpMessages = [];
+        const result = this._queueTracker.clearAll();
         this.agent.clearAllQueues();
-        return { steering, followUp };
+        return result;
     }
     /** Number of pending messages (includes both steering and follow-up) */
     get pendingMessageCount() {
-        return this._steeringMessages.length + this._followUpMessages.length;
+        return this._queueTracker.pendingCount;
     }
     /** Get pending steering messages (read-only) */
     getSteeringMessages() {
-        return this._steeringMessages;
+        return this._queueTracker.steeringMessages;
     }
     /** Get pending follow-up messages (read-only) */
     getFollowUpMessages() {
-        return this._followUpMessages;
+        return this._queueTracker.followUpMessages;
     }
     get resourceLoader() {
         return this._resourceLoader;
@@ -1010,8 +786,7 @@ export class AgentSession {
         this.agent.reset();
         this.sessionManager.newSession({ parentSession: options?.parentSession });
         this.agent.sessionId = this.sessionManager.getSessionId();
-        this._steeringMessages = [];
-        this._followUpMessages = [];
+        this._queueTracker.clearAll();
         this._pendingNextTurnMessages = [];
         this.sessionManager.appendThinkingLevelChange(this.thinkingLevel);
         // Run setup callback if provided (e.g., to append initial messages)
@@ -1034,75 +809,19 @@ export class AgentSession {
         return true;
     }
     // =========================================================================
-    // Model Management
+    // Model Management (delegated to ModelManager)
     // =========================================================================
-    async _emitModelSelect(nextModel, previousModel, source) {
-        if (!this._extensionRunner)
-            return;
-        if (modelsAreEqual(previousModel, nextModel))
-            return;
-        await this._extensionRunner.emit({
-            type: 'model_select',
-            model: nextModel,
-            previousModel,
-            source
-        });
-    }
-    /**
-     * Set model directly.
-     * Validates API key, saves to session and settings.
-     * @throws Error if no API key available for the model
-     */
     async setModel(model) {
-        const apiKey = await this._modelRegistry.getApiKey(model);
-        if (!apiKey) {
-            throw new Error(`No API key for ${model.provider}/${model.id}`);
-        }
-        const previousModel = this.model;
-        this._applyModel(model);
-        this.setThinkingLevel(this.thinkingLevel);
-        await this._emitModelSelect(model, previousModel, 'set');
+        return this._models.setModel(model, this._extensionRunner);
     }
-    // SHORTCUT PATCH: simplified cycleModel — always cycles through all authed models
     async cycleModel(direction = 'forward') {
-        const availableModels = await this._modelRegistry.getAvailable();
-        const nextModel = computeNextModel(availableModels, this.model, direction);
-        if (!nextModel)
-            return undefined;
-        const apiKey = await this._modelRegistry.getApiKey(nextModel);
-        if (!apiKey) {
-            throw new Error(`No API key for ${nextModel.provider}/${nextModel.id}`);
-        }
-        const previousModel = this.model;
-        this._applyModel(nextModel);
-        this.setThinkingLevel(this.thinkingLevel);
-        await this._emitModelSelect(nextModel, previousModel, 'cycle');
-        return { model: nextModel, thinkingLevel: this.thinkingLevel };
-    }
-    /** Apply a model change to agent + persistence (no validation). */
-    _applyModel(model) {
-        this.agent.setModel(model);
-        this.sessionManager.appendModelChange(model.provider, model.id);
-        this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
+        return this._models.cycleModel(direction, this._extensionRunner);
     }
-    // =========================================================================
-    // Thinking Level Management (delegated to session-models.ts)
-    // =========================================================================
     setThinkingLevel(level) {
-        const effectiveLevel = clampThinkingLevel(level, getAvailableThinkingLevels(this.model));
-        const isChanging = effectiveLevel !== this.agent.state.thinkingLevel;
-        this.agent.setThinkingLevel(effectiveLevel);
-        if (isChanging) {
-            this.sessionManager.appendThinkingLevelChange(effectiveLevel);
-            this.settingsManager.setDefaultThinkingLevel(effectiveLevel);
-        }
+        this._models.setThinkingLevel(level);
     }
     cycleThinkingLevel() {
-        const nextLevel = computeNextThinkingLevel(this.thinkingLevel, this.model);
-        if (nextLevel === undefined)
-            return undefined;
-        this.setThinkingLevel(nextLevel);
-        return nextLevel;
+        return this._models.cycleThinkingLevel();
     }
     getAvailableThinkingLevels() {
         return getAvailableThinkingLevels(this.model);
@@ -1238,8 +957,8 @@ export class AgentSession {
             themePaths: this.buildExtensionResourcePaths(themePaths)
         };
         this._resourceLoader.extendResources(extensionPaths);
-        this._baseSystemPrompt = this._rebuildSystemPrompt(this.getActiveToolNames());
-        this.agent.setSystemPrompt(this._baseSystemPrompt);
+        const prompt = this._tools.rebuildSystemPrompt(this._tools.getActiveToolNames());
+        this._tools.overrideBaseSystemPrompt(prompt);
     }
     buildExtensionResourcePaths(entries) {
         return entries.map((entry) => {
@@ -1378,57 +1097,11 @@ export class AgentSession {
         });
     }
     _refreshToolRegistry(options) {
-        const previousRegistryNames = new Set(this._toolRegistry.keys());
-        const previousActiveToolNames = this.getActiveToolNames();
-        const registeredTools = this._extensionRunner?.getAllRegisteredTools() ?? [];
-        const allCustomTools = [
-            ...registeredTools,
-            ...this._customTools.map((def) => ({ definition: def, extensionPath: '<sdk>' }))
-        ];
-        this._toolPromptSnippets = new Map(allCustomTools
-            .map((registeredTool) => {
-            const snippet = this._normalizePromptSnippet(registeredTool.definition.promptSnippet ?? registeredTool.definition.description);
-            return snippet ? [registeredTool.definition.name, snippet] : undefined;
-        })
-            .filter((entry) => entry !== undefined));
-        this._toolPromptGuidelines = new Map(allCustomTools
-            .map((registeredTool) => {
-            const guidelines = this._normalizePromptGuidelines(registeredTool.definition.promptGuidelines);
-            return guidelines.length > 0
-                ? [registeredTool.definition.name, guidelines]
-                : undefined;
-        })
-            .filter((entry) => entry !== undefined));
-        const wrappedExtensionTools = this._extensionRunner
-            ? wrapRegisteredTools(allCustomTools, this._extensionRunner)
-            : [];
-        const toolRegistry = new Map(this._baseToolRegistry);
-        for (const tool of wrappedExtensionTools) {
-            toolRegistry.set(tool.name, tool);
-        }
-        if (this._extensionRunner) {
-            const wrappedAllTools = wrapToolsWithExtensions(Array.from(toolRegistry.values()), this._extensionRunner);
-            this._toolRegistry = new Map(wrappedAllTools.map((tool) => [tool.name, tool]));
-        }
-        else {
-            this._toolRegistry = toolRegistry;
-        }
-        const nextActiveToolNames = options?.activeToolNames
-            ? [...options.activeToolNames]
-            : [...previousActiveToolNames];
-        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)]);
+        this._tools.refresh({
+            extensionRunner: this._extensionRunner,
+            customTools: this._customTools,
+            activeToolNames: options?.activeToolNames
+        });
     }
     _buildRuntime(options) {
         const autoResizeImages = this.settingsManager.getImageAutoResize();
@@ -1439,7 +1112,7 @@ export class AgentSession {
                 read: { autoResizeImages },
                 bash: { commandPrefix: shellCommandPrefix }
             });
-        this._baseToolRegistry = new Map(Object.entries(baseTools).map(([name, tool]) => [name, tool]));
+        this._tools.setBaseTools(baseTools);
         const extensionsResult = this._resourceLoader.getExtensions();
         if (options.flagValues) {
             for (const [name, value] of options.flagValues) {
@@ -1462,8 +1135,7 @@ export class AgentSession {
         // SHORTCUT PATCH: no default tools — every agent must explicitly declare its tools
         const baseActiveToolNames = options.activeToolNames ?? [];
         this._refreshToolRegistry({
-            activeToolNames: baseActiveToolNames,
-            includeAllExtensionTools: options.includeAllExtensionTools
+            activeToolNames: baseActiveToolNames
         });
     }
     async reload() {
@@ -1477,8 +1149,7 @@ export class AgentSession {
         await this._resourceLoader.reload();
         this._buildRuntime({
             activeToolNames: this.getActiveToolNames(),
-            flagValues: previousFlagValues,
-            includeAllExtensionTools: true
+            flagValues: previousFlagValues
         });
         const hasBindings = this._extensionUIContext ||
             this._extensionCommandContextActions ||
@@ -1509,33 +1180,6 @@ export class AgentSession {
         this.settingsManager.setRetryEnabled(enabled);
     }
     // =========================================================================
-    // Bash Execution (delegated to SessionBash)
-    // =========================================================================
-    _bashActions = {
-        appendToAgent: (msg) => this.agent.appendMessage(msg),
-        persistToSession: (msg) => this.sessionManager.appendMessage(msg),
-        isStreaming: () => this.isStreaming,
-        getShellCommandPrefix: () => this.settingsManager.getShellCommandPrefix()
-    };
-    async executeBash(command, onChunk, options) {
-        return this._bash.execute(command, this._bashActions, onChunk, options);
-    }
-    recordBashResult(command, result, options) {
-        this._bash.record(command, result, this._bashActions, options);
-    }
-    abortBash() {
-        this._bash.abort();
-    }
-    get isBashRunning() {
-        return this._bash.isRunning;
-    }
-    get hasPendingBashMessages() {
-        return this._bash.hasPendingMessages;
-    }
-    _flushPendingBashMessages() {
-        this._bash.flush(this._bashActions);
-    }
-    // =========================================================================
     // Session Management
     // =========================================================================
     /**
@@ -1559,8 +1203,7 @@ export class AgentSession {
         }
         this._disconnectFromAgent();
         await this.abort();
-        this._steeringMessages = [];
-        this._followUpMessages = [];
+        this._queueTracker.clearAll();
         this._pendingNextTurnMessages = [];
         // Set new session
         this.sessionManager.setSessionFile(sessionPath);
@@ -1579,12 +1222,10 @@ export class AgentSession {
         this.agent.replaceMessages(sessionContext.messages);
         // Restore model if saved
         if (sessionContext.model) {
-            const previousModel = this.model;
             const availableModels = await this._modelRegistry.getAvailable();
             const match = availableModels.find((m) => m.provider === sessionContext.model.provider && m.id === sessionContext.model.modelId);
             if (match) {
-                this.agent.setModel(match);
-                await this._emitModelSelect(match, previousModel, 'restore');
+                await this._models.restoreModel(match, this._extensionRunner);
             }
         }
         const hasThinkingEntry = this.sessionManager
@@ -1596,9 +1237,8 @@ export class AgentSession {
             this.setThinkingLevel(sessionContext.thinkingLevel);
         }
         else {
-            const effectiveLevel = clampThinkingLevel(defaultThinkingLevel, this.getAvailableThinkingLevels());
-            this.agent.setThinkingLevel(effectiveLevel);
-            this.sessionManager.appendThinkingLevelChange(effectiveLevel);
+            // Set thinking level without persisting — we're restoring, not changing
+            this._models.setThinkingLevel(defaultThinkingLevel);
         }
         this._reconnectToAgent();
         return true;