erosolar-cli 1.7.195 → 1.7.196

package/dist/shell/interactiveShell.js

@@ -0,0 +1,3339 @@
+import { stdin as input, stdout as output, exit } from 'node:process';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { display } from '../ui/display.js';
+import { formatUserPrompt, theme } from '../ui/theme.js';
+import { getContextWindowTokens } from '../core/contextWindow.js';
+import { ensureSecretForProvider, getSecretDefinitionForProvider, getSecretValue, listSecretDefinitions, maskSecret, setSecretValue, } from '../core/secretStore.js';
+import { saveActiveProfilePreference, saveModelPreference, loadToolSettings, saveToolSettings, clearToolSettings, clearActiveProfilePreference, loadSessionPreferences, saveSessionPreferences, } from '../core/preferences.js';
+import { buildEnabledToolSet, evaluateToolPermissions, getToolToggleOptions, } from '../capabilities/toolRegistry.js';
+import { detectApiKeyError } from '../core/errors/apiKeyErrors.js';
+import { buildWorkspaceContext } from '../workspace.js';
+import { buildInteractiveSystemPrompt } from './systemPrompt.js';
+import { getTaskCompletionDetector, resetTaskCompletionDetector, } from './taskCompletionDetector.js';
+import { discoverAllModels, quickCheckProviders, getCachedDiscoveredModels, sortModelsByPriority } from '../core/modelDiscovery.js';
+import { getModels, getSlashCommands, getProviders } from '../core/agentSchemaLoader.js';
+import { clearAutosaveSnapshot, deleteSession, listSessions, loadAutosaveSnapshot, loadSessionById, saveAutosaveSnapshot, saveSessionSnapshot, } from '../core/sessionStore.js';
+import { buildCustomCommandPrompt, loadCustomSlashCommands, } from '../core/customCommands.js';
+import { SkillRepository } from '../skills/skillRepository.js';
+import { createSkillTools } from '../tools/skillTools.js';
+import { FileChangeTracker } from './fileChangeTracker.js';
+import { formatShortcutsHelp } from '../ui/shortcutsHelp.js';
+import { MetricsTracker } from '../alpha-zero/index.js';
+import { listAvailablePlugins } from '../plugins/index.js';
+import { TerminalInputAdapter } from './terminalInputAdapter.js';
+const execAsync = promisify(exec);
+const DROPDOWN_COLORS = [
+    theme.primary,
+    theme.info,
+    theme.accent,
+    theme.secondary,
+    theme.success,
+    theme.warning,
+];
+// Load MODEL_PRESETS from centralized schema
+const MODEL_PRESETS = getModels().map((model) => ({
+    id: model.id,
+    label: model.label,
+    provider: model.provider,
+    description: model.description ?? '',
+    reasoningEffort: model.reasoningEffort,
+    temperature: model.temperature,
+    maxTokens: model.maxTokens,
+}));
+// Load BASE_SLASH_COMMANDS from centralized schema
+const BASE_SLASH_COMMANDS = getSlashCommands().map((cmd) => ({
+    command: cmd.command,
+    description: cmd.description,
+}));
+// Load PROVIDER_LABELS from centralized schema
+const PROVIDER_LABELS = Object.fromEntries(getProviders().map((provider) => [provider.id, provider.label]));
+// Allow enough time for paste detection to kick in before flushing buffered lines
+const CONTEXT_USAGE_THRESHOLD = 0.9;
+const CONTEXT_RECENT_MESSAGE_COUNT = 12;
+const CONTEXT_CLEANUP_CHARS_PER_CHUNK = 6000;
+const CONTEXT_CLEANUP_MAX_OUTPUT_TOKENS = 800;
+const CONTEXT_CLEANUP_SYSTEM_PROMPT = `You condense earlier IDE collaboration logs so the agent can keep working.
+- Merge any prior summary with the new conversation chunk.
+- Capture key decisions, TODOs, file edits, tool observations, and open questions.
+- Clearly distinguish resolved work from outstanding follow-ups.
+- Keep the response under roughly 200 words, prefer short bullet lists.
+- Never call tools or run shell commands; respond with plain Markdown text only.`;
+export class InteractiveShell {
+    agent = null;
+    profile;
+    profileLabel;
+    workingDir;
+    runtimeSession;
+    baseSystemPrompt;
+    workspaceOptions;
+    sessionState;
+    isProcessing = false;
+    shuttingDown = false;
+    pendingInteraction = null;
+    pendingSecretRetry = null;
+    terminalInput;
+    currentInput = '';
+    pendingCleanup = null;
+    cleanupInProgress = false;
+    slashPreviewVisible = false;
+    skillRepository;
+    skillToolHandlers = new Map();
+    thinkingMode = 'balanced';
+    agentMenu;
+    slashCommands;
+    bannerSessionState = null;
+    statusTracker;
+    uiAdapter;
+    _fileChangeTracker = new FileChangeTracker(); // Reserved for future file tracking features
+    alphaZeroMetrics; // Alpha Zero 2 performance tracking
+    statusSubscription = null;
+    followUpQueue = [];
+    isDrainingQueue = false;
+    activeContextWindowTokens = null;
+    sessionPreferences;
+    autosaveEnabled;
+    autoContinueEnabled;
+    editGuardMode = 'display-edits';
+    pendingPermissionInput = null;
+    pendingHistoryLoad = null;
+    cachedHistory = [];
+    activeSessionId = null;
+    activeSessionTitle = null;
+    sessionResumeNotice = null;
+    customCommands;
+    customCommandMap;
+    sessionRestoreConfig;
+    _enabledPlugins;
+    // Cached provider status for unified status bar display after streaming
+    cachedProviderStatus = [];
+    // Auto-test tracking
+    autoTestInFlight = false;
+    lastAutoTestRun = null;
+    // Streaming UX tracking
+    streamingHeartbeat = null;
+    streamingHeartbeatStart = null;
+    streamingHeartbeatFrame = 0;
+    promptRefreshTimer = null;
+    constructor(config) {
+        this.profile = config.profile;
+        this.profileLabel = config.profileLabel;
+        this.workingDir = config.workingDir;
+        this.runtimeSession = config.session;
+        this.baseSystemPrompt = config.baseSystemPrompt;
+        this.workspaceOptions = { ...config.workspaceOptions };
+        this.sessionPreferences = loadSessionPreferences();
+        this.thinkingMode = this.sessionPreferences.thinkingMode;
+        this.autosaveEnabled = this.sessionPreferences.autosave;
+        this.autoContinueEnabled = this.sessionPreferences.autoContinue;
+        this.sessionRestoreConfig = config.sessionRestore ?? { mode: 'none' };
+        this._enabledPlugins = config.enabledPlugins ?? [];
+        this.initializeSessionHistory();
+        this.sessionState = {
+            provider: config.initialModel.provider,
+            model: config.initialModel.model,
+            temperature: config.initialModel.temperature,
+            maxTokens: config.initialModel.maxTokens,
+            reasoningEffort: config.initialModel.reasoningEffort,
+        };
+        this.applyPresetReasoningDefaults();
+        // The welcome banner only includes model + provider on launch, so mark that as the initial state.
+        this.bannerSessionState = {
+            model: this.sessionState.model,
+            provider: this.sessionState.provider,
+        };
+        this.agentMenu = config.agentSelection ?? null;
+        this.slashCommands = [...BASE_SLASH_COMMANDS];
+        if (this.agentMenu) {
+            this.slashCommands.push({
+                command: '/agents',
+                description: 'Select the default agent profile (applies on next launch)',
+            });
+        }
+        this.customCommands = loadCustomSlashCommands();
+        this.customCommandMap = new Map(this.customCommands.map((command) => [command.command, command]));
+        for (const custom of this.customCommands) {
+            this.slashCommands.push({
+                command: custom.command,
+                description: `${custom.description} (custom)`,
+            });
+        }
+        // Add /plugins command
+        this.slashCommands.push({
+            command: '/plugins',
+            description: 'Show available and loaded plugins',
+        });
+        this.statusTracker = config.statusTracker;
+        this.uiAdapter = config.uiAdapter;
+        // Set up file change tracking callback
+        this.uiAdapter.setFileChangeCallback((path, type, additions, removals) => {
+            this._fileChangeTracker.recordChange(path, type, additions, removals);
+        });
+        // Set up tool status callback to update status during tool execution
+        this.uiAdapter.setToolStatusCallback((status) => {
+            this.updateStatusMessage(status ?? null);
+        });
+        this.skillRepository = new SkillRepository({
+            workingDir: this.workingDir,
+            env: process.env,
+        });
+        for (const definition of createSkillTools({ repository: this.skillRepository })) {
+            this.skillToolHandlers.set(definition.name, definition.handler);
+        }
+        // Initialize unified terminal input handler
+        this.terminalInput = new TerminalInputAdapter(input, output, {
+            onSubmit: (text) => this.processInput(text),
+            onQueue: (text) => this.handleQueuedInput(text),
+            onInterrupt: () => this.handleInterrupt(),
+            onChange: (text) => this.handleInputChange(text),
+            onEditModeChange: (mode) => this.handleEditModeChange(mode),
+        });
+        // Register output interceptor for cursor positioning during streaming
+        this.terminalInput.registerOutputInterceptor(display);
+        // Initialize Alpha Zero 2 metrics tracking
+        this.alphaZeroMetrics = new MetricsTracker(`${this.profile}-${Date.now()}`);
+        this.setupStatusTracking();
+        this.refreshContextGauge();
+        this.terminalInput.start();
+        this.rebuildAgent();
+        this.setupHandlers();
+        this.refreshBannerSessionInfo();
+    }
+    initializeSessionHistory() {
+        this.cachedHistory = [];
+        this.pendingHistoryLoad = null;
+        this.activeSessionId = null;
+        this.activeSessionTitle = null;
+        this.sessionResumeNotice = null;
+        // Handle explicit session restore requests via CLI flags
+        if (this.sessionRestoreConfig.mode === 'session-id' && this.sessionRestoreConfig.sessionId) {
+            const stored = loadSessionById(this.sessionRestoreConfig.sessionId);
+            if (stored) {
+                this.cachedHistory = stored.messages;
+                this.pendingHistoryLoad = stored.messages;
+                this.activeSessionId = stored.id;
+                this.activeSessionTitle = stored.title;
+                this.sessionResumeNotice = `Resumed session "${stored.title}".`;
+                return;
+            }
+            display.showWarning(`Session "${this.sessionRestoreConfig.sessionId}" not found. Starting fresh session.`);
+            return;
+        }
+        if (this.sessionRestoreConfig.mode === 'autosave') {
+            const autosave = loadAutosaveSnapshot(this.profile);
+            if (autosave) {
+                this.cachedHistory = autosave.messages;
+                this.pendingHistoryLoad = autosave.messages;
+                this.activeSessionId = null;
+                this.activeSessionTitle = autosave.title;
+                this.sessionResumeNotice = 'Restored last autosaved session.';
+                return;
+            }
+            display.showWarning('No autosaved session found. Starting fresh session.');
+        }
+        // Default: Start fresh (mode === 'none')
+    }
+    showSessionResumeNotice() {
+        if (!this.sessionResumeNotice) {
+            return;
+        }
+        display.showInfo(this.sessionResumeNotice);
+        this.sessionResumeNotice = null;
+    }
+    async start(initialPrompt) {
+        if (initialPrompt) {
+            display.newLine();
+            console.log(`${formatUserPrompt(this.profileLabel || this.profile)}${initialPrompt}`);
+            await this.processInputBlock(initialPrompt);
+            return;
+        }
+        // Ensure the terminal input is visible
+        this.terminalInput.render();
+    }
+    /**
+     * TerminalInputAdapter submit handler
+     */
+    processInput(text) {
+        const approved = this.resolveEditPermission(text);
+        if (!approved) {
+            this.handleInputChange('');
+            return;
+        }
+        this.handleInputChange('');
+        void this.processInputBlock(approved).catch((err) => {
+            display.showError(err instanceof Error ? err.message : String(err), err);
+        });
+    }
+    /**
+     * TerminalInputAdapter queue handler (streaming mode)
+     */
+    handleQueuedInput(text) {
+        // Keep adapter queue trimmed so hints stay accurate
+        this.terminalInput.dequeue();
+        this.followUpQueue.push({ type: 'request', text });
+        display.showInfo(`Queued: "${text}"`);
+        this.refreshQueueIndicators();
+        this.scheduleQueueProcessing();
+        this.handleInputChange('');
+    }
+    /**
+     * TerminalInputAdapter change handler
+     */
+    handleInputChange(text) {
+        this.currentInput = text;
+        this.handleSlashCommandPreviewChange();
+    }
+    /**
+     * Edit guard mode change handler (Shift+Tab from terminal input)
+     */
+    handleEditModeChange(mode) {
+        this.editGuardMode = mode;
+        this.pendingPermissionInput = null;
+        if (mode === 'ask-permission') {
+            display.showSystemMessage('🛡️ Ask-to-edit mode enabled. Confirm each request before sending.');
+        }
+        else {
+            display.showSystemMessage('✏️ Display edits mode enabled.');
+        }
+        this.terminalInput.render();
+    }
+    /**
+     * Gate submissions when edit permission mode is active.
+     * Returns the text to send when approved, or null when waiting for confirmation.
+     */
+    resolveEditPermission(text) {
+        if (this.editGuardMode !== 'ask-permission') {
+            this.pendingPermissionInput = null;
+            return text;
+        }
+        const trimmed = text.trim();
+        const lower = trimmed.toLowerCase();
+        if (this.pendingPermissionInput === null) {
+            this.pendingPermissionInput = text;
+            this.showPermissionPrompt(text, false);
+            return null;
+        }
+        if (!trimmed || lower === 'y' || lower === 'yes') {
+            const toSend = this.pendingPermissionInput;
+            this.pendingPermissionInput = null;
+            return toSend;
+        }
+        if (['n', 'no', 'cancel', '/cancel'].includes(lower)) {
+            this.pendingPermissionInput = null;
+            display.showInfo('Request cancelled.');
+            this.terminalInput.render();
+            return null;
+        }
+        // Treat any other input as a replacement request that also needs confirmation
+        this.pendingPermissionInput = text;
+        this.showPermissionPrompt(text, true);
+        return null;
+    }
+    showPermissionPrompt(text, updated) {
+        const singleLine = text.replace(/\s+/g, ' ').trim();
+        const preview = singleLine.length > 120 ? `${singleLine.slice(0, 117)}...` : singleLine;
+        const prefix = updated ? 'Updated request captured.' : 'Edit permission required.';
+        display.showSystemMessage([
+            `${prefix} Press Enter again (or type "yes") to allow edits, or type "cancel" to abort.`,
+            preview ? `Pending: "${preview}"` : '',
+        ]
+            .filter(Boolean)
+            .join('\n'));
+        this.terminalInput.render();
+    }
+    /**
+     * TerminalInputAdapter interrupt handler (Ctrl+C with empty buffer)
+     */
+    handleInterrupt() {
+        if (this.isProcessing && this.agent) {
+            this.agent.requestCancellation();
+            display.showWarning('Cancelling current operation... (Ctrl+C again to force quit)');
+            return;
+        }
+        this.shutdown();
+    }
+    /**
+     * Gracefully tear down the shell and exit
+     */
+    shutdown() {
+        if (this.shuttingDown) {
+            return;
+        }
+        this.shuttingDown = true;
+        // Stop any active spinner to prevent process hang
+        display.stopThinking(false);
+        this.stopStreamingHeartbeat();
+        this.clearPromptRefreshTimer();
+        this.teardownStatusTracking();
+        // Clear any pending cleanup to prevent hanging
+        this.pendingCleanup = null;
+        // Dispose terminal input handler
+        this.terminalInput.dispose();
+        // Dispose unified UI adapter
+        this.uiAdapter.dispose();
+        display.newLine();
+        const highlightedEmail = theme.info('support@ero.solar');
+        const infoMessage = [
+            'Thank you to Anthropic for allowing me to use Claude Code to build erosolar-cli.',
+            'https://www.anthropic.com/news/disrupting-AI-espionage',
+            '',
+            `Email ${highlightedEmail} with any bugs or feedback`,
+            'GitHub: https://github.com/ErosolarAI/erosolar-by-bo',
+            'npm: https://www.npmjs.com/package/erosolar-cli',
+        ].join('\n');
+        display.showInfo(infoMessage);
+        exit(0);
+    }
+    /**
+     * Update status bar message
+     */
+    updateStatusMessage(_message) {
+        this.terminalInput.render();
+    }
+    async handleToolSettingsInput(input) {
+        const pending = this.pendingInteraction;
+        if (!pending || pending.type !== 'tool-settings') {
+            return;
+        }
+        const trimmed = input.trim();
+        if (!trimmed) {
+            display.showWarning('Enter a number, "save", "defaults", or "cancel".');
+            this.terminalInput.render();
+            return;
+        }
+        const normalized = trimmed.toLowerCase();
+        if (normalized === 'cancel') {
+            this.pendingInteraction = null;
+            display.showInfo('Tool selection cancelled.');
+            this.terminalInput.render();
+            return;
+        }
+        if (normalized === 'defaults') {
+            pending.selection = buildEnabledToolSet(null);
+            this.renderToolMenu(pending);
+            this.terminalInput.render();
+            return;
+        }
+        if (normalized === 'save') {
+            await this.persistToolSelection(pending);
+            this.pendingInteraction = null;
+            this.terminalInput.render();
+            return;
+        }
+        const choice = Number.parseInt(trimmed, 10);
+        if (Number.isFinite(choice)) {
+            const option = pending.options[choice - 1];
+            if (!option) {
+                display.showWarning('That option is not available.');
+            }
+            else {
+                if (pending.selection.has(option.id)) {
+                    pending.selection.delete(option.id);
+                }
+                else {
+                    pending.selection.add(option.id);
+                }
+                this.renderToolMenu(pending);
+            }
+            this.terminalInput.render();
+            return;
+        }
+        display.showWarning('Enter a number, "save", "defaults", or "cancel".');
+        this.terminalInput.render();
+    }
+    async persistToolSelection(interaction) {
+        if (setsEqual(interaction.selection, interaction.initialSelection)) {
+            display.showInfo('No changes to save.');
+            return;
+        }
+        const defaults = buildEnabledToolSet(null);
+        if (setsEqual(interaction.selection, defaults)) {
+            clearToolSettings();
+            display.showInfo('Tool settings cleared. Defaults will be used on the next launch.');
+            return;
+        }
+        const ordered = interaction.options
+            .map((option) => option.id)
+            .filter((id) => interaction.selection.has(id));
+        saveToolSettings({ enabledTools: ordered });
+        display.showInfo('Tool settings saved. Restart the CLI to apply them.');
+    }
+    async handleAgentSelectionInput(input) {
+        const pending = this.pendingInteraction;
+        if (!pending || pending.type !== 'agent-selection') {
+            return;
+        }
+        if (!this.agentMenu) {
+            this.pendingInteraction = null;
+            display.showWarning('Agent selection is unavailable in this CLI.');
+            this.terminalInput.render();
+            return;
+        }
+        const trimmed = input.trim();
+        if (!trimmed) {
+            display.showWarning('Enter a number or type "cancel".');
+            this.terminalInput.render();
+            return;
+        }
+        if (trimmed.toLowerCase() === 'cancel') {
+            this.pendingInteraction = null;
+            display.showInfo('Agent selection cancelled.');
+            this.terminalInput.render();
+            return;
+        }
+        const choice = Number.parseInt(trimmed, 10);
+        if (!Number.isFinite(choice)) {
+            display.showWarning('Please enter a valid number.');
+            this.terminalInput.render();
+            return;
+        }
+        const option = pending.options[choice - 1];
+        if (!option) {
+            display.showWarning('That option is not available.');
+            this.terminalInput.render();
+            return;
+        }
+        await this.persistAgentSelection(option.name);
+        this.pendingInteraction = null;
+        this.terminalInput.render();
+    }
+    async persistAgentSelection(profileName) {
+        if (!this.agentMenu) {
+            return;
+        }
+        const currentDefault = this.agentMenu.persistedProfile ?? this.agentMenu.defaultProfile;
+        if (profileName === currentDefault) {
+            display.showInfo(`${this.agentMenuLabel(profileName)} is already configured for the next launch.`);
+            return;
+        }
+        if (profileName === this.agentMenu.defaultProfile) {
+            clearActiveProfilePreference();
+            this.agentMenu.persistedProfile = null;
+            display.showInfo(`${this.agentMenuLabel(profileName)} restored as the default agent. Restart the CLI to switch.`);
+            return;
+        }
+        saveActiveProfilePreference(profileName);
+        this.agentMenu.persistedProfile = profileName;
+        display.showInfo(`${this.agentMenuLabel(profileName)} will load the next time you start the CLI. Restart to switch now.`);
+    }
+    setupHandlers() {
+        // Handle terminal resize
+        output.on('resize', () => {
+            this.terminalInput.handleResize();
+        });
+        // Show initial input UI
+        this.terminalInput.render();
+    }
+    setupStatusTracking() {
+        this.statusSubscription = this.statusTracker.subscribe((_state) => {
+            // Status tracking callback - currently no-op
+        });
+        this.setIdleStatus();
+    }
+    teardownStatusTracking() {
+        if (this.statusSubscription) {
+            this.statusSubscription();
+            this.statusSubscription = null;
+        }
+        this.statusTracker.reset();
+    }
+    setIdleStatus(detail) {
+        this.statusTracker.setBase('Ready for prompts', {
+            detail: this.describeStatusDetail(detail),
+            tone: 'success',
+        });
+    }
+    setProcessingStatus(detail) {
+        this.statusTracker.setBase('Working on your request', {
+            detail: this.describeStatusDetail(detail),
+            tone: 'info',
+        });
+    }
+    describeStatusDetail(detail) {
+        const parts = [detail?.trim() || this.describeModelDetail()];
+        const queued = this.followUpQueue.length;
+        if (queued > 0) {
+            parts.push(`${queued} follow-up${queued === 1 ? '' : 's'} queued`);
+        }
+        return parts.join(' • ');
+    }
+    describeModelDetail() {
+        const provider = this.providerLabel(this.sessionState.provider);
+        return `${provider} · ${this.sessionState.model}`;
+    }
+    refreshContextGauge() {
+        const tokens = getContextWindowTokens(this.sessionState.model);
+        this.activeContextWindowTokens =
+            typeof tokens === 'number' && Number.isFinite(tokens) ? tokens : null;
+    }
+    updateContextUsage(percentage) {
+        this.uiAdapter.updateContextUsage(percentage);
+        this.terminalInput.setContextUsage(percentage);
+    }
+    handleSlashCommandPreviewChange() {
+        if (this.pendingInteraction) {
+            this.slashPreviewVisible = false;
+            return;
+        }
+        const shouldShow = this.shouldShowSlashCommandPreview();
+        if (shouldShow && !this.slashPreviewVisible) {
+            this.slashPreviewVisible = true;
+            this.showSlashCommandPreview();
+            return;
+        }
+        if (!shouldShow && this.slashPreviewVisible) {
+            this.slashPreviewVisible = false;
+            this.uiAdapter.hideSlashCommandPreview();
+        }
+    }
+    shouldShowSlashCommandPreview() {
+        const line = this.currentInput ?? '';
+        if (!line.trim()) {
+            return false;
+        }
+        const trimmed = line.trimStart();
+        return trimmed.startsWith('/');
+    }
+    showSlashCommandPreview() {
+        // Filter commands based on current input
+        const line = this.currentInput ?? '';
+        const trimmed = line.trimStart();
+        // Filter commands that match the current input
+        const filtered = this.slashCommands.filter(cmd => cmd.command.startsWith(trimmed) || trimmed === '/');
+        // Show in the unified UI with dynamic overlay
+        this.uiAdapter.showSlashCommandPreview(filtered);
+        // Don't reprompt - this causes flickering
+    }
+    /**
+     * Ensure the terminal input is ready for interactive input.
+     */
+    ensureReadlineReady() {
+        this.terminalInput.render();
+    }
+    requestPromptRefresh(force = false) {
+        if (force) {
+            this.terminalInput.forceRender();
+            return;
+        }
+        if (this.promptRefreshTimer) {
+            return;
+        }
+        this.promptRefreshTimer = setTimeout(() => {
+            this.promptRefreshTimer = null;
+            this.terminalInput.render();
+        }, 48);
+    }
+    clearPromptRefreshTimer() {
+        if (this.promptRefreshTimer) {
+            clearTimeout(this.promptRefreshTimer);
+            this.promptRefreshTimer = null;
+        }
+    }
+    startStreamingHeartbeat(label = 'Streaming response') {
+        this.stopStreamingHeartbeat();
+        this.streamingHeartbeatStart = Date.now();
+        this.streamingHeartbeatFrame = 0;
+        const frames = ['●', '◐', '◉', '◐'];
+        const tick = () => {
+            const frame = frames[this.streamingHeartbeatFrame % frames.length];
+            this.streamingHeartbeatFrame++;
+            const elapsed = this.streamingHeartbeatStart
+                ? Math.floor((Date.now() - this.streamingHeartbeatStart) / 1000)
+                : 0;
+            const suffix = elapsed > 0 ? ` • ${elapsed}s` : '';
+            display.updateStreamingStatus(`${theme.info(frame)} ${label}${suffix}`);
+            this.requestPromptRefresh();
+        };
+        tick();
+        this.streamingHeartbeat = setInterval(tick, 2000);
+    }
+    stopStreamingHeartbeat() {
+        if (this.streamingHeartbeat) {
+            clearInterval(this.streamingHeartbeat);
+            this.streamingHeartbeat = null;
+        }
+        this.streamingHeartbeatStart = null;
+        display.clearStreamingStatus();
+        this.requestPromptRefresh();
+    }
+    refreshQueueIndicators() {
+        if (this.isProcessing) {
+            this.setProcessingStatus();
+        }
+        else {
+            this.setIdleStatus();
+        }
+        this.terminalInput.render();
+    }
+    enqueueFollowUpAction(action) {
+        this.followUpQueue.push(action);
+        const normalized = action.text.replace(/\s+/g, ' ').trim();
+        const previewLimit = 80;
+        const preview = normalized.length > previewLimit ? `${normalized.slice(0, previewLimit - 3)}...` : normalized;
+        const position = this.followUpQueue.length === 1 ? 'to run next' : `#${this.followUpQueue.length} in queue`;
+        const label = action.type === 'continuous' ? 'continuous command' : 'follow-up';
+        // Show immediate acknowledgment with checkmark
+        if (preview) {
+            display.showInfo(`✓ ${theme.info(label)} ${position}: ${theme.ui.muted(preview)}`);
+        }
+        else {
+            display.showInfo(`✓ ${theme.info(label)} queued ${position}.`);
+        }
+        this.refreshQueueIndicators();
+        this.scheduleQueueProcessing();
+        // Re-show the prompt so user can continue typing more follow-ups
+        this.terminalInput.render();
+    }
+    scheduleQueueProcessing() {
+        if (!this.followUpQueue.length) {
+            this.refreshQueueIndicators();
+            return;
+        }
+        queueMicrotask(() => {
+            void this.processQueuedActions();
+        });
+    }
+    /**
+     * Process queued follow-up actions.
+     */
+    async processQueuedActions() {
+        if (this.isDrainingQueue || this.isProcessing || !this.followUpQueue.length) {
+            return;
+        }
+        this.isDrainingQueue = true;
+        try {
+            while (!this.isProcessing && this.followUpQueue.length) {
+                const next = this.followUpQueue.shift();
+                const remaining = this.followUpQueue.length;
+                const label = next.type === 'continuous' ? 'continuous command' : 'follow-up';
+                const suffix = remaining ? ` (${remaining} left after this)` : '';
+                display.showSystemMessage(`▶ Running queued ${label}${suffix}.`);
+                this.refreshQueueIndicators();
+                if (next.type === 'continuous') {
+                    await this.processContinuousRequest(next.text);
+                }
+                else {
+                    await this.processRequest(next.text);
+                }
+            }
+        }
+        finally {
+            this.isDrainingQueue = false;
+            this.refreshQueueIndicators();
+        }
+    }
+    async processInputBlock(line, _wasRapidMultiLine = false) {
+        this.slashPreviewVisible = false;
+        this.uiAdapter.hideSlashCommandPreview();
+        const trimmed = line.trim();
+        if (await this.handlePendingInteraction(trimmed)) {
+            return;
+        }
+        if (!trimmed) {
+            return;
+        }
+        const lower = trimmed.toLowerCase();
+        if (lower === 'exit' || lower === 'quit') {
+            this.shutdown();
+            return;
+        }
+        if (lower === 'clear') {
+            display.clear();
+            this.terminalInput.render();
+            return;
+        }
+        if (lower === 'help') {
+            this.showHelp();
+            this.terminalInput.render();
+            return;
+        }
+        if (trimmed.startsWith('/')) {
+            await this.processSlashCommand(trimmed);
+            return;
+        }
+        // Check for continuous/infinite loop commands
+        if (this.isContinuousCommand(trimmed)) {
+            await this.processContinuousRequest(trimmed);
+            this.terminalInput.render();
+            return;
+        }
+        // Direct execution for all inputs, including multi-line pastes
+        await this.processRequest(trimmed);
+        this.terminalInput.render();
+    }
+    /**
+     * Check if the command is a continuous/infinite loop command
+     * These commands run until the task is complete or user interrupts
+     */
+    isContinuousCommand(input) {
+        const lower = input.toLowerCase().trim();
+        const patterns = [
+            /^(keep going|continue|finish|until done|run until done|complete|finish it|keep working)/i,
+            /\b(until done|until complete|until finished|to completion|to the end)\b/i,
+            /^(do it|just do it|make it work|fix it all|finish everything)\b/i,
+        ];
+        return patterns.some(pattern => pattern.test(lower));
+    }
+    /**
+     * Check if the request is a self-improvement task
+     * These requests should use git to track changes
+     */
+    isSelfImprovementRequest(input) {
+        const lower = input.toLowerCase();
+        const patterns = [
+            /\b(improve|enhance|upgrade|refactor|optimize)\b.*\b(codebase|code|project|app|application)\b/i,
+            /\b(self[- ]?improv|self[- ]?modif|self[- ]?updat)/i,
+            /\b(make.*better|add.*feature|fix.*bug|implement)/i,
+            /\b(ability to code|coding capabilit)/i,
+        ];
+        return patterns.some(pattern => pattern.test(lower));
+    }
+    async handlePendingInteraction(input) {
+        if (!this.pendingInteraction) {
+            return false;
+        }
+        switch (this.pendingInteraction.type) {
+            case 'model-provider':
+                await this.handleModelProviderSelection(input);
+                return true;
+            case 'model':
+                await this.handleModelSelection(input);
+                return true;
+            case 'secret-select':
+                await this.handleSecretSelection(input);
+                return true;
+            case 'secret-input':
+                await this.handleSecretInput(input);
+                return true;
+            case 'tool-settings':
+                await this.handleToolSettingsInput(input);
+                return true;
+            case 'agent-selection':
+                await this.handleAgentSelectionInput(input);
+                return true;
+            default:
+                return false;
+        }
+    }
+    async processSlashCommand(input) {
+        const [command] = input.split(/\s+/);
+        if (!command) {
+            display.showWarning('Enter a slash command.');
+            this.terminalInput.render();
+            return;
+        }
+        switch (command) {
+            case '/model':
+                this.showModelMenu();
+                break;
+            case '/secrets':
+                this.showSecretsMenu();
+                break;
+            case '/tools':
+                this.showToolsMenu();
+                break;
+            case '/doctor':
+                this.runDoctor();
+                break;
+            case '/checks':
+                await this.runRepoChecksCommand();
+                break;
+            case '/context':
+                await this.refreshWorkspaceContextCommand(input);
+                break;
+            case '/agents':
+                this.showAgentsMenu();
+                break;
+            case '/sessions':
+                await this.handleSessionCommand(input);
+                break;
+            case '/skills':
+                await this.handleSkillsCommand(input);
+                break;
+            case '/thinking':
+                this.handleThinkingCommand(input);
+                break;
+            case '/autocontinue':
+                this.handleAutoContinueCommand(input);
+                break;
+            case '/shortcuts':
+            case '/keys':
+                this.handleShortcutsCommand();
+                break;
+            case '/changes':
+            case '/summary':
+                this.showFileChangeSummary();
+                break;
+            case '/metrics':
+            case '/stats':
+            case '/perf':
+                this.showAlphaZeroMetrics();
+                break;
+            case '/suggestions':
+            case '/improve':
+                this.showImprovementSuggestions();
+                break;
+            case '/plugins':
+                this.showPluginStatus();
+                break;
+            case '/provider':
+                await this.handleProviderCommand(input);
+                break;
+            case '/providers':
+                this.showConfiguredProviders();
+                break;
+            case '/local':
+                await this.handleLocalCommand(input);
+                break;
+            case '/discover':
+                await this.discoverModelsCommand();
+                break;
+            default:
+                if (!(await this.tryCustomSlashCommand(command, input))) {
+                    display.showWarning(`Unknown command "${command}".`);
+                }
+                break;
+        }
+        this.terminalInput.render();
+    }
+    async tryCustomSlashCommand(command, fullInput) {
+        const custom = this.customCommandMap.get(command);
+        if (!custom) {
+            return false;
+        }
+        const args = fullInput.slice(command.length).trim();
+        if (custom.requireInput && !args) {
+            display.showWarning(`${command} requires additional input.`);
+            return true;
+        }
+        const prompt = buildCustomCommandPrompt(custom, args, {
+            workspace: this.workingDir,
+            profile: this.profile,
+            provider: this.sessionState.provider,
+            model: this.sessionState.model,
+        }).trim();
+        if (!prompt) {
+            display.showWarning(`Custom command ${command} did not produce any text. Check ${custom.source} for errors.`);
+            return true;
+        }
+        display.showInfo(`Running ${command} from ${custom.source}...`);
+        await this.processRequest(prompt);
+        return true;
+    }
+    showHelp() {
+        const info = [
+            this.buildSlashCommandList('Available Commands:'),
+            '',
+            'Type your request in natural language and press Enter.',
+        ];
+        display.showSystemMessage(info.join('\n'));
+    }
+    runDoctor() {
+        const lines = [];
+        lines.push(theme.bold('Environment diagnostics'));
+        lines.push('');
+        lines.push(`${theme.secondary('Workspace')}: ${this.workingDir}`);
+        lines.push('');
+        lines.push(theme.bold('Provider credentials'));
+        const providerDefinition = getSecretDefinitionForProvider(this.sessionState.provider);
+        if (providerDefinition) {
+            const currentValue = getSecretValue(providerDefinition.id);
+            if (currentValue) {
+                lines.push(`${theme.success('✓')} ${providerDefinition.label} configured (${providerDefinition.envVar}).`);
+            }
+            else {
+                lines.push(`${theme.warning('⚠')} Missing ${providerDefinition.label} (${providerDefinition.envVar}). Run /secrets to configure it.`);
+            }
+        }
+        else {
+            lines.push(`${theme.secondary('•')} ${this.providerLabel(this.sessionState.provider)} does not require an API key.`);
+        }
+        lines.push('');
+        lines.push(theme.bold('Tool suites'));
+        const toolSettings = loadToolSettings();
+        const selection = buildEnabledToolSet(toolSettings);
+        const permissions = evaluateToolPermissions(selection);
+        const options = getToolToggleOptions();
+        const enabledLabels = options
+            .filter((option) => selection.has(option.id))
+            .map((option) => option.label);
+        lines.push(`Enabled: ${enabledLabels.length ? enabledLabels.join(', ') : 'none'}`);
+        if (!permissions.warnings.length) {
+            lines.push(theme.success('All enabled suites loaded successfully.'));
+        }
+        else {
+            lines.push(theme.warning('Issues detected:'));
+            for (const warning of permissions.warnings) {
+                const detail = this.describeToolWarning(warning);
+                lines.push(`  - ${detail}`);
+            }
+        }
+        display.showSystemMessage(lines.join('\n'));
+    }
+    async runRepoChecksCommand() {
+        if (this.isProcessing) {
+            display.showWarning('Wait for the active response to finish before running checks.');
+            return;
+        }
+        const call = {
+            id: 'manual-run-repo-checks',
+            name: 'run_repo_checks',
+            arguments: {},
+        };
+        display.showInfo('Running repo checks (npm test/build/lint when available)...');
+        const output = await this.runtimeSession.toolRuntime.execute(call);
+        display.showSystemMessage(output);
+    }
+    async refreshWorkspaceContextCommand(input) {
+        if (this.isProcessing) {
+            display.showWarning('Wait for the active response to finish before refreshing the snapshot.');
+            return;
+        }
+        const { overrides, error } = this.parseContextOverrideTokens(input);
+        if (error) {
+            display.showWarning(`${error} ${this.describeContextOverrideUsage()}`);
+            return;
+        }
+        if (overrides) {
+            this.workspaceOptions = { ...this.workspaceOptions, ...overrides };
+        }
+        display.showInfo('Refreshing workspace snapshot...');
+        const context = buildWorkspaceContext(this.workingDir, this.workspaceOptions);
+        const profileConfig = this.runtimeSession.refreshWorkspaceContext(context);
+        const tools = this.runtimeSession.toolRuntime.listProviderTools();
+        this.baseSystemPrompt = buildInteractiveSystemPrompt(profileConfig.systemPrompt, profileConfig.label, tools);
+        if (this.rebuildAgent()) {
+            display.showInfo(`Workspace snapshot refreshed (${this.describeWorkspaceOptions()}).`);
+            this.resetChatBoxAfterModelSwap();
+        }
+        else {
+            display.showWarning('Workspace snapshot refreshed, but the agent failed to rebuild. Run /doctor for details.');
+        }
+    }
+    parseContextOverrideTokens(input) {
+        const overrides = {};
+        let hasOverride = false;
+        const tokens = input
+            .trim()
+            .split(/\s+/)
+            .slice(1);
+        for (const token of tokens) {
+            if (!token) {
+                continue;
+            }
+            const [rawKey, rawValue] = token.split('=');
+            if (!rawKey || !rawValue) {
+                return { overrides: null, error: `Invalid option "${token}".` };
+            }
+            const key = rawKey.toLowerCase();
+            const value = Number.parseInt(rawValue, 10);
+            if (!Number.isFinite(value) || value <= 0) {
+                return { overrides: null, error: `Value for "${key}" must be a positive integer.` };
+            }
+            switch (key) {
+                case 'depth':
+                    overrides.treeDepth = value;
+                    hasOverride = true;
+                    break;
+                case 'entries':
+                    overrides.maxEntries = value;
+                    hasOverride = true;
+                    break;
+                case 'excerpt':
+                case 'doc':
+                case 'docs':
+                    overrides.docExcerptLimit = value;
+                    hasOverride = true;
+                    break;
+                default:
+                    return { overrides: null, error: `Unknown option "${key}".` };
+            }
+        }
+        return { overrides: hasOverride ? overrides : null };
+    }
+    async handleSessionCommand(input) {
+        const tokens = input
+            .trim()
+            .split(/\s+/)
+            .slice(1);
+        const action = (tokens.shift() ?? 'list').toLowerCase();
+        switch (action) {
+            case '':
+            case 'list':
+                this.showSessionList();
+                return;
+            case 'save':
+                await this.saveSessionCommand(tokens.join(' ').trim());
+                return;
+            case 'load':
+                await this.loadSessionCommand(tokens.join(' ').trim());
+                return;
+            case 'delete':
+            case 'remove':
+                this.deleteSessionCommand(tokens.join(' ').trim());
+                return;
+            case 'new':
+                this.newSessionCommand(tokens.join(' ').trim());
+                return;
+            case 'autosave':
+                this.toggleAutosaveCommand(tokens[0]);
+                return;
+            case 'clear':
+                this.clearAutosaveCommand();
+                return;
+            default:
+                display.showWarning('Usage: /sessions [list|save <title>|load <id>|delete <id>|new <title>|autosave on|off|clear]');
+                return;
+        }
+    }
+    async handleSkillsCommand(input) {
+        const raw = input.slice('/skills'.length).trim();
+        const tokens = raw ? raw.split(/\s+/).filter(Boolean) : [];
+        let refresh = false;
+        const filtered = [];
+        for (const token of tokens) {
+            if (token === '--refresh' || token === '-r') {
+                refresh = true;
+                continue;
+            }
+            filtered.push(token);
+        }
+        let mode = filtered.shift()?.toLowerCase() ?? 'list';
+        if (mode === 'refresh') {
+            refresh = true;
+            mode = 'list';
+        }
+        try {
+            switch (mode) {
+                case '':
+                case 'list': {
+                    const query = filtered.join(' ');
+                    const output = await this.invokeSkillTool('ListSkills', {
+                        query: query || undefined,
+                        refresh_cache: refresh,
+                    });
+                    display.showSystemMessage(output);
+                    break;
+                }
+                case 'show':
+                case 'view': {
+                    const identifier = filtered.shift();
+                    if (!identifier) {
+                        display.showWarning('Usage: /skills show <skill-id> [sections=metadata,body]');
+                        return;
+                    }
+                    let sectionsArg;
+                    for (let i = 0; i < filtered.length; i += 1) {
+                        const token = filtered[i];
+                        if (!token) {
+                            continue;
+                        }
+                        if (token.startsWith('sections=')) {
+                            sectionsArg = token.slice('sections='.length);
+                            filtered.splice(i, 1);
+                            break;
+                        }
+                    }
+                    const sections = sectionsArg
+                        ? sectionsArg
+                            .split(',')
+                            .map((section) => section.trim())
+                            .filter(Boolean)
+                        : undefined;
+                    const output = await this.invokeSkillTool('Skill', {
+                        skill: identifier,
+                        sections,
+                        refresh_cache: refresh,
+                    });
+                    display.showSystemMessage(output);
+                    break;
+                }
+                default:
+                    display.showWarning('Usage: /skills [list|refresh|show <id> [sections=a,b]]');
+                    break;
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            display.showError(`Skill command failed: ${message}`);
+        }
+    }
+    async invokeSkillTool(name, args) {
+        const handler = this.skillToolHandlers.get(name);
+        if (!handler) {
+            throw new Error(`Skill tool "${name}" is not registered.`);
+        }
+        const result = await handler(args);
+        return typeof result === 'string' ? result : JSON.stringify(result, null, 2);
+    }
+    handleThinkingCommand(input) {
+        const value = input.slice('/thinking'.length).trim().toLowerCase();
+        if (!value) {
+            display.showInfo(`Thinking mode is currently ${theme.info(this.thinkingMode)}. Usage: /thinking [concise|balanced|extended]`);
+            return;
+        }
+        if (value !== 'concise' && value !== 'balanced' && value !== 'extended') {
+            display.showWarning('Usage: /thinking [concise|balanced|extended]');
+            return;
+        }
+        if (this.isProcessing) {
+            display.showWarning('Wait until the current request finishes before changing thinking mode.');
+            return;
+        }
+        this.thinkingMode = value;
+        saveSessionPreferences({ thinkingMode: this.thinkingMode });
+        if (this.rebuildAgent()) {
+            this.resetChatBoxAfterModelSwap();
+        }
+        const descriptions = {
+            concise: 'Hides internal reasoning and responds directly.',
+            balanced: 'Shows short thoughts only when helpful.',
+            extended: 'Always emits a <thinking> block before the final response.',
+        };
+        display.showInfo(`Thinking mode set to ${theme.info(value)} – ${descriptions[this.thinkingMode]}`);
+    }
+    handleShortcutsCommand() {
+        // Display keyboard shortcuts help (Claude Code style)
+        display.showSystemMessage(formatShortcutsHelp());
+    }
+    showFileChangeSummary() {
+        const summary = this._fileChangeTracker.getSummary();
+        const changes = this._fileChangeTracker.getAllChanges();
+        if (changes.length === 0) {
+            display.showInfo('No files modified in this session.');
+            return;
+        }
+        const lines = [];
+        lines.push(theme.bold('Session File Changes'));
+        lines.push('');
+        lines.push(`${theme.info('•')} ${summary.files} file${summary.files === 1 ? '' : 's'} modified`);
+        lines.push(`${theme.info('•')} ${theme.success('+' + summary.additions)} ${theme.error('-' + summary.removals)} lines`);
+        lines.push('');
+        // Group changes by file
+        const fileMap = new Map();
+        for (const change of changes) {
+            const existing = fileMap.get(change.path) || { edits: 0, writes: 0, additions: 0, removals: 0 };
+            if (change.type === 'edit') {
+                existing.edits++;
+            }
+            else if (change.type === 'write') {
+                existing.writes++;
+            }
+            existing.additions += change.additions;
+            existing.removals += change.removals;
+            fileMap.set(change.path, existing);
+        }
+        // Display each file
+        for (const [path, stats] of fileMap) {
+            const operations = [];
+            if (stats.edits > 0)
+                operations.push(`${stats.edits} edit${stats.edits === 1 ? '' : 's'}`);
+            if (stats.writes > 0)
+                operations.push(`${stats.writes} write${stats.writes === 1 ? '' : 's'}`);
+            const opsText = operations.join(', ');
+            const diffText = `${theme.success('+' + stats.additions)} ${theme.error('-' + stats.removals)}`;
+            lines.push(`  ${theme.dim(path)}`);
+            lines.push(`    ${opsText} • ${diffText}`);
+        }
+        display.showSystemMessage(lines.join('\n'));
+    }
+    showAlphaZeroMetrics() {
+        const summary = this.alphaZeroMetrics.getPerformanceSummary();
+        display.showSystemMessage(summary);
+    }
+    showImprovementSuggestions() {
+        const suggestions = this.alphaZeroMetrics.getImprovementSuggestions();
+        if (suggestions.length === 0) {
+            display.showInfo('No improvement suggestions at this time. Keep using the shell to generate metrics!');
+            return;
+        }
+        const lines = [
+            theme.bold('Improvement Suggestions (Alpha Zero 2):'),
+            '',
+        ];
+        for (let i = 0; i < suggestions.length; i++) {
+            const suggestion = suggestions[i];
+            const severityColor = suggestion.severity === 'high'
+                ? theme.error
+                : suggestion.severity === 'medium'
+                    ? theme.warning
+                    : theme.info;
+            lines.push(`${i + 1}. [${severityColor(suggestion.severity.toUpperCase())}] ${suggestion.message}`);
+            if (suggestion.suggestedAction) {
+                lines.push(`   ${theme.dim('Action:')} ${suggestion.suggestedAction}`);
+            }
+        }
+        display.showSystemMessage(lines.join('\n'));
+    }
+    showPluginStatus() {
+        const available = listAvailablePlugins();
+        const lines = [];
+        lines.push(theme.bold('Plugin Status'));
+        lines.push('');
+        if (available.length === 0) {
+            lines.push(theme.secondary('No plugins registered.'));
+        }
+        else {
+            lines.push(theme.secondary('Available Plugins:'));
+            lines.push('');
+            for (const pluginId of available) {
+                const isEnabled = this._enabledPlugins.includes(pluginId);
+                const status = isEnabled
+                    ? theme.success('[ENABLED]')
+                    : theme.dim('[available]');
+                const displayName = pluginId.replace(/-/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase());
+                lines.push(`  ${status} ${theme.bold(displayName)}`);
+                lines.push(`    ${theme.dim(`ID: ${pluginId}`)}`);
+                lines.push('');
+            }
+        }
+        lines.push(theme.secondary('CLI Flags:'));
+        lines.push('  --alpha-zero    Enable Alpha Zero 2 RL framework');
+        lines.push('  --coding        Enable enhanced coding tools');
+        lines.push('  --security      Enable security research tools');
+        lines.push('  --all-plugins   Enable all optional plugins');
+        display.showSystemMessage(lines.join('\n'));
+    }
+    showSessionList() {
+        const sessions = listSessions(this.profile);
+        const lines = [];
+        lines.push(theme.bold('Saved sessions'));
+        lines.push('Use "/sessions save <title>" to persist history or "/sessions load <id>" to resume.');
+        lines.push('');
+        if (!sessions.length) {
+            lines.push(theme.secondary('No saved sessions yet.'));
+        }
+        else {
+            sessions.forEach((session, index) => {
+                const prefix = `${index + 1}.`;
+                const label = session.title || '(untitled)';
+                const relative = this.describeRelativeTime(session.updatedAt);
+                const active = this.activeSessionId && session.id === this.activeSessionId
+                    ? ` ${theme.success('[active]')}`
+                    : '';
+                const messageCount = `${session.messageCount} msg`;
+                const shortId = this.formatSessionId(session.id);
+                lines.push(`${prefix.padEnd(3)} ${label} ${theme.secondary(`(${messageCount}, ${relative}, ${shortId})`)}${active}`);
+            });
+        }
+        lines.push('');
+        lines.push(`Autosave: ${this.autosaveEnabled ? theme.success('on') : theme.warning('off')} (toggle via "/sessions autosave on|off")`);
+        display.showSystemMessage(lines.join('\n'));
+    }
+    async saveSessionCommand(title) {
+        const agent = this.agent;
+        if (!agent) {
+            display.showWarning('Start a conversation before saving a session.');
+            return;
+        }
+        const history = agent.getHistory();
+        if (!history || history.length <= 1) {
+            display.showWarning('You need at least one user message before saving a session.');
+            return;
+        }
+        const summary = saveSessionSnapshot({
+            id: this.activeSessionId ?? undefined,
+            title: title || this.activeSessionTitle || null,
+            profile: this.profile,
+            provider: this.sessionState.provider,
+            model: this.sessionState.model,
+            workspaceRoot: this.workingDir,
+            messages: history,
+        });
+        this.cachedHistory = history;
+        this.updateActiveSession(summary, true);
+        this.sessionResumeNotice = null;
+        this.autosaveIfEnabled();
+        display.showInfo(`Session saved as "${summary.title}" (id ${this.formatSessionId(summary.id)}).`);
+    }
+    async loadSessionCommand(selector) {
+        const summary = this.resolveSessionBySelector(selector);
+        if (!summary) {
+            display.showWarning('No session matches that selection.');
+            return;
+        }
+        const stored = loadSessionById(summary.id);
+        if (!stored) {
+            display.showWarning('Failed to load that session. It may have been corrupted or deleted.');
+            return;
+        }
+        this.cachedHistory = stored.messages;
+        this.updateActiveSession(summary, true);
+        this.sessionResumeNotice = `Loaded session "${summary.title}".`;
+        if (this.agent) {
+            this.agent.loadHistory(stored.messages);
+            this.sessionResumeNotice = null;
+            display.showInfo(`Loaded session "${summary.title}".`);
+            this.refreshContextGauge();
+            this.captureHistorySnapshot();
+            this.pendingHistoryLoad = null;
+        }
+        else {
+            this.pendingHistoryLoad = stored.messages;
+            display.showInfo(`Session "${summary.title}" queued to load once the agent is ready.`);
+        }
+        this.autosaveIfEnabled();
+    }
+    deleteSessionCommand(selector) {
+        const summary = this.resolveSessionBySelector(selector);
+        if (!summary) {
+            display.showWarning('No session matches that selection.');
+            return;
+        }
+        if (!deleteSession(summary.id)) {
+            display.showWarning('Unable to delete that session.');
+            return;
+        }
+        display.showInfo(`Deleted session "${summary.title}".`);
+        if (this.activeSessionId === summary.id) {
+            this.activeSessionId = null;
+            this.activeSessionTitle = null;
+            saveSessionPreferences({ lastSessionId: null });
+        }
+    }
+    newSessionCommand(title) {
+        if (this.agent) {
+            this.agent.clearHistory();
+            this.cachedHistory = this.agent.getHistory();
+            this.pendingHistoryLoad = null;
+        }
+        if (!this.agent) {
+            this.cachedHistory = [];
+            this.pendingHistoryLoad = [];
+        }
+        this.activeSessionId = null;
+        this.activeSessionTitle = title || null;
+        this.sessionResumeNotice = null;
+        saveSessionPreferences({ lastSessionId: null });
+        clearAutosaveSnapshot(this.profile);
+        display.showInfo('Started a new empty session.');
+        this.refreshContextGauge();
+    }
+    toggleAutosaveCommand(value) {
+        if (!value) {
+            display.showWarning('Usage: /sessions autosave on|off');
+            return;
+        }
+        const normalized = value.toLowerCase();
+        if (normalized !== 'on' && normalized !== 'off') {
+            display.showWarning('Usage: /sessions autosave on|off');
+            return;
+        }
+        this.autosaveEnabled = normalized === 'on';
+        saveSessionPreferences({ autosave: this.autosaveEnabled });
+        display.showInfo(`Autosave ${this.autosaveEnabled ? 'enabled' : 'disabled'}.`);
+        if (!this.autosaveEnabled) {
+            clearAutosaveSnapshot(this.profile);
+        }
+        else {
+            this.autosaveIfEnabled();
+        }
+    }
+    clearAutosaveCommand() {
+        clearAutosaveSnapshot(this.profile);
+        display.showInfo('Cleared autosave history.');
+    }
+    handleAutoContinueCommand(input) {
+        const tokens = input.split(/\s+/).slice(1);
+        const value = tokens[0]?.toLowerCase();
+        if (!value) {
+            // Show current status
+            display.showInfo(`Auto-continue is ${this.autoContinueEnabled ? 'enabled' : 'disabled'}. ` +
+                `Use /autocontinue on|off to toggle.`);
+            return;
+        }
+        if (value !== 'on' && value !== 'off') {
+            display.showWarning('Usage: /autocontinue on|off');
+            return;
+        }
+        this.autoContinueEnabled = value === 'on';
+        saveSessionPreferences({ autoContinue: this.autoContinueEnabled });
+        // Update the current agent if it exists
+        if (this.agent) {
+            this.agent.setAutoContinue(this.autoContinueEnabled);
+        }
+        display.showInfo(`Auto-continue ${this.autoContinueEnabled ? 'enabled' : 'disabled'}. ` +
+            (this.autoContinueEnabled
+                ? 'The model will be auto-prompted to continue when it expresses intent but does not use tools.'
+                : 'The model will not be auto-prompted to continue.'));
+    }
+    updateActiveSession(summary, remember = false) {
+        this.activeSessionId = summary?.id ?? null;
+        this.activeSessionTitle = summary?.title ?? null;
+        if (remember) {
+            saveSessionPreferences({ lastSessionId: summary?.id ?? null });
+        }
+    }
+    resolveSessionBySelector(selector) {
+        const sessions = listSessions(this.profile);
+        if (!sessions.length) {
+            return null;
+        }
+        if (!selector) {
+            return sessions[0] ?? null;
+        }
+        const trimmed = selector.trim();
+        if (!trimmed) {
+            return sessions[0] ?? null;
+        }
+        const index = Number.parseInt(trimmed, 10);
+        if (Number.isFinite(index)) {
+            const entry = sessions[index - 1];
+            return entry ?? null;
+        }
+        const match = sessions.find((session) => session.id.startsWith(trimmed));
+        return match ?? null;
+    }
+    formatSessionId(id) {
+        return id.length > 8 ? `${id.slice(0, 8)}…` : id;
+    }
+    describeRelativeTime(timestamp) {
+        const updated = Date.parse(timestamp);
+        if (!updated) {
+            return 'unknown';
+        }
+        const deltaMs = Date.now() - updated;
+        const minutes = Math.round(deltaMs / 60000);
+        if (minutes < 1) {
+            return 'just now';
+        }
+        if (minutes < 60) {
+            return `${minutes}m ago`;
+        }
+        const hours = Math.round(minutes / 60);
+        if (hours < 24) {
+            return `${hours}h ago`;
+        }
+        const days = Math.round(hours / 24);
+        return `${days}d ago`;
+    }
+    captureHistorySnapshot() {
+        if (!this.agent) {
+            return;
+        }
+        this.cachedHistory = this.agent.getHistory();
+    }
+    autosaveIfEnabled() {
+        if (!this.autosaveEnabled) {
+            return;
+        }
+        if (!this.cachedHistory || this.cachedHistory.length <= 1) {
+            return;
+        }
+        saveAutosaveSnapshot(this.profile, {
+            provider: this.sessionState.provider,
+            model: this.sessionState.model,
+            workspaceRoot: this.workingDir,
+            title: this.activeSessionTitle,
+            messages: this.cachedHistory,
+        });
+    }
+    describeWorkspaceOptions() {
+        const depth = this.workspaceOptions.treeDepth ?? 'default';
+        const entries = this.workspaceOptions.maxEntries ?? 'default';
+        const excerpt = this.workspaceOptions.docExcerptLimit ?? 'default';
+        return `depth=${depth}, entries=${entries}, excerpt=${excerpt}`;
+    }
+    describeContextOverrideUsage() {
+        return 'Usage: /context [depth=<n>] [entries=<n>] [excerpt=<n>]';
+    }
+    describeToolWarning(warning) {
+        if (warning.reason === 'missing-secret' && warning.secretId) {
+            return `${warning.label}: missing ${warning.secretId}. Use /secrets to configure it.`;
+        }
+        return `${warning.label}: ${warning.reason}.`;
+    }
+    buildSlashCommandList(header) {
+        const lines = [theme.gradient.primary(header), ''];
+        for (const command of this.slashCommands) {
+            lines.push(`${theme.primary(command.command)} - ${command.description}`);
+        }
+        return lines.join('\n');
+    }
+    async showModelMenu() {
+        display.showSystemMessage(theme.ui.muted('Fetching latest models from providers...'));
+        // Fetch live models from all configured providers
+        const providerStatuses = await quickCheckProviders();
+        const providerOptions = this.buildProviderOptionsWithDiscovery(providerStatuses);
+        if (!providerOptions.length) {
+            display.showWarning('No providers are available.');
+            return;
+        }
+        const lines = [
+            theme.bold('Select a provider:'),
+            ...providerOptions.map((option, index) => {
+                const isCurrent = option.provider === this.sessionState.provider;
+                const countLabel = `${option.modelCount} model${option.modelCount === 1 ? '' : 's'}`;
+                const latestLabel = option.latestModel ? theme.success(` (latest: ${option.latestModel})`) : '';
+                const label = this.colorizeDropdownLine(`${index + 1}. ${option.label} — ${countLabel}${latestLabel}`, index);
+                const suffix = isCurrent ? ` ${theme.primary('• current')}` : '';
+                return `${label}${suffix}`;
+            }),
+            'Type the number of the provider to continue, or type "cancel".',
+        ];
+        display.showSystemMessage(lines.join('\n'));
+        this.pendingInteraction = { type: 'model-provider', options: providerOptions };
+    }
+    buildProviderOptions() {
+        const counts = new Map();
+        for (const preset of MODEL_PRESETS) {
+            counts.set(preset.provider, (counts.get(preset.provider) ?? 0) + 1);
+        }
+        const orderedProviders = [];
+        const seen = new Set();
+        for (const preset of MODEL_PRESETS) {
+            if (seen.has(preset.provider)) {
+                continue;
+            }
+            seen.add(preset.provider);
+            orderedProviders.push(preset.provider);
+        }
+        return orderedProviders.map((provider) => ({
+            provider,
+            label: this.providerLabel(provider),
+            modelCount: counts.get(provider) ?? 0,
+        }));
+    }
+    buildProviderOptionsWithDiscovery(providerStatuses) {
+        // Merge static presets with discovered models
+        const providerData = new Map();
+        // Initialize with static presets
+        for (const preset of MODEL_PRESETS) {
+            const existing = providerData.get(preset.provider);
+            if (existing) {
+                existing.count++;
+            }
+            else {
+                providerData.set(preset.provider, {
+                    count: 1,
+                    latestModel: '',
+                    discoveredModels: [],
+                });
+            }
+        }
+        // Merge in discovered models from API
+        for (const status of providerStatuses) {
+            if (!status.available)
+                continue;
+            const existing = providerData.get(status.provider);
+            if (existing) {
+                existing.latestModel = status.latestModel;
+            }
+            else {
+                providerData.set(status.provider, {
+                    count: 1,
+                    latestModel: status.latestModel,
+                    discoveredModels: [],
+                });
+            }
+        }
+        // Also check cached discovered models for additional models
+        const cachedModels = getCachedDiscoveredModels();
+        for (const model of cachedModels) {
+            const existing = providerData.get(model.provider);
+            if (existing && !existing.discoveredModels.includes(model.id)) {
+                existing.discoveredModels.push(model.id);
+            }
+        }
+        // Build ordered list (same order as static presets)
+        const orderedProviders = [];
+        const seen = new Set();
+        for (const preset of MODEL_PRESETS) {
+            if (!seen.has(preset.provider)) {
+                seen.add(preset.provider);
+                orderedProviders.push(preset.provider);
+            }
+        }
+        // Add any providers that only have discovered models
+        for (const status of providerStatuses) {
+            if (status.available && !seen.has(status.provider)) {
+                seen.add(status.provider);
+                orderedProviders.push(status.provider);
+            }
+        }
+        return orderedProviders.map((provider) => {
+            const data = providerData.get(provider);
+            return {
+                provider,
+                label: this.providerLabel(provider),
+                modelCount: data?.count ?? 0,
+                latestModel: data?.latestModel,
+                discoveredModels: data?.discoveredModels ?? [],
+            };
+        });
+    }
+    showProviderModels(option) {
+        // Start with static presets
+        const staticModels = MODEL_PRESETS.filter((preset) => preset.provider === option.provider);
+        // Build combined list with latest model at top if discovered
+        const allModels = [];
+        const seenIds = new Set();
+        // If we have a latestModel from discovery, add it first if not in static list
+        if (option.latestModel && !staticModels.some(m => m.id === option.latestModel)) {
+            allModels.push({
+                id: option.latestModel,
+                label: option.latestModel,
+                provider: option.provider,
+                description: `Latest ${this.providerLabel(option.provider)} model (auto-discovered)`,
+            });
+            seenIds.add(option.latestModel);
+        }
+        // Add static models
+        for (const model of staticModels) {
+            if (!seenIds.has(model.id)) {
+                allModels.push(model);
+                seenIds.add(model.id);
+            }
+        }
+        // Add any additional discovered models not in static list
+        if (option.discoveredModels) {
+            const sortedDiscovered = sortModelsByPriority(option.provider, option.discoveredModels);
+            for (const modelId of sortedDiscovered) {
+                if (!seenIds.has(modelId)) {
+                    allModels.push({
+                        id: modelId,
+                        label: modelId,
+                        provider: option.provider,
+                        description: `${this.providerLabel(option.provider)} model (auto-discovered)`,
+                    });
+                    seenIds.add(modelId);
+                }
+            }
+        }
+        if (!allModels.length) {
+            display.showWarning(`No models available for ${option.label}.`);
+            this.pendingInteraction = null;
+            return;
+        }
+        const lines = [
+            theme.bold(`Select a model from ${option.label}:`),
+            ...allModels.map((preset, index) => {
+                const isCurrent = preset.id === this.sessionState.model;
+                const isLatest = preset.id === option.latestModel;
+                const latestBadge = isLatest ? theme.success(' ★ LATEST') : '';
+                const label = this.colorizeDropdownLine(`${index + 1}. ${preset.label}${latestBadge}`, index);
+                const suffix = isCurrent ? ` ${theme.primary('• current')}` : '';
+                const description = this.colorizeDropdownLine(`   ${preset.description}`, index);
+                return `${label}${suffix}\n${description}`;
+            }),
+            'Type the number of the model to select it, type "back" to change provider, or type "cancel".',
+        ];
+        display.showSystemMessage(lines.join('\n'));
+        this.pendingInteraction = { type: 'model', provider: option.provider, options: allModels };
+    }
+    showSecretsMenu() {
+        const definitions = listSecretDefinitions();
+        const lines = [
+            theme.bold('Manage Secrets:'),
+            ...definitions.map((definition, index) => {
+                const value = getSecretValue(definition.id);
+                const status = value ? maskSecret(value) : theme.warning('not set');
+                const providers = definition.providers.map((id) => this.providerLabel(id)).join(', ');
+                const label = this.colorizeDropdownLine(`${index + 1}. ${definition.label} (${providers})`, index);
+                return `${label} — ${status}`;
+            }),
+            'Enter the number to update a key, or type "cancel".',
+        ];
+        display.showSystemMessage(lines.join('\n'));
+        this.pendingInteraction = { type: 'secret-select', options: definitions };
+    }
+    showToolsMenu() {
+        const options = getToolToggleOptions();
+        if (!options.length) {
+            display.showWarning('No configurable tools are available.');
+            return;
+        }
+        const selection = buildEnabledToolSet(loadToolSettings());
+        const interaction = {
+            type: 'tool-settings',
+            options,
+            selection,
+            initialSelection: new Set(selection),
+        };
+        this.pendingInteraction = interaction;
+        this.renderToolMenu(interaction);
+    }
+    renderToolMenu(interaction) {
+        const lines = [
+            theme.bold('Select which tools are enabled (changes apply on next launch):'),
+            ...interaction.options.map((option, index) => this.formatToolOptionLine(option, index, interaction.selection)),
+            '',
+            'Enter the number to toggle, "save" to persist, "defaults" to restore recommended tools, or "cancel".',
+        ];
+        display.showSystemMessage(lines.join('\n'));
+    }
+    formatToolOptionLine(option, index, selection) {
+        const enabled = selection.has(option.id);
+        const checkbox = enabled ? theme.primary('[x]') : theme.ui.muted('[ ]');
+        const details = [option.description];
+        if (option.requiresSecret) {
+            const hasSecret = Boolean(getSecretValue(option.requiresSecret));
+            const status = hasSecret ? theme.success('API key set') : theme.warning('API key missing');
+            details.push(status);
+        }
+        const numberLabel = this.colorizeDropdownLine(`${index + 1}.`, index);
+        const optionLabel = this.colorizeDropdownLine(option.label, index);
+        const detailLine = this.colorizeDropdownLine(`   ${details.join(' • ')}`, index);
+        return `${numberLabel} ${checkbox} ${optionLabel}\n${detailLine}`;
+    }
+    showAgentsMenu() {
+        if (!this.agentMenu) {
+            display.showWarning('Agent selection is not available in this CLI.');
+            return;
+        }
+        const lines = [
+            theme.bold('Select the default agent profile (changes apply on next launch):'),
+            ...this.agentMenu.options.map((option, index) => this.formatAgentOptionLine(option, index)),
+            '',
+            'Enter the number to save it, or type "cancel".',
+        ];
+        display.showSystemMessage(lines.join('\n'));
+        this.pendingInteraction = { type: 'agent-selection', options: this.agentMenu.options };
+    }
+    formatAgentOptionLine(option, index) {
+        const numberLabel = this.colorizeDropdownLine(`${index + 1}. ${option.label}`, index);
+        if (!this.agentMenu) {
+            return numberLabel;
+        }
+        const badges = [];
+        const nextProfile = this.agentMenu.persistedProfile ?? this.agentMenu.defaultProfile;
+        if (option.name === nextProfile) {
+            badges.push(theme.primary('next launch'));
+        }
+        if (option.name === this.profile) {
+            badges.push(theme.success('current session'));
+        }
+        const badgeSuffix = badges.length ? ` ${badges.join(' • ')}` : '';
+        const rows = [
+            `${numberLabel}${badgeSuffix}`,
+            `   ${this.providerLabel(option.defaultProvider)} • ${option.defaultModel}`,
+        ];
+        if (option.description?.trim()) {
+            rows.push(`   ${option.description.trim()}`);
+        }
+        return rows.join('\n');
+    }
+    async handleModelProviderSelection(input) {
+        const pending = this.pendingInteraction;
+        if (!pending || pending.type !== 'model-provider') {
+            return;
+        }
+        const trimmed = input.trim();
+        if (!trimmed) {
+            display.showWarning('Enter a number or type cancel.');
+            this.terminalInput.render();
+            return;
+        }
+        if (trimmed.toLowerCase() === 'cancel') {
+            this.pendingInteraction = null;
+            display.showInfo('Model selection cancelled.');
+            this.terminalInput.render();
+            return;
+        }
+        const choice = Number.parseInt(trimmed, 10);
+        if (!Number.isFinite(choice)) {
+            display.showWarning('Please enter a valid number.');
+            this.terminalInput.render();
+            return;
+        }
+        const option = pending.options[choice - 1];
+        if (!option) {
+            display.showWarning('That option is not available.');
+            this.terminalInput.render();
+            return;
+        }
+        this.showProviderModels(option);
+        this.terminalInput.render();
+    }
+    async handleModelSelection(input) {
+        const pending = this.pendingInteraction;
+        if (!pending || pending.type !== 'model') {
+            return;
+        }
+        const trimmed = input.trim();
+        if (!trimmed) {
+            display.showWarning('Enter a number, type "back", or type "cancel".');
+            this.terminalInput.render();
+            return;
+        }
+        if (trimmed.toLowerCase() === 'back') {
+            this.showModelMenu();
+            this.terminalInput.render();
+            return;
+        }
+        if (trimmed.toLowerCase() === 'cancel') {
+            this.pendingInteraction = null;
+            display.showInfo('Model selection cancelled.');
+            this.terminalInput.render();
+            return;
+        }
+        const choice = Number.parseInt(trimmed, 10);
+        if (!Number.isFinite(choice)) {
+            display.showWarning('Please enter a valid number.');
+            this.terminalInput.render();
+            return;
+        }
+        const preset = pending.options[choice - 1];
+        if (!preset) {
+            display.showWarning('That option is not available.');
+            this.terminalInput.render();
+            return;
+        }
+        this.pendingInteraction = null;
+        await this.applyModelPreset(preset);
+        this.terminalInput.render();
+    }
+    async applyModelPreset(preset) {
+        try {
+            ensureSecretForProvider(preset.provider);
+        }
+        catch (error) {
+            this.handleAgentSetupError(error, () => this.applyModelPreset(preset), preset.provider);
+            return;
+        }
+        this.sessionState = {
+            provider: preset.provider,
+            model: preset.id,
+            temperature: preset.temperature,
+            maxTokens: preset.maxTokens,
+            reasoningEffort: preset.reasoningEffort,
+        };
+        this.applyPresetReasoningDefaults();
+        if (this.rebuildAgent()) {
+            display.showInfo(`Switched to ${preset.label}.`);
+            this.refreshBannerSessionInfo();
+            this.persistSessionPreference();
+            this.resetChatBoxAfterModelSwap();
+        }
+    }
+    async handleSecretSelection(input) {
+        const pending = this.pendingInteraction;
+        if (!pending || pending.type !== 'secret-select') {
+            return;
+        }
+        const trimmed = input.trim();
+        if (!trimmed) {
+            display.showWarning('Enter a number or type cancel.');
+            this.terminalInput.render();
+            return;
+        }
+        if (trimmed.toLowerCase() === 'cancel') {
+            this.pendingInteraction = null;
+            display.showInfo('Secret management cancelled.');
+            this.terminalInput.render();
+            return;
+        }
+        const choice = Number.parseInt(trimmed, 10);
+        if (!Number.isFinite(choice)) {
+            display.showWarning('Please enter a valid number.');
+            this.terminalInput.render();
+            return;
+        }
+        const secret = pending.options[choice - 1];
+        if (!secret) {
+            display.showWarning('That option is not available.');
+            this.terminalInput.render();
+            return;
+        }
+        display.showSystemMessage(`Enter a new value for ${secret.label} or type "cancel".`);
+        this.pendingInteraction = { type: 'secret-input', secret };
+        this.terminalInput.render();
+    }
+    async handleSecretInput(input) {
+        const pending = this.pendingInteraction;
+        if (!pending || pending.type !== 'secret-input') {
+            return;
+        }
+        const trimmed = input.trim();
+        if (!trimmed) {
+            display.showWarning('Enter a value or type cancel.');
+            this.terminalInput.render();
+            return;
+        }
+        if (trimmed.toLowerCase() === 'cancel') {
+            this.pendingInteraction = null;
+            this.pendingSecretRetry = null;
+            display.showInfo('Secret unchanged.');
+            this.terminalInput.render();
+            return;
+        }
+        try {
+            setSecretValue(pending.secret.id, trimmed);
+            display.showInfo(`${pending.secret.label} updated.`);
+            this.pendingInteraction = null;
+            const deferred = this.pendingSecretRetry;
+            this.pendingSecretRetry = null;
+            if (pending.secret.providers.includes(this.sessionState.provider)) {
+                if (this.rebuildAgent()) {
+                    this.resetChatBoxAfterModelSwap();
+                }
+            }
+            if (deferred) {
+                await deferred();
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            display.showError(message);
+            this.pendingInteraction = null;
+            this.pendingSecretRetry = null;
+        }
+        this.terminalInput.render();
+    }
+    async processRequest(request) {
+        if (this.isProcessing) {
+            this.enqueueFollowUpAction({ type: 'request', text: request });
+            return;
+        }
+        if (!this.agent && !this.rebuildAgent()) {
+            display.showWarning('Configure an API key via /secrets before sending requests.');
+            return;
+        }
+        const agent = this.agent;
+        if (!agent) {
+            return;
+        }
+        this.isProcessing = true;
+        this.terminalInput.setStreaming(true);
+        const requestStartTime = Date.now(); // Alpha Zero 2 timing
+        this.uiAdapter.startProcessing('Working on your request');
+        this.setProcessingStatus();
+        let responseText = '';
+        try {
+            // Add visual separator between user prompt and AI response
+            display.newLine();
+            // Claude Code style: Show unified streaming header before response
+            // This provides visual consistency with the startup Ready bar
+            display.showStreamingHeader();
+            this.startStreamingHeartbeat('Streaming response');
+            display.showThinking('Responding...');
+            // Stream responses so users immediately see progress like Claude Code
+            responseText = await agent.send(request, true);
+            await this.awaitPendingCleanup();
+            this.captureHistorySnapshot();
+            this.autosaveIfEnabled();
+            // Track metrics with Alpha Zero 2
+            const elapsedMs = Date.now() - requestStartTime;
+            this.alphaZeroMetrics.recordMessage(elapsedMs);
+            if (!responseText?.trim()) {
+                display.showWarning('The provider returned an empty response. Check your API key/provider selection or retry the prompt.');
+            }
+        }
+        catch (error) {
+            const handled = this.handleProviderError(error, () => this.processRequest(request));
+            if (!handled) {
+                // Pass full error object for enhanced formatting with stack trace
+                display.showError(error instanceof Error ? error.message : String(error), error);
+            }
+        }
+        finally {
+            display.stopThinking(false);
+            this.stopStreamingHeartbeat();
+            this.isProcessing = false;
+            this.terminalInput.setStreaming(false);
+            this.uiAdapter.endProcessing('Ready for prompts');
+            this.setIdleStatus();
+            display.newLine();
+            this.updateStatusMessage(null);
+            // Claude Code style: Show unified status bar before prompt
+            // This creates consistent UI between startup and post-streaming
+            this.showUnifiedStatusBar();
+            // CRITICAL: Ensure readline prompt is active for user input
+            // Claude Code style: New prompt naturally appears at bottom
+            this.ensureReadlineReady();
+            this.terminalInput.render();
+            this.scheduleQueueProcessing();
+            this.refreshQueueIndicators();
+        }
+    }
+    /**
+     * Process a continuous/infinite loop request.
+     * Runs the agent in a loop until:
+     * 1. The agent indicates completion (verified by AI confirmation)
+     * 2. User interrupts (Ctrl+C)
+     * 3. Maximum iterations reached (safety limit)
+     *
+     * Uses intelligent task completion detection with AI verification
+     * to ensure tasks are truly complete before stopping.
+     *
+     * Context is automatically managed - overflow errors trigger auto-recovery.
+     */
+    async processContinuousRequest(initialRequest) {
+        const MAX_ITERATIONS = 100; // Safety limit to prevent truly infinite loops
+        if (this.isProcessing) {
+            this.enqueueFollowUpAction({ type: 'continuous', text: initialRequest });
+            return;
+        }
+        if (!this.agent && !this.rebuildAgent()) {
+            display.showWarning('Configure an API key via /secrets before sending requests.');
+            return;
+        }
+        const agent = this.agent;
+        if (!agent) {
+            return;
+        }
+        this.isProcessing = true;
+        this.terminalInput.setStreaming(true);
+        const overallStartTime = Date.now();
+        // Initialize the task completion detector
+        const completionDetector = getTaskCompletionDetector();
+        completionDetector.reset();
+        display.showSystemMessage(`🔄 Starting continuous execution mode. Press Ctrl+C to stop.`);
+        display.showSystemMessage(`📊 Using intelligent task completion detection with AI verification.`);
+        this.uiAdapter.startProcessing('Continuous execution mode');
+        this.setProcessingStatus();
+        // Claude Code style: Show unified streaming header before response
+        display.showStreamingHeader();
+        this.startStreamingHeartbeat('Continuous streaming');
+        let iteration = 0;
+        let lastResponse = '';
+        let consecutiveNoProgress = 0;
+        const MAX_NO_PROGRESS = 5; // Increased to allow more attempts before giving up
+        let pendingVerification = false;
+        let verificationAttempts = 0;
+        const MAX_VERIFICATION_ATTEMPTS = 2;
+        try {
+            // Enhance initial prompt with git context for self-improvement tasks
+            let currentPrompt = initialRequest;
+            if (this.isSelfImprovementRequest(initialRequest)) {
+                currentPrompt = `${initialRequest}
+
+IMPORTANT: You have full git access. After making improvements:
+1. Use bash to run: git status (see changes)
+2. Use bash to run: git add -A (stage changes)
+3. Use bash to run: git commit -m "descriptive message" (commit)
+4. Use bash to run: git push (when milestone reached)
+
+Commit frequently with descriptive messages. Push when ready.
+When truly finished with ALL tasks, explicitly state "TASK_FULLY_COMPLETE".`;
+            }
+            while (iteration < MAX_ITERATIONS) {
+                iteration++;
+                display.showSystemMessage(`\n📍 Iteration ${iteration}/${MAX_ITERATIONS}`);
+                this.updateStatusMessage(`Working on iteration ${iteration}...`);
+                try {
+                    // Send the request and capture the response (streaming disabled)
+                    display.showThinking('Responding...');
+                    const response = await agent.send(currentPrompt, true);
+                    await this.awaitPendingCleanup();
+                    this.captureHistorySnapshot();
+                    this.autosaveIfEnabled();
+                    // Track metrics
+                    const elapsedMs = Date.now() - overallStartTime;
+                    this.alphaZeroMetrics.recordMessage(elapsedMs);
+                    if (!response?.trim()) {
+                        display.showWarning('Model returned an empty response. Retrying this iteration...');
+                        consecutiveNoProgress++;
+                        currentPrompt = `${initialRequest}
+
+The previous reply was empty. Resume the task now: take the next action, call the necessary tools, and report progress.`;
+                        continue;
+                    }
+                    // Extract tools used from the response (look for tool call patterns)
+                    const toolsUsed = this.extractToolsFromResponse(response);
+                    completionDetector.recordToolCall.bind(completionDetector);
+                    toolsUsed.forEach(tool => completionDetector.recordToolCall(tool, true, true));
+                    // Use intelligent completion detection
+                    const completionAnalysis = completionDetector.analyzeCompletion(response, toolsUsed);
+                    display.showSystemMessage(`📈 Completion confidence: ${(completionAnalysis.confidence * 100).toFixed(0)}%`);
+                    // Check for explicit TASK_FULLY_COMPLETE marker (highest priority)
+                    // BUT: Don't terminate if the response also indicates work is incomplete
+                    if (response.includes('TASK_FULLY_COMPLETE')) {
+                        const hasContradiction = this.responseIndicatesIncompleteWork(response);
+                        if (hasContradiction) {
+                            display.showSystemMessage(`\n⚠️ TASK_FULLY_COMPLETE detected but response indicates incomplete work. Continuing...`);
+                            // Override the completion signal - the AI is contradicting itself
+                            currentPrompt = `You marked the task as TASK_FULLY_COMPLETE but also indicated that work is still pending or not integrated. Please clarify:
+
+1. Is ALL the originally requested work actually complete and functional?
+2. If there are parts that are "ready but not integrated" or "implemented but not connected", those are NOT complete.
+3. Only say TASK_FULLY_COMPLETE when the user's original request is 100% fulfilled.
+
+What remains to be done? Continue with the next step.`;
+                            await new Promise(resolve => setTimeout(resolve, 500));
+                            continue;
+                        }
+                        display.showSystemMessage(`\n✅ Task explicitly marked complete after ${iteration} iteration(s).`);
+                        break;
+                    }
+                    // High confidence completion without verification needed
+                    if (completionAnalysis.isComplete && completionAnalysis.confidence >= 0.85) {
+                        display.showSystemMessage(`\n✅ Task completed with high confidence after ${iteration} iteration(s).`);
+                        display.showSystemMessage(`   Reason: ${completionAnalysis.reason}`);
+                        break;
+                    }
+                    // Medium confidence - run verification round
+                    if (completionAnalysis.shouldVerify && completionAnalysis.verificationPrompt && !pendingVerification) {
+                        if (verificationAttempts < MAX_VERIFICATION_ATTEMPTS) {
+                            display.showSystemMessage(`\n🔍 Running verification round (confidence: ${(completionAnalysis.confidence * 100).toFixed(0)}%)...`);
+                            pendingVerification = true;
+                            verificationAttempts++;
+                            currentPrompt = completionAnalysis.verificationPrompt;
+                            await new Promise(resolve => setTimeout(resolve, 500));
+                            continue;
+                        }
+                    }
+                    // If we were in verification mode, check the result
+                    if (pendingVerification) {
+                        pendingVerification = false;
+                        if (completionDetector.isVerificationConfirmed(response)) {
+                            display.showSystemMessage(`\n✅ Task completion verified by AI after ${iteration} iteration(s).`);
+                            break;
+                        }
+                        else {
+                            display.showSystemMessage(`🔄 Verification indicates more work needed. Continuing...`);
+                        }
+                    }
+                    // Check for no progress (same response multiple times)
+                    const responseChanged = response !== lastResponse;
+                    if (!responseChanged) {
+                        consecutiveNoProgress++;
+                        if (consecutiveNoProgress >= MAX_NO_PROGRESS) {
+                            // Before giving up, ask one final verification
+                            if (verificationAttempts < MAX_VERIFICATION_ATTEMPTS) {
+                                display.showSystemMessage(`\n⚠️ No progress for ${MAX_NO_PROGRESS} iterations. Running final verification...`);
+                                currentPrompt = `I notice you may be stuck or finished. Please confirm:
+
+1. Is the original task FULLY complete?
+2. If yes, respond with exactly: "TASK_FULLY_COMPLETE"
+3. If no, what specific action should be taken next?
+
+Be explicit about the current state.`;
+                                verificationAttempts++;
+                                consecutiveNoProgress = 0;
+                                await new Promise(resolve => setTimeout(resolve, 500));
+                                continue;
+                            }
+                            display.showSystemMessage(`\n⚠️ No progress detected for ${MAX_NO_PROGRESS} iterations and verification exhausted. Stopping.`);
+                            break;
+                        }
+                    }
+                    else {
+                        consecutiveNoProgress = 0;
+                    }
+                    lastResponse = response;
+                    // Prepare next iteration prompt - explicitly encourage progress reporting
+                    currentPrompt = `Continue with the next step. Remember:
+- Use bash to run git commands (git status, git add, git commit, git push)
+- Commit your changes with descriptive messages after completing improvements
+- Push changes when a logical milestone is reached
+- If all tasks are complete, respond with exactly: "TASK_FULLY_COMPLETE"
+- If there are errors or blockers, explain what's preventing progress
+
+What's the next action?`;
+                    // Small delay between iterations to prevent rate limiting
+                    await new Promise(resolve => setTimeout(resolve, 500));
+                }
+                catch (error) {
+                    display.stopThinking(false);
+                    // Handle context overflow specially - the agent should auto-recover
+                    // but if it propagates here, we continue the loop
+                    if (this.isContextOverflowError(error)) {
+                        display.showSystemMessage(`⚡ Context overflow handled. Continuing with reduced context...`);
+                        // The agent.ts should have already handled recovery
+                        // Continue to next iteration
+                        continue;
+                    }
+                    // For other errors, check if handled by provider error handler
+                    const handled = this.handleProviderError(error, () => this.processContinuousRequest(initialRequest));
+                    if (!handled) {
+                        display.showError(error instanceof Error ? error.message : String(error), error);
+                        break;
+                    }
+                }
+            }
+            if (iteration >= MAX_ITERATIONS) {
+                display.showWarning(`\n⚠️ Reached maximum iterations (${MAX_ITERATIONS}). Stopping to prevent infinite loop.`);
+            }
+        }
+        finally {
+            const totalElapsed = Date.now() - overallStartTime;
+            const minutes = Math.floor(totalElapsed / 60000);
+            const seconds = Math.floor((totalElapsed % 60000) / 1000);
+            display.showSystemMessage(`\n🏁 Continuous execution completed: ${iteration} iterations, ${minutes}m ${seconds}s total`);
+            // Reset completion detector for next task
+            resetTaskCompletionDetector();
+            this.isProcessing = false;
+            this.terminalInput.setStreaming(false);
+            this.updateStatusMessage(null);
+            this.uiAdapter.endProcessing('Ready for prompts');
+            this.setIdleStatus();
+            this.stopStreamingHeartbeat();
+            display.newLine();
+            // Claude Code style: Show unified status bar before prompt
+            // This creates consistent UI between startup and post-streaming
+            this.showUnifiedStatusBar();
+            // CRITICAL: Ensure readline prompt is active for user input
+            // Claude Code style: New prompt naturally appears at bottom
+            this.ensureReadlineReady();
+            this.scheduleQueueProcessing();
+            this.refreshQueueIndicators();
+        }
+    }
+    /**
+     * Check if a response contains indicators that work is actually incomplete,
+     * even if it also contains TASK_FULLY_COMPLETE marker.
+     * This catches contradictory responses where the AI says "done" but also "not integrated yet".
+     */
+    responseIndicatesIncompleteWork(response) {
+        // Patterns that indicate work isn't actually complete
+        // Organized by category for maintainability
+        const incompletePatterns = [
+            // === INTEGRATION/DEPLOYMENT STATE ===
+            // "hasn't been integrated/implemented/connected yet"
+            /hasn'?t\s+been\s+(integrated|implemented|connected|deployed|added|completed|tested|verified)\s*(yet|still)?/i,
+            // "not yet integrated/implemented" or "not integrated"
+            /not\s+(yet\s+)?(integrated|implemented|connected|deployed|functional|working|complete|tested|verified)/i,
+            // "ready for integration" = NOT integrated
+            /ready\s+(for|to\s+be)\s+(integration|integrated|connected|deployed|testing|review)/i,
+            // "needs to be integrated"
+            /needs?\s+to\s+be\s+(integrated|connected|deployed|added|hooked|wired|tested|reviewed|merged)/i,
+            // Passive voice: "was not performed/completed"
+            /was\s+not\s+(performed|completed|implemented|deployed|integrated|tested)/i,
+            // "the [X] service hasn't been"
+            /the\s+\w+\s+(service|module|component|feature)\s+hasn'?t\s+been/i,
+            // === PARTIAL/INCOMPLETE STATE ===
+            // "still stores/uses/has" (current bad state persists)
+            /still\s+(stores?|uses?|has|contains?|needs?|requires?|missing|lacks?|broken)/i,
+            // Partial completion: "partially", "mostly", "almost"
+            /\b(partially|mostly|almost|nearly|not\s+fully)\s+(complete|done|finished|implemented|working)/i,
+            // Explicit partial: "part of", "some of", "half of"
+            /\b(only\s+)?(part|some|half|portion)\s+of\s+(the\s+)?(task|work|feature|implementation)/i,
+            // === QUALIFIER WORDS (uncertain completion) ===
+            // "should be complete", "appears complete", "theoretically"
+            /\b(should|might|may|could|appears?\s+to)\s+be\s+(complete|done|working|functional)/i,
+            /\btheoretically\s+(complete|done|working|functional)/i,
+            // "assuming", "if everything works"
+            /\b(assuming|provided|if)\s+(everything|it|this|that)\s+(works?|is\s+correct)/i,
+            // === SELF-CONTRADICTION PHRASES ===
+            // "done but...", "complete except...", "finished however..."
+            /\b(done|complete|finished)\s+(but|except|however|although|though)/i,
+            // "however" followed by incomplete indicator
+            /however[,\s].{0,50}?(hasn'?t|not\s+yet|still\s+needs?|pending|remains?|missing|broken|failing)/i,
+            // "but" followed by negative state
+            /\bbut\s+.{0,30}?(not|hasn'?t|won'?t|can'?t|doesn'?t|isn'?t|wasn'?t)/i,
+            // === FUTURE TENSE / DEFERRED WORK ===
+            // "will need to", "will require"
+            /will\s+(need\s+to|require|have\s+to)\s+(integrate|connect|deploy|complete|implement|test|fix)/i,
+            // Deferred: "left as", "deferred", "postponed", "out of scope"
+            /\b(left\s+as|deferred|postponed|out\s+of\s+scope|for\s+later|in\s+a\s+future)/i,
+            // Time-dependent: "after restart", "takes effect after", "once you"
+            /\b(after\s+(restart|reboot|redeploy)|takes?\s+effect\s+after|once\s+you)/i,
+            // === REMAINING WORK INDICATORS ===
+            // "remaining tasks", "outstanding items"
+            /\b(remaining|outstanding|pending|leftover)\s+(tasks?|items?|work|issues?|steps?)/i,
+            // "X more to do", "still have to"
+            /\b(more\s+to\s+do|still\s+have\s+to|yet\s+to\s+be\s+done)/i,
+            // Explicit blockers
+            /\b(blocker|blocked\s+by|waiting\s+(for|on)|depends?\s+on)/i,
+            // === ERROR/FAILURE STATE ===
+            // "failing tests", "build errors"
+            /\b(failing|broken|erroring)\s+(tests?|builds?|checks?|validations?)/i,
+            // "tests? (are )?(still )?failing"
+            /\btests?\s+(are\s+)?(still\s+)?failing/i,
+            // "errors? to (address|fix)"
+            /\b(errors?|warnings?|issues?)\s+to\s+(address|fix|resolve)/i,
+            // "doesn't work", "isn't working", "not working"
+            /\b(doesn'?t|isn'?t|not)\s+(work|working|functional|functioning)/i,
+            // === MANUAL STEPS REQUIRED ===
+            // "you'll need to", "manually run", "requires user"
+            /\b(you('ll|\s+will)\s+need\s+to|manually\s+(run|configure|set|update)|requires?\s+user)/i,
+            // "run this command", "execute the following"
+            /\b(run\s+this|execute\s+the\s+following|apply\s+the\s+migration)/i,
+            // === TODO/FIXME IN PROSE ===
+            // TODO or FIXME mentioned as remaining work (not in code blocks)
+            /\b(todo|fixme|hack|xxx):\s/i,
+            // "need to add", "should implement"
+            /\b(need\s+to|should|must)\s+(add|implement|create|write|build|fix)\b/i,
+            // === SCOPE LIMITATIONS ===
+            // "didn't have time", "ran out of time"
+            /\b(didn'?t|did\s+not)\s+have\s+(time|chance|opportunity)/i,
+            // "beyond scope", "outside scope"
+            /\b(beyond|outside)\s+(the\s+)?scope/i,
+            // "for now" (temporary state)
+            /\b(for\s+now|at\s+this\s+point|currently)\s*.{0,20}?(not|without|lacks?|missing)/i,
+        ];
+        for (const pattern of incompletePatterns) {
+            if (pattern.test(response)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Extract tool names from a response by looking for tool call patterns
+     */
+    extractToolsFromResponse(response) {
+        const tools = [];
+        // Look for common tool call patterns in the response
+        const toolPatterns = [
+            /(?:running|executing|called?|using)\s+(?:the\s+)?(\w+(?:_\w+)*)\s+tool/gi,
+            /tool[:\s]+(\w+(?:_\w+)*)/gi,
+            /⎿\s*(\w+)/g, // Tool result prefix pattern
+            /(?:read_file|edit_file|Edit|bash|grep|glob|search)/gi,
+        ];
+        for (const pattern of toolPatterns) {
+            let match;
+            while ((match = pattern.exec(response)) !== null) {
+                const toolName = match[1] || match[0];
+                if (toolName && !tools.includes(toolName.toLowerCase())) {
+                    tools.push(toolName.toLowerCase());
+                }
+            }
+        }
+        return tools;
+    }
+    /**
+     * Check if an error is a context overflow error
+     */
+    isContextOverflowError(error) {
+        if (!(error instanceof Error))
+            return false;
+        const message = error.message.toLowerCase();
+        return (message.includes('context length') ||
+            (message.includes('token') && (message.includes('limit') || message.includes('exceed') || message.includes('maximum'))) ||
+            message.includes('too long') ||
+            message.includes('too many tokens') ||
+            message.includes('max_tokens') ||
+            message.includes('context window'));
+    }
+    async awaitPendingCleanup() {
+        if (!this.pendingCleanup) {
+            return;
+        }
+        let timeoutId = null;
+        try {
+            // Add timeout to prevent indefinite hangs (10 second max wait)
+            const CLEANUP_TIMEOUT_MS = 10000;
+            const timeoutPromise = new Promise((_, reject) => {
+                timeoutId = setTimeout(() => reject(new Error('Cleanup timed out')), CLEANUP_TIMEOUT_MS);
+            });
+            await Promise.race([this.pendingCleanup, timeoutPromise]);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            display.showWarning(`Context cleanup failed: ${message}`);
+        }
+        finally {
+            // Clear timeout to prevent leaking timers
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            this.pendingCleanup = null;
+        }
+    }
+    getLatestFileChangeTimestamp() {
+        const changes = this._fileChangeTracker.getAllChanges();
+        if (!changes.length) {
+            return null;
+        }
+        let latest = 0;
+        for (const change of changes) {
+            latest = Math.max(latest, change.timestamp);
+        }
+        return latest || null;
+    }
+    isTestToolCall(entry) {
+        const name = entry.toolName.toLowerCase();
+        if (name === 'run_tests' || name === 'run_repo_checks' || name === 'run_build') {
+            return true;
+        }
+        if (name === 'bash' || name === 'execute_bash') {
+            const command = String(entry.args['command'] ?? '').toLowerCase();
+            return command.includes('npm test') || command.includes('yarn test') || command.includes('pnpm test');
+        }
+        return false;
+    }
+    getLatestTestTimestamp() {
+        const history = this.runtimeSession.toolRuntime.getToolHistory?.() ?? [];
+        let latest = this.lastAutoTestRun;
+        for (const entry of history) {
+            if (this.isTestToolCall(entry)) {
+                latest = latest ? Math.max(latest, entry.timestamp) : entry.timestamp;
+            }
+        }
+        return latest;
+    }
+    formatCommandError(error) {
+        const parts = [error?.stdout, error?.stderr, error?.message].filter((part) => typeof part === 'string' && part.trim());
+        return parts.join('\n').trim();
+    }
+    async enforceAutoTests(trigger) {
+        if (this.autoTestInFlight) {
+            return;
+        }
+        const latestChange = this.getLatestFileChangeTimestamp();
+        if (!latestChange) {
+            return;
+        }
+        const latestTest = this.getLatestTestTimestamp();
+        if (latestTest && latestChange <= latestTest) {
+            return;
+        }
+        this.autoTestInFlight = true;
+        const command = 'npm test -- --runInBand';
+        display.showSystemMessage(`🧪 Auto-testing recent changes (${trigger}) with "${command}"...`);
+        this.updateStatusMessage('Running tests automatically...');
+        try {
+            const { stdout, stderr } = await execAsync(command, {
+                cwd: this.workingDir,
+                timeout: 10 * 60 * 1000,
+                maxBuffer: 10 * 1024 * 1024,
+            });
+            this.lastAutoTestRun = Date.now();
+            const outputText = [stdout, stderr].filter(Boolean).join('\n').trim();
+            display.showSystemMessage('✅ Auto-tests finished.');
+            if (outputText) {
+                process.stdout.write(`${outputText}\n`);
+            }
+            this.statusTracker.clearOverride('tests');
+        }
+        catch (error) {
+            this.lastAutoTestRun = Date.now();
+            const message = this.formatCommandError(error);
+            display.showWarning('⚠️ Auto-tests failed. Review output below.');
+            if (message) {
+                process.stdout.write(`${message}\n`);
+            }
+            this.statusTracker.pushOverride('tests', 'Tests failing', {
+                detail: 'Auto-run npm test failed',
+                tone: 'danger',
+            });
+        }
+        finally {
+            this.updateStatusMessage(null);
+            this.autoTestInFlight = false;
+        }
+    }
+    rebuildAgent() {
+        const previousHistory = this.agent ? this.agent.getHistory() : this.cachedHistory;
+        try {
+            ensureSecretForProvider(this.sessionState.provider);
+            this.runtimeSession.updateToolContext(this.sessionState);
+            const selection = {
+                provider: this.sessionState.provider,
+                model: this.sessionState.model,
+                temperature: this.sessionState.temperature,
+                maxTokens: this.sessionState.maxTokens,
+                systemPrompt: this.buildSystemPrompt(),
+                reasoningEffort: this.sessionState.reasoningEffort,
+                autoContinue: this.autoContinueEnabled,
+            };
+            this.agent = this.runtimeSession.createAgent(selection, {
+                onStreamChunk: (chunk) => {
+                    // Claude Code style: Stream output through display module
+                    // The output interceptor automatically refreshes the fixed input area
+                    // after each chunk, keeping cursor at the chat box
+                    if (display.isSpinnerActive()) {
+                        display.stopThinking(false);
+                        display.stream('\n');
+                    }
+                    display.stream(chunk);
+                    this.requestPromptRefresh();
+                },
+                onStreamFallback: (info) => this.handleStreamingFallback(info),
+                onAssistantMessage: (content, metadata) => {
+                    const enriched = this.buildDisplayMetadata(metadata);
+                    // Update spinner based on message type
+                    if (metadata.isFinal) {
+                        // Skip display if content was already streamed to avoid double-display
+                        if (!metadata.wasStreamed) {
+                            const parsed = this.splitThinkingResponse(content);
+                            if (parsed?.thinking) {
+                                const summary = this.extractThoughtSummary(parsed.thinking);
+                                if (summary) {
+                                    display.updateThinking(`💭 ${summary}`);
+                                }
+                                display.showAssistantMessage(parsed.thinking, { ...enriched, isFinal: false });
+                            }
+                            const finalContent = parsed?.response?.trim() || content;
+                            if (finalContent) {
+                                display.showAssistantMessage(finalContent, enriched);
+                            }
+                        }
+                        // Show status line at end (Claude Code style: "• Context X% used • Ready for prompts (2s)")
+                        display.stopThinking();
+                        // Calculate context usage
+                        let contextInfo;
+                        if (enriched.contextWindowTokens && metadata.usage) {
+                            const total = this.totalTokens(metadata.usage);
+                            if (total && total > 0) {
+                                const percentage = Math.round((total / enriched.contextWindowTokens) * 100);
+                                contextInfo = { percentage, tokens: total };
+                            }
+                        }
+                        display.showStatusLine('Ready for prompts', enriched.elapsedMs, contextInfo);
+                        void this.enforceAutoTests('final-response');
+                    }
+                    else {
+                        // Non-final message = narrative text before tool calls (Claude Code style)
+                        // Stop spinner and show the narrative text directly
+                        display.stopThinking();
+                        // Skip display if content was already streamed to avoid double-display
+                        if (!metadata.wasStreamed) {
+                            display.showNarrative(content.trim());
+                        }
+                        // The isProcessing flag already shows "⏳ Processing..." - no need for duplicate status
+                        this.requestPromptRefresh();
+                        return;
+                    }
+                    const cleanup = this.handleContextTelemetry(metadata, enriched);
+                    if (cleanup) {
+                        this.pendingCleanup = cleanup;
+                    }
+                    this.requestPromptRefresh();
+                },
+                onContextSquishing: (message) => {
+                    // Show notification in UI when auto context squishing occurs
+                    display.showSystemMessage(`🔄 ${message}`);
+                    this.statusTracker.pushOverride('context-squish', 'Auto-squishing context', {
+                        detail: 'Reducing conversation history to fit within token limits',
+                        tone: 'warning',
+                    });
+                },
+                onContextRecovery: (attempt, maxAttempts, message) => {
+                    // Show recovery progress in UI
+                    display.showSystemMessage(`⚡ Context Recovery (${attempt}/${maxAttempts}): ${message}`);
+                },
+                onContextPruned: (removedCount, stats) => {
+                    // Clear squish overlay if active
+                    this.statusTracker.clearOverride('context-squish');
+                    // Show notification that context was pruned
+                    const method = stats['method'];
+                    const percentage = stats['percentage'];
+                    if (method === 'emergency-recovery') {
+                        display.showSystemMessage(`✅ Context recovery complete. Removed ${removedCount} messages. Context now at ${percentage ?? 'unknown'}%`);
+                    }
+                    // Update context usage in UI
+                    if (typeof percentage === 'number') {
+                        this.updateContextUsage(percentage);
+                    }
+                    // Ensure prompt remains visible at bottom after context messages
+                    this.terminalInput.render();
+                },
+                onContinueAfterRecovery: () => {
+                    // Update UI to show we're continuing after context recovery
+                    display.showSystemMessage(`🔄 Continuing after context recovery...`);
+                    this.updateStatusMessage('Retrying with reduced context...');
+                    this.terminalInput.render();
+                },
+                onAutoContinue: (attempt, maxAttempts, _message) => {
+                    // Show auto-continue progress in UI
+                    display.showSystemMessage(`🔄 Auto-continue (${attempt}/${maxAttempts}): Model expressed intent, prompting to act...`);
+                    this.updateStatusMessage('Auto-continuing...');
+                    this.terminalInput.render();
+                },
+                onCancelled: () => {
+                    // Update UI to show operation was cancelled
+                    display.showWarning('Operation cancelled.');
+                    this.updateStatusMessage(null);
+                    this.stopStreamingHeartbeat();
+                    this.terminalInput.setStreaming(false);
+                    this.terminalInput.render();
+                },
+                onVerificationNeeded: () => {
+                    void this.enforceAutoTests('verification');
+                },
+            });
+            const historyToLoad = (this.pendingHistoryLoad && this.pendingHistoryLoad.length
+                ? this.pendingHistoryLoad
+                : previousHistory && previousHistory.length
+                    ? previousHistory
+                    : null) ?? null;
+            if (historyToLoad && historyToLoad.length) {
+                this.agent.loadHistory(historyToLoad);
+                this.cachedHistory = historyToLoad;
+            }
+            else {
+                this.cachedHistory = [];
+            }
+            this.pendingHistoryLoad = null;
+            this.showSessionResumeNotice();
+            return true;
+        }
+        catch (error) {
+            this.agent = null;
+            this.handleAgentSetupError(error, () => this.rebuildAgent(), this.sessionState.provider);
+            return false;
+        }
+    }
+    /**
+     * Reset the unified input box to a fresh state after model/provider swap.
+     * Ensures the input area is visible and ready for input, just like on startup.
+     */
+    resetChatBoxAfterModelSwap() {
+        this.updateStatusMessage(null);
+        this.terminalInput.setStreaming(false);
+        this.terminalInput.render();
+        this.ensureReadlineReady();
+    }
+    buildSystemPrompt() {
+        const providerLabel = this.providerLabel(this.sessionState.provider);
+        const lines = [
+            this.baseSystemPrompt.trim(),
+            '',
+            'ACTIVE RUNTIME METADATA:',
+            `- CLI profile: ${this.profileLabel} (${this.profile})`,
+            `- Provider: ${providerLabel} (${this.sessionState.provider})`,
+            `- Model: ${this.sessionState.model}`,
+        ];
+        if (typeof this.sessionState.temperature === 'number') {
+            lines.push(`- Temperature: ${this.sessionState.temperature}`);
+        }
+        if (typeof this.sessionState.maxTokens === 'number') {
+            lines.push(`- Max tokens: ${this.sessionState.maxTokens}`);
+        }
+        lines.push('', 'Use these values when describing your identity or answering model/provider questions. If anything feels stale, call the `profile_details` tool before responding.');
+        const thinkingDirective = this.buildThinkingDirective();
+        if (thinkingDirective) {
+            lines.push('', thinkingDirective);
+        }
+        return lines.join('\n').trim();
+    }
+    buildThinkingDirective() {
+        switch (this.thinkingMode) {
+            case 'concise':
+                return 'Concise thinking mode is enabled: respond directly with the final answer and skip <thinking> blocks unless the user explicitly asks for your reasoning.';
+            case 'extended':
+                return [
+                    'Extended thinking mode is enabled. Format every reply as:',
+                    '<thinking>',
+                    'Detailed multi-step reasoning (reference tool runs/files when relevant, keep secrets redacted, no code blocks unless citing filenames).',
+                    '</thinking>',
+                    '<response>',
+                    'Final answer with actionable next steps and any code/commands requested.',
+                    '</response>',
+                ].join('\n');
+            case 'balanced':
+            default:
+                return 'Balanced thinking mode: include a short <thinking>...</thinking> block before <response> when the reasoning is non-trivial; skip it for simple answers.';
+        }
+    }
+    buildDisplayMetadata(metadata) {
+        return {
+            ...metadata,
+            contextWindowTokens: this.activeContextWindowTokens,
+        };
+    }
+    handleContextTelemetry(metadata, displayMetadata) {
+        if (!metadata.isFinal) {
+            return null;
+        }
+        const windowTokens = displayMetadata.contextWindowTokens;
+        if (!windowTokens || windowTokens <= 0) {
+            return null;
+        }
+        const total = this.totalTokens(metadata.usage);
+        if (total === null) {
+            return null;
+        }
+        const usageRatio = total / windowTokens;
+        // Always update context usage in the UI
+        const percentUsed = Math.round(usageRatio * 100);
+        this.updateContextUsage(percentUsed);
+        if (usageRatio < CONTEXT_USAGE_THRESHOLD) {
+            return null;
+        }
+        if (!this.agent || this.cleanupInProgress) {
+            return null;
+        }
+        return this.runContextCleanup(windowTokens, total);
+    }
+    totalTokens(usage) {
+        if (!usage) {
+            return null;
+        }
+        if (typeof usage.totalTokens === 'number' && Number.isFinite(usage.totalTokens)) {
+            return usage.totalTokens;
+        }
+        const input = typeof usage.inputTokens === 'number' ? usage.inputTokens : 0;
+        const output = typeof usage.outputTokens === 'number' ? usage.outputTokens : 0;
+        const sum = input + output;
+        return sum > 0 ? sum : null;
+    }
+    async runContextCleanup(windowTokens, totalTokens) {
+        if (!this.agent) {
+            return;
+        }
+        this.cleanupInProgress = true;
+        const cleanupStatusId = 'context-cleanup';
+        let cleanupOverlayActive = false;
+        try {
+            const history = this.agent.getHistory();
+            const { system, conversation } = this.partitionHistory(history);
+            if (!conversation.length) {
+                return;
+            }
+            const preserveCount = Math.min(conversation.length, CONTEXT_RECENT_MESSAGE_COUNT);
+            const preserved = conversation.slice(conversation.length - preserveCount);
+            const toSummarize = conversation.slice(0, conversation.length - preserveCount);
+            if (!toSummarize.length) {
+                return;
+            }
+            cleanupOverlayActive = true;
+            this.statusTracker.pushOverride(cleanupStatusId, 'Running context cleanup', {
+                detail: `Summarizing ${toSummarize.length} earlier messages`,
+                tone: 'warning',
+            });
+            const percentUsed = Math.round((totalTokens / windowTokens) * 100);
+            // Update context usage in unified UI
+            this.updateContextUsage(percentUsed);
+            display.showSystemMessage([
+                `Context usage: ${totalTokens.toLocaleString('en-US')} of ${windowTokens.toLocaleString('en-US')} tokens`,
+                `(${percentUsed}% full). Running automatic cleanup...`,
+            ].join(' '));
+            const summary = await this.buildContextSummary(toSummarize);
+            if (!summary) {
+                throw new Error('Summary could not be generated.');
+            }
+            const trimmed = this.buildTrimmedHistory(system, summary, preserved);
+            this.agent.loadHistory(trimmed);
+            display.showSystemMessage(`Context cleanup complete. Summarized ${toSummarize.length} earlier messages and preserved the latest ${preserved.length}.`);
+        }
+        finally {
+            if (cleanupOverlayActive) {
+                this.statusTracker.clearOverride(cleanupStatusId);
+            }
+            this.cleanupInProgress = false;
+        }
+    }
+    partitionHistory(history) {
+        const system = [];
+        const conversation = [];
+        for (const message of history) {
+            if (message.role === 'system') {
+                if (system.length === 0) {
+                    system.push(message);
+                }
+                continue;
+            }
+            conversation.push(message);
+        }
+        return { system, conversation };
+    }
+    async buildContextSummary(messages) {
+        const chunks = this.buildSummaryChunks(messages);
+        if (!chunks.length) {
+            return null;
+        }
+        const summarizer = this.runtimeSession.createAgent({
+            provider: this.sessionState.provider,
+            model: this.sessionState.model,
+            temperature: 0,
+            maxTokens: Math.min(this.sessionState.maxTokens ?? CONTEXT_CLEANUP_MAX_OUTPUT_TOKENS, CONTEXT_CLEANUP_MAX_OUTPUT_TOKENS),
+            systemPrompt: CONTEXT_CLEANUP_SYSTEM_PROMPT,
+        }, {});
+        let runningSummary = '';
+        for (const chunk of chunks) {
+            const prompt = this.buildSummaryPrompt(chunk, runningSummary);
+            runningSummary = (await summarizer.send(prompt)).trim();
+            summarizer.clearHistory();
+        }
+        return runningSummary || null;
+    }
+    buildSummaryChunks(messages) {
+        const serialized = messages.map((message) => this.serializeMessage(message)).filter((text) => text.length > 0);
+        if (!serialized.length) {
+            return [];
+        }
+        const chunks = [];
+        let buffer = '';
+        for (const entry of serialized) {
+            const segment = buffer ? `\n\n${entry}` : entry;
+            if (buffer && buffer.length + segment.length > CONTEXT_CLEANUP_CHARS_PER_CHUNK) {
+                chunks.push(buffer.trim());
+                buffer = entry;
+                continue;
+            }
+            buffer += buffer ? `\n\n${entry}` : entry;
+        }
+        if (buffer.trim()) {
+            chunks.push(buffer.trim());
+        }
+        return chunks;
+    }
+    serializeMessage(message) {
+        const role = this.describeRole(message);
+        const parts = [`${role}:`];
+        const content = message.content?.trim() ?? '';
+        if (content) {
+            parts.push(content);
+        }
+        if (message.role === 'assistant' && message.toolCalls && message.toolCalls.length > 0) {
+            parts.push('Tool calls:', ...message.toolCalls.map((call) => {
+                const args = JSON.stringify(call.arguments ?? {});
+                return `- ${call.name} ${args}`;
+            }));
+        }
+        return parts.join('\n').trim();
+    }
+    describeRole(message) {
+        switch (message.role) {
+            case 'assistant':
+                return 'Assistant';
+            case 'user':
+                return 'User';
+            case 'tool':
+                return `Tool(${message.name ?? message.toolCallId ?? 'result'})`;
+            case 'system':
+            default:
+                return 'System';
+        }
+    }
+    buildSummaryPrompt(chunk, existingSummary) {
+        const sections = [];
+        if (existingSummary) {
+            sections.push(`Existing summary:\n${existingSummary}`);
+        }
+        sections.push(`Conversation chunk:\n${chunk}`);
+        sections.push([
+            'Instructions:',
+            '- Merge the chunk into the running summary.',
+            '- Preserve critical TODOs, bugs, test gaps, and file references.',
+            '- Call out what is resolved vs. still pending.',
+            '- Keep the output concise (<= 200 words) using short headings or bullets.',
+        ].join('\n'));
+        return sections.join('\n\n');
+    }
+    buildTrimmedHistory(systemMessages, summary, preserved) {
+        const history = [];
+        if (systemMessages.length > 0) {
+            history.push(systemMessages[0]);
+        }
+        else {
+            history.push({ role: 'system', content: this.buildSystemPrompt() });
+        }
+        history.push({
+            role: 'system',
+            content: [
+                'Condensed context summary (auto cleanup):',
+                summary.trim(),
+                `Last updated: ${new Date().toISOString()}`,
+            ].join('\n\n'),
+        });
+        history.push(...preserved);
+        return history;
+    }
+    handleAgentSetupError(error, retryAction, providerOverride) {
+        this.pendingInteraction = null;
+        const provider = providerOverride ?? this.sessionState.provider;
+        const apiKeyIssue = detectApiKeyError(error, provider);
+        if (apiKeyIssue) {
+            this.handleApiKeyIssue(apiKeyIssue, retryAction);
+            return;
+        }
+        this.pendingSecretRetry = null;
+        const message = error instanceof Error ? error.message : String(error);
+        display.showError(message);
+    }
+    handleStreamingFallback(info) {
+        const detailText = info.message.trim();
+        const detail = detailText ? ` Error: ${detailText}` : '';
+        display.showWarning(`Streaming failed, retrying without streaming.${detail}`);
+        this.startStreamingHeartbeat('Fallback in progress');
+        this.requestPromptRefresh(true);
+    }
+    handleProviderError(error, retryAction) {
+        const apiKeyIssue = detectApiKeyError(error, this.sessionState.provider);
+        if (!apiKeyIssue) {
+            return false;
+        }
+        this.handleApiKeyIssue(apiKeyIssue, retryAction);
+        return true;
+    }
+    handleApiKeyIssue(info, retryAction) {
+        const secret = info.secret ?? null;
+        const providerLabel = info.provider ? this.providerLabel(info.provider) : 'the selected provider';
+        if (!secret) {
+            this.pendingSecretRetry = null;
+            const guidance = 'Run "/secrets" to configure the required API key or export it (e.g., EXPORT KEY=value) before launching the CLI.';
+            const baseMessage = info.type === 'missing'
+                ? `An API key is required before using ${providerLabel}.`
+                : `API authentication failed for ${providerLabel}.`;
+            display.showWarning(`${baseMessage} ${guidance}`.trim());
+            return;
+        }
+        const isMissing = info.type === 'missing';
+        if (!isMissing && info.message && info.message.trim()) {
+            display.showWarning(info.message.trim());
+        }
+        const prefix = isMissing
+            ? `${secret.label} is required before you can use ${providerLabel}.`
+            : `${secret.label} appears to be invalid for ${providerLabel}.`;
+        display.showWarning(prefix);
+        this.pendingSecretRetry = retryAction ?? null;
+        this.pendingInteraction = { type: 'secret-input', secret };
+        this.showSecretGuidance(secret, isMissing);
+    }
+    showSecretGuidance(secret, promptForInput) {
+        const lines = [];
+        if (promptForInput) {
+            lines.push(`Enter a new value for ${secret.label} or type "cancel".`);
+        }
+        else {
+            lines.push(`Update the stored value for ${secret.label} or type "cancel".`);
+        }
+        lines.push(`Tip: run "/secrets" anytime to manage credentials or export ${secret.envVar}=<value> before launching the CLI.`);
+        display.showSystemMessage(lines.join('\n'));
+    }
+    colorizeDropdownLine(text, index) {
+        if (!DROPDOWN_COLORS.length) {
+            return text;
+        }
+        const color = DROPDOWN_COLORS[index % DROPDOWN_COLORS.length];
+        return color(text);
+    }
+    findModelPreset(modelId) {
+        return MODEL_PRESETS.find((preset) => preset.id === modelId);
+    }
+    applyPresetReasoningDefaults() {
+        if (this.sessionState.reasoningEffort) {
+            return;
+        }
+        const preset = this.findModelPreset(this.sessionState.model);
+        if (preset?.reasoningEffort) {
+            this.sessionState.reasoningEffort = preset.reasoningEffort;
+        }
+    }
+    refreshBannerSessionInfo() {
+        const nextState = {
+            model: this.sessionState.model,
+            provider: this.sessionState.provider,
+        };
+        const previous = this.bannerSessionState;
+        if (previous && previous.model === nextState.model && previous.provider === nextState.provider) {
+            return;
+        }
+        this.refreshContextGauge();
+        display.updateSessionInfo(nextState.model, nextState.provider);
+        if (!this.isProcessing) {
+            this.setIdleStatus();
+        }
+        this.bannerSessionState = nextState;
+    }
+    providerLabel(id) {
+        return PROVIDER_LABELS[id] ?? id;
+    }
+    agentMenuLabel(name) {
+        if (!this.agentMenu) {
+            return name;
+        }
+        const entry = this.agentMenu.options.find((option) => option.name === name);
+        return entry?.label ?? name;
+    }
+    extractThoughtSummary(thought) {
+        // Extract first non-empty line
+        const lines = thought?.split('\n').filter(line => line.trim()) ?? [];
+        if (!lines.length) {
+            return null;
+        }
+        // Remove common thought prefixes
+        const cleaned = lines[0]
+            .trim()
+            .replace(/^(Thinking|Analyzing|Considering|Looking at|Let me)[:.\s]+/i, '')
+            .replace(/^I (should|need to|will|am)[:.\s]+/i, '')
+            .trim();
+        if (!cleaned) {
+            return null;
+        }
+        // Truncate to reasonable length
+        const maxLength = 50;
+        return cleaned.length > maxLength
+            ? cleaned.slice(0, maxLength - 3) + '...'
+            : cleaned;
+    }
+    splitThinkingResponse(content) {
+        if (!content?.includes('<thinking') && !content?.includes('<response')) {
+            return null;
+        }
+        const thinkingMatch = /<thinking>([\s\S]*?)<\/thinking>/i.exec(content);
+        const responseMatch = /<response>([\s\S]*?)<\/response>/i.exec(content);
+        if (!thinkingMatch && !responseMatch) {
+            return null;
+        }
+        const thinkingBody = thinkingMatch?.[1]?.trim() ?? null;
+        let responseBody = responseMatch?.[1]?.trim();
+        if (!responseBody) {
+            responseBody = content
+                .replace(thinkingMatch?.[0] ?? '', '')
+                .replace(/<\/?response>/gi, '')
+                .trim();
+        }
+        return {
+            thinking: thinkingBody && thinkingBody.length ? thinkingBody : null,
+            response: responseBody ?? '',
+        };
+    }
+    persistSessionPreference() {
+        saveModelPreference(this.profile, {
+            provider: this.sessionState.provider,
+            model: this.sessionState.model,
+            temperature: this.sessionState.temperature,
+            maxTokens: this.sessionState.maxTokens,
+            reasoningEffort: this.sessionState.reasoningEffort,
+        });
+    }
+    /**
+     * Handle the /provider command to switch AI providers.
+     */
+    async handleProviderCommand(input) {
+        const tokens = input.trim().split(/\s+/).slice(1);
+        const targetProvider = tokens[0]?.toLowerCase();
+        if (!targetProvider) {
+            this.showConfiguredProviders();
+            return;
+        }
+        // Find matching provider
+        const providerOptions = this.buildProviderOptions();
+        const match = providerOptions.find((opt) => opt.provider.toLowerCase() === targetProvider || opt.label.toLowerCase() === targetProvider);
+        if (!match) {
+            display.showWarning(`Unknown provider "${targetProvider}".`);
+            const available = providerOptions.map((opt) => opt.provider).join(', ');
+            display.showInfo(`Available providers: ${available}`);
+            return;
+        }
+        if (match.provider === this.sessionState.provider) {
+            display.showInfo(`Already using ${match.label}.`);
+            return;
+        }
+        // Get default model for the provider
+        const models = MODEL_PRESETS.filter((preset) => preset.provider === match.provider);
+        if (!models.length) {
+            display.showWarning(`No models available for ${match.label}.`);
+            return;
+        }
+        const defaultModel = models[0];
+        const oldProvider = this.sessionState.provider;
+        const oldModel = this.sessionState.model;
+        // Update session state
+        this.sessionState = {
+            provider: match.provider,
+            model: defaultModel.id,
+            temperature: defaultModel.temperature,
+            maxTokens: defaultModel.maxTokens,
+            reasoningEffort: defaultModel.reasoningEffort,
+        };
+        // Rebuild agent with new provider
+        if (this.rebuildAgent()) {
+            this.persistSessionPreference();
+            this.refreshBannerSessionInfo();
+            display.showInfo(`Switched from ${this.providerLabel(oldProvider)}/${oldModel} to ${match.label}/${defaultModel.id}`);
+            this.resetChatBoxAfterModelSwap();
+        }
+        else {
+            // Revert on failure
+            this.sessionState.provider = oldProvider;
+            this.sessionState.model = oldModel;
+            display.showError(`Failed to switch to ${match.label}. Reverted to ${this.providerLabel(oldProvider)}.`);
+        }
+    }
+    /**
+     * Discover models from provider APIs.
+     */
+    async discoverModelsCommand() {
+        display.showInfo('Discovering models from provider APIs...');
+        try {
+            const result = await discoverAllModels();
+            const lines = [
+                theme.bold('Model Discovery Results:'),
+                '',
+            ];
+            for (const providerResult of result.results) {
+                if (providerResult.success) {
+                    const count = providerResult.models.length;
+                    lines.push(`  ${theme.success('✓')} ${providerResult.provider}: ${count} model${count === 1 ? '' : 's'} found`);
+                    // Show top 3 models
+                    const topModels = providerResult.models.slice(0, 3).map(m => m.id);
+                    if (topModels.length > 0) {
+                        lines.push(`    ${theme.secondary(topModels.join(', '))}${providerResult.models.length > 3 ? '...' : ''}`);
+                    }
+                }
+                else {
+                    const errorMsg = providerResult.error || 'Unknown error';
+                    lines.push(`  ${theme.warning('⚠')} ${providerResult.provider}: ${errorMsg}`);
+                }
+            }
+            lines.push('');
+            lines.push(`Total: ${result.totalModelsDiscovered} models discovered`);
+            if (result.errors.length > 0) {
+                lines.push('');
+                lines.push(theme.secondary('Some providers had errors. Check API keys with /secrets.'));
+            }
+            display.showSystemMessage(lines.join('\n'));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            display.showError(`Discovery failed: ${message}`);
+        }
+    }
+    /**
+     * Show all configured providers and their status.
+     */
+    showConfiguredProviders() {
+        const providerOptions = this.buildProviderOptions();
+        if (!providerOptions.length) {
+            display.showWarning('No providers are configured.');
+            display.showInfo('Set an API key: OPENAI_API_KEY, ANTHROPIC_API_KEY, GEMINI_API_KEY, etc.');
+            return;
+        }
+        const lines = [
+            theme.bold('Configured Providers:'),
+            '',
+            ...providerOptions.map((option) => {
+                const isCurrent = option.provider === this.sessionState.provider;
+                const marker = isCurrent ? theme.primary(' ← active') : '';
+                const countLabel = `${option.modelCount} model${option.modelCount === 1 ? '' : 's'}`;
+                return `  ${theme.success('✓')} ${option.label} (${option.provider}) — ${countLabel}${marker}`;
+            }),
+            '',
+            'Switch with: /provider <name>',
+            'Example: /provider xai',
+        ];
+        display.showSystemMessage(lines.join('\n'));
+    }
+    /**
+     * Handle the /local command for local/air-gapped LLM management.
+     */
+    async handleLocalCommand(input) {
+        const tokens = input.trim().split(/\s+/).slice(1);
+        const subcommand = (tokens[0] ?? '').toLowerCase();
+        switch (subcommand) {
+            case '':
+            case 'scan':
+            case 'status':
+                await this.scanLocalProviders();
+                break;
+            case 'use':
+                const provider = tokens[1]?.toLowerCase();
+                if (!provider) {
+                    display.showWarning('Usage: /local use <provider>');
+                    display.showInfo('Example: /local use ollama');
+                    return;
+                }
+                await this.handleProviderCommand(`/provider ${provider}`);
+                break;
+            default:
+                this.showLocalHelp();
+                break;
+        }
+    }
+    /**
+     * Scan for running local LLM servers.
+     */
+    async scanLocalProviders() {
+        const localProviders = [
+            { id: 'ollama', label: 'Ollama', url: 'http://localhost:11434', envVar: 'OLLAMA_BASE_URL' },
+            { id: 'lmstudio', label: 'LM Studio', url: 'http://localhost:1234', envVar: 'LMSTUDIO_BASE_URL' },
+            { id: 'vllm', label: 'vLLM', url: 'http://localhost:8000', envVar: 'VLLM_BASE_URL' },
+            { id: 'llamacpp', label: 'llama.cpp', url: 'http://localhost:8080', envVar: 'LLAMACPP_BASE_URL' },
+        ];
+        display.showInfo('Scanning for local LLM servers...');
+        const results = [];
+        for (const provider of localProviders) {
+            const baseUrl = process.env[provider.envVar] || provider.url;
+            try {
+                const controller = new AbortController();
+                const timeout = setTimeout(() => controller.abort(), 2000);
+                const response = await fetch(`${baseUrl}/api/tags`, {
+                    signal: controller.signal,
+                }).catch(() => fetch(`${baseUrl}/v1/models`, { signal: controller.signal }));
+                clearTimeout(timeout);
+                if (response.ok) {
+                    const data = await response.json();
+                    const models = data.models?.map((m) => m.name) ?? [];
+                    results.push({ provider, running: true, models });
+                }
+                else {
+                    results.push({ provider, running: false });
+                }
+            }
+            catch {
+                results.push({ provider, running: false });
+            }
+        }
+        const running = results.filter((r) => r.running);
+        const stopped = results.filter((r) => !r.running);
+        const lines = [theme.bold('Local LLM Servers:'), ''];
+        if (running.length) {
+            lines.push(theme.success('Running:'));
+            for (const r of running) {
+                const modelCount = r.models?.length ?? 0;
+                const modelInfo = modelCount ? ` (${modelCount} model${modelCount === 1 ? '' : 's'})` : '';
+                lines.push(`  ${theme.success('●')} ${r.provider.label}${modelInfo}`);
+                if (r.models?.length) {
+                    for (const model of r.models.slice(0, 5)) {
+                        lines.push(`    • ${model}`);
+                    }
+                    if (r.models.length > 5) {
+                        lines.push(`    • ... and ${r.models.length - 5} more`);
+                    }
+                }
+            }
+            lines.push('');
+        }
+        if (stopped.length) {
+            lines.push(theme.secondary('Not detected:'));
+            for (const r of stopped) {
+                lines.push(`  ${theme.ui.muted('○')} ${r.provider.label}`);
+            }
+            lines.push('');
+        }
+        if (running.length) {
+            lines.push(`Switch with: /local use ${running[0].provider.id}`);
+        }
+        else {
+            lines.push('No local servers running.');
+            lines.push('Install Ollama: https://ollama.ai');
+        }
+        display.showSystemMessage(lines.join('\n'));
+    }
+    /**
+     * Show help for /local commands.
+     */
+    showLocalHelp() {
+        const lines = [
+            theme.bold('/local Commands:'),
+            '',
+            '  /local              Scan for running local LLM servers',
+            '  /local status       Same as /local (scan for servers)',
+            '  /local use <name>   Switch to a local provider',
+            '',
+            'Supported Local Providers:',
+            '  ollama     - Easy-to-use local LLM runner (recommended)',
+            '  lmstudio   - GUI-based local model serving',
+            '  vllm       - High-throughput production serving',
+            '  llamacpp   - Lightweight llama.cpp server',
+            '',
+            'Example:',
+            '  /local              # Scan for running servers',
+            '  /local use ollama   # Switch to Ollama',
+        ];
+        display.showSystemMessage(lines.join('\n'));
+    }
+    /**
+     * Set the cached provider status for unified status bar display.
+     * Called once at startup after checking providers.
+     */
+    setProviderStatus(providers) {
+        this.cachedProviderStatus = providers;
+    }
+    /**
+     * Show the unified status bar (Claude Code style).
+     * Displays provider indicators and ready hints before the prompt.
+     */
+    showUnifiedStatusBar() {
+        display.showUnifiedStatusBar(this.cachedProviderStatus);
+    }
+}
+function setsEqual(first, second) {
+    if (first.size !== second.size) {
+        return false;
+    }
+    for (const entry of first) {
+        if (!second.has(entry)) {
+            return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=interactiveShell.js.map