erosolar-cli 2.1.175 → 2.1.176

package/dist/shell/interactiveShell.js

@@ -12,6 +12,7 @@ import { ensureSecretForProvider, getSecretDefinitionForProvider, getSecretValue
 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 { FlowOrchestrator } from '../runtime/flowOrchestrator.js';
 import { detectApiKeyError } from '../core/errors/apiKeyErrors.js';
 import { detectPromptBlockError, } from '../core/errors/promptBlockErrors.js';
 import { detectNetworkError } from '../core/errors/networkErrors.js';
@@ -123,6 +124,7 @@ export class InteractiveShell {
     uiUpdates;
     _fileChangeTracker = new FileChangeTracker(); // Reserved for future file tracking features
     alphaZeroMetrics; // Alpha Zero 2 performance tracking
+    flowOrchestrator = new FlowOrchestrator();
     maxNetworkRetries = 2;
     statusSubscription = null;
     followUpQueue = [];
@@ -2356,7 +2358,7 @@ export class InteractiveShell {
             return false;
         }
         const mutatingToolUsed = toolsUsed.some((tool) => WRITE_TOOL_NAMES.has(tool.toLowerCase()));
-        const planOnly = this.isPlanOnlyResponse(response);
+        const planOnly = this.flowOrchestrator.isPlanOnlyResponse(response);
         const lowActionDensity = response.split(/\s+/).length < 80;
         // If it's clearly a plan-only response, continue regardless of prior tool usage
         if (planOnly) {
@@ -6035,13 +6037,8 @@ Execute the plan you outlined. Use the available tools (bash, edits, git) to tak
         this.beginAiRuntime();
         // No streaming header - just start streaming directly
         this.startStreamingHeartbeat('Streaming');
+        this.flowOrchestrator.start(initialRequest);
         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;
@@ -6076,7 +6073,6 @@ When truly finished with ALL tasks, explicitly state "TASK_FULLY_COMPLETE".`;
                     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.`;
@@ -6088,91 +6084,41 @@ The previous reply was empty. Resume the task now: take the next action, call th
                     // 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).`);
+                    const decision = this.flowOrchestrator.decide({
+                        iteration,
+                        response,
+                        toolsUsed,
+                        completionAnalysis,
+                        verificationConfirmed: this.flowOrchestrator.isVerificationPending()
+                            ? completionDetector.isVerificationConfirmed(response)
+                            : false,
+                    });
+                    if (decision.type === 'stop') {
+                        display.showSystemMessage(decision.message);
                         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}`);
+                    if (decision.type === 'stagnation-stop') {
+                        display.showWarning(decision.message);
                         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 (decision.type === 'execute-plan') {
+                        display.showSystemMessage(decision.message);
+                        currentPrompt = decision.prompt;
+                        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...`);
-                        }
+                    if (decision.type === 'verify') {
+                        display.showSystemMessage(decision.message);
+                        currentPrompt = decision.prompt;
+                        await new Promise(resolve => setTimeout(resolve, 500));
+                        continue;
                     }
-                    // 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;
+                    if (decision.type === 'continue') {
+                        if (decision.message) {
+                            display.showSystemMessage(decision.message);
                         }
+                        currentPrompt = decision.prompt;
                     }
-                    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));
                 }
@@ -6245,129 +6191,6 @@ What's the next action?`;
         }
         return this.extractToolsFromResponse(responseText);
     }
-    /**
-     * Detect plan-only responses that narrate intent without executing actions.
-     */
-    isPlanOnlyResponse(response) {
-        const normalized = response.trim().toLowerCase();
-        if (!normalized) {
-            return false;
-        }
-        // If the assistant is clearly declaring completion, don't treat it as plan-only
-        const completionGuards = [
-            /\bnothing\s+(left|else)\s+(to\s+do|pending)\b/i,
-            /\b(already|now)\s+(clean|complete|done)\b/i,
-            /\b(no\s+(junk|issues?|changes?)\s+found)\b/i,
-        ];
-        if (completionGuards.some((pattern) => pattern.test(response))) {
-            return false;
-        }
-        const planIndicators = [
-            /\bplan\b/i,
-            /\bapproach\b/i,
-            /\bsteps?:\b/i,
-            /\bstep\s+1\b/i,
-            /\bstart by\b/i,
-            /\bfirst[, ]/i,
-            /\bthen\b/i,
-            /\bnext\b/i,
-            /\bi['’]?\s*will\b/i,
-            /\bi['’]?\s*ll\b/i,
-            /\bi['’]?\s*can\b.{0,40}\bthen\b/i,
-            /\bi['’]?\s*(?:will|ll)\s+begin\b/i,
-        ];
-        return planIndicators.some((pattern) => pattern.test(response));
-    }
-    /**
-     * Check if a response contains indicators that work is actually incomplete,
-     * even if it also contains TASK_FULLY_COMPLETE marker.
-     * This catches contradictory responses where the AI says "done" but also "not integrated yet".
-     */
-    responseIndicatesIncompleteWork(response) {
-        // Patterns that indicate work isn't actually complete
-        // Organized by category for maintainability
-        const incompletePatterns = [
-            // === INTEGRATION/DEPLOYMENT STATE ===
-            // "hasn't been integrated/implemented/connected yet"
-            /hasn'?t\s+been\s+(integrated|implemented|connected|deployed|added|completed|tested|verified)\s*(yet|still)?/i,
-            // "not yet integrated/implemented" or "not integrated"
-            /not\s+(yet\s+)?(integrated|implemented|connected|deployed|functional|working|complete|tested|verified)/i,
-            // "ready for integration" = NOT integrated
-            /ready\s+(for|to\s+be)\s+(integration|integrated|connected|deployed|testing|review)/i,
-            // "needs to be integrated"
-            /needs?\s+to\s+be\s+(integrated|connected|deployed|added|hooked|wired|tested|reviewed|merged)/i,
-            // Passive voice: "was not performed/completed"
-            /was\s+not\s+(performed|completed|implemented|deployed|integrated|tested)/i,
-            // "the [X] service hasn't been"
-            /the\s+\w+\s+(service|module|component|feature)\s+hasn'?t\s+been/i,
-            // === PARTIAL/INCOMPLETE STATE ===
-            // "still stores/uses/has" (current bad state persists)
-            /still\s+(stores?|uses?|has|contains?|needs?|requires?|missing|lacks?|broken)/i,
-            // Partial completion: "partially", "mostly", "almost"
-            /\b(partially|mostly|almost|nearly|not\s+fully)\s+(complete|done|finished|implemented|working)/i,
-            // Explicit partial: "part of", "some of", "half of"
-            /\b(only\s+)?(part|some|half|portion)\s+of\s+(the\s+)?(task|work|feature|implementation)/i,
-            // === QUALIFIER WORDS (uncertain completion) ===
-            // "should be complete", "appears complete", "theoretically"
-            /\b(should|might|may|could|appears?\s+to)\s+be\s+(complete|done|working|functional)/i,
-            /\btheoretically\s+(complete|done|working|functional)/i,
-            // "assuming", "if everything works"
-            /\b(assuming|provided|if)\s+(everything|it|this|that)\s+(works?|is\s+correct)/i,
-            // === SELF-CONTRADICTION PHRASES ===
-            // "done but...", "complete except...", "finished however..."
-            /\b(done|complete|finished)\s+(but|except|however|although|though)/i,
-            // "however" followed by incomplete indicator
-            /however[,\s].{0,50}?(hasn'?t|not\s+yet|still\s+needs?|pending|remains?|missing|broken|failing)/i,
-            // "but" followed by negative state
-            /\bbut\s+.{0,30}?(not|hasn'?t|won'?t|can'?t|doesn'?t|isn'?t|wasn'?t)/i,
-            // === FUTURE TENSE / DEFERRED WORK ===
-            // "will need to", "will require"
-            /will\s+(need\s+to|require|have\s+to)\s+(integrate|connect|deploy|complete|implement|test|fix)/i,
-            // Deferred: "left as", "deferred", "postponed", "out of scope"
-            /\b(left\s+as|deferred|postponed|out\s+of\s+scope|for\s+later|in\s+a\s+future)/i,
-            // Time-dependent: "after restart", "takes effect after", "once you"
-            /\b(after\s+(restart|reboot|redeploy)|takes?\s+effect\s+after|once\s+you)/i,
-            // === REMAINING WORK INDICATORS ===
-            // "remaining tasks", "outstanding items"
-            /\b(remaining|outstanding|pending|leftover)\s+(tasks?|items?|work|issues?|steps?)/i,
-            // "X more to do", "still have to"
-            /\b(more\s+to\s+do|still\s+have\s+to|yet\s+to\s+be\s+done)/i,
-            // Explicit blockers
-            /\b(blocker|blocked\s+by|waiting\s+(for|on)|depends?\s+on)/i,
-            // === ERROR/FAILURE STATE ===
-            // "failing tests", "build errors"
-            /\b(failing|broken|erroring)\s+(tests?|builds?|checks?|validations?)/i,
-            // "tests? (are )?(still )?failing"
-            /\btests?\s+(are\s+)?(still\s+)?failing/i,
-            // "errors? to (address|fix)"
-            /\b(errors?|warnings?|issues?)\s+to\s+(address|fix|resolve)/i,
-            // "doesn't work", "isn't working", "not working"
-            /\b(doesn'?t|isn'?t|not)\s+(work|working|functional|functioning)/i,
-            // === MANUAL STEPS REQUIRED ===
-            // "you'll need to", "manually run", "requires user"
-            /\b(you('ll|\s+will)\s+need\s+to|manually\s+(run|configure|set|update)|requires?\s+user)/i,
-            // "run this command", "execute the following"
-            /\b(run\s+this|execute\s+the\s+following|apply\s+the\s+migration)/i,
-            // === TODO/FIXME IN PROSE ===
-            // TODO or FIXME mentioned as remaining work (not in code blocks)
-            /\b(todo|fixme|hack|xxx):\s/i,
-            // "need to add", "should implement"
-            /\b(need\s+to|should|must)\s+(add|implement|create|write|build|fix)\b/i,
-            // === SCOPE LIMITATIONS ===
-            // "didn't have time", "ran out of time"
-            /\b(didn'?t|did\s+not)\s+have\s+(time|chance|opportunity)/i,
-            // "beyond scope", "outside scope"
-            /\b(beyond|outside)\s+(the\s+)?scope/i,
-            // "for now" (temporary state)
-            /\b(for\s+now|at\s+this\s+point|currently)\s*.{0,20}?(not|without|lacks?|missing)/i,
-        ];
-        for (const pattern of incompletePatterns) {
-            if (pattern.test(response)) {
-                return true;
-            }
-        }
-        return false;
-    }
     /**
      * Extract tool names from a response by looking for tool call patterns
      */