erosolar-cli 1.7.193 → 1.7.195

package/dist/shell/interactiveShell.js

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