testchimp-runner-core 0.0.33 → 0.0.35

package/dist/execution-service.js

@@ -3,13 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExecutionService = void 0;
 const playwright_mcp_service_1 = require("./playwright-mcp-service");
 const types_1 = require("./types");
-const page_info_utils_1 = require("./utils/page-info-utils");
 const browser_utils_1 = require("./utils/browser-utils");
 const llm_facade_1 = require("./llm-facade");
 const script_utils_1 = require("./script-utils");
 const credit_usage_service_1 = require("./credit-usage-service");
 const model_constants_1 = require("./model-constants");
 const backend_proxy_llm_provider_1 = require("./providers/backend-proxy-llm-provider");
+const orchestrator_1 = require("./orchestrator");
 /**
  * Service for orchestrating Playwright script execution
  */
@@ -23,6 +23,13 @@ class ExecutionService {
         this.progressReporter = progressReporter;
         this.creditUsageService = new credit_usage_service_1.CreditUsageService(authConfig, backendUrl);
         this.maxConcurrentExecutions = maxConcurrentExecutions;
+        // Initialize orchestrator for repair mode (reuses all SoM infrastructure)
+        const toolRegistry = new orchestrator_1.ToolRegistry();
+        const repairConfig = {
+            useSoM: true,
+            somRestrictCoordinates: true // Prefer SoM markers for repairs
+        };
+        this.orchestratorAgent = new orchestrator_1.OrchestratorAgent(this.llmFacade, toolRegistry, repairConfig, progressReporter, (msg, level) => this.log(msg));
     }
     /**
      * Set a logger callback for capturing execution logs
@@ -201,7 +208,7 @@ class ExecutionService {
                     await this.progressReporter.beforeStartTest(page, browser, context);
                 }
                 // Execute the script as-is
-                await this.executeScriptContent(request.script, page);
+                await this.executeStepCode(request.script, page);
                 // LIFECYCLE: Call afterEndTest on success
                 if (this.progressReporter?.afterEndTest) {
                     await this.progressReporter.afterEndTest('passed', undefined, page);
@@ -243,7 +250,7 @@ class ExecutionService {
                     await this.progressReporter.beforeStartTest(page, browser, context);
                 }
                 // Execute the script as-is
-                await this.executeScriptContent(request.script, page);
+                await this.executeStepCode(request.script, page);
                 // LIFECYCLE: Call afterEndTest on success
                 if (this.progressReporter?.afterEndTest) {
                     await this.progressReporter.afterEndTest('passed', undefined, page);
@@ -315,8 +322,11 @@ class ExecutionService {
         }
         // Start AI repair process
         this.log('Starting AI repair process...');
+        let repairBrowser = null;
+        let repairContext = null;
+        let repairPage = null;
         try {
-            let repairBrowser, repairContext, repairPage, steps, updatedSteps;
+            let steps, updatedSteps;
             if (useExistingBrowser) {
                 // Use existing browser
                 this.log('Using existing browser for AI repair...');
@@ -376,8 +386,8 @@ class ExecutionService {
                 this.log('Starting AI repair with parsed steps...');
                 updatedSteps = await this.repairStepsWithAI(steps, repairPage, repairFlexibility, model, request.jobId);
             }
-            // Always generate the updated script
-            const updatedScript = this.generateUpdatedScript(updatedSteps);
+            // Always generate the updated script (preserve original test name)
+            const updatedScript = this.generateUpdatedScript(updatedSteps, undefined, request.script);
             // Check if repair was successful by seeing if we completed all steps
             const allStepsSuccessful = updatedSteps.length > 0 && updatedSteps.every(step => step.success);
             // Check if we have any successful repairs (partial success)
@@ -392,10 +402,29 @@ class ExecutionService {
             });
             // Update file if we have any successful repairs (partial or complete)
             if (hasSuccessfulRepairs) {
+                // IMPORTANT: Use the orchestrator-generated script directly (already has proper Playwright commands)
+                // Don't regenerate via LLM as it loses the actual repairs
+                this.log('Using orchestrator-generated script (skipping LLM regeneration to preserve repairs)');
+                // For repair advice, compare original vs repaired
                 const confidenceResponse = await this.llmFacade.assessRepairConfidence(request.script, updatedScript, model);
-                const finalScript = await this.llmFacade.generateFinalScript(request.script, updatedScript, confidenceResponse.advice, model);
-                // Ensure the final script has the correct TestChimp comment format with repair advice
-                const scriptWithRepairAdvice = (0, script_utils_1.addTestChimpComment)(finalScript, confidenceResponse.advice);
+                // Add TestChimp comment with repair advice
+                const scriptWithAdvice = (0, script_utils_1.addTestChimpComment)(updatedScript, confidenceResponse.advice);
+                // Polish the script with minor LLM cleanup (removes redundancies, fixes formatting)
+                this.log('Applying final LLM polish to repaired script (minor cleanup only)...');
+                const cleanupResult = await this.llmFacade.cleanupScript(scriptWithAdvice, model);
+                if (cleanupResult.changes.length > 0) {
+                    this.log(`Script cleanup made ${cleanupResult.changes.length} minor improvements:`);
+                    cleanupResult.changes.forEach((change, i) => {
+                        this.log(`  ${i + 1}. ${change}`);
+                    });
+                }
+                else if (cleanupResult.skipped) {
+                    this.log(`Script cleanup skipped: ${cleanupResult.skipped}`);
+                }
+                else {
+                    this.log('Script cleanup: no changes needed');
+                }
+                const scriptWithRepairAdvice = cleanupResult.script;
                 // Report credit usage for successful AI repair
                 this.creditUsageService.reportAIRepairCredit().catch(error => {
                     this.log(`Failed to report credit usage for AI repair: ${error}`, 'warn');
@@ -409,10 +438,6 @@ class ExecutionService {
                         this.log(`afterEndTest callback failed: ${callbackError}`, 'warn');
                     }
                 }
-                // Only close browser if we created it (not provided by caller)
-                if (!useExistingBrowser) {
-                    await repairBrowser.close();
-                }
                 return {
                     runStatus: 'failed', // Original script failed
                     repairStatus: allStepsSuccessful ? 'success' : 'partial', // Complete or partial repair success
@@ -434,10 +459,6 @@ class ExecutionService {
                         this.log(`afterEndTest callback failed: ${callbackError}`, 'warn');
                     }
                 }
-                // Only close browser if we created it (not provided by caller)
-                if (!useExistingBrowser) {
-                    await repairBrowser.close();
-                }
                 return {
                     runStatus: 'failed', // Original script failed
                     repairStatus: 'failed',
@@ -459,6 +480,18 @@ class ExecutionService {
                 error: error instanceof Error ? error.message : 'Script execution failed'
             };
         }
+        finally {
+            // Clean up browser resources if we created them (not provided by caller)
+            if (!useExistingBrowser && repairBrowser) {
+                try {
+                    await repairBrowser.close();
+                    this.log('AI repair browser closed');
+                }
+                catch (closeError) {
+                    this.log(`Error closing AI repair browser: ${closeError}`, 'warn');
+                }
+            }
+        }
     }
     async parseScriptIntoSteps(script, model) {
         // First try LLM-based parsing
@@ -520,6 +553,8 @@ class ExecutionService {
         let updatedSteps = [...steps];
         const maxTries = 3;
         const recentRepairs = [];
+        // Track actual executed steps (including agent repairs) for proper history
+        const executedStepDescriptions = [];
         // Create a shared execution context that accumulates all executed code for variable tracking
         let executionContext = '';
         const contextVariables = new Map();
@@ -544,6 +579,8 @@ class ExecutionService {
                 step.success = true;
                 this.log(`Step ${i + 1} executed successfully: ${step.description}`);
                 this.log(`Step ${i + 1} success status set to: ${step.success}`);
+                // Track executed step description for agent context
+                executedStepDescriptions.push(step.description);
                 // Report successful step execution
                 this.log(`DEBUG: About to check callback - progressReporter=${!!this.progressReporter}, onStepProgress=${!!this.progressReporter?.onStepProgress}, jobId=${jobId}`);
                 if (this.progressReporter?.onStepProgress && jobId) {
@@ -575,234 +612,98 @@ class ExecutionService {
                 }
                 step.success = false;
                 step.error = this.safeSerializeError(error);
-                // Try multiple repair attempts
-                const repairHistory = [];
+                // Use orchestrator for repair (reuses all SoM infrastructure)
+                this.log(`Calling orchestrator in REPAIR mode for step ${i + 1}`);
+                // Prepare repair context - use executedStepDescriptions (includes agent repairs)
+                const priorSteps = executedStepDescriptions; // What was ACTUALLY executed (scripted + agent)
+                const nextSteps = updatedSteps.slice(i + 1).map(s => s.description);
+                this.log(`  Prior steps executed: ${priorSteps.length}, Next steps: ${nextSteps.length}`);
+                this.log(`  Prior steps context:\n    ${priorSteps.map((s, idx) => `${idx + 1}. ${s}`).join('\n    ')}`);
+                // Create minimal memory for repair
+                const memory = {
+                    experiences: [],
+                    extractedData: {},
+                    history: [],
+                    latestNote: undefined
+                };
                 let repairSuccess = false;
-                const originalDescription = step.description;
-                const originalCode = step.code;
-                let usedVisionMode = false;
-                for (let attempt = 1; attempt <= maxTries; attempt++) {
-                    this.log(`Step ${i + 1} repair attempt ${attempt}/${maxTries}`);
-                    // Get current page state for AI repair
-                    const pageInfo = await this.getEnhancedPageInfo(page);
-                    // Build failure history for LLM context
-                    const failureHistory = this.buildFailureHistory(repairHistory, step, error);
-                    // Build recent repairs context for LLM
-                    const recentRepairsContext = this.buildRecentRepairsContext(recentRepairs);
-                    let repairSuggestion;
-                    // VISION-BASED FALLBACK: After 2 regular repair attempts, consider vision diagnostics on final attempt
-                    if (attempt === maxTries - 1 && repairHistory.length >= 2 && !usedVisionMode) {
-                        // Ask LLM if screenshot would help for repair diagnostics
-                        this.log(`  🤔 After ${repairHistory.length} failed repairs: Asking LLM if screenshot would help (last resort)...`);
-                        const screenshotNeed = await this.llmFacade.assessScreenshotNeed(step.description, step.error || 'Unknown error', repairHistory.length + 1, pageInfo, model);
-                        this.log(`  💭 LLM assessment: ${screenshotNeed.needsScreenshot ? 'SCREENSHOT NEEDED' : 'NO SCREENSHOT'} - ${screenshotNeed.reason}`);
-                        if (screenshotNeed.needsScreenshot) {
-                            // Two-step supervisor pattern for vision-based repair:
-                            // 1. Supervisor analyzes screenshot and provides diagnostic insights
-                            // 2. Get repair suggestion with enhanced context from vision analysis
-                            this.log(`  📸 Taking screenshot for supervisor analysis...`);
-                            // Capture optimized screenshot using utility method
-                            const imageDataUrl = await (0, browser_utils_1.captureOptimizedScreenshot)(page, { timeout: 10000 }, // Uses default quality 60
-                            (msg) => this.log(msg));
-                            this.log(`  👔 STEP 1: Supervisor analyzing screenshot (${model_constants_1.VISION_MODEL})...`);
-                            const supervisorDiagnostics = await this.llmFacade.getVisionDiagnostics(step.description, pageInfo, [], // No previous steps context for repair
-                            step.error, imageDataUrl, model_constants_1.VISION_MODEL);
-                            // DEBUG: Log vision diagnostics
-                            this.log(`  📸 Visual insights: ${supervisorDiagnostics.visualAnalysis}`);
-                            this.log(`  🔍 Root cause: ${supervisorDiagnostics.rootCause}`);
-                            this.log(`  💡 Recommended approach: ${supervisorDiagnostics.recommendedApproach}`);
-                            if (supervisorDiagnostics.elementsFound.length > 0) {
-                                this.log(`  ✅ Elements found: ${supervisorDiagnostics.elementsFound.join(', ')}`);
-                            }
-                            if (supervisorDiagnostics.elementsNotFound.length > 0) {
-                                this.log(`  ❌ Elements not found: ${supervisorDiagnostics.elementsNotFound.join(', ')}`);
-                            }
-                            // Get repair suggestion with vision-enhanced context
-                            this.log(`  🔨 STEP 2: Getting repair suggestion with vision insights...`);
-                            const visionEnhancedFailureHistory = `${failureHistory}
-
-VISION-BASED DIAGNOSTIC INSIGHTS:
-Visual Analysis: ${supervisorDiagnostics.visualAnalysis}
-Root Cause: ${supervisorDiagnostics.rootCause}
-Recommended Approach: ${supervisorDiagnostics.recommendedApproach}
-Elements Found: ${supervisorDiagnostics.elementsFound.join(', ') || 'None'}
-Elements Not Found: ${supervisorDiagnostics.elementsNotFound.join(', ') || 'None'}
-
-Use these vision insights to inform your repair strategy.`;
-                            repairSuggestion = await this.llmFacade.getRepairSuggestion(step.description, step.code, step.error || 'Unknown error', pageInfo, visionEnhancedFailureHistory, recentRepairsContext, model);
-                            usedVisionMode = true;
-                        }
-                        else {
-                            // Regular repair without vision
-                            if (screenshotNeed.alternativeApproach) {
-                                this.log(`  💡 Alternative approach: ${screenshotNeed.alternativeApproach}`);
-                            }
-                            repairSuggestion = await this.llmFacade.getRepairSuggestion(step.description, step.code, step.error || 'Unknown error', pageInfo, failureHistory, recentRepairsContext, model);
-                        }
-                    }
-                    else {
-                        // Regular repair attempt (first 2 attempts or already used vision)
-                        repairSuggestion = await this.llmFacade.getRepairSuggestion(step.description, step.code, step.error || 'Unknown error', pageInfo, failureHistory, recentRepairsContext, model);
-                    }
-                    if (!repairSuggestion.shouldContinue) {
-                        this.log(`AI decided to stop repair at attempt ${attempt}: ${repairSuggestion.reason}`);
-                        break;
-                    }
-                    // Apply the repair action
-                    try {
-                        // Set the step index and insertAfterIndex on the client side based on current step being processed
-                        const repairAction = {
-                            ...repairSuggestion.action,
-                            stepIndex: i, // Client-side step index management
-                            insertAfterIndex: repairSuggestion.action.operation === types_1.StepOperation.INSERT ? i - 1 : undefined // For INSERT, insert before current step
+                try {
+                    // Call orchestrator with repair context (page object persisted)
+                    const repairResult = await this.orchestratorAgent.executeStep(page, // Same page object (persisted state)
+                    step.description, // Goal with testdata embedded
+                    i + 1, // Current step number
+                    updatedSteps.length, // Total steps
+                    updatedSteps.map(s => s.description), // All step descriptions
+                    memory, // Memory (empty for repair)
+                    jobId || 'repair', priorSteps, // NEW: What was already completed
+                    nextSteps // NEW: What comes after this
+                    );
+                    if (repairResult.success && repairResult.commands.length > 0) {
+                        // MODIFY: Orchestrator fixed the step - replace with new code
+                        const repairedCode = repairResult.commands.join('\n');
+                        updatedSteps[i] = {
+                            ...step,
+                            code: repairedCode,
+                            success: true,
+                            error: undefined
                         };
-                        this.log(`🔧 Applying repair action: ${repairAction.operation} on step ${repairAction.stepIndex}`);
-                        this.log(`🔧 Steps array before repair: ${updatedSteps.map((s, idx) => `${idx}: "${s.description}" (success: ${s.success})`).join(', ')}`);
-                        const result = await this.applyRepairActionInContext(repairAction, updatedSteps, i, page, executionContext, contextVariables);
-                        if (result.success) {
-                            repairSuccess = true;
-                            this.log(`🔧 Steps array after repair: ${updatedSteps.map((s, idx) => `${idx}: "${s.description}" (success: ${s.success})`).join(', ')}`);
-                            // Mark the appropriate step(s) as successful based on operation type
-                            if (repairAction.operation === types_1.StepOperation.MODIFY) {
-                                // For MODIFY: mark the modified step as successful
-                                step.success = true;
-                                step.error = undefined;
-                                updatedSteps[i].success = true;
-                                updatedSteps[i].error = undefined;
-                                this.log(`Step ${i + 1} marked as successful after MODIFY repair`);
-                                // Report repaired step
-                                if (this.progressReporter?.onStepProgress && jobId) {
-                                    this.log(`DEBUG: Reporting repaired step ${i + 1}:`);
-                                    this.log(`  description: ${updatedSteps[i].description}`);
-                                    this.log(`  code: ${updatedSteps[i].code}`);
-                                    await this.progressReporter.onStepProgress({
-                                        jobId,
-                                        stepId: updatedSteps[i].id, // Preserve original step ID if provided
-                                        stepNumber: i + 1,
-                                        description: updatedSteps[i].description,
-                                        code: updatedSteps[i].code,
-                                        status: 'SUCCESS_STEP_EXECUTION',
-                                        wasRepaired: true
-                                    });
-                                }
-                            }
-                            else if (repairAction.operation === types_1.StepOperation.INSERT) {
-                                // For INSERT: mark the newly inserted step as successful
-                                const insertIndex = repairAction.insertAfterIndex !== undefined ? repairAction.insertAfterIndex + 1 : i + 1;
-                                if (updatedSteps[insertIndex]) {
-                                    updatedSteps[insertIndex].success = true;
-                                    updatedSteps[insertIndex].error = undefined;
-                                    // Report inserted step
-                                    if (this.progressReporter?.onStepProgress && jobId) {
-                                        await this.progressReporter.onStepProgress({
-                                            jobId,
-                                            stepId: updatedSteps[insertIndex].id, // Preserve original step ID if provided
-                                            stepNumber: insertIndex + 1,
-                                            description: updatedSteps[insertIndex].description,
-                                            code: updatedSteps[insertIndex].code,
-                                            status: 'SUCCESS_STEP_EXECUTION',
-                                            wasRepaired: true
-                                        });
-                                    }
-                                }
-                            }
-                            else if (repairAction.operation === types_1.StepOperation.REMOVE) {
-                                // For REMOVE: no step to mark as successful since we removed it
-                                // The step is already removed from the array
-                            }
-                            const commandInfo = repairAction.operation === types_1.StepOperation.MODIFY ?
-                                `MODIFY: "${repairAction.newStep?.code || 'N/A'}"` :
-                                repairAction.operation === types_1.StepOperation.INSERT ?
-                                    `INSERT: "${repairAction.newStep?.code || 'N/A'}"` :
-                                    repairAction.operation === types_1.StepOperation.REMOVE ?
-                                        `REMOVE: step at index ${repairAction.stepIndex}` :
-                                        repairAction.operation;
-                            this.log(`Step ${i + 1} repair action ${commandInfo} executed successfully on attempt ${attempt}${usedVisionMode ? ' (vision-aided)' : ''}`);
-                            // Update execution context based on the repair action
-                            if (repairAction.operation === types_1.StepOperation.MODIFY && repairAction.newStep) {
-                                // Update the step in the execution context for variable tracking
-                                executionContext = executionContext.replace(originalCode, repairAction.newStep.code);
-                            }
-                            else if (repairAction.operation === types_1.StepOperation.INSERT && repairAction.newStep) {
-                                // Insert the new step code into execution context for variable tracking
-                                executionContext += repairAction.newStep.code + '\n';
-                            }
-                            else if (repairAction.operation === types_1.StepOperation.REMOVE) {
-                                // Remove the step code from execution context for variable tracking
-                                executionContext = executionContext.replace(originalCode, '');
-                            }
-                            // Record this successful repair
-                            recentRepairs.push({
+                        this.log(`✓ Step ${i + 1} MODIFIED by orchestrator (repair successful)`);
+                        this.log(`  Original code: ${step.code}`);
+                        this.log(`  New code (${repairResult.commands.length} commands):\n    ${repairResult.commands.join('\n    ')}`);
+                        // Track what agent actually did in history (for future repair context)
+                        const agentActionSummary = `${step.description} [AI-repaired: ${repairResult.commands.length} commands]`;
+                        executedStepDescriptions.push(agentActionSummary);
+                        // Report repaired step
+                        if (this.progressReporter?.onStepProgress && jobId) {
+                            await this.progressReporter.onStepProgress({
+                                jobId,
+                                stepId: step.id,
                                 stepNumber: i + 1,
-                                operation: repairAction.operation,
-                                originalDescription: repairAction.operation === types_1.StepOperation.REMOVE ? originalDescription : undefined,
-                                newDescription: repairAction.newStep?.description,
-                                originalCode: repairAction.operation === types_1.StepOperation.REMOVE ? originalCode : undefined,
-                                newCode: repairAction.newStep?.code
+                                description: updatedSteps[i].description,
+                                code: updatedSteps[i].code,
+                                status: 'SUCCESS_STEP_EXECUTION',
+                                wasRepaired: true
                             });
-                            // Keep only the last 3 repairs for context
-                            if (recentRepairs.length > 3) {
-                                recentRepairs.shift();
-                            }
-                            // Update step index based on operation
-                            if (repairAction.operation === types_1.StepOperation.INSERT) {
-                                // For INSERT: inserted step is already executed
-                                this.log(`INSERT operation: current i=${i}, insertAfterIndex=${repairAction.insertAfterIndex}`);
-                                this.log(`INSERT: Steps array length before: ${updatedSteps.length}`);
-                                this.log(`INSERT: Steps before operation: ${updatedSteps.map((s, idx) => `${idx}: "${s.description}" (success: ${s.success})`).join(', ')}`);
-                                if (repairAction.insertAfterIndex !== undefined && repairAction.insertAfterIndex < i) {
-                                    // If inserting before current position, current step moved down by 1
-                                    this.log(`INSERT before current position: incrementing i from ${i} to ${i + 1}`);
-                                    i++; // Move to the original step that was pushed to the next position
-                                }
-                                else {
-                                    // If inserting at or after current position, stay at current step
-                                    this.log(`INSERT at/after current position: keeping i at ${i}`);
-                                }
-                                this.log(`INSERT: Steps array length after: ${updatedSteps.length}`);
-                                this.log(`INSERT: Steps after operation: ${updatedSteps.map((s, idx) => `${idx}: "${s.description}" (success: ${s.success})`).join(', ')}`);
-                            }
-                            else if (repairAction.operation === types_1.StepOperation.REMOVE) {
-                                // For REMOVE: stay at same index since the next step moved to current position
-                                // Don't increment i because the array shifted left
+                        }
+                        // Ensure page is stable after agent repairs before returning control to script
+                        this.log(`Waiting for page stability after agent repair...`);
+                        try {
+                            await page.waitForLoadState('networkidle', { timeout: 5000 });
+                            this.log(`Page stabilized (networkidle) after agent repair`);
+                        }
+                        catch (stabilityError) {
+                            try {
+                                await page.waitForLoadState('domcontentloaded', { timeout: 3000 });
+                                this.log(`Page loaded (domcontentloaded) after agent repair`);
                             }
-                            else {
-                                // For MODIFY: move to next step since modified step was executed
-                                i++; // Move to next step for MODIFY
+                            catch (fallbackError) {
+                                this.log(`Page stability wait timed out (continuing anyway)`, 'warn');
                             }
-                            // Add the repaired step's code to execution context for variable tracking
-                            executionContext += step.code + '\n';
-                            break;
-                        }
-                        else {
-                            throw new Error(result.error || 'Repair action failed');
                         }
+                        repairSuccess = true;
+                        i++; // Continue to NEXT step (hand control back to script)
                     }
-                    catch (repairError) {
-                        const repairErrorMessage = repairError instanceof Error ? repairError.message : 'Repair failed';
-                        const commandInfo = repairSuggestion.action.operation === types_1.StepOperation.MODIFY ?
-                            `MODIFY: "${repairSuggestion.action.newStep?.code || 'N/A'}"` :
-                            repairSuggestion.action.operation === types_1.StepOperation.INSERT ?
-                                `INSERT: "${repairSuggestion.action.newStep?.code || 'N/A'}"` :
-                                repairSuggestion.action.operation === types_1.StepOperation.REMOVE ?
-                                    `REMOVE: step at index ${repairSuggestion.action.stepIndex}` :
-                                    repairSuggestion.action.operation;
-                        this.log(`Step ${i + 1} repair attempt ${attempt} failed (${commandInfo}): ${repairErrorMessage}`);
-                        if (repairError instanceof Error && repairError.stack) {
-                            this.log(`  Repair stack trace: ${repairError.stack}`);
-                        }
-                        // Record this attempt in history
-                        repairHistory.push({
-                            attempt,
-                            action: repairSuggestion.action,
-                            error: repairErrorMessage,
-                            pageInfo
-                        });
-                        step.error = repairErrorMessage;
+                    else if (repairResult.success && repairResult.commands.length === 0) {
+                        // DELETE: Step goal already achieved or no longer needed (e.g., modal already dismissed)
+                        this.log(`✓ Step ${i + 1} DELETED by orchestrator (goal already achieved, step obsolete)`);
+                        this.log(`  Reason: Orchestrator completed with 0 commands - step no longer needed`);
+                        // Track deletion in history (helps agent understand what was skipped)
+                        executedStepDescriptions.push(`${step.description} [AI-deleted: step obsolete/already done]`);
+                        // Remove the step from array
+                        updatedSteps.splice(i, 1);
+                        repairSuccess = true;
+                        // Don't increment i - next step moved to current position
                     }
+                    else {
+                        this.log(`✗ Step ${i + 1} could not be repaired by orchestrator (reason: ${repairResult.terminationReason})`);
+                    }
+                }
+                catch (repairError) {
+                    this.log(`✗ Orchestrator repair failed: ${repairError.message}`);
                 }
+                // Legacy repair code removed - now using orchestrator
                 if (!repairSuccess) {
-                    this.log(`Step ${i + 1} failed after ${maxTries} repair attempts`);
+                    this.log(`Step ${i + 1} could not be repaired - stopping execution`);
                     break;
                 }
             }
@@ -845,244 +746,30 @@ Use these vision insights to inform your repair strategy.`;
         }
         return code; // Return the original code without removing comments
     }
-    async executeStepInContext(code, page, executionContext, contextVariables) {
-        // Detect if code contains navigation or load state operations that need longer timeout
-        const needsLongerTimeout = code.includes('waitForLoadState') ||
-            code.includes('goto(') ||
-            code.includes('waitForURL') ||
-            code.includes('waitForNavigation');
-        // Use appropriate timeout based on operation type
-        const timeout = needsLongerTimeout ? 30000 : 5000;
-        page.setDefaultTimeout(timeout);
-        try {
-            // Execute only the current step code, but make context variables available
-            const fullCode = code;
-            // Dynamically import expect
-            const { expect } = require('@playwright/test');
-            // Create a function that has access to page, expect, and the context variables
-            const executeCode = new Function('page', 'expect', 'contextVariables', `return (async () => { 
-        // Make context variables available in the execution scope
-        for (const [key, value] of contextVariables) {
-          globalThis[key] = value;
-        }
-        
-        ${fullCode}
-        
-        // Capture any new variables that might have been created
-        const newVars = {};
-        for (const key in globalThis) {
-          if (!contextVariables.has(key) && typeof globalThis[key] !== 'function' && key !== 'page' && key !== 'expect') {
-            newVars[key] = globalThis[key];
-          }
-        }
-        return newVars;
-      })()`);
-            const newVars = await executeCode(page, expect, contextVariables);
-            // Update the context variables with any new variables created
-            for (const [key, value] of Object.entries(newVars)) {
-                contextVariables.set(key, value);
-            }
-        }
-        finally {
-            // Reset to default timeout for element operations
-            page.setDefaultTimeout(5000);
-        }
-    }
-    async executeScriptContent(script, page) {
-        // Extract the test function content
-        const testMatch = script.match(/test\([^,]+,\s*async\s*\(\s*\{\s*page[^}]*\}\s*\)\s*=>\s*\{([\s\S]*)\}\s*\);/);
-        if (!testMatch) {
-            throw new Error('Could not extract test function from script');
-        }
-        const testBody = testMatch[1];
-        // Dynamically import expect
-        const { expect } = require('@playwright/test');
-        // Execute the entire test body as one async function
-        const executeTest = new Function('page', 'expect', `return (async () => { ${testBody} })()`);
-        await executeTest(page, expect);
+    // Legacy repair helper methods (now unused but kept for compilation)
+    buildFailureHistory() { return ''; }
+    buildRecentRepairsContext() { return ''; }
+    async applyRepairActionInContext() {
+        return { success: false };
     }
-    async getEnhancedPageInfo(page) {
-        try {
-            return await (0, page_info_utils_1.getEnhancedPageInfo)(page);
-        }
-        catch (error) {
-            return {
-                url: page.url(),
-                title: 'Unknown',
-                ariaSnapshot: null,
-                interactiveElements: [],
-                formattedElements: 'Unable to extract'
-            };
-        }
-    }
-    buildFailureHistory(repairHistory, originalStep, originalError) {
-        if (repairHistory.length === 0) {
-            return `Original failure: ${this.safeSerializeError(originalError)}`;
-        }
-        let history = `Original failure: ${this.safeSerializeError(originalError)}\n\n`;
-        history += `Previous repair attempts:\n`;
-        repairHistory.forEach((attempt, index) => {
-            history += `Attempt ${attempt.attempt}:\n`;
-            history += `  Operation: ${attempt.action.operation}\n`;
-            if (attempt.action.newStep) {
-                history += `  Description: ${attempt.action.newStep.description}\n`;
-                history += `  Code: ${attempt.action.newStep.code}\n`;
+    generateUpdatedScript(steps, repairAdvice, originalScript) {
+        // Extract test name and hashtags from original script if provided
+        let testName = 'repairedTest';
+        let hashtags = [];
+        if (originalScript) {
+            const testNameMatch = originalScript.match(/test\(['"]([^'"]+)['"]/);
+            if (testNameMatch) {
+                testName = testNameMatch[1];
             }
-            history += `  Error: ${attempt.error}\n`;
-            if (index < repairHistory.length - 1) {
-                history += `\n`;
+            // Extract hashtags from TestChimp comment
+            const hashtagMatch = originalScript.match(/#\w+(?:\s+#\w+)*/);
+            if (hashtagMatch) {
+                hashtags = hashtagMatch[0].split(/\s+/).filter(tag => tag.startsWith('#'));
             }
-        });
-        return history;
-    }
-    buildRecentRepairsContext(recentRepairs) {
-        if (recentRepairs.length === 0) {
-            return 'No recent repairs to consider.';
         }
-        let context = 'Recent successful repairs that may affect this step:\n\n';
-        recentRepairs.forEach((repair, index) => {
-            context += `Step ${repair.stepNumber} was successfully repaired:\n`;
-            context += `  Operation: ${repair.operation}\n`;
-            if (repair.operation === 'REMOVE') {
-                context += `  Removed: "${repair.originalDescription}"\n`;
-                context += `  Code removed:\n    ${repair.originalCode?.replace(/\n/g, '\n    ')}\n`;
-            }
-            else if (repair.operation === 'INSERT') {
-                context += `  Inserted: "${repair.newDescription}"\n`;
-                context += `  Code inserted:\n    ${repair.newCode?.replace(/\n/g, '\n    ')}\n`;
-            }
-            else {
-                context += `  Original: "${repair.originalDescription}"\n`;
-                context += `  Repaired: "${repair.newDescription}"\n`;
-                context += `  Code changed from:\n    ${repair.originalCode?.replace(/\n/g, '\n    ')}\n`;
-                context += `  To:\n    ${repair.newCode?.replace(/\n/g, '\n    ')}\n`;
-            }
-            if (index < recentRepairs.length - 1) {
-                context += `\n`;
-            }
-        });
-        context += '\nConsider how these changes might affect the current step and adjust accordingly.';
-        return context;
-    }
-    async applyRepairActionInContext(action, steps, currentIndex, page, executionContext, contextVariables) {
-        try {
-            switch (action.operation) {
-                case types_1.StepOperation.MODIFY:
-                    if (action.newStep && action.stepIndex !== undefined) {
-                        // Modify existing step
-                        steps[action.stepIndex] = {
-                            ...action.newStep,
-                            success: false,
-                            error: undefined
-                        };
-                        // Test the modified step with current page state and variables
-                        await this.executeStepCode(action.newStep.code, page);
-                        return { success: true, updatedContext: executionContext + action.newStep.code };
-                    }
-                    break;
-                case types_1.StepOperation.INSERT:
-                    if (action.newStep && action.insertAfterIndex !== undefined) {
-                        // Insert new step after specified index
-                        const insertIndex = action.insertAfterIndex + 1;
-                        const newStep = {
-                            ...action.newStep,
-                            success: false,
-                            error: undefined
-                        };
-                        this.log(`INSERT: Inserting step at index ${insertIndex} with description "${newStep.description}"`);
-                        this.log(`INSERT: Steps before insertion: ${steps.map((s, i) => `${i}: "${s.description}" (success: ${s.success})`).join(', ')}`);
-                        // Preserve success status of existing steps before insertion
-                        const successStatusMap = new Map(steps.map((step, index) => [index, { success: step.success, error: step.error }]));
-                        steps.splice(insertIndex, 0, newStep);
-                        // Restore success status for steps that were shifted by the insertion
-                        // Steps at insertIndex and before keep their original status
-                        // Steps after insertIndex need to be shifted to their new positions
-                        for (let i = insertIndex + 1; i < steps.length; i++) {
-                            const originalIndex = i - 1; // The step that was originally at this position
-                            if (successStatusMap.has(originalIndex)) {
-                                const status = successStatusMap.get(originalIndex);
-                                steps[i].success = status.success;
-                                steps[i].error = status.error;
-                            }
-                        }
-                        // CRITICAL FIX: Ensure the inserted step doesn't overwrite existing step data
-                        // The new step should only have its own description, not inherit from existing steps
-                        this.log(`INSERT: Final step array after restoration: ${steps.map((s, i) => `${i}: "${s.description}" (success: ${s.success})`).join(', ')}`);
-                        this.log(`INSERT: Steps after insertion: ${steps.map((s, i) => `${i}: "${s.description}" (success: ${s.success})`).join(', ')}`);
-                        // Test the new step with current page state
-                        await this.executeStepCode(action.newStep.code, page);
-                        return { success: true, updatedContext: executionContext + action.newStep.code };
-                    }
-                    break;
-                case types_1.StepOperation.REMOVE:
-                    if (action.stepIndex !== undefined) {
-                        // Remove step
-                        steps.splice(action.stepIndex, 1);
-                        return { success: true, updatedContext: executionContext };
-                    }
-                    break;
-            }
-            return { success: false, error: 'Invalid repair action' };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error during repair action'
-            };
-        }
-    }
-    async applyRepairAction(action, steps, currentIndex, page) {
-        try {
-            switch (action.operation) {
-                case types_1.StepOperation.MODIFY:
-                    if (action.newStep && action.stepIndex !== undefined) {
-                        // Modify existing step
-                        steps[action.stepIndex] = {
-                            ...action.newStep,
-                            success: false,
-                            error: undefined
-                        };
-                        // Test the modified step
-                        await this.executeStepCode(action.newStep.code, page);
-                        return { success: true };
-                    }
-                    break;
-                case types_1.StepOperation.INSERT:
-                    if (action.newStep && action.insertAfterIndex !== undefined) {
-                        // Insert new step after specified index
-                        const insertIndex = action.insertAfterIndex + 1;
-                        const newStep = {
-                            ...action.newStep,
-                            success: false,
-                            error: undefined
-                        };
-                        steps.splice(insertIndex, 0, newStep);
-                        // Test the inserted step
-                        await this.executeStepCode(action.newStep.code, page);
-                        return { success: true };
-                    }
-                    break;
-                case types_1.StepOperation.REMOVE:
-                    if (action.stepIndex !== undefined) {
-                        // Remove the step
-                        steps.splice(action.stepIndex, 1);
-                        return { success: true };
-                    }
-                    break;
-            }
-            return { success: false, error: 'Invalid repair action' };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Repair action execution failed'
-            };
-        }
-    }
-    generateUpdatedScript(steps, repairAdvice) {
         const scriptLines = [
             "import { test, expect } from '@playwright/test';",
-            `test('repairedTest', async ({ page, browser, context }) => {`
+            `test('${testName}', async ({ page, browser, context }) => {`
         ];
         steps.forEach((step, index) => {
             // Only add step if it has code to execute
@@ -1096,8 +783,8 @@ Use these vision insights to inform your repair strategy.`;
         });
         scriptLines.push('});');
         const script = scriptLines.join('\n');
-        // Add TestChimp comment to the repaired script with repair advice
-        return (0, script_utils_1.addTestChimpComment)(script, repairAdvice);
+        // Add TestChimp comment with hashtags and repair advice
+        return (0, script_utils_1.addTestChimpComment)(script, repairAdvice, hashtags);
     }
     /**
      * Initialize browser with configuration (delegates to utility function)