erosolar-cli 2.1.175 → 2.1.177

package/dist/shell/interactiveShell.js

@@ -4,6 +4,7 @@ import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
 import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
+import { AgentOrchestrator } from '../core/agentOrchestrator.js';
 import { display } from '../ui/display.js';
 import { theme } from '../ui/theme.js';
 import { getTerminalColumns } from '../ui/layout.js';
@@ -17,7 +18,7 @@ import { detectPromptBlockError, } from '../core/errors/promptBlockErrors.js';
 import { detectNetworkError } from '../core/errors/networkErrors.js';
 import { buildWorkspaceContext } from '../workspace.js';
 import { buildInteractiveSystemPrompt } from './systemPrompt.js';
-import { getTaskCompletionDetector, resetTaskCompletionDetector, WRITE_TOOLS, } from './taskCompletionDetector.js';
+import { WRITE_TOOLS } from './taskCompletionDetector.js';
 import { discoverAllModels, quickCheckProviders, getCachedDiscoveredModels, sortModelsByPriority } from '../core/modelDiscovery.js';
 import { getModels, getSlashCommands, getProviders } from '../core/agentSchemaLoader.js';
 import { loadMcpServers } from '../mcp/config.js';
@@ -2274,14 +2275,17 @@ export class InteractiveShell {
         // Check for continuous/infinite loop commands or auto-escalation to completion mode
         const explicitContinuous = this.isContinuousCommand(trimmed);
         const autoContinuous = this.shouldAutoRunToCompletion(trimmed);
-        if (explicitContinuous || autoContinuous) {
-            if (autoContinuous && !explicitContinuous) {
-                display.showSystemMessage('⚡ Actionable request detected; running continuously until complete (Ctrl+C to stop).');
-            }
+        if (explicitContinuous) {
             await this.processContinuousRequest(trimmed);
             this.syncRendererInput();
             return;
         }
+        if (autoContinuous) {
+            display.showSystemMessage('⚡ Actionable request detected; orchestrating until complete (Ctrl+C to stop).');
+            await this.processRequest(trimmed, { orchestrate: true });
+            this.syncRendererInput();
+            return;
+        }
         // Direct execution for all inputs, including multi-line pastes
         await this.processRequest(trimmed);
         this.syncRendererInput();
@@ -5830,7 +5834,7 @@ Execute the plan you outlined. Use the available tools (bash, edits, git) to tak
         this.clearInlinePanel();
         this.syncRendererInput();
     }
-    async processRequest(request) {
+    async processRequest(request, options) {
         if (this.isProcessing) {
             this.enqueueFollowUpAction({ type: 'request', text: request });
             return;
@@ -5882,10 +5886,23 @@ Execute the plan you outlined. Use the available tools (bash, edits, git) to tak
         this.beginAiRuntime();
         let responseText = '';
         let autoFollowThrough = null;
+        let orchestratorResult = null;
+        const orchestrate = options?.orchestrate ?? false;
         try {
             // Start streaming - no header needed, the input area already provides context
             this.startStreamingHeartbeat('Streaming response');
-            responseText = await agent.send(request, true);
+            if (orchestrate) {
+                const orchestrator = new AgentOrchestrator(agent);
+                orchestratorResult = await orchestrator.runToCompletion(request, {
+                    streaming: true,
+                    maxPasses: options?.maxPasses ?? 4,
+                    enforceActions: true,
+                });
+                responseText = orchestratorResult.finalResponse;
+            }
+            else {
+                responseText = await agent.send(request, true);
+            }
             this.finishStreamingFormatter(undefined, { refreshPrompt: false, mode: 'complete' });
             await this.awaitPendingCleanup();
             this.captureHistorySnapshot();
@@ -5897,14 +5914,24 @@ Execute the plan you outlined. Use the available tools (bash, edits, git) to tak
                 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.getExecutedTools(responseText);
+            const toolsUsed = orchestratorResult
+                ? orchestratorResult.passes.flatMap(pass => pass.toolsUsed)
+                : this.getExecutedTools(responseText);
             this.currentToolCalls = toolsUsed.map(name => ({
                 name,
                 arguments: {},
                 success: true, // Assume success if we got here
                 duration: 0,
             }));
-            autoFollowThrough = this.maybeAutoFollowThrough(request, responseText, toolsUsed);
+            if (!orchestrate) {
+                autoFollowThrough = this.maybeAutoFollowThrough(request, responseText, toolsUsed);
+            }
+            if (orchestratorResult && orchestratorResult.exitReason !== 'complete') {
+                const exitDetail = orchestratorResult.exitReason === 'max-passes'
+                    ? 'Reached orchestrator pass limit; showing last response.'
+                    : 'Received empty replies while orchestrating; showing last response.';
+                display.showSystemMessage(`⚠️ ${exitDetail}`);
+            }
             // AlphaZero: Check for failure in response
             const failure = detectFailure(responseText, {
                 toolCalls: this.currentToolCalls,
@@ -5936,7 +5963,7 @@ Execute the plan you outlined. Use the available tools (bash, edits, git) to tak
             }
         }
         catch (error) {
-            const handled = this.handleProviderError(error, () => this.processRequest(request));
+            const handled = this.handleProviderError(error, () => this.processRequest(request, options));
             if (!handled) {
                 // Pass full error object for enhanced formatting with stack trace
                 display.showError(error instanceof Error ? error.message : String(error), error);
@@ -5990,7 +6017,7 @@ Execute the plan you outlined. Use the available tools (bash, edits, git) to tak
      * Context is automatically managed - overflow errors trigger auto-recovery.
      */
     async processContinuousRequest(initialRequest) {
-        const MAX_ITERATIONS = 100; // Safety limit to prevent truly infinite loops
+        const MAX_PASSES = 100; // Safety limit to prevent truly infinite loops
         if (this.isProcessing) {
             this.enqueueFollowUpAction({ type: 'continuous', text: initialRequest });
             return;
@@ -5999,54 +6026,9 @@ Execute the plan you outlined. Use the available tools (bash, edits, git) to tak
             display.showWarning('Configure an API key via /secrets before sending requests.');
             return;
         }
-        this.inlinePanelScopeActive = false;
-        this.clearInlinePanel();
-        const agent = this.agent;
-        if (!agent) {
-            return;
-        }
-        this.toolsUsedThisRun = [];
-        this.currentToolCalls = [];
-        this.lastUserQuery = initialRequest;
-        this.clearToolUsageMeta();
-        this.isProcessing = true;
-        this.uiUpdates.setMode('processing');
-        this.streamingTokenCount = 0; // Reset token counter for new request
-        this.terminalInput.setStreaming(true);
-        if (this.suppressNextNetworkReset) {
-            this.suppressNextNetworkReset = false;
-        }
-        else {
-            this.resetNetworkRetryState();
-        }
-        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();
-        // Display user prompt in scrollback (Claude Code style)
-        this.logUserPrompt(initialRequest);
         display.showSystemMessage(`Continuous mode active. Ctrl+C to stop.`);
-        this.uiAdapter.startProcessing('Continuous execution mode');
-        this.setProcessingStatus();
-        this.beginAiRuntime();
-        // No streaming header - just start streaming directly
-        this.startStreamingHeartbeat('Streaming');
-        let iteration = 0;
-        let lastResponse = '';
-        let consecutiveNoProgress = 0;
-        const MAX_NO_PROGRESS = 5; // Increased to allow more attempts before giving up
-        let pendingVerification = false;
-        let verificationAttempts = 0;
-        const MAX_VERIFICATION_ATTEMPTS = 2;
-        try {
-            // Enhance initial prompt with git context for self-improvement tasks
-            let currentPrompt = initialRequest;
-            if (this.isSelfImprovementRequest(initialRequest)) {
-                currentPrompt = `${initialRequest}
+        const preparedRequest = this.isSelfImprovementRequest(initialRequest)
+            ? `${initialRequest}
 
 IMPORTANT: You have full git access. After making improvements:
 1. Use bash to run: git status (see changes)
@@ -6055,175 +6037,9 @@ IMPORTANT: You have full git access. After making improvements:
 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++;
-                this.toolsUsedThisRun = [];
-                display.showSystemMessage(`\n📍 Iteration ${iteration}/${MAX_ITERATIONS}`);
-                this.updateStatusMessage(`Working on iteration ${iteration}...`);
-                try {
-                    // Send the request and capture the response (streaming disabled)
-                    display.showThinking('Responding...');
-                    this.refreshStatusLine(true);
-                    const response = await agent.send(currentPrompt, true);
-                    this.finishStreamingFormatter(undefined, { refreshPrompt: false, mode: 'complete' });
-                    await this.awaitPendingCleanup();
-                    this.captureHistorySnapshot();
-                    this.autosaveIfEnabled();
-                    // Track metrics
-                    const elapsedMs = Date.now() - overallStartTime;
-                    this.alphaZeroMetrics.recordMessage(elapsedMs);
-                    if (!response?.trim()) {
-                        display.showWarning('Model returned an empty response. Retrying this iteration...');
-                        consecutiveNoProgress++;
-                        currentPrompt = `${initialRequest}
-
-The previous reply was empty. Resume the task now: take the next action, call the necessary tools, and report progress.`;
-                        continue;
-                    }
-                    // Extract tools used from the response (look for tool call patterns)
-                    const toolsUsed = this.getExecutedTools(response);
-                    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 {
-            this.finishStreamingFormatter(undefined, { refreshPrompt: false, mode: 'complete' });
-            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.uiUpdates.setMode('processing');
-            this.stopStreamingHeartbeat('complete', { quiet: true });
-            this.endAiRuntime();
-            this.isProcessing = false;
-            this.terminalInput.setStreaming(false);
-            this.uiAdapter.endProcessing('Ready for prompts');
-            this.updateToolUsageMeta(this.uiAdapter.getToolUsageSummary({ plain: true }));
-            this.setIdleStatus();
-            this.updateStatusMessage(null);
-            this.toolsUsedThisRun = [];
-            queueMicrotask(() => this.uiUpdates.setMode('idle'));
-            // CRITICAL: Ensure readline prompt is active for user input
-            // Erosolar-CLI style: New prompt naturally appears at bottom
-            this.ensureReadlineReady();
-            this.scheduleQueueProcessing();
-            this.maybeProcessPromptInbox();
-            this.refreshQueueIndicators();
-        }
+When truly finished with ALL tasks, explicitly state "TASK_FULLY_COMPLETE".`
+            : initialRequest;
+        await this.processRequest(preparedRequest, { orchestrate: true, maxPasses: MAX_PASSES });
     }
     /**
      * Resolve executed tools for the current turn. Prefer the actual tool