erosolar-cli 1.7.373 → 1.7.379

package/dist/shell/interactiveShell.js

@@ -6,6 +6,7 @@ import { 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, loadFeatureFlags, saveFeatureFlags, toggleFeatureFlag, FEATURE_FLAG_INFO, } from '../core/preferences.js';
+import { getLearningSummary, getRecentLearning, commitLearning, exportAllLearning, getLearningDir, } from '../core/learningPersistence.js';
 import { buildEnabledToolSet, evaluateToolPermissions, getToolToggleOptions, } from '../capabilities/toolRegistry.js';
 import { detectApiKeyError } from '../core/errors/apiKeyErrors.js';
 import { buildWorkspaceContext } from '../workspace.js';
@@ -20,8 +21,16 @@ import { SkillRepository } from '../skills/skillRepository.js';
 import { createSkillTools } from '../tools/skillTools.js';
 import { FileChangeTracker } from './fileChangeTracker.js';
 import { formatShortcutsHelp } from '../ui/shortcutsHelp.js';
+import { setPlanApprovalCallback } from '../tools/planningTools.js';
 import { MetricsTracker } from '../core/metricsTracker.js';
+import { detectFailure, clearActionHistory, findRecoveryStrategy, } from '../core/failureRecovery.js';
+import { addToolPattern } from '../core/learningPersistence.js';
+import { classifyTaskType } from '../core/alphaZeroEngine.js';
+import { analyzeImprovementOpportunities, runSelfImprovementCycle, getImprovementSummary, runAutonomousImprovement, requestAutoImprovementStop, getAutoImprovementState, emergencyRollback, } from '../core/selfImprovement.js';
 import { listAvailablePlugins } from '../plugins/index.js';
+import { isErosolarRepo, isValidSourceRepo, getRepoName, analyzeSource, runSelfEvolution, stopEvolution, getEvolutionStatus, emergencyEvolutionRollback, learnSourcePatterns, generateFix, } from '../core/selfEvolution.js';
+import { analyzeTokenUsage, discoverModularTargets, getModularStatusDisplay, generateContextOptimizations, getGuidelines, deleteGuideline, getPendingActions, executeModularAction, } from '../core/alphaZeroModular.js';
+import { generateTestFlows, detectBugs, detectUIUpdates, saveTestFlows, saveBugReports, saveUIUpdates, getTestFlowStatus, } from '../core/intelligentTestFlows.js';
 import { TerminalInputAdapter } from './terminalInputAdapter.js';
 import { renderSessionFrame } from '../ui/unified/layout.js';
 import { isUpdateInProgress, maybeOfferCliUpdate } from './updateManager.js';
@@ -29,6 +38,7 @@ import { writeLock } from '../ui/writeLock.js';
 import { enterStreamingMode, exitStreamingMode } from '../ui/globalWriteLock.js';
 import { setGlobalAIEnhancer } from '../tools/localExplore.js';
 import { createProvider } from '../providers/providerFactory.js';
+import { getParallelAgentManager } from '../subagents/parallelAgentManager.js';
 const execAsync = promisify(exec);
 const DROPDOWN_COLORS = [
     theme.primary,
@@ -125,6 +135,11 @@ export class InteractiveShell {
     cachedProviderStatus = [];
     // Auto-test tracking
     autoTestInFlight = false;
+    // AlphaZero learning tracking
+    currentTaskType = 'general';
+    currentToolCalls = [];
+    lastUserQuery = '';
+    lastFailure = null;
     lastAutoTestRun = null;
     // Auto-build tracking
     autoBuildInFlight = false;
@@ -240,6 +255,8 @@ export class InteractiveShell {
         this.refreshContextGauge();
         // Start terminal input (sets up handlers)
         this.terminalInput.start();
+        // Set up command autocomplete with all slash commands
+        this.setupCommandAutocomplete();
         // Enter alternate screen buffer when enabled, otherwise clear the main screen for layout
         if (this.alternateScreenEnabled) {
             this.terminalInput.enterAlternateScreen();
@@ -256,6 +273,37 @@ export class InteractiveShell {
         this.rebuildAgent();
         this.setupHandlers();
         this.refreshBannerSessionInfo();
+        // Subscribe to parallel agent manager events
+        this.setupParallelAgentTracking();
+    }
+    parallelAgentDisplayLines = [];
+    setupParallelAgentTracking() {
+        const manager = getParallelAgentManager();
+        // Update display when agent status changes
+        const updateDisplay = () => {
+            this.parallelAgentDisplayLines = manager.formatDisplay();
+            // Trigger UI refresh if streaming
+            if (this.streamingHeartbeatStart) {
+                this.displayParallelAgents();
+            }
+        };
+        manager.on('agent:started', updateDisplay);
+        manager.on('agent:progress', updateDisplay);
+        manager.on('agent:completed', updateDisplay);
+        manager.on('agent:error', updateDisplay);
+        manager.on('batch:completed', () => {
+            // Clear after batch completes to show final summary
+            setTimeout(() => {
+                this.parallelAgentDisplayLines = [];
+            }, 2000);
+        });
+    }
+    displayParallelAgents() {
+        if (this.parallelAgentDisplayLines.length === 0)
+            return;
+        // Display parallel agent tree above the current output
+        const agentDisplay = this.parallelAgentDisplayLines.join('\n');
+        display.parallelAgentStatus(agentDisplay);
     }
     initializeSessionHistory() {
         this.cachedHistory = [];
@@ -362,6 +410,18 @@ export class InteractiveShell {
             this.shutdown();
             return;
         }
+        // Handle pending interactions (from /model, /secrets, etc.) immediately
+        if (this.pendingInteraction) {
+            this.terminalInput.dequeue();
+            void this.handlePendingInteraction(text);
+            return;
+        }
+        // Allow certain commands to run immediately during streaming
+        if (this.isImmediateCommand(text)) {
+            this.terminalInput.dequeue();
+            void this.executeImmediateCommand(text);
+            return;
+        }
         // Keep adapter queue trimmed so hints stay accurate
         this.terminalInput.dequeue();
         this.followUpQueue.push({ type: 'request', text });
@@ -370,6 +430,51 @@ export class InteractiveShell {
         this.scheduleQueueProcessing();
         this.handleInputChange('');
     }
+    /**
+     * Check if a command can execute immediately during streaming.
+     * These are configuration and info commands that don't interact with the AI.
+     */
+    isImmediateCommand(text) {
+        const trimmed = text.trim().toLowerCase();
+        if (!trimmed.startsWith('/'))
+            return false;
+        // Commands that can run during streaming
+        const immediateCommands = [
+            '/help', '/?',
+            '/model', '/models',
+            '/secrets',
+            '/tools',
+            '/mcp',
+            '/provider', '/providers',
+            '/thinking',
+            '/autocontinue',
+            '/shortcuts', '/keys',
+            '/cost', '/usage',
+            '/context',
+            '/sessions',
+            '/features',
+            '/local', '/discover',
+            '/evolve', '/modular', '/a0',
+            '/learn',
+            '/test', '/tests',
+            '/plugins',
+            '/metrics', '/stats', '/perf',
+            '/terminal-setup',
+            '/permissions',
+            '/vim',
+            '/output-style',
+        ];
+        const cmd = trimmed.split(/\s+/)[0];
+        return immediateCommands.includes(cmd);
+    }
+    /**
+     * Execute a command immediately during streaming.
+     */
+    async executeImmediateCommand(text) {
+        // Pause streaming display briefly to show command output
+        display.showInfo(`Running command during stream: ${text}`);
+        await this.processSlashCommand(text);
+    }
     /**
      * TerminalInputAdapter change handler
      */
@@ -386,11 +491,22 @@ export class InteractiveShell {
     handleEditModeChange(mode) {
         this.editGuardMode = mode;
         this.pendingPermissionInput = null;
-        if (mode === 'ask-permission') {
-            display.showSystemMessage('🛡️ Ask-to-edit mode enabled. Confirm each request before sending.');
+        if (mode === 'plan') {
+            // Register plan approval callback for interactive UI
+            setPlanApprovalCallback((steps, explanation) => {
+                this.showPlanApproval(steps, explanation);
+            });
+            display.showSystemMessage('📋 Plan mode enabled. AI will create a plan and ask for approval before implementing.');
         }
         else {
-            display.showSystemMessage('✏️ Display edits mode enabled.');
+            // Unregister callback when not in plan mode
+            setPlanApprovalCallback(null);
+            if (mode === 'ask-permission') {
+                display.showSystemMessage('🛡️ Ask-to-edit mode enabled. Confirm each request before sending.');
+            }
+            else {
+                display.showSystemMessage('✏️ Display edits mode enabled.');
+            }
         }
         this.terminalInput.render();
     }
@@ -757,6 +873,130 @@ export class InteractiveShell {
         this.agentMenu.persistedProfile = profileName;
         display.showInfo(`${this.agentMenuLabel(profileName)} will load the next time you start the CLI. Restart to switch now.`);
     }
+    /**
+     * Show plan approval UI with interactive step selection
+     */
+    showPlanApproval(steps, explanation) {
+        const planSteps = steps.map((step, idx) => ({
+            id: idx + 1,
+            description: step.description,
+            status: 'pending',
+        }));
+        this.pendingInteraction = {
+            type: 'plan-approval',
+            steps: planSteps,
+            selectedSteps: new Set(planSteps.map(s => s.id)), // All selected by default
+            explanation,
+        };
+        this.displayPlanApprovalUI();
+    }
+    displayPlanApprovalUI() {
+        const pending = this.pendingInteraction;
+        if (!pending || pending.type !== 'plan-approval')
+            return;
+        const lines = [];
+        lines.push('');
+        lines.push(theme.gradient.primary('═'.repeat(60)));
+        lines.push(theme.gradient.primary('📋 PLAN FOR APPROVAL'));
+        lines.push(theme.gradient.primary('═'.repeat(60)));
+        lines.push('');
+        if (pending.explanation) {
+            lines.push(theme.ui.muted(pending.explanation));
+            lines.push('');
+        }
+        lines.push(theme.info('Steps (toggle with number, or enter your own):'));
+        lines.push('');
+        for (const step of pending.steps) {
+            const isSelected = pending.selectedSteps.has(step.id);
+            const checkbox = isSelected ? theme.success('☑') : theme.ui.muted('☐');
+            const stepNum = theme.info(`${step.id}.`);
+            const desc = isSelected ? step.description : theme.ui.muted(step.description);
+            lines.push(`  ${checkbox} ${stepNum} ${desc}`);
+        }
+        lines.push('');
+        lines.push(theme.ui.muted('─'.repeat(60)));
+        lines.push('');
+        lines.push(theme.info('Commands:'));
+        lines.push(`  ${theme.primary('1-N')}      Toggle step selection`);
+        lines.push(`  ${theme.primary('all')}      Select all steps`);
+        lines.push(`  ${theme.primary('none')}     Deselect all steps`);
+        lines.push(`  ${theme.primary('go')}       Execute selected steps`);
+        lines.push(`  ${theme.primary('cancel')}   Cancel planning`);
+        lines.push(`  ${theme.primary('[text]')}   Submit your own solution instead`);
+        lines.push('');
+        display.showSystemMessage(lines.join('\n'));
+        this.terminalInput.render();
+    }
+    async handlePlanApprovalInput(input) {
+        const pending = this.pendingInteraction;
+        if (!pending || pending.type !== 'plan-approval')
+            return;
+        const trimmed = input.trim();
+        if (!trimmed) {
+            display.showWarning('Enter a command or your own solution.');
+            this.terminalInput.render();
+            return;
+        }
+        const lower = trimmed.toLowerCase();
+        // Cancel
+        if (lower === 'cancel' || lower === 'c') {
+            this.pendingInteraction = null;
+            display.showInfo('Plan cancelled. You can continue with a different approach.');
+            this.terminalInput.render();
+            return;
+        }
+        // Select all
+        if (lower === 'all' || lower === 'a') {
+            pending.selectedSteps = new Set(pending.steps.map(s => s.id));
+            this.displayPlanApprovalUI();
+            return;
+        }
+        // Deselect all
+        if (lower === 'none' || lower === 'n') {
+            pending.selectedSteps.clear();
+            this.displayPlanApprovalUI();
+            return;
+        }
+        // Execute selected steps
+        if (lower === 'go' || lower === 'g' || lower === 'yes' || lower === 'y') {
+            const selectedSteps = pending.steps.filter(s => pending.selectedSteps.has(s.id));
+            if (selectedSteps.length === 0) {
+                display.showWarning('No steps selected. Select steps or enter your own solution.');
+                this.terminalInput.render();
+                return;
+            }
+            this.pendingInteraction = null;
+            // Build the implementation prompt with selected steps
+            const stepList = selectedSteps.map(s => `${s.id}. ${s.description}`).join('\n');
+            const implementPrompt = `Proceed with implementing the following steps:\n\n${stepList}\n\nStart implementing now. Use the appropriate tools.`;
+            // Queue the implementation request
+            await this.processInputBlock(implementPrompt);
+            return;
+        }
+        // Toggle step by number
+        const num = Number.parseInt(trimmed, 10);
+        if (Number.isFinite(num) && num >= 1 && num <= pending.steps.length) {
+            if (pending.selectedSteps.has(num)) {
+                pending.selectedSteps.delete(num);
+            }
+            else {
+                pending.selectedSteps.add(num);
+            }
+            this.displayPlanApprovalUI();
+            return;
+        }
+        // User submitted their own solution - treat as custom input
+        if (trimmed.length > 10) {
+            this.pendingInteraction = null;
+            display.showInfo('Using your custom solution...');
+            // Send the custom solution as the implementation request
+            const customPrompt = `The user has provided their own solution instead of the plan. Please implement this:\n\n${trimmed}`;
+            await this.processInputBlock(customPrompt);
+            return;
+        }
+        display.showWarning('Invalid input. Enter a step number, command (go/cancel/all/none), or your own solution.');
+        this.terminalInput.render();
+    }
     setupHandlers() {
         // Handle terminal resize
         output.on('resize', () => {
@@ -765,6 +1005,39 @@ export class InteractiveShell {
         // Show initial input UI
         this.terminalInput.render();
     }
+    /**
+     * Set up command autocomplete with all available slash commands.
+     * Commands are loaded from agent-schemas.json and custom commands.
+     */
+    setupCommandAutocomplete() {
+        const commands = [];
+        // Load built-in slash commands from schema
+        const schemaCommands = getSlashCommands();
+        for (const cmd of schemaCommands) {
+            commands.push({
+                command: cmd.command,
+                description: cmd.description,
+                category: cmd.category,
+            });
+        }
+        // Load custom commands (if any)
+        try {
+            const customCommands = loadCustomSlashCommands(this.workingDir);
+            for (const custom of customCommands) {
+                commands.push({
+                    command: custom.command,
+                    description: custom.description || 'Custom command',
+                    category: custom.category || 'custom',
+                });
+            }
+        }
+        catch {
+            // Custom commands are optional
+        }
+        // Sort commands alphabetically
+        commands.sort((a, b) => a.command.localeCompare(b.command));
+        this.terminalInput.setAvailableCommands(commands);
+    }
     setupStatusTracking() {
         this.statusSubscription = this.statusTracker.subscribe((state) => {
             this.statusLineState = state;
@@ -1008,6 +1281,12 @@ export class InteractiveShell {
                 const frame = STREAMING_SPINNER_FRAMES[this.streamingHeartbeatFrame];
                 this.streamingStatusLabel = this.buildStreamingStatus(`${frame} ${label}`, elapsedSeconds);
                 display.updateStreamingStatus(this.streamingStatusLabel);
+                // Update parallel agent display during streaming
+                const manager = getParallelAgentManager();
+                if (manager.isRunning()) {
+                    this.parallelAgentDisplayLines = manager.formatDisplay();
+                    this.displayParallelAgents();
+                }
                 this.refreshStatusLine(true);
             },
         });
@@ -1219,6 +1498,9 @@ export class InteractiveShell {
             case 'agent-selection':
                 await this.handleAgentSelectionInput(input);
                 return true;
+            case 'plan-approval':
+                await this.handlePlanApprovalInput(input);
+                return true;
             default:
                 return false;
         }
@@ -1238,6 +1520,12 @@ export class InteractiveShell {
             case '/features':
                 this.showFeaturesMenu(input);
                 break;
+            case '/learn':
+                this.showLearningStatus(input);
+                break;
+            case '/improve':
+                void this.handleImprovementCommand(input);
+                break;
             case '/model':
                 this.showModelMenu();
                 break;
@@ -1299,6 +1587,17 @@ export class InteractiveShell {
             case '/plugins':
                 this.showPluginStatus();
                 break;
+            case '/evolve':
+                void this.handleEvolveCommand(input);
+                break;
+            case '/modular':
+            case '/a0':
+                void this.handleModularCommand(input);
+                break;
+            case '/test':
+            case '/tests':
+                void this.handleTestCommand(input);
+                break;
             case '/provider':
                 await this.handleProviderCommand(input);
                 break;
@@ -1311,6 +1610,58 @@ export class InteractiveShell {
             case '/discover':
                 await this.discoverModelsCommand();
                 break;
+            // Claude Code style commands
+            case '/rewind':
+                await this.handleRewindCommand(input);
+                break;
+            case '/memory':
+                this.handleMemoryCommand(input);
+                break;
+            case '/vim':
+                this.handleVimCommand();
+                break;
+            case '/output-style':
+                this.handleOutputStyleCommand(input);
+                break;
+            case '/cost':
+                this.handleCostCommand();
+                break;
+            case '/usage':
+                this.handleUsageCommand();
+                break;
+            case '/update':
+                await this.handleUpdateCommand();
+                break;
+            case '/clear':
+                this.handleClearCommand();
+                break;
+            case '/resume':
+                await this.handleResumeCommand(input);
+                break;
+            case '/export':
+                this.handleExportCommand(input);
+                break;
+            case '/review':
+                await this.handleReviewCommand();
+                break;
+            case '/security-review':
+                await this.handleSecurityReviewCommand();
+                break;
+            case '/bug':
+                this.handleBugCommand();
+                break;
+            case '/terminal-setup':
+                this.handleTerminalSetupCommand();
+                break;
+            case '/permissions':
+                this.handlePermissionsCommand();
+                break;
+            case '/init':
+                this.handleInitCommand();
+                break;
+            case '/compact':
+                await this.handleCompactCommand();
+                break;
             default:
                 if (!(await this.tryCustomSlashCommand(command, input))) {
                     display.showWarning(`Unknown command "${command}".`);
@@ -1772,6 +2123,878 @@ export class InteractiveShell {
         lines.push(theme.ui.muted('Feature changes take effect on next launch.'));
         display.showSystemMessage(lines.join('\n'));
     }
+    showLearningStatus(input) {
+        const args = input.split(/\s+/).slice(1);
+        const subcommand = args[0]?.toLowerCase();
+        // Handle subcommands
+        if (subcommand === 'commit') {
+            const result = commitLearning(args.slice(1).join(' ') || 'Manual learning checkpoint', this.workingDir);
+            if (result.success) {
+                display.showInfo(`Learning committed: ${result.commitHash}`);
+            }
+            else {
+                display.showWarning(`Could not commit: ${result.error}`);
+            }
+            return;
+        }
+        if (subcommand === 'export') {
+            const data = exportAllLearning();
+            const json = JSON.stringify(data, null, 2);
+            display.showSystemMessage(`Exported learning data:\n\n${json.slice(0, 2000)}${json.length > 2000 ? '\n...(truncated)' : ''}`);
+            return;
+        }
+        if (subcommand === 'history') {
+            const history = getRecentLearning(20);
+            const lines = [];
+            lines.push(theme.gradient.primary('Recent Learning History'));
+            lines.push('');
+            if (history.length === 0) {
+                lines.push(theme.ui.muted('No learning history yet.'));
+            }
+            else {
+                for (const entry of history) {
+                    const date = new Date(entry.timestamp).toLocaleString();
+                    const icon = entry.type === 'tool-pattern' ? '🔧' :
+                        entry.type === 'quality-threshold' ? '📊' :
+                            entry.type === 'failure-pattern' ? '⚠️' : '💡';
+                    lines.push(`  ${icon} ${theme.ui.muted(date)}`);
+                    lines.push(`     ${entry.description}`);
+                }
+            }
+            display.showSystemMessage(lines.join('\n'));
+            return;
+        }
+        // Default: show summary
+        const summary = getLearningSummary();
+        const lines = [];
+        lines.push(theme.gradient.primary('🧠 AlphaZero Learning Status'));
+        lines.push('');
+        // Tool patterns
+        lines.push(theme.bold('Tool Patterns Learned:'));
+        if (summary.toolPatterns.totalPatterns === 0) {
+            lines.push(`  ${theme.ui.muted('No patterns learned yet. Use the CLI to build up patterns.')}`);
+        }
+        else {
+            lines.push(`  Total: ${theme.info(String(summary.toolPatterns.totalPatterns))} patterns across ${summary.toolPatterns.taskTypes.length} task types`);
+            if (summary.toolPatterns.bestPatterns.length > 0) {
+                lines.push('  Best patterns:');
+                for (const p of summary.toolPatterns.bestPatterns) {
+                    const rate = Math.round(p.successRate * 100);
+                    lines.push(`    ${theme.success('•')} ${p.taskType}: ${theme.ui.muted(p.pattern)} (${rate}% success)`);
+                }
+            }
+        }
+        lines.push('');
+        // Quality thresholds
+        lines.push(theme.bold('Quality Thresholds:'));
+        lines.push(`  Min acceptable: ${theme.warning(String(Math.round(summary.qualityThresholds.avgMinAcceptable)))}/100`);
+        lines.push(`  Target quality: ${theme.success(String(Math.round(summary.qualityThresholds.avgTargetQuality)))}/100`);
+        lines.push(`  Task types: ${summary.qualityThresholds.taskTypes.join(', ')}`);
+        lines.push('');
+        // Failure patterns
+        lines.push(theme.bold('Failure Patterns:'));
+        if (summary.failurePatterns.totalPatterns === 0) {
+            lines.push(`  ${theme.ui.muted('No failure patterns recorded.')}`);
+        }
+        else {
+            lines.push(`  Total: ${theme.warning(String(summary.failurePatterns.totalPatterns))} patterns to avoid`);
+            if (summary.failurePatterns.mostFrequent.length > 0) {
+                for (const f of summary.failurePatterns.mostFrequent) {
+                    lines.push(`    ${theme.error('✗')} ${f.description} (${f.occurrences}x)`);
+                }
+            }
+        }
+        lines.push('');
+        // Prompt improvements
+        lines.push(theme.bold('Prompt Improvements:'));
+        if (summary.promptImprovements.totalImprovements === 0) {
+            lines.push(`  ${theme.ui.muted('No prompt improvements discovered yet.')}`);
+        }
+        else {
+            lines.push(`  Total: ${theme.info(String(summary.promptImprovements.totalImprovements))} improvements`);
+            lines.push(`  Categories: ${summary.promptImprovements.categories.join(', ')}`);
+            lines.push(`  Avg quality gain: ${theme.success(`+${Math.round(summary.promptImprovements.avgQualityGain)}%`)}`);
+        }
+        lines.push('');
+        // Recent activity
+        lines.push(theme.bold('Activity:'));
+        lines.push(`  Learning events (24h): ${summary.recentActivity}`);
+        lines.push(`  Storage: ${theme.ui.muted(getLearningDir())}`);
+        lines.push('');
+        // Commands
+        lines.push(theme.bold('Commands:'));
+        lines.push(`  ${theme.primary('/learn')}          - Show this summary`);
+        lines.push(`  ${theme.primary('/learn history')}  - View recent learning events`);
+        lines.push(`  ${theme.primary('/learn commit')}   - Commit learning to git`);
+        lines.push(`  ${theme.primary('/learn export')}   - Export learning data as JSON`);
+        display.showSystemMessage(lines.join('\n'));
+    }
+    /**
+     * Handle /improve command for self-improvement
+     */
+    async handleImprovementCommand(input) {
+        const args = input.split(/\s+/).slice(1);
+        const subcommand = args[0]?.toLowerCase();
+        if (subcommand === 'analyze') {
+            const opportunities = analyzeImprovementOpportunities(this.workingDir);
+            const lines = [];
+            lines.push(theme.gradient.primary('🔍 Improvement Analysis'));
+            lines.push('');
+            if (opportunities.length === 0) {
+                lines.push(theme.ui.muted('No improvement opportunities found. Keep using the CLI to build learning data.'));
+            }
+            else {
+                lines.push(`Found ${theme.info(String(opportunities.length))} improvement opportunities:`);
+                lines.push('');
+                for (const opp of opportunities.slice(0, 10)) {
+                    const icon = opp.type === 'bug-fix' ? '🐛' : opp.type === 'refactor' ? '🔧' : '⚡';
+                    const priorityColor = opp.priority === 'critical' ? theme.error :
+                        opp.priority === 'high' ? theme.warning : theme.info;
+                    lines.push(`  ${icon} ${priorityColor(`[${opp.priority}]`)} ${opp.description.slice(0, 60)}`);
+                    lines.push(`     ${theme.ui.muted(`Confidence: ${Math.round(opp.confidence * 100)}%`)} | ${theme.ui.muted(`File: ${opp.sourceFile}`)}`);
+                    for (const ev of opp.evidence.slice(0, 2)) {
+                        lines.push(`     ${theme.dim(`• ${ev}`)}`);
+                    }
+                    lines.push('');
+                }
+                if (opportunities.length > 10) {
+                    lines.push(theme.ui.muted(`... and ${opportunities.length - 10} more`));
+                }
+            }
+            display.showSystemMessage(lines.join('\n'));
+            return;
+        }
+        if (subcommand === 'apply') {
+            display.showSystemMessage(theme.gradient.primary('🚀 Running Self-Improvement Cycle...'));
+            display.showSystemMessage('');
+            try {
+                const result = await runSelfImprovementCycle(this.workingDir, {
+                    maxChanges: 3,
+                    minConfidence: 0.7,
+                    runTests: true,
+                    autoCommit: true,
+                });
+                const lines = [];
+                lines.push(theme.bold('Results:'));
+                lines.push(result.summary);
+                lines.push('');
+                if (result.applied > 0) {
+                    lines.push(theme.success(`✅ Applied ${result.applied} improvements!`));
+                    for (const r of result.results.filter(r => r.success)) {
+                        lines.push(`  - Files: ${r.filesChanged.join(', ')}`);
+                        if (r.commitHash) {
+                            lines.push(`    Commit: ${theme.ui.muted(r.commitHash)}`);
+                            lines.push(`    Rollback: ${theme.dim(r.rollbackCommand ?? '')}`);
+                        }
+                    }
+                }
+                else {
+                    lines.push(theme.warning('No improvements were applied.'));
+                    for (const r of result.results.filter(r => !r.success)) {
+                        lines.push(`  ${theme.error('✗')} ${r.error}`);
+                    }
+                }
+                display.showSystemMessage(lines.join('\n'));
+            }
+            catch (error) {
+                display.showError(`Self-improvement failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return;
+        }
+        if (subcommand === 'dry-run') {
+            const opportunities = analyzeImprovementOpportunities(this.workingDir);
+            const filtered = opportunities.filter(o => o.confidence >= 0.7);
+            const toApply = filtered.slice(0, 3);
+            const lines = [];
+            lines.push(theme.gradient.primary('🔮 Dry Run - Preview Changes'));
+            lines.push('');
+            if (toApply.length === 0) {
+                lines.push(theme.ui.muted('No high-confidence improvements to apply.'));
+            }
+            else {
+                lines.push(`Would apply ${theme.info(String(toApply.length))} improvements:`);
+                lines.push('');
+                for (const opp of toApply) {
+                    const icon = opp.type === 'bug-fix' ? '🐛' : opp.type === 'refactor' ? '🔧' : '⚡';
+                    lines.push(`  ${icon} ${opp.description.slice(0, 60)}`);
+                    lines.push(`     ${theme.ui.muted(`File: ${opp.sourceFile}`)}`);
+                    lines.push(`     ${theme.dim(`Suggested: ${opp.suggestedChange.slice(0, 100)}...`)}`);
+                    lines.push('');
+                }
+                lines.push(theme.bold('Run `/improve apply` to execute these changes.'));
+            }
+            display.showSystemMessage(lines.join('\n'));
+            return;
+        }
+        if (subcommand === 'auto') {
+            void this.runAutonomousImprovementMode();
+            return;
+        }
+        if (subcommand === 'stop') {
+            requestAutoImprovementStop();
+            display.showInfo('Requested stop of autonomous improvement...');
+            return;
+        }
+        if (subcommand === 'rollback') {
+            const result = emergencyRollback(this.workingDir);
+            if (result.success) {
+                display.showSuccess(result.message);
+            }
+            else {
+                display.showError(result.message);
+            }
+            return;
+        }
+        if (subcommand === 'status') {
+            const state = getAutoImprovementState();
+            const lines = [];
+            lines.push(theme.gradient.primary('🤖 Auto-Improvement Status'));
+            lines.push('');
+            lines.push(`Running: ${state.isRunning ? theme.success('Yes') : theme.ui.muted('No')}`);
+            if (state.startTime) {
+                lines.push(`Started: ${theme.ui.muted(state.startTime)}`);
+            }
+            lines.push(`Iteration: ${state.iteration}`);
+            lines.push(`Applied: ${theme.success(String(state.applied))}`);
+            lines.push(`Failed: ${theme.warning(String(state.failed))}`);
+            lines.push(`Rollbacks: ${theme.error(String(state.rollbacks))}`);
+            if (state.lastError) {
+                lines.push(`Last Error: ${theme.error(state.lastError)}`);
+            }
+            display.showSystemMessage(lines.join('\n'));
+            return;
+        }
+        // Default: show summary
+        const summary = getImprovementSummary(this.workingDir);
+        display.showSystemMessage(summary);
+    }
+    /**
+     * Run autonomous improvement mode with self-relaunch capability
+     */
+    async runAutonomousImprovementMode() {
+        const isSelfImproving = this.workingDir.includes('erosolar');
+        display.showSystemMessage(theme.gradient.primary('🤖 Starting Autonomous Improvement Mode'));
+        display.showSystemMessage('');
+        display.showSystemMessage(`${theme.bold('Safety Features:')}`);
+        display.showSystemMessage('  • Git checkpoint created before starting');
+        display.showSystemMessage('  • Each change validated with build + tests');
+        display.showSystemMessage('  • Auto-rollback on failures');
+        display.showSystemMessage('  • Press Ctrl+C to stop gracefully');
+        if (isSelfImproving) {
+            display.showSystemMessage('  • CLI will relaunch after improvements to run new code');
+        }
+        display.showSystemMessage('');
+        display.showSystemMessage(`${theme.bold('Commands while running:')}`);
+        display.showSystemMessage('  /improve stop     - Request graceful stop');
+        display.showSystemMessage('  /improve status   - Check current status');
+        display.showSystemMessage('  /improve rollback - Emergency rollback to checkpoint');
+        display.showSystemMessage('');
+        let stopRequested = false;
+        // Set up Ctrl+C handler
+        const originalSigintHandler = process.listeners('SIGINT');
+        process.removeAllListeners('SIGINT');
+        process.once('SIGINT', () => {
+            display.showWarning('Ctrl+C pressed - stopping after current iteration...');
+            stopRequested = true;
+            requestAutoImprovementStop();
+        });
+        try {
+            const result = await runAutonomousImprovement({
+                workingDir: this.workingDir,
+                minConfidence: 0.75,
+                maxIterations: 100,
+                delayBetweenMs: 3000,
+                runTests: true,
+                shouldStop: () => stopRequested,
+                onProgress: (event) => {
+                    switch (event.type) {
+                        case 'start':
+                            display.showInfo(event.message);
+                            break;
+                        case 'iteration':
+                            display.showSystemMessage(`\n${theme.bold(`[Iteration ${event.iteration}]`)} ${event.message}`);
+                            break;
+                        case 'applied':
+                            display.showSuccess(event.message);
+                            display.showSystemMessage(`  Total applied: ${event.totalApplied}`);
+                            break;
+                        case 'failed':
+                            display.showWarning(event.message);
+                            break;
+                        case 'rollback':
+                            display.showError(event.message);
+                            break;
+                        case 'no-opportunities':
+                            display.showInfo(event.message);
+                            break;
+                        case 'complete':
+                            display.showSystemMessage('');
+                            display.showSystemMessage(theme.gradient.primary('═══ Autonomous Improvement Complete ═══'));
+                            display.showSystemMessage(event.message);
+                            if (event.totalApplied !== undefined) {
+                                display.showSystemMessage(`Applied: ${theme.success(String(event.totalApplied))}`);
+                            }
+                            if (event.totalFailed !== undefined) {
+                                display.showSystemMessage(`Failed: ${theme.warning(String(event.totalFailed))}`);
+                            }
+                            break;
+                    }
+                },
+            });
+            // Restore SIGINT handlers
+            process.removeAllListeners('SIGINT');
+            for (const handler of originalSigintHandler) {
+                process.on('SIGINT', handler);
+            }
+            // Summary
+            display.showSystemMessage('');
+            display.showSystemMessage(theme.bold('Final Summary:'));
+            display.showSystemMessage(`  Iterations: ${result.iterations}`);
+            display.showSystemMessage(`  Applied: ${theme.success(String(result.totalApplied))}`);
+            display.showSystemMessage(`  Failed: ${theme.warning(String(result.totalFailed))}`);
+            display.showSystemMessage(`  Rollbacks: ${theme.error(String(result.totalRollbacks))}`);
+            display.showSystemMessage(`  Stopped: ${result.stoppedReason}`);
+            // If we improved erosolar-cli itself and applied changes, offer to relaunch
+            if (isSelfImproving && result.totalApplied > 0) {
+                display.showSystemMessage('');
+                display.showSystemMessage(theme.gradient.primary('🔄 CLI source code was updated!'));
+                display.showSystemMessage('To run the improved version:');
+                display.showSystemMessage(`  ${theme.bold('npm run build && erosolar')}`);
+                display.showSystemMessage('');
+                display.showSystemMessage('Or to continue auto-improvement with new code:');
+                display.showSystemMessage(`  ${theme.bold('npm run build && erosolar -c "/improve auto"')}`);
+            }
+        }
+        catch (error) {
+            // Restore SIGINT handlers
+            process.removeAllListeners('SIGINT');
+            for (const handler of originalSigintHandler) {
+                process.on('SIGINT', handler);
+            }
+            display.showError(`Autonomous improvement failed: ${error instanceof Error ? error.message : String(error)}`);
+            display.showSystemMessage('');
+            display.showSystemMessage('Run `/improve rollback` to restore to the checkpoint if needed.');
+        }
+    }
+    /**
+     * Handle /evolve command for self-evolution (erosolar-cli source only)
+     */
+    async handleEvolveCommand(input) {
+        const args = input.split(/\s+/).slice(1);
+        const subcommand = args[0]?.toLowerCase();
+        // Check if we're in a valid source repository
+        if (!isValidSourceRepo(this.workingDir)) {
+            display.showWarning('Self-evolution requires a git repository with source code.');
+            display.showSystemMessage('');
+            display.showSystemMessage('Current directory: ' + this.workingDir);
+            display.showSystemMessage('');
+            display.showSystemMessage('Requirements:');
+            display.showSystemMessage('  • Must be a git repository (.git folder)');
+            display.showSystemMessage('  • Must have package.json or src/ directory');
+            display.showSystemMessage('');
+            display.showSystemMessage('Navigate to your project directory and try again.');
+            return;
+        }
+        const repoName = getRepoName(this.workingDir);
+        const isErosolar = isErosolarRepo(this.workingDir);
+        if (subcommand === 'analyze') {
+            display.showSystemMessage(theme.gradient.primary(`🔍 Analyzing ${repoName} Source Code...`));
+            display.showSystemMessage('');
+            const issues = analyzeSource(this.workingDir);
+            const lines = [];
+            if (issues.length === 0) {
+                lines.push(theme.success('✅ No issues found! Source code looks clean.'));
+            }
+            else {
+                const bySeverity = {
+                    critical: issues.filter(i => i.severity === 'critical'),
+                    high: issues.filter(i => i.severity === 'high'),
+                    medium: issues.filter(i => i.severity === 'medium'),
+                    low: issues.filter(i => i.severity === 'low'),
+                };
+                lines.push(`Found ${theme.bold(String(issues.length))} issues:`);
+                lines.push('');
+                if (bySeverity.critical.length > 0) {
+                    lines.push(theme.error(`  🔴 Critical: ${bySeverity.critical.length}`));
+                }
+                if (bySeverity.high.length > 0) {
+                    lines.push(theme.warning(`  🟠 High: ${bySeverity.high.length}`));
+                }
+                if (bySeverity.medium.length > 0) {
+                    lines.push(theme.info(`  🟡 Medium: ${bySeverity.medium.length}`));
+                }
+                if (bySeverity.low.length > 0) {
+                    lines.push(theme.dim(`  ⚪ Low: ${bySeverity.low.length}`));
+                }
+                lines.push('');
+                // Show top 10 issues
+                lines.push(theme.bold('Top Issues:'));
+                for (const issue of issues.slice(0, 10)) {
+                    const icon = issue.severity === 'critical' ? '🔴' :
+                        issue.severity === 'high' ? '🟠' :
+                            issue.severity === 'medium' ? '🟡' : '⚪';
+                    lines.push(`  ${icon} ${issue.file}:${issue.line ?? '?'}`);
+                    lines.push(`     ${theme.dim(issue.description.slice(0, 70))}`);
+                    lines.push(`     ${theme.ui.muted(`Confidence: ${Math.round(issue.confidence * 100)}%`)}`);
+                }
+                if (issues.length > 10) {
+                    lines.push('');
+                    lines.push(theme.ui.muted(`... and ${issues.length - 10} more issues`));
+                }
+            }
+            display.showSystemMessage(lines.join('\n'));
+            return;
+        }
+        if (subcommand === 'start') {
+            display.showSystemMessage(theme.gradient.primary('🧬 Starting Self-Evolution Mode'));
+            display.showSystemMessage('');
+            display.showSystemMessage(theme.bold('Safety Features:'));
+            display.showSystemMessage('  • Git checkpoint created before starting');
+            display.showSystemMessage('  • Each change validated with build + tests');
+            display.showSystemMessage('  • Auto-rollback on failures');
+            display.showSystemMessage('  • Auto-relaunch with improved code');
+            display.showSystemMessage('  • Press Ctrl+C to stop gracefully');
+            display.showSystemMessage('');
+            try {
+                const result = await runSelfEvolution(this.workingDir, {
+                    maxIterations: 50,
+                    minConfidence: 0.8,
+                    runTests: true,
+                    autoRelaunch: true,
+                }, {
+                    onStart: () => {
+                        display.showInfo('Evolution started. Creating checkpoint...');
+                    },
+                    onIteration: (iteration, issues) => {
+                        display.showSystemMessage(`\n[Iteration ${iteration}] Found ${issues.length} high-confidence issues`);
+                    },
+                    onFix: (issue, success) => {
+                        if (success) {
+                            display.showSuccess(`Fixed: ${issue.description.slice(0, 50)}`);
+                        }
+                        else {
+                            display.showWarning(`Failed: ${issue.description.slice(0, 50)}`);
+                        }
+                    },
+                    onRelaunch: () => {
+                        display.showSystemMessage('');
+                        display.showSystemMessage(theme.gradient.primary('🔄 Relaunching with improved code...'));
+                    },
+                    onComplete: (result) => {
+                        display.showSystemMessage('');
+                        display.showSuccess(`Evolution complete! Fixed ${result.issuesFixed} issues.`);
+                    },
+                    onError: (error) => {
+                        display.showError(`Evolution error: ${error}`);
+                    },
+                });
+                const lines = [];
+                lines.push('');
+                lines.push(theme.bold('Evolution Result:'));
+                lines.push(`  Success: ${result.success ? theme.success('Yes') : theme.error('No')}`);
+                lines.push(`  Iterations: ${result.iteration}`);
+                lines.push(`  Issues Found: ${result.issuesFound}`);
+                lines.push(`  Issues Fixed: ${result.issuesFixed}`);
+                if (result.error) {
+                    lines.push(`  Error: ${theme.error(result.error)}`);
+                }
+                lines.push(`  Next Action: ${result.nextAction}`);
+                display.showSystemMessage(lines.join('\n'));
+            }
+            catch (error) {
+                display.showError(`Evolution failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return;
+        }
+        if (subcommand === 'stop') {
+            stopEvolution();
+            display.showInfo('Requested stop of evolution...');
+            return;
+        }
+        if (subcommand === 'rollback') {
+            const result = emergencyEvolutionRollback(this.workingDir);
+            if (result.success) {
+                display.showSuccess(result.message);
+            }
+            else {
+                display.showError(result.message);
+            }
+            return;
+        }
+        if (subcommand === 'status') {
+            const status = getEvolutionStatus(this.workingDir);
+            display.showSystemMessage(status);
+            return;
+        }
+        if (subcommand === 'learn') {
+            display.showSystemMessage(theme.gradient.primary(`📚 Learning from ${repoName} Source Code...`));
+            display.showSystemMessage('');
+            const patterns = learnSourcePatterns(this.workingDir);
+            const lines = [];
+            if (patterns.length === 0) {
+                lines.push(theme.warning('No patterns could be extracted.'));
+            }
+            else {
+                lines.push(`Learned ${theme.bold(String(patterns.length))} patterns from source code:`);
+                lines.push('');
+                const byCategory = {
+                    'tool-implementation': patterns.filter(p => p.category === 'tool-implementation'),
+                    'error-handling': patterns.filter(p => p.category === 'error-handling'),
+                    'type-pattern': patterns.filter(p => p.category === 'type-pattern'),
+                    'api-design': patterns.filter(p => p.category === 'api-design'),
+                };
+                for (const [category, catPatterns] of Object.entries(byCategory)) {
+                    if (catPatterns.length > 0) {
+                        const icon = category === 'tool-implementation' ? '🔧' :
+                            category === 'error-handling' ? '⚠️' :
+                                category === 'type-pattern' ? '📝' : '🏗️';
+                        lines.push(`${icon} ${theme.bold(category)}: ${catPatterns.length} patterns`);
+                        for (const pattern of catPatterns.slice(0, 3)) {
+                            lines.push(`   • ${pattern.description}`);
+                            lines.push(`     ${theme.dim(`Source: ${pattern.sourceFile}`)}`);
+                        }
+                        if (catPatterns.length > 3) {
+                            lines.push(`     ${theme.ui.muted(`... and ${catPatterns.length - 3} more`)}`);
+                        }
+                        lines.push('');
+                    }
+                }
+                lines.push(theme.success('✅ Patterns saved to ~/.erosolar/source-patterns.json'));
+                lines.push('');
+                lines.push('These patterns help the system understand optimal code structures');
+                lines.push('and can be used to guide future code generation.');
+            }
+            display.showSystemMessage(lines.join('\n'));
+            return;
+        }
+        if (subcommand === 'fix') {
+            display.showSystemMessage(theme.gradient.primary('🔧 Generating Fixes for Source Issues...'));
+            display.showSystemMessage('');
+            const issues = analyzeSource(this.workingDir);
+            const highConfidence = issues.filter(i => i.confidence >= 0.7);
+            if (highConfidence.length === 0) {
+                display.showInfo('No high-confidence issues found that need fixing.');
+                return;
+            }
+            const lines = [];
+            lines.push(`Found ${highConfidence.length} issues. Generating fixes...`);
+            lines.push('');
+            let fixCount = 0;
+            for (const issue of highConfidence.slice(0, 5)) {
+                const fix = generateFix(issue, this.workingDir);
+                if (fix) {
+                    fixCount++;
+                    lines.push(`${theme.bold(`Fix ${fixCount}:`)} ${issue.file}:${issue.line}`);
+                    lines.push(`  Issue: ${issue.description.slice(0, 60)}`);
+                    lines.push(`  Fix: ${fix.explanation}`);
+                    lines.push(`  Confidence: ${Math.round(fix.confidence * 100)}%`);
+                    lines.push(`  ${fix.requiresManualReview ? theme.warning('⚠️ Requires review') : theme.success('✅ Auto-applicable')}`);
+                    lines.push('');
+                }
+            }
+            if (fixCount === 0) {
+                lines.push(theme.warning('No automatic fixes could be generated for these issues.'));
+            }
+            else {
+                lines.push(`Generated ${fixCount} fix suggestions.`);
+                lines.push('');
+                lines.push(`Run ${theme.bold('/evolve start')} to apply fixes automatically with safety checks.`);
+            }
+            display.showSystemMessage(lines.join('\n'));
+            return;
+        }
+        // ========== MODULAR / TOKEN OPTIMIZATION COMMANDS ==========
+        if (subcommand === 'tokens') {
+            display.showSystemMessage(theme.gradient.primary('🔍 Analyzing Token Usage...'));
+            display.showSystemMessage('');
+            const analysis = analyzeTokenUsage(this.workingDir);
+            const lines = [];
+            lines.push(`Total Tokens: ${theme.bold(analysis.totalTokens.toLocaleString())}`);
+            lines.push('');
+            lines.push(theme.bold('By Category:'));
+            for (const [category, tokens] of Object.entries(analysis.byCategory)) {
+                const pct = ((tokens / analysis.totalTokens) * 100).toFixed(1);
+                const bar = '█'.repeat(Math.floor(Number(pct) / 5)) + '░'.repeat(20 - Math.floor(Number(pct) / 5));
+                lines.push(`  ${category.padEnd(15)} ${bar} ${tokens.toLocaleString().padStart(8)} (${pct}%)`);
+            }
+            lines.push('');
+            lines.push(theme.bold('Optimization Opportunities:'));
+            for (const opp of analysis.optimizationOpportunities.slice(0, 10)) {
+                lines.push(`  ${opp.autoFixable ? '✅' : '⚠️'} ${opp.target}`);
+                lines.push(`     Save: ${opp.savings} tokens (${opp.savingsPercent}%)`);
+                lines.push(`     ${theme.dim(opp.strategy)}`);
+            }
+            display.showSystemMessage(lines.join('\n'));
+            return;
+        }
+        if (subcommand === 'targets') {
+            const targets = discoverModularTargets(this.workingDir);
+            const lines = [];
+            lines.push(theme.gradient.primary('🎯 Modular Targets'));
+            lines.push('');
+            lines.push(`Found ${theme.bold(String(targets.length))} targets`);
+            lines.push('');
+            const byType = {};
+            for (const target of targets) {
+                if (!byType[target.type])
+                    byType[target.type] = [];
+                byType[target.type].push(target);
+            }
+            for (const [type, typeTargets] of Object.entries(byType)) {
+                lines.push(theme.bold(`${type} (${typeTargets.length}):`));
+                for (const target of typeTargets.slice(0, 5)) {
+                    const issueCount = target.issues.length;
+                    const icon = issueCount === 0 ? '✅' : issueCount < 3 ? '⚠️' : '🔴';
+                    lines.push(`  ${icon} ${target.name} (${target.tokenCount} tokens)`);
+                    if (target.issues.length > 0) {
+                        lines.push(`     ${theme.dim(target.issues[0]?.description ?? '')}`);
+                    }
+                }
+                if (typeTargets.length > 5) {
+                    lines.push(`  ${theme.dim(`... and ${typeTargets.length - 5} more`)}`);
+                }
+                lines.push('');
+            }
+            display.showSystemMessage(lines.join('\n'));
+            return;
+        }
+        if (subcommand === 'optimize') {
+            const optimizations = generateContextOptimizations(this.workingDir);
+            const lines = [];
+            lines.push(theme.gradient.primary('⚡ Context Optimization Strategies'));
+            lines.push('');
+            const totalSavings = optimizations.reduce((sum, o) => sum + o.tokensSaved, 0);
+            lines.push(`Total potential savings: ${theme.success(totalSavings.toLocaleString())} tokens`);
+            lines.push('');
+            for (const opt of optimizations) {
+                const icon = opt.impact === 'high' ? '🔴' : opt.impact === 'medium' ? '🟡' : '⚪';
+                lines.push(`${icon} ${theme.bold(opt.strategy)}`);
+                lines.push(`   ${opt.description}`);
+                lines.push(`   Savings: ${theme.success(opt.tokensSaved.toLocaleString())} tokens`);
+                lines.push(`   ${theme.dim(opt.implementation)}`);
+                lines.push('');
+            }
+            display.showSystemMessage(lines.join('\n'));
+            return;
+        }
+        if (subcommand === 'guidelines') {
+            const action = args[1]?.toLowerCase();
+            if (action === 'add') {
+                display.showInfo('Use: /evolve guidelines add <id> <category> <rule>');
+                return;
+            }
+            if (action === 'delete' && args[2]) {
+                const result = deleteGuideline(args[2]);
+                if (result.success) {
+                    display.showSuccess(`Deleted guideline: ${args[2]}`);
+                }
+                else {
+                    display.showError(result.error ?? 'Failed to delete');
+                }
+                return;
+            }
+            const guidelines = getGuidelines();
+            const lines = [];
+            lines.push(theme.gradient.primary('📋 Active Guidelines'));
+            lines.push('');
+            for (const g of guidelines) {
+                const icon = g.severity === 'must' ? '🔴' : g.severity === 'should' ? '🟡' : '⚪';
+                lines.push(`${icon} [${g.category}] ${theme.bold(g.id)}`);
+                lines.push(`   ${g.rule}`);
+                lines.push(`   ${theme.dim(g.rationale)}`);
+                lines.push('');
+            }
+            display.showSystemMessage(lines.join('\n'));
+            return;
+        }
+        if (subcommand === 'actions') {
+            const actions = getPendingActions();
+            const lines = [];
+            lines.push(theme.gradient.primary('📝 Pending Actions'));
+            lines.push('');
+            if (actions.length === 0) {
+                lines.push(theme.dim('No pending actions'));
+            }
+            else {
+                for (let i = 0; i < actions.length; i++) {
+                    const action = actions[i];
+                    lines.push(`${i + 1}. [${action.type}] ${action.target.name}`);
+                    lines.push(`   Impact: ${action.tokenImpact > 0 ? '+' : ''}${action.tokenImpact} tokens`);
+                    lines.push(`   ${theme.dim(action.changes.slice(0, 60))}`);
+                    lines.push('');
+                }
+                lines.push('Run /evolve execute <number> to apply an action');
+            }
+            display.showSystemMessage(lines.join('\n'));
+            return;
+        }
+        if (subcommand === 'execute') {
+            const actionIndex = parseInt(args[1] ?? '', 10) - 1;
+            const result = executeModularAction(actionIndex, this.workingDir);
+            if (result.success) {
+                display.showSuccess('Action executed successfully');
+            }
+            else {
+                display.showError(result.error ?? 'Failed to execute');
+            }
+            return;
+        }
+        // Default: show combined status
+        const evolveStatus = getEvolutionStatus(this.workingDir);
+        const modularStatus = getModularStatusDisplay(this.workingDir);
+        display.showSystemMessage(evolveStatus);
+        display.showSystemMessage('');
+        display.showSystemMessage(modularStatus);
+    }
+    /**
+     * Handle /modular command - redirects to /evolve (merged functionality)
+     */
+    async handleModularCommand(input) {
+        // Redirect /modular to /evolve with the same arguments
+        const evolveInput = input.replace(/^\/(?:modular|a0)\s*/i, '/evolve ');
+        display.showInfo('Note: /modular is now part of /evolve. Use /evolve tokens, /evolve targets, etc.');
+        await this.handleEvolveCommand(evolveInput);
+    }
+    /**
+     * Handle /test command for intelligent test flows
+     */
+    async handleTestCommand(input) {
+        const args = input.split(/\s+/).slice(1);
+        const subcommand = args[0]?.toLowerCase();
+        if (subcommand === 'status' || !subcommand) {
+            const status = getTestFlowStatus(this.workingDir);
+            display.showSystemMessage(status);
+            return;
+        }
+        if (subcommand === 'generate') {
+            const targetPath = args[1];
+            if (!targetPath) {
+                display.showWarning('Usage: /test generate <file-path>');
+                return;
+            }
+            display.showSystemMessage(theme.gradient.primary(`🧪 Generating Test Flows for ${targetPath}...`));
+            display.showSystemMessage('');
+            const flows = generateTestFlows(this.workingDir, targetPath);
+            saveTestFlows(flows);
+            const lines = [];
+            lines.push(`Generated ${theme.bold(String(flows.length))} test flows`);
+            lines.push('');
+            const byCategory = {};
+            for (const flow of flows) {
+                byCategory[flow.category] = (byCategory[flow.category] || 0) + 1;
+            }
+            for (const [category, count] of Object.entries(byCategory)) {
+                lines.push(`  ${category}: ${count}`);
+            }
+            lines.push('');
+            lines.push(theme.bold('Generated flows:'));
+            for (const flow of flows.slice(0, 10)) {
+                const icon = flow.complexity === 'extreme' ? '🔴' :
+                    flow.complexity === 'complex' ? '🟠' :
+                        flow.complexity === 'moderate' ? '🟡' : '⚪';
+                lines.push(`  ${icon} ${flow.name}`);
+                lines.push(`     ${theme.dim(flow.description.slice(0, 60))}`);
+            }
+            if (flows.length > 10) {
+                lines.push(`  ${theme.dim(`... and ${flows.length - 10} more`)}`);
+            }
+            lines.push('');
+            lines.push(`Saved to ~/.erosolar/test-flows/`);
+            display.showSystemMessage(lines.join('\n'));
+            return;
+        }
+        if (subcommand === 'bugs') {
+            display.showSystemMessage(theme.gradient.primary('🐛 Detecting Potential Bugs...'));
+            display.showSystemMessage('');
+            const bugs = detectBugs(this.workingDir);
+            saveBugReports(bugs);
+            const lines = [];
+            lines.push(`Found ${theme.bold(String(bugs.length))} potential issues`);
+            lines.push('');
+            const bySeverity = {};
+            for (const bug of bugs) {
+                bySeverity[bug.severity] = (bySeverity[bug.severity] || 0) + 1;
+            }
+            if (bySeverity['critical'])
+                lines.push(`  🔴 Critical: ${bySeverity['critical']}`);
+            if (bySeverity['high'])
+                lines.push(`  🟠 High: ${bySeverity['high']}`);
+            if (bySeverity['medium'])
+                lines.push(`  🟡 Medium: ${bySeverity['medium']}`);
+            if (bySeverity['low'])
+                lines.push(`  ⚪ Low: ${bySeverity['low']}`);
+            lines.push('');
+            lines.push(theme.bold('Top Issues:'));
+            for (const bug of bugs.slice(0, 10)) {
+                const icon = bug.severity === 'critical' ? '🔴' :
+                    bug.severity === 'high' ? '🟠' :
+                        bug.severity === 'medium' ? '🟡' : '⚪';
+                lines.push(`  ${icon} ${bug.title}`);
+                lines.push(`     ${bug.file}:${bug.line ?? '?'}`);
+                lines.push(`     ${theme.dim(bug.description.slice(0, 50))}`);
+                if (bug.suggestedFix) {
+                    lines.push(`     ${theme.success('Fix:')} ${bug.suggestedFix.slice(0, 50)}`);
+                }
+                lines.push('');
+            }
+            display.showSystemMessage(lines.join('\n'));
+            return;
+        }
+        if (subcommand === 'ui') {
+            display.showSystemMessage(theme.gradient.primary('🎨 Detecting UI Updates...'));
+            display.showSystemMessage('');
+            const updates = detectUIUpdates(this.workingDir);
+            saveUIUpdates(updates);
+            const lines = [];
+            lines.push(`Found ${theme.bold(String(updates.length))} UI improvements`);
+            lines.push('');
+            const byType = {};
+            for (const update of updates) {
+                byType[update.type] = (byType[update.type] || 0) + 1;
+            }
+            for (const [type, count] of Object.entries(byType)) {
+                const icon = type === 'accessibility' ? '♿' :
+                    type === 'performance' ? '⚡' :
+                        type === 'style' ? '🎨' : '🔧';
+                lines.push(`  ${icon} ${type}: ${count}`);
+            }
+            lines.push('');
+            lines.push(theme.bold('Updates:'));
+            for (const update of updates.slice(0, 10)) {
+                lines.push(`  📦 ${update.component} [${update.type}]`);
+                lines.push(`     ${theme.dim(update.description)}`);
+                lines.push(`     Before: ${theme.error(update.before.slice(0, 40))}`);
+                lines.push(`     After:  ${theme.success(update.after.slice(0, 40))}`);
+                lines.push('');
+            }
+            display.showSystemMessage(lines.join('\n'));
+            return;
+        }
+        if (subcommand === 'edge') {
+            display.showSystemMessage(theme.gradient.primary('🔬 Edge Case Analysis'));
+            display.showSystemMessage('');
+            const bugs = detectBugs(this.workingDir);
+            const edgeCases = bugs.filter(b => b.type === 'edge-case');
+            const lines = [];
+            lines.push(`Found ${theme.bold(String(edgeCases.length))} edge case issues`);
+            lines.push('');
+            for (const bug of edgeCases.slice(0, 15)) {
+                const icon = bug.severity === 'critical' ? '🔴' :
+                    bug.severity === 'high' ? '🟠' : '🟡';
+                lines.push(`  ${icon} ${bug.title}`);
+                lines.push(`     ${bug.file}:${bug.line ?? '?'}`);
+                if (bug.suggestedFix) {
+                    lines.push(`     ${theme.success('Fix:')} ${bug.suggestedFix}`);
+                }
+                lines.push('');
+            }
+            display.showSystemMessage(lines.join('\n'));
+            return;
+        }
+        // Default: show status
+        const status = getTestFlowStatus(this.workingDir);
+        display.showSystemMessage(status);
+    }
     showPluginStatus() {
         const available = listAvailablePlugins();
         const lines = [];
@@ -1956,6 +3179,277 @@ export class InteractiveShell {
         }
         this.setAutoContinueMode(value === 'on', 'command');
     }
+    // ==================== Claude Code Style Commands ====================
+    async handleRewindCommand(input) {
+        const lines = [];
+        lines.push(theme.bold('Rewind / Checkpoint System'));
+        lines.push('');
+        lines.push('Use checkpoints to restore previous states of your code and conversation.');
+        lines.push('');
+        lines.push(theme.secondary('Usage:'));
+        lines.push('  /rewind                 Show available checkpoints');
+        lines.push('  /rewind list            List all checkpoints');
+        lines.push('  /rewind <id>            Rewind to specific checkpoint');
+        lines.push('  /rewind code            Rewind code only (keep conversation)');
+        lines.push('  /rewind conv            Rewind conversation only (keep code)');
+        lines.push('');
+        lines.push(theme.ui.muted('Tip: Press Esc+Esc for quick access to rewind menu'));
+        display.showSystemMessage(lines.join('\n'));
+    }
+    handleMemoryCommand(input) {
+        const lines = [];
+        lines.push(theme.bold('Memory System (EROSOLAR.md)'));
+        lines.push('');
+        lines.push('Create EROSOLAR.md files to store persistent context and preferences.');
+        lines.push('');
+        lines.push(theme.secondary('Memory Locations:'));
+        lines.push(`  ~/.erosolar/EROSOLAR.md     ${theme.ui.muted('User preferences (global)')}`);
+        lines.push(`  ./EROSOLAR.md               ${theme.ui.muted('Project memory')}`);
+        lines.push(`  ./.erosolar/EROSOLAR.md     ${theme.ui.muted('Project memory (alternative)')}`);
+        lines.push('');
+        lines.push(theme.secondary('Features:'));
+        lines.push('  - Use @path/to/file in prompts to reference files');
+        lines.push('  - Use # prefix to quickly add notes to project memory');
+        lines.push('  - Import other files with @./relative/path syntax');
+        lines.push('');
+        lines.push(theme.ui.muted('Tip: Create EROSOLAR.md with project coding standards for better results'));
+        display.showSystemMessage(lines.join('\n'));
+    }
+    handleVimCommand() {
+        const lines = [];
+        lines.push(theme.bold('Vim Mode'));
+        lines.push('');
+        lines.push('Enable vim-style editing in the input area.');
+        lines.push('');
+        lines.push(theme.secondary('Basic Commands:'));
+        lines.push('  h/j/k/l      Move left/down/up/right');
+        lines.push('  w/b          Word forward/backward');
+        lines.push('  0/$          Line start/end');
+        lines.push('  i/a          Insert before/after cursor');
+        lines.push('  I/A          Insert at line start/end');
+        lines.push('  o/O          Open line below/above');
+        lines.push('  x            Delete character');
+        lines.push('  dd           Delete line');
+        lines.push('  yy           Yank (copy) line');
+        lines.push('  p            Paste');
+        lines.push('  Escape       Return to normal mode');
+        lines.push('');
+        lines.push(theme.ui.muted('Vim mode is experimental. Toggle with /vim'));
+        display.showSystemMessage(lines.join('\n'));
+    }
+    handleOutputStyleCommand(input) {
+        const lines = [];
+        lines.push(theme.bold('Output Styles'));
+        lines.push('');
+        lines.push('Change how the AI responds to your requests.');
+        lines.push('');
+        lines.push(theme.secondary('Built-in Styles:'));
+        lines.push(`  default      ${theme.ui.muted('Standard efficient coding mode')}`);
+        lines.push(`  explanatory  ${theme.ui.muted('Educational with detailed explanations')}`);
+        lines.push(`  learning     ${theme.ui.muted('Collaborative with TODO(human) markers')}`);
+        lines.push(`  concise      ${theme.ui.muted('Minimal output, code-focused only')}`);
+        lines.push('');
+        lines.push(theme.secondary('Custom Styles:'));
+        lines.push('  Create custom styles in ~/.erosolar/output-styles/');
+        lines.push('  or .erosolar/output-styles/ for project-specific styles.');
+        lines.push('');
+        lines.push(theme.secondary('Usage:'));
+        lines.push('  /output-style <name>    Switch to a style');
+        display.showSystemMessage(lines.join('\n'));
+    }
+    handleCostCommand() {
+        const lines = [];
+        lines.push(theme.bold('Cost & Token Usage'));
+        lines.push('');
+        // This will be populated with actual data from costTracker
+        lines.push(theme.secondary('Session Statistics:'));
+        lines.push('  Input tokens:  (tracking enabled)');
+        lines.push('  Output tokens: (tracking enabled)');
+        lines.push('  Estimated cost: $0.00');
+        lines.push('');
+        lines.push(theme.ui.muted('Token usage is tracked automatically during the session.'));
+        display.showSystemMessage(lines.join('\n'));
+    }
+    handleUsageCommand() {
+        const percentage = this.latestTokenUsage.limit && this.latestTokenUsage.used
+            ? Math.round((this.latestTokenUsage.used / this.latestTokenUsage.limit) * 100)
+            : 0;
+        const lines = [];
+        lines.push(theme.bold('Context Usage'));
+        lines.push('');
+        lines.push(theme.secondary('Current Context:'));
+        lines.push(`  Used:  ${this.latestTokenUsage.used?.toLocaleString() ?? '?'} tokens`);
+        lines.push(`  Limit: ${this.latestTokenUsage.limit?.toLocaleString() ?? '?'} tokens`);
+        lines.push(`  Usage: ${percentage}%`);
+        lines.push('');
+        if (percentage > 80) {
+            lines.push(theme.warning('Context is getting full. Consider using /compact.'));
+        }
+        else if (percentage > 60) {
+            lines.push(theme.secondary('Context usage is moderate.'));
+        }
+        else {
+            lines.push(theme.success('Plenty of context available.'));
+        }
+        display.showSystemMessage(lines.join('\n'));
+    }
+    async handleUpdateCommand() {
+        display.showInfo('Checking for updates...');
+        const lines = [];
+        lines.push(theme.bold('Update Check'));
+        lines.push('');
+        lines.push(`Current version: ${this.version ?? 'unknown'}`);
+        lines.push('');
+        lines.push(theme.secondary('To update:'));
+        lines.push('  npm install -g erosolar-cli@latest');
+        lines.push('  or: npm update erosolar-cli');
+        lines.push('');
+        lines.push(theme.ui.muted('Auto-updates will be checked periodically.'));
+        display.showSystemMessage(lines.join('\n'));
+    }
+    handleClearCommand() {
+        if (this.agent) {
+            this.agent.clearHistory();
+            this.cachedHistory = this.agent.getHistory();
+        }
+        display.clear();
+        clearAutosaveSnapshot(this.profile);
+        display.showInfo('Conversation cleared. Starting fresh.');
+        this.terminalInput.render();
+    }
+    async handleResumeCommand(input) {
+        const tokens = input.split(/\s+/).slice(1);
+        const sessionId = tokens[0];
+        if (sessionId) {
+            await this.loadSessionCommand(sessionId);
+        }
+        else {
+            // Show session list and auto-select the most recent
+            const sessions = listSessions(this.profile);
+            if (sessions.length > 0) {
+                display.showInfo('Resuming most recent session...');
+                await this.loadSessionCommand('1');
+            }
+            else {
+                display.showWarning('No previous sessions found. Use /sessions to manage sessions.');
+            }
+        }
+    }
+    handleExportCommand(input) {
+        const lines = [];
+        lines.push(theme.bold('Export Conversation'));
+        lines.push('');
+        lines.push('Export your conversation history for sharing or documentation.');
+        lines.push('');
+        lines.push(theme.secondary('Usage:'));
+        lines.push('  /export                 Export to default file');
+        lines.push('  /export <filename>      Export to specific file');
+        lines.push('');
+        lines.push(theme.ui.muted('Exports include conversation history and tool results.'));
+        display.showSystemMessage(lines.join('\n'));
+    }
+    async handleReviewCommand() {
+        if (this.isProcessing) {
+            display.showWarning('Wait for the current operation to finish.');
+            return;
+        }
+        display.showInfo('Triggering code review of pending changes...');
+        await this.processRequest('Please review all the code changes we made in this session. Look for bugs, security issues, and improvements.');
+    }
+    async handleSecurityReviewCommand() {
+        if (this.isProcessing) {
+            display.showWarning('Wait for the current operation to finish.');
+            return;
+        }
+        display.showInfo('Running comprehensive security review...');
+        await this.processRequest('Please perform a comprehensive security review of the codebase. Check for OWASP top 10 vulnerabilities, insecure patterns, and potential attack vectors.');
+    }
+    handleBugCommand() {
+        const lines = [];
+        lines.push(theme.bold('Report an Issue'));
+        lines.push('');
+        lines.push('Found a bug or have a suggestion?');
+        lines.push('');
+        lines.push(theme.secondary('Report issues at:'));
+        lines.push('  https://github.com/erosolar/erosolar-cli/issues');
+        lines.push('');
+        lines.push(theme.secondary('Include:'));
+        lines.push('  - Steps to reproduce');
+        lines.push('  - Expected vs actual behavior');
+        lines.push('  - Version info (erosolar --version)');
+        display.showSystemMessage(lines.join('\n'));
+    }
+    handleTerminalSetupCommand() {
+        const lines = [];
+        lines.push(theme.bold('Terminal Setup'));
+        lines.push('');
+        lines.push('Configure terminal keybindings for better experience.');
+        lines.push('');
+        lines.push(theme.secondary('Recommended Settings:'));
+        lines.push('');
+        lines.push(theme.bold('  iTerm2:'));
+        lines.push('    Preferences > Keys > Key Bindings');
+        lines.push('    Add: Shift+Enter → Send Escape Sequence: [13;2u');
+        lines.push('');
+        lines.push(theme.bold('  VS Code Terminal:'));
+        lines.push('    Already supports Shift+Enter natively');
+        lines.push('');
+        lines.push(theme.bold('  Kitty/Wezterm:'));
+        lines.push('    Modern terminals support extended keys automatically');
+        lines.push('');
+        lines.push(theme.ui.muted('Shift+Enter enables multi-line input.'));
+        display.showSystemMessage(lines.join('\n'));
+    }
+    handlePermissionsCommand() {
+        const lines = [];
+        lines.push(theme.bold('Tool Permissions'));
+        lines.push('');
+        lines.push('Configure which tools require confirmation before execution.');
+        lines.push('');
+        lines.push(theme.secondary('Current Mode:'));
+        const editMode = this.editGuardMode;
+        lines.push(`  Edit Guard: ${editMode === 'ask-permission' ? 'Ask before edits' : editMode === 'plan' ? 'Plan mode' : 'Auto-accept'}`);
+        lines.push('');
+        lines.push(theme.secondary('Toggle with:'));
+        lines.push('  Shift+Tab    Cycle through modes');
+        lines.push('  Option+E     Toggle edit permission');
+        lines.push('');
+        lines.push(theme.ui.muted('Use /tools to manage which tool suites are enabled.'));
+        display.showSystemMessage(lines.join('\n'));
+    }
+    handleInitCommand() {
+        const lines = [];
+        lines.push(theme.bold('Initialize Project'));
+        lines.push('');
+        lines.push('Create EROSOLAR.md to configure project-specific settings.');
+        lines.push('');
+        lines.push(theme.secondary('This will create:'));
+        lines.push(`  ${this.workingDir}/EROSOLAR.md`);
+        lines.push('');
+        lines.push(theme.secondary('Template includes:'));
+        lines.push('  - Project description');
+        lines.push('  - Coding standards');
+        lines.push('  - File conventions');
+        lines.push('  - Testing requirements');
+        lines.push('');
+        lines.push(theme.ui.muted('Use /init confirm to create the file.'));
+        display.showSystemMessage(lines.join('\n'));
+    }
+    async handleCompactCommand() {
+        if (this.isProcessing) {
+            display.showWarning('Wait for the current operation to finish.');
+            return;
+        }
+        display.showInfo('Compacting conversation context...');
+        // Check if compaction is needed based on tracked usage
+        const { used, limit } = this.latestTokenUsage;
+        if (used && limit && used / limit < 0.5) {
+            display.showInfo('Context usage is low. No compaction needed.');
+            return;
+        }
+        await this.processRequest('Please summarize our conversation so far in a concise way, preserving key decisions, code changes, and next steps. This will help compact the context.');
+    }
+    // ==================== End Claude Code Style Commands ====================
     updateActiveSession(summary, remember = false) {
         this.activeSessionId = summary?.id ?? null;
         this.activeSessionTitle = summary?.title ?? null;
@@ -2631,6 +4125,14 @@ export class InteractiveShell {
         // Keep the persistent input/control bar active as we transition into streaming.
         this.terminalInput.forceRender();
         const requestStartTime = Date.now(); // Alpha Zero 2 timing
+        // Clear previous parallel agents and start fresh for new request
+        const parallelManager = getParallelAgentManager();
+        parallelManager.clear();
+        parallelManager.startBatch();
+        // AlphaZero: Track task for learning
+        this.lastUserQuery = request;
+        this.currentTaskType = classifyTaskType(request);
+        this.currentToolCalls = [];
         this.uiAdapter.startProcessing('Working on your request');
         this.setProcessingStatus();
         let responseText = '';
@@ -2647,6 +4149,43 @@ export class InteractiveShell {
             if (!responseText?.trim()) {
                 display.showWarning('The provider returned an empty response. Check your API key/provider selection or retry the prompt.');
             }
+            // AlphaZero: Extract and track tool calls from response
+            const toolsUsed = this.extractToolsFromResponse(responseText);
+            this.currentToolCalls = toolsUsed.map(name => ({
+                name,
+                arguments: {},
+                success: true, // Assume success if we got here
+                duration: 0,
+            }));
+            // AlphaZero: Check for failure in response
+            const failure = detectFailure(responseText, {
+                toolCalls: this.currentToolCalls,
+                userMessage: request,
+            });
+            if (failure) {
+                this.lastFailure = failure;
+                // Check if we have a recovery strategy
+                const strategy = findRecoveryStrategy(failure);
+                if (strategy) {
+                    display.showSystemMessage(`🔄 Found recovery strategy for this type of issue (success rate: ${Math.round(strategy.successRate * 100)}%)`);
+                }
+            }
+            else {
+                // Success - record the tool pattern for this task type
+                if (this.currentToolCalls.length > 0) {
+                    const toolPattern = {
+                        taskType: this.currentTaskType,
+                        toolSequence: this.currentToolCalls.map(t => t.name),
+                        successRate: 1.0,
+                        avgDuration: elapsedMs,
+                        occurrences: 1,
+                    };
+                    addToolPattern(this.currentTaskType, toolPattern);
+                }
+                // Clear action history on success
+                clearActionHistory();
+                this.lastFailure = null;
+            }
         }
         catch (error) {
             const handled = this.handleProviderError(error, () => this.processRequest(request));
@@ -2704,6 +4243,10 @@ export class InteractiveShell {
         this.uiUpdates.setMode('processing');
         this.terminalInput.setStreaming(true);
         const overallStartTime = Date.now();
+        // Clear previous parallel agents and start fresh for continuous mode
+        const parallelManager = getParallelAgentManager();
+        parallelManager.clear();
+        parallelManager.startBatch();
         // Initialize the task completion detector
         const completionDetector = getTaskCompletionDetector();
         completionDetector.reset();