erosolar-cli 1.7.13 → 1.7.15

package/dist/bin/shell/interactiveShell.js

@@ -1,2908 +0,0 @@
-import readline from 'node:readline';
-import { stdin as input, stdout as output, exit } from 'node:process';
-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 { BracketedPasteManager } from './bracketedPasteManager.js';
-import { detectApiKeyError } from '../core/errors/apiKeyErrors.js';
-import { buildWorkspaceContext } from '../workspace.js';
-import { buildInteractiveSystemPrompt } from './systemPrompt.js';
-import { discoverAllModels } 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 { PersistentPrompt } from '../ui/persistentPrompt.js';
-import { formatShortcutsHelp } from '../ui/shortcutsHelp.js';
-import { MetricsTracker } from '../alpha-zero/index.js';
-import { listAvailablePlugins } from '../plugins/index.js';
-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]));
-const MULTILINE_INPUT_FLUSH_DELAY_MS = 30;
-const BRACKETED_PASTE_ENABLE = '\u001b[?2004h';
-const BRACKETED_PASTE_DISABLE = '\u001b[?2004l';
-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 {
-    constructor(config) {
-        this.agent = null;
-        this.isProcessing = false;
-        this.pendingInteraction = null;
-        this.pendingSecretRetry = null;
-        this.bufferedInputLines = [];
-        this.bufferedInputTimer = null;
-        this.bracketedPasteEnabled = false;
-        this.pendingCleanup = null;
-        this.cleanupInProgress = false;
-        this.slashPreviewVisible = false;
-        this.keypressHandler = null;
-        this.rawDataHandler = null;
-        this.skillToolHandlers = new Map();
-        this.thinkingMode = 'balanced';
-        this.bannerSessionState = null;
-        this._fileChangeTracker = new FileChangeTracker(); // Reserved for future file tracking features
-        this.statusSubscription = null;
-        this.followUpQueue = [];
-        this.isDrainingQueue = false;
-        this.activeContextWindowTokens = null;
-        this.pendingHistoryLoad = null;
-        this.cachedHistory = [];
-        this.activeSessionId = null;
-        this.activeSessionTitle = null;
-        this.sessionResumeNotice = null;
-        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.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);
-            // Update persistent prompt status bar with file changes
-            this.updatePersistentPromptFileChanges();
-        });
-        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);
-        }
-        this.rl = readline.createInterface({
-            input,
-            output,
-            prompt: formatUserPrompt(this.profileLabel || this.profile),
-            terminal: true,
-        });
-        // Wrap prompt() so we always re-arm stdin before showing it
-        const originalPrompt = this.rl.prompt.bind(this.rl);
-        this.rl.prompt = (preserveCursor) => {
-            this.ensureReadlineReady();
-            originalPrompt(preserveCursor);
-        };
-        // Initialize persistent prompt (Claude Code style)
-        this.persistentPrompt = new PersistentPrompt(output, formatUserPrompt(this.profileLabel || this.profile));
-        // Initialize Alpha Zero 2 metrics tracking
-        this.alphaZeroMetrics = new MetricsTracker(`${this.profile}-${Date.now()}`);
-        this.setupStatusTracking();
-        this.refreshContextGauge();
-        this.bracketedPasteEnabled = this.enableBracketedPasteMode();
-        this.bracketedPaste = new BracketedPasteManager(this.bracketedPasteEnabled);
-        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;
-        }
-        this.rl.prompt();
-    }
-    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.rl.prompt();
-            return;
-        }
-        const normalized = trimmed.toLowerCase();
-        if (normalized === 'cancel') {
-            this.pendingInteraction = null;
-            display.showInfo('Tool selection cancelled.');
-            this.rl.prompt();
-            return;
-        }
-        if (normalized === 'defaults') {
-            pending.selection = buildEnabledToolSet(null);
-            this.renderToolMenu(pending);
-            this.rl.prompt();
-            return;
-        }
-        if (normalized === 'save') {
-            await this.persistToolSelection(pending);
-            this.pendingInteraction = null;
-            this.rl.prompt();
-            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.rl.prompt();
-            return;
-        }
-        display.showWarning('Enter a number, "save", "defaults", or "cancel".');
-        this.rl.prompt();
-    }
-    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.rl.prompt();
-            return;
-        }
-        const trimmed = input.trim();
-        if (!trimmed) {
-            display.showWarning('Enter a number or type "cancel".');
-            this.rl.prompt();
-            return;
-        }
-        if (trimmed.toLowerCase() === 'cancel') {
-            this.pendingInteraction = null;
-            display.showInfo('Agent selection cancelled.');
-            this.rl.prompt();
-            return;
-        }
-        const choice = Number.parseInt(trimmed, 10);
-        if (!Number.isFinite(choice)) {
-            display.showWarning('Please enter a valid number.');
-            this.rl.prompt();
-            return;
-        }
-        const option = pending.options[choice - 1];
-        if (!option) {
-            display.showWarning('That option is not available.');
-            this.rl.prompt();
-            return;
-        }
-        await this.persistAgentSelection(option.name);
-        this.pendingInteraction = null;
-        this.rl.prompt();
-    }
-    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() {
-        // Set up raw data interception for bracketed paste
-        this.setupRawPasteHandler();
-        this.rl.on('line', (line) => {
-            // If we're capturing raw paste data, ignore readline line events
-            // (they've already been handled by the raw data handler)
-            if (this.bracketedPaste.isCapturingRaw()) {
-                // Show paste progress
-                this.showMultiLinePastePreview(this.bracketedPaste.getRawBufferLineCount(), this.bracketedPaste.getRawBufferPreview());
-                return;
-            }
-            const normalized = this.bracketedPaste.process(line);
-            if (normalized.handled) {
-                // If still accumulating multi-line paste, show preview
-                if (normalized.isPending) {
-                    this.showMultiLinePastePreview(normalized.lineCount || 0, normalized.preview);
-                    return;
-                }
-                // Paste complete, submit the full content
-                if (typeof normalized.result === 'string') {
-                    this.clearMultiLinePastePreview();
-                    // Show collapsed summary of what was submitted
-                    if (normalized.lineCount && normalized.lineCount > 1) {
-                        this.displayMultiLineSubmission(normalized.result, normalized.lineCount);
-                    }
-                    this.enqueueUserInput(normalized.result, true);
-                }
-                return;
-            }
-            this.enqueueUserInput(line);
-            // Clear input in persistent prompt after submission
-            this.persistentPrompt.updateInput('', 0);
-        });
-        this.rl.on('close', () => {
-            // Stop any active spinner to prevent process hang
-            display.stopThinking(false);
-            this.disableBracketedPasteMode();
-            this.teardownStatusTracking();
-            // Remove keypress listener to prevent memory leaks
-            const inputStream = input;
-            if (inputStream && this.keypressHandler) {
-                inputStream.off('keypress', this.keypressHandler);
-                this.keypressHandler = null;
-            }
-            // Remove raw data handler
-            if (inputStream && this.rawDataHandler) {
-                inputStream.off('data', this.rawDataHandler);
-                this.rawDataHandler = null;
-            }
-            // Clear any pending cleanup to prevent hanging
-            this.pendingCleanup = null;
-            // Dispose persistent prompt
-            this.persistentPrompt.dispose();
-            // Dispose unified UI adapter
-            this.uiAdapter.dispose();
-            display.newLine();
-            const highlightedEmail = theme.info('support@ero.solar');
-            const infoMessage = [
-                'Made available for defensive and offensive security operations.',
-                '',
-                'Learn more:',
-                '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);
-        });
-        // Handle terminal resize
-        output.on('resize', () => {
-            this.persistentPrompt.handleResize();
-        });
-        this.setupSlashCommandPreviewHandler();
-        // Show initial persistent prompt
-        this.persistentPrompt.show();
-    }
-    /**
-     * Set up raw stdin data interception for bracketed paste mode.
-     * This intercepts data before readline processes it, allowing us to
-     * capture complete multi-line pastes without readline splitting them.
-     */
-    setupRawPasteHandler() {
-        if (!this.bracketedPasteEnabled) {
-            return;
-        }
-        const inputStream = input;
-        if (!inputStream || !inputStream.isTTY) {
-            return;
-        }
-        // Set up callback for when a complete paste is captured
-        this.bracketedPaste.setRawPasteCallback((content) => {
-            this.clearMultiLinePastePreview();
-            const lines = content.split('\n');
-            const lineCount = lines.length;
-            // Show collapsed summary for multi-line pastes
-            if (lineCount > 1) {
-                this.displayMultiLineSubmission(content, lineCount);
-            }
-            // Submit the pasted content
-            this.enqueueUserInput(content, true);
-            // Restore the prompt
-            this.persistentPrompt.updateInput('', 0);
-            this.rl.prompt();
-        });
-        // We need to intercept raw data, but we can't easily do this with
-        // readline already consuming stdin. Instead, we handle paste detection
-        // via the bracketed paste markers that appear in line events.
-        // The raw handler approach works better when we control the input stream.
-        //
-        // For now, we rely on the line-event-based approach with enhanced
-        // detection in the BracketedPasteManager.
-    }
-    setupSlashCommandPreviewHandler() {
-        const inputStream = input;
-        if (!inputStream || typeof inputStream.on !== 'function' || !inputStream.isTTY) {
-            return;
-        }
-        if (inputStream.listenerCount('keypress') === 0) {
-            readline.emitKeypressEvents(inputStream, this.rl);
-        }
-        this.keypressHandler = (_str, key) => {
-            // Update persistent prompt with current input
-            const currentLine = this.rl.line || '';
-            const cursorPos = this.rl.cursor || 0;
-            this.persistentPrompt.updateInput(currentLine, cursorPos);
-            this.handleSlashCommandPreviewChange();
-            // Handle Shift+Tab for profile switching
-            if (key && key.name === 'tab' && key.shift && this.agentMenu) {
-                this.showProfileSwitcher();
-            }
-        };
-        inputStream.on('keypress', this.keypressHandler);
-    }
-    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;
-    }
-    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();
-            // Show persistent prompt again after hiding overlay
-            if (!this.isProcessing) {
-                this.persistentPrompt.show();
-            }
-        }
-    }
-    shouldShowSlashCommandPreview() {
-        const line = this.rl.line ?? '';
-        if (!line.trim()) {
-            return false;
-        }
-        const trimmed = line.trimStart();
-        return trimmed.startsWith('/');
-    }
-    showSlashCommandPreview() {
-        // Filter commands based on current input
-        const line = this.rl.line ?? '';
-        const trimmed = line.trimStart();
-        // Filter commands that match the current input
-        const filtered = this.slashCommands.filter(cmd => cmd.command.startsWith(trimmed) || trimmed === '/');
-        // Hide persistent prompt to avoid conflicts with overlay
-        this.persistentPrompt.hide();
-        // Show in the unified UI with dynamic overlay
-        this.uiAdapter.showSlashCommandPreview(filtered);
-        // Don't reprompt - this causes flickering
-    }
-    showProfileSwitcher() {
-        if (!this.agentMenu) {
-            return;
-        }
-        // Build profile options with current/next indicators
-        const profiles = this.agentMenu.options.map((option, index) => {
-            const badges = [];
-            const nextProfile = this.agentMenu.persistedProfile ?? this.agentMenu.defaultProfile;
-            if (option.name === this.profile) {
-                badges.push('current');
-            }
-            if (option.name === nextProfile && option.name !== this.profile) {
-                badges.push('next');
-            }
-            const badgeText = badges.length > 0 ? ` (${badges.join(', ')})` : '';
-            return {
-                command: `${index + 1}. ${option.label}${badgeText}`,
-                description: `${this.providerLabel(option.defaultProvider)} • ${option.defaultModel}`,
-            };
-        });
-        // Show profile switcher overlay
-        this.uiAdapter.showProfileSwitcher(profiles, this.profileLabel);
-    }
-    /**
-     * Ensure stdin is ready for interactive input before showing the prompt.
-     * This recovers from cases where a nested readline/prompt or partial paste
-     * left the stream paused, raw mode disabled, or keypress listeners detached.
-     */
-    ensureReadlineReady() {
-        // Clear any stuck bracketed paste state so new input isn't dropped
-        this.bracketedPaste.reset();
-        const inputStream = input;
-        if (!inputStream) {
-            return;
-        }
-        // Resume stdin if another consumer paused it
-        if (typeof inputStream.isPaused === 'function' && inputStream.isPaused()) {
-            inputStream.resume();
-        }
-        else if (inputStream.readableFlowing === false) {
-            inputStream.resume();
-        }
-        // Restore raw mode if a nested readline turned it off
-        if (inputStream.isTTY && typeof inputStream.isRaw === 'boolean') {
-            const ttyStream = inputStream;
-            if (!ttyStream.isRaw) {
-                ttyStream.setRawMode(true);
-            }
-        }
-        // Reattach keypress handler if it was removed
-        if (this.keypressHandler) {
-            const listeners = inputStream.listeners('keypress');
-            const hasHandler = listeners.includes(this.keypressHandler);
-            if (!hasHandler) {
-                if (inputStream.listenerCount('keypress') === 0) {
-                    readline.emitKeypressEvents(inputStream, this.rl);
-                }
-                inputStream.on('keypress', this.keypressHandler);
-            }
-        }
-    }
-    enqueueUserInput(line, flushImmediately = false) {
-        this.bufferedInputLines.push(line);
-        if (flushImmediately) {
-            if (this.bufferedInputTimer) {
-                clearTimeout(this.bufferedInputTimer);
-                this.bufferedInputTimer = null;
-            }
-            void this.flushBufferedInput();
-            return;
-        }
-        if (this.bufferedInputTimer) {
-            clearTimeout(this.bufferedInputTimer);
-        }
-        this.bufferedInputTimer = setTimeout(() => {
-            void this.flushBufferedInput();
-        }, MULTILINE_INPUT_FLUSH_DELAY_MS);
-    }
-    /**
-     * Show a preview indicator while accumulating multi-line paste
-     */
-    showMultiLinePastePreview(lineCount, preview) {
-        // Clear the current line and show paste accumulation status
-        readline.clearLine(output, 0);
-        readline.cursorTo(output, 0);
-        const statusText = preview
-            ? `${theme.ui.muted('📋 Pasting:')} ${theme.ui.muted(preview.slice(0, 50))}${preview.length > 50 ? '...' : ''}`
-            : `${theme.ui.muted(`📋 Pasting ${lineCount} line${lineCount !== 1 ? 's' : ''}...`)}`;
-        output.write(statusText);
-    }
-    /**
-     * Clear the multi-line paste preview
-     */
-    clearMultiLinePastePreview() {
-        readline.clearLine(output, 0);
-        readline.cursorTo(output, 0);
-    }
-    /**
-     * Display a collapsed summary of multi-line content that was submitted
-     */
-    displayMultiLineSubmission(content, lineCount) {
-        const lines = content.split('\n');
-        const firstLine = (lines[0] || '').trim();
-        const maxPreviewLen = Math.min(60, (output.columns || 80) - 20);
-        const truncatedFirst = firstLine.length > maxPreviewLen
-            ? firstLine.slice(0, maxPreviewLen - 3) + '...'
-            : firstLine;
-        // Show collapsed block indicator
-        const collapsedDisplay = theme.ui.muted(`📋 ${truncatedFirst} [${lineCount} lines]`);
-        // Clear line and show the collapsed preview, then newline for response
-        readline.clearLine(output, 0);
-        readline.cursorTo(output, 0);
-        console.log(`${formatUserPrompt(this.profileLabel || this.profile)}${collapsedDisplay}`);
-    }
-    async flushBufferedInput() {
-        if (!this.bufferedInputLines.length) {
-            this.bufferedInputTimer = null;
-            return;
-        }
-        const lineCount = this.bufferedInputLines.length;
-        const combined = this.bufferedInputLines.join('\n');
-        this.bufferedInputLines = [];
-        this.bufferedInputTimer = null;
-        try {
-            await this.processInputBlock(combined, lineCount > 1);
-        }
-        catch (error) {
-            // Pass full error object for enhanced formatting
-            display.showError(error instanceof Error ? error.message : String(error), error);
-            this.rl.prompt();
-        }
-    }
-    refreshQueueIndicators() {
-        const queued = this.followUpQueue.length;
-        const message = queued > 0 ? `${queued} follow-up${queued === 1 ? '' : 's'} queued` : undefined;
-        this.persistentPrompt.updateStatusBar({ message });
-        if (this.isProcessing) {
-            this.setProcessingStatus();
-        }
-        else {
-            this.setIdleStatus();
-        }
-    }
-    enqueueFollowUpAction(action) {
-        this.followUpQueue.push(action);
-        const normalized = action.text.replace(/\s+/g, ' ').trim();
-        const previewLimit = 120;
-        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 request';
-        if (preview) {
-            display.showInfo(`Queued ${label} ${position} after the current response: ${theme.ui.muted(preview)}`);
-        }
-        else {
-            display.showInfo(`Queued ${label} ${position} after the current response.`);
-        }
-        this.refreshQueueIndicators();
-        this.scheduleQueueProcessing();
-    }
-    scheduleQueueProcessing() {
-        if (!this.followUpQueue.length) {
-            this.refreshQueueIndicators();
-            return;
-        }
-        queueMicrotask(() => {
-            void this.processQueuedActions();
-        });
-    }
-    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) {
-            this.rl.prompt();
-            return;
-        }
-        if (trimmed.toLowerCase() === 'exit' || trimmed.toLowerCase() === 'quit') {
-            this.rl.close();
-            return;
-        }
-        if (trimmed.toLowerCase() === 'clear') {
-            display.clear();
-            this.rl.prompt();
-            return;
-        }
-        if (trimmed.toLowerCase() === 'help') {
-            this.showHelp();
-            this.rl.prompt();
-            return;
-        }
-        if (trimmed.startsWith('/')) {
-            await this.processSlashCommand(trimmed);
-            return;
-        }
-        // Check for continuous/infinite loop commands
-        if (this.isContinuousCommand(trimmed)) {
-            await this.processContinuousRequest(trimmed);
-            this.rl.prompt();
-            return;
-        }
-        // Direct execution for all inputs, including multi-line pastes
-        await this.processRequest(trimmed);
-        this.rl.prompt();
-    }
-    /**
-     * 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.rl.prompt();
-            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 '/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.rl.prompt();
-    }
-    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()}).`);
-        }
-        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 });
-        this.rebuildAgent();
-        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.');
-    }
-    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');
-    }
-    showModelMenu() {
-        const providerOptions = this.buildProviderOptions();
-        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 label = this.colorizeDropdownLine(`${index + 1}. ${option.label} — ${countLabel}`, 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,
-        }));
-    }
-    showProviderModels(option) {
-        const models = MODEL_PRESETS.filter((preset) => preset.provider === option.provider);
-        if (!models.length) {
-            display.showWarning(`No models available for ${option.label}.`);
-            this.pendingInteraction = null;
-            return;
-        }
-        const lines = [
-            theme.bold(`Select a model from ${option.label}:`),
-            ...models.map((preset, index) => {
-                const isCurrent = preset.id === this.sessionState.model;
-                const label = this.colorizeDropdownLine(`${index + 1}. ${preset.label}`, 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: models };
-    }
-    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.rl.prompt();
-            return;
-        }
-        if (trimmed.toLowerCase() === 'cancel') {
-            this.pendingInteraction = null;
-            display.showInfo('Model selection cancelled.');
-            this.rl.prompt();
-            return;
-        }
-        const choice = Number.parseInt(trimmed, 10);
-        if (!Number.isFinite(choice)) {
-            display.showWarning('Please enter a valid number.');
-            this.rl.prompt();
-            return;
-        }
-        const option = pending.options[choice - 1];
-        if (!option) {
-            display.showWarning('That option is not available.');
-            this.rl.prompt();
-            return;
-        }
-        this.showProviderModels(option);
-        this.rl.prompt();
-    }
-    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.rl.prompt();
-            return;
-        }
-        if (trimmed.toLowerCase() === 'back') {
-            this.showModelMenu();
-            this.rl.prompt();
-            return;
-        }
-        if (trimmed.toLowerCase() === 'cancel') {
-            this.pendingInteraction = null;
-            display.showInfo('Model selection cancelled.');
-            this.rl.prompt();
-            return;
-        }
-        const choice = Number.parseInt(trimmed, 10);
-        if (!Number.isFinite(choice)) {
-            display.showWarning('Please enter a valid number.');
-            this.rl.prompt();
-            return;
-        }
-        const preset = pending.options[choice - 1];
-        if (!preset) {
-            display.showWarning('That option is not available.');
-            this.rl.prompt();
-            return;
-        }
-        this.pendingInteraction = null;
-        await this.applyModelPreset(preset);
-        this.rl.prompt();
-    }
-    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();
-        }
-    }
-    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.rl.prompt();
-            return;
-        }
-        if (trimmed.toLowerCase() === 'cancel') {
-            this.pendingInteraction = null;
-            display.showInfo('Secret management cancelled.');
-            this.rl.prompt();
-            return;
-        }
-        const choice = Number.parseInt(trimmed, 10);
-        if (!Number.isFinite(choice)) {
-            display.showWarning('Please enter a valid number.');
-            this.rl.prompt();
-            return;
-        }
-        const secret = pending.options[choice - 1];
-        if (!secret) {
-            display.showWarning('That option is not available.');
-            this.rl.prompt();
-            return;
-        }
-        display.showSystemMessage(`Enter a new value for ${secret.label} or type "cancel".`);
-        this.pendingInteraction = { type: 'secret-input', secret };
-        this.rl.prompt();
-    }
-    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.rl.prompt();
-            return;
-        }
-        if (trimmed.toLowerCase() === 'cancel') {
-            this.pendingInteraction = null;
-            this.pendingSecretRetry = null;
-            display.showInfo('Secret unchanged.');
-            this.rl.prompt();
-            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)) {
-                this.rebuildAgent();
-            }
-            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.rl.prompt();
-    }
-    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;
-        const requestStartTime = Date.now(); // Alpha Zero 2 timing
-        // Hide persistent prompt during processing to avoid UI conflicts
-        this.persistentPrompt.hide();
-        this.uiAdapter.startProcessing('Working on your request');
-        this.setProcessingStatus();
-        try {
-            display.newLine();
-            display.showThinking('Working on your request...');
-            // Enable streaming for real-time text output (Claude Code style)
-            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);
-        }
-        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.isProcessing = false;
-            this.uiAdapter.endProcessing('Ready for prompts');
-            this.setIdleStatus();
-            display.newLine();
-            // Ensure persistent prompt is visible after processing
-            this.persistentPrompt.show();
-            // CRITICAL: Ensure readline prompt is active for user input
-            // This is a safety net in case the caller doesn't call rl.prompt()
-            this.rl.prompt();
-            this.scheduleQueueProcessing();
-            this.refreshQueueIndicators();
-        }
-    }
-    /**
-     * Process a continuous/infinite loop request.
-     * Runs the agent in a loop until:
-     * 1. The agent indicates completion (no more actions needed)
-     * 2. User interrupts (Ctrl+C)
-     * 3. Maximum iterations reached (safety limit)
-     *
-     * Context is automatically managed - overflow errors trigger auto-recovery.
-     */
-    async processContinuousRequest(initialRequest) {
-        const MAX_ITERATIONS = 100; // Safety limit to prevent truly infinite loops
-        const COMPLETION_PATTERNS = [
-            /\b(completed?|done|finished|all.*done|task.*complete|nothing.*left|no.*more.*tasks?)\b/i,
-            /\b(everything.*done|all.*tasks?.*complete|successfully.*completed?)\b/i,
-        ];
-        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;
-        const overallStartTime = Date.now();
-        // Hide persistent prompt during processing
-        this.persistentPrompt.hide();
-        display.showSystemMessage(`🔄 Starting continuous execution mode. Press Ctrl+C to stop.`);
-        this.uiAdapter.startProcessing('Continuous execution mode');
-        this.setProcessingStatus();
-        let iteration = 0;
-        let lastResponse = '';
-        let consecutiveNoProgress = 0;
-        const MAX_NO_PROGRESS = 3;
-        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.`;
-            }
-            while (iteration < MAX_ITERATIONS) {
-                iteration++;
-                display.showSystemMessage(`\n📍 Iteration ${iteration}/${MAX_ITERATIONS}`);
-                display.showThinking(`Working on iteration ${iteration}...`);
-                try {
-                    // Send the request and capture the response
-                    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);
-                    display.stopThinking(false);
-                    // Check if the response indicates completion
-                    const isComplete = COMPLETION_PATTERNS.some(pattern => pattern.test(response));
-                    const responseChanged = response !== lastResponse;
-                    if (isComplete && responseChanged) {
-                        display.showSystemMessage(`\n✅ Task completed after ${iteration} iteration(s).`);
-                        break;
-                    }
-                    // Check for no progress (same response multiple times)
-                    if (!responseChanged) {
-                        consecutiveNoProgress++;
-                        if (consecutiveNoProgress >= MAX_NO_PROGRESS) {
-                            display.showSystemMessage(`\n⚠️ No progress detected for ${MAX_NO_PROGRESS} iterations. Stopping.`);
-                            break;
-                        }
-                    }
-                    else {
-                        consecutiveNoProgress = 0;
-                    }
-                    lastResponse = response;
-                    // Prepare next iteration prompt - explicitly encourage git usage
-                    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, say "done".`;
-                    // 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`);
-            this.isProcessing = false;
-            this.uiAdapter.endProcessing('Ready for prompts');
-            this.setIdleStatus();
-            display.newLine();
-            this.persistentPrompt.show();
-            // CRITICAL: Ensure readline prompt is active for user input
-            // This is a safety net in case the caller doesn't call rl.prompt()
-            this.rl.prompt();
-            this.scheduleQueueProcessing();
-            this.refreshQueueIndicators();
-        }
-    }
-    /**
-     * 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;
-        }
-    }
-    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,
-            };
-            this.agent = this.runtimeSession.createAgent(selection, {
-                onStreamChunk: (chunk) => {
-                    // Stream text directly to console for real-time display (Claude Code style)
-                    // Use safe write to prevent interleaving with spinner animation frames
-                    display.safeWrite(() => {
-                        // Stop spinner on first chunk to avoid interference
-                        if (display.isSpinnerActive()) {
-                            display.stopThinking(false);
-                            process.stdout.write('\n'); // Newline after spinner
-                        }
-                        process.stdout.write(chunk);
-                    });
-                },
-                onAssistantMessage: (content, metadata) => {
-                    const enriched = this.buildDisplayMetadata(metadata);
-                    // Update spinner based on message type
-                    if (metadata.isFinal) {
-                        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);
-                    }
-                    else {
-                        // Non-final message = narrative text before tool calls (Claude Code style)
-                        // Stop spinner and show the narrative text directly
-                        display.stopThinking();
-                        display.showNarrative(content.trim());
-                        // Restart spinner for tool execution
-                        display.showThinking('Working on your request...');
-                        return;
-                    }
-                    const cleanup = this.handleContextTelemetry(metadata, enriched);
-                    if (cleanup) {
-                        this.pendingCleanup = cleanup;
-                    }
-                },
-                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}`);
-                    // Update persistent prompt to show recovery status
-                    this.persistentPrompt.updateStatusBar({
-                        contextUsage: 100, // Show as full during recovery
-                    });
-                },
-                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.uiAdapter.updateContextUsage(percentage);
-                        this.persistentPrompt.updateStatusBar({ contextUsage: percentage });
-                    }
-                },
-            });
-            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;
-        }
-    }
-    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.uiAdapter.updateContextUsage(percentUsed);
-        // Update persistent prompt status bar with context usage
-        this.persistentPrompt.updateStatusBar({ contextUsage: 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.uiAdapter.updateContextUsage(percentUsed);
-            // Update persistent prompt status bar with context usage
-            this.persistentPrompt.updateStatusBar({ contextUsage: 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);
-    }
-    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;
-    }
-    updatePersistentPromptFileChanges() {
-        const summary = this._fileChangeTracker.getSummary();
-        if (summary.files === 0) {
-            return;
-        }
-        const fileChangesText = `${summary.files} file${summary.files === 1 ? '' : 's'} +${summary.additions} -${summary.removals}`;
-        this.persistentPrompt.updateStatusBar({ fileChanges: fileChangesText });
-    }
-    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}`);
-        }
-        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'));
-    }
-    enableBracketedPasteMode() {
-        if (!input.isTTY || !output.isTTY) {
-            return false;
-        }
-        try {
-            output.write(BRACKETED_PASTE_ENABLE);
-            return true;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            display.showWarning(`Unable to enable bracketed paste: ${message}`);
-            return false;
-        }
-    }
-    disableBracketedPasteMode() {
-        if (!this.bracketedPasteEnabled || !output.isTTY) {
-            return;
-        }
-        try {
-            output.write(BRACKETED_PASTE_DISABLE);
-        }
-        finally {
-            this.bracketedPasteEnabled = false;
-            this.bracketedPaste.reset();
-        }
-    }
-}
-function setsEqual(first, second) {
-    if (first.size !== second.size) {
-        return false;
-    }
-    for (const entry of first) {
-        if (!second.has(entry)) {
-            return false;
-        }
-    }
-    return true;
-}