testchimp-runner-core 0.0.34 → 0.0.36

package/src/orchestrator/orchestrator-agent.ts

@@ -1,862 +0,0 @@
-/**
- * Orchestrator Agent
- * Single agent with tool-use capabilities that maintains journey memory and executes scenarios
- */
-
-import { expect } from '@playwright/test';
-import { LLMFacade } from '../llm-facade';
-import { ProgressReporter, TokenUsage, StepExecutionStatus } from '../progress-reporter';
-import { getEnhancedPageInfo } from '../utils/page-info-utils';
-import { CoordinateConverter } from '../utils/coordinate-converter';
-import { ToolRegistry, ToolExecutionContext } from './tool-registry';
-import { DEFAULT_MODEL } from '../model-constants';
-import {
-  AgentConfig,
-  AgentContext,
-  AgentDecision,
-  JourneyMemory,
-  MemoryStep,
-  OrchestratorStepResult,
-  SelfReflection,
-  NoteToFutureSelf,
-  CoordinateAction,
-  DEFAULT_AGENT_CONFIG
-} from './types';
-import { OrchestratorPrompts } from './orchestrator-prompts';
-
-/**
- * Orchestrator Agent - manages step execution with tool use and memory
- */
-export class OrchestratorAgent {
-  private llmFacade: LLMFacade;
-  private toolRegistry: ToolRegistry;
-  private progressReporter?: ProgressReporter;
-  private config: Required<AgentConfig>;
-  private logger?: (message: string, level?: 'log' | 'error' | 'warn' | 'debug') => void;
-  private debugMode: boolean = false;
-  
-  constructor(
-    llmFacade: LLMFacade,
-    toolRegistry: ToolRegistry,
-    config?: Partial<AgentConfig>,
-    progressReporter?: ProgressReporter,
-    logger?: (message: string, level?: 'log' | 'error' | 'warn' | 'debug') => void,
-    debugMode?: boolean
-  ) {
-    this.llmFacade = llmFacade;
-    this.toolRegistry = toolRegistry;
-    this.config = { ...DEFAULT_AGENT_CONFIG, ...config };
-    this.progressReporter = progressReporter;
-    this.logger = logger;
-    this.debugMode = debugMode || false;
-  }
-  
-  setDebugMode(enabled: boolean): void {
-    this.debugMode = enabled;
-  }
-  
-  /**
-   * Execute a single step of the scenario
-   */
-  async executeStep(
-    page: any,
-    stepDescription: string,
-    stepNumber: number,
-    totalSteps: number,
-    scenarioSteps: string[],
-    memory: JourneyMemory,
-    jobId: string
-  ): Promise<OrchestratorStepResult> {
-    this.logger?.(`\n[Orchestrator] ========== STEP ${stepNumber}/${totalSteps} ==========`);
-    this.logger?.(`[Orchestrator] 🎯 Goal: ${stepDescription}`);
-    
-    let iteration = 0;
-    let previousReflection: SelfReflection | undefined = undefined;
-    let noteToSelf: NoteToFutureSelf | undefined = memory.latestNote;  // Start with note from previous step
-    const commandsExecuted: string[] = [];
-    let consecutiveFailures = 0;  // Track consecutive iterations with failed commands
-    let coordinateAttempts = 0;  // Track coordinate mode attempts (max 2)
-    
-    while (iteration < this.config.maxIterationsPerStep) {
-      iteration++;
-      
-      this.logger?.(`\n[Orchestrator] === Iteration ${iteration}/${this.config.maxIterationsPerStep} ===`);
-      
-      // Build context for agent
-      const context = await this.buildAgentContext(
-        page,
-        stepDescription,
-        stepNumber,
-        totalSteps,
-        scenarioSteps,
-        memory,
-        previousReflection,
-        consecutiveFailures,
-        noteToSelf  // NEW: Pass note from previous iteration
-      );
-      
-      // Call agent to make decision
-      const decision = await this.callAgent(
-        context,
-        jobId,
-        stepNumber,
-        iteration,
-        consecutiveFailures
-      );
-      
-      // Log agent's reasoning
-      this.logAgentDecision(decision, iteration);
-      
-      // Report progress
-      await this.reportStepProgress(jobId, stepNumber, stepDescription, decision, iteration);
-      
-      // Execute tools if requested (tools are READ-ONLY, they don't change state)
-      let toolResults: Record<string, any> = {};
-      
-      // ANTI-LOOP: Detect if agent is taking screenshots repeatedly without acting
-      const recentScreenshots = memory.history.slice(-3).filter(s => 
-        s.code.includes('take_screenshot') || s.action.includes('Screenshot')
-      );
-      if (recentScreenshots.length >= 2 && iteration >= 3) {
-        this.logger?.(`[Orchestrator] ⚠️  WARNING: ${recentScreenshots.length} screenshots in last 3 iterations - agent may be looping`, 'warn');
-        this.logger?.(`[Orchestrator] 💭 System: Stop gathering info, START ACTING with available selectors`);
-      }
-      
-      if (decision.toolCalls && decision.toolCalls.length > 0) {
-        toolResults = await this.executeTools(decision.toolCalls, page, memory, stepNumber);
-        
-        // If agent wants to wait for tool results before proceeding, call agent again
-        if (decision.needsToolResults) {
-          const updatedContext = { ...context, toolResults };
-          const continuedDecision = await this.callAgent(updatedContext, jobId, stepNumber, iteration, consecutiveFailures);
-          
-          // Merge continued decision
-          decision.commands = continuedDecision.commands || decision.commands;
-          decision.commandReasoning = continuedDecision.commandReasoning || decision.commandReasoning;
-          decision.status = continuedDecision.status;
-          decision.statusReasoning = continuedDecision.statusReasoning;
-          decision.reasoning = continuedDecision.reasoning;
-        }
-      }
-      
-      // Execute commands sequentially
-      let iterationHadFailure = false;
-      
-      // Handle blocker if detected (clear blocker FIRST, then proceed with main commands)
-      if (decision.blockerDetected && decision.blockerDetected.clearingCommands && decision.blockerDetected.clearingCommands.length > 0) {
-        this.logger?.(`[Orchestrator] 🚧 BLOCKER DETECTED: ${decision.blockerDetected.description}`);
-        this.logger?.(`[Orchestrator] 🧹 Clearing blocker with ${decision.blockerDetected.clearingCommands.length} command(s)...`);
-        
-        const blockerResult = await this.executeCommandsSequentially(
-          decision.blockerDetected.clearingCommands,
-          page,
-          memory,
-          stepNumber,
-          iteration,
-          jobId
-        );
-        
-        // Add blocker commands with comment to output
-        if (blockerResult.executed.length > 0) {
-          commandsExecuted.push(`// Blocker: ${decision.blockerDetected.description}`);
-          commandsExecuted.push(...blockerResult.executed);
-        }
-        
-        // If blocker clearing failed, track it
-        if (!blockerResult.allSucceeded) {
-          this.logger?.(`[Orchestrator] ❌ Failed to clear blocker - continuing anyway`);
-          consecutiveFailures++;
-          iterationHadFailure = true;
-        }
-      }
-      
-      // Execute main commands (only if no blocker failure)
-      if (decision.commands && decision.commands.length > 0 && !iterationHadFailure) {
-        const executeResult = await this.executeCommandsSequentially(
-          decision.commands,
-          page,
-          memory,
-          stepNumber,
-          iteration,
-          jobId
-        );
-        
-        commandsExecuted.push(...executeResult.executed);
-        
-        // Track failures
-        if (!executeResult.allSucceeded) {
-          this.logger?.(`[Orchestrator] ⚠ Command execution stopped at failure`);
-          consecutiveFailures++;
-          iterationHadFailure = true;
-        } else {
-          consecutiveFailures = 0;  // Reset on success
-        }
-      }
-      
-      // Handle coordinate-based actions (NEW - fallback when selectors fail)
-      if (decision.coordinateAction && !iterationHadFailure) {
-        coordinateAttempts++;
-        
-        this.logger?.(`[Orchestrator] 🎯 Coordinate Action (attempt ${coordinateAttempts}/2): ${decision.coordinateAction.action} at (${decision.coordinateAction.xPercent}%, ${decision.coordinateAction.yPercent}%)`);
-        
-        try {
-          // BEFORE screenshot for visual verification
-          const beforeScreenshot = await page.screenshot({ encoding: 'base64', fullPage: false, type: 'jpeg', quality: 60 });
-          const beforeDataUrl = `data:image/jpeg;base64,${beforeScreenshot}`;
-          
-          // Generate Playwright commands from coordinate action
-          const coordCommands = await CoordinateConverter.generateCommands(decision.coordinateAction, page);
-          
-          this.logger?.(`[Orchestrator] Generated commands:`);
-          coordCommands.forEach(cmd => this.logger?.(`  ${cmd}`));
-          
-          // Execute coordinate commands
-          const coordResult = await this.executeCommandsSequentially(
-            coordCommands,
-            page,
-            memory,
-            stepNumber,
-            iteration,
-            jobId
-          );
-          
-          commandsExecuted.push(...coordResult.executed);
-          
-          if (!coordResult.allSucceeded) {
-            this.logger?.(`[Orchestrator] ❌ Coordinate action failed (Playwright error)`);
-            consecutiveFailures++;
-            iterationHadFailure = true;
-            
-            // Give up after 2 coordinate attempts
-            if (coordinateAttempts >= 2) {
-              this.logger?.(`[Orchestrator] 🛑 Coordinate mode exhausted (2 attempts) - marking stuck`);
-              return {
-                success: false,
-                commands: commandsExecuted,
-                iterations: iteration,
-                terminationReason: 'agent_stuck',
-                memory,
-                error: 'Coordinate fallback failed after 2 attempts - unable to proceed'
-              };
-            }
-          } else {
-            this.logger?.(`[Orchestrator] ✅ Coordinate action succeeded (no Playwright error)`);
-            
-            // CRITICAL: Verify visually if goal was achieved (coordinates might have clicked wrong place)
-            // Wait for network idle (smarter than fixed timeout - waits as needed, max 10s)
-            try {
-              await page.waitForLoadState('networkidle', { timeout: 10000 });
-            } catch (e) {
-              // Network idle timeout - page may still be loading, but proceed with verification
-              this.logger?.(`[Orchestrator] ⚠️  Network idle timeout after 10s, proceeding with verification`, 'warn');
-            }
-            
-            const afterScreenshot = await page.screenshot({ encoding: 'base64', fullPage: false, type: 'jpeg', quality: 60 });
-            const afterDataUrl = `data:image/jpeg;base64,${afterScreenshot}`;
-            
-            this.logger?.(`[Orchestrator] 📸 Verifying coordinate action visually...`);
-            
-            const verificationRequest = {
-              model: 'gpt-5-mini',
-              systemPrompt: 'You are a visual verification expert for web automation. Compare before/after screenshots to determine if an action achieved its goal.',
-              userPrompt: `Goal: ${scenarioSteps[stepNumber - 1]}\n\nA coordinate-based action was just executed. Compare the BEFORE and AFTER screenshots.\n\nDid the action achieve the goal? Respond with JSON:\n{\n  "verified": boolean,\n  "reasoning": "What changed (or didn't change) between screenshots",\n  "visibleChanges": ["List of UI changes observed"],\n  "clickedWrongPlace": boolean\n}\n\nBe strict: Only return verified=true if you clearly see the expected change matching the goal.`,
-              images: [
-                { label: 'BEFORE', dataUrl: beforeDataUrl },
-                { label: 'AFTER', dataUrl: afterDataUrl }
-              ]
-            };
-            
-            const verificationResponse = await this.llmFacade.llmProvider.callLLM(verificationRequest);
-            const jsonMatch = verificationResponse.answer.match(/\{[\s\S]*\}/);
-            
-            if (jsonMatch) {
-              const verificationResult = JSON.parse(jsonMatch[0]);
-              const verified = verificationResult.verified === true;
-              const reasoning = verificationResult.reasoning || 'No reasoning provided';
-              const clickedWrongPlace = verificationResult.clickedWrongPlace === true;
-              
-              this.logger?.(`[Orchestrator] 📊 Visual verification: ${verified ? '✅ VERIFIED' : '❌ NOT VERIFIED'}`);
-              this.logger?.(`[Orchestrator] 💭 Reasoning: ${reasoning}`);
-              
-              if (verified) {
-                // Goal achieved! Can mark complete
-                consecutiveFailures = 0;
-                
-                // Store note for context
-                noteToSelf = {
-                  fromIteration: iteration,
-                  content: `Coordinate action verified successful: ${reasoning}`
-                };
-                memory.latestNote = noteToSelf;
-              } else {
-                // Goal NOT achieved despite no error
-                this.logger?.(`[Orchestrator] ⚠️  Coordinate click succeeded but goal NOT achieved`, 'warn');
-                consecutiveFailures++;
-                iterationHadFailure = true;
-                
-                // Store diagnostic note for next attempt
-                const diagnostic = clickedWrongPlace 
-                  ? `Clicked wrong place. ${reasoning}. Try different coordinates.`
-                  : `Action executed but goal not achieved. ${reasoning}. May need different approach.`;
-                
-                noteToSelf = {
-                  fromIteration: iteration,
-                  content: diagnostic
-                };
-                memory.latestNote = noteToSelf;
-                
-                // Give up after 2 coordinate attempts
-                if (coordinateAttempts >= 2) {
-                  this.logger?.(`[Orchestrator] 🛑 Coordinate mode exhausted (2 attempts, none achieved goal) - marking stuck`);
-                  return {
-                    success: false,
-                    commands: commandsExecuted,
-                    iterations: iteration,
-                    terminationReason: 'agent_stuck',
-                    memory,
-                    error: `Coordinate actions clicked but didn't achieve goal: ${reasoning}`
-                  };
-                }
-              }
-            } else {
-              this.logger?.(`[Orchestrator] ⚠️  Could not parse verification response - treating as unverified`, 'warn');
-              consecutiveFailures++;
-              iterationHadFailure = true;
-            }
-          }
-          
-        } catch (error: any) {
-          this.logger?.(`[Orchestrator] ❌ Coordinate action error: ${error.message}`, 'error');
-          consecutiveFailures++;
-          iterationHadFailure = true;
-          
-          // Give up after 2 coordinate attempts
-          if (coordinateAttempts >= 2) {
-            this.logger?.(`[Orchestrator] 🛑 Coordinate mode exhausted (2 attempts) - marking stuck`);
-            return {
-              success: false,
-              commands: commandsExecuted,
-              iterations: iteration,
-              terminationReason: 'agent_stuck',
-              memory,
-              error: 'Coordinate fallback failed after 2 attempts - unable to proceed'
-            };
-          }
-        }
-      }
-      
-      // System-enforced stuck detection (agent might not detect it)
-      // Allow 5 failures: 3 selector attempts + 2 coordinate attempts
-      if (consecutiveFailures >= 5) {
-        this.logger?.(`[Orchestrator] 🛑 SYSTEM: ${consecutiveFailures} consecutive failures detected - forcing stuck`, 'warn');
-        return {
-          success: false,
-          commands: commandsExecuted,
-          iterations: iteration,
-          terminationReason: 'agent_stuck',
-          memory,
-          error: `Failed ${consecutiveFailures} iterations in a row - unable to proceed`
-        };
-      }
-      
-      // Update memory with experiences
-      if (decision.experiences && decision.experiences.length > 0) {
-        for (const exp of decision.experiences) {
-          // Deduplicate - don't add if very similar experience exists
-          const exists = memory.experiences.some(existing =>
-            existing.toLowerCase().includes(exp.toLowerCase()) ||
-            exp.toLowerCase().includes(existing.toLowerCase())
-          );
-          
-          if (!exists) {
-            memory.experiences.push(exp);
-            this.logger?.(`[Orchestrator] 📚 Experience: ${exp}`);
-          }
-        }
-        
-        // Cap experiences
-        if (memory.experiences.length > this.config.maxExperiences) {
-          memory.experiences = memory.experiences.slice(-this.config.maxExperiences);
-        }
-      }
-      
-      // Store self-reflection for next iteration
-      previousReflection = decision.selfReflection;
-      
-      // Store note to future self (NEW - tactical memory across iterations AND steps)
-      if (decision.noteToFutureSelf) {
-        noteToSelf = {
-          fromIteration: iteration,
-          content: decision.noteToFutureSelf
-        };
-        memory.latestNote = noteToSelf;  // Persist in journey memory across steps
-        this.logger?.(`[Orchestrator] 📝 Note to self: ${decision.noteToFutureSelf}`);
-      }
-      
-      // Check termination
-      if (decision.status !== 'continue') {
-        this.logger?.(`[Orchestrator] 🎯 Status: ${decision.status}`);
-        this.logger?.(`[Orchestrator] 💭 Reason: ${decision.statusReasoning}`);
-        
-        // SAFETY CHECK: Don't allow "complete" if commands failed this iteration
-        if (decision.status === 'complete' && iterationHadFailure) {
-          this.logger?.(`[Orchestrator] ⚠️  OVERRIDE: Agent said "complete" but commands FAILED - forcing "continue"`, 'warn');
-          this.logger?.(`[Orchestrator] 💭 System: Commands must succeed before marking complete`);
-          // Don't return - continue to next iteration
-        } else {
-          // Valid termination
-          return {
-            success: decision.status === 'complete',
-            commands: commandsExecuted,
-            iterations: iteration,
-            terminationReason: decision.status === 'complete' ? 'complete' :
-                             decision.status === 'stuck' ? 'agent_stuck' :
-                             'infeasible',
-            memory
-          };
-        }
-      }
-    }
-    
-    // Hit iteration limit
-    this.logger?.(`[Orchestrator] ⚠ Maximum iterations reached (${this.config.maxIterationsPerStep})`);
-    
-    return {
-      success: false,
-      commands: commandsExecuted,
-      iterations: iteration,
-      terminationReason: 'system_limit',
-      memory,
-      error: 'Maximum iterations reached'
-    };
-  }
-  
-  /**
-   * Build context for agent
-   */
-  private async buildAgentContext(
-    page: any,
-    currentStepGoal: string,
-    stepNumber: number,
-    totalSteps: number,
-    scenarioSteps: string[],
-    memory: JourneyMemory,
-    previousReflection?: SelfReflection,
-    consecutiveFailures?: number,
-    noteFromPreviousIteration?: NoteToFutureSelf  // NEW
-  ): Promise<AgentContext> {
-    // Get fresh DOM
-    const currentPageInfo = await getEnhancedPageInfo(page);
-    const currentURL = page.url();
-    
-    // Get recent steps
-    const recentSteps = memory.history.slice(-this.config.recentStepsCount);
-    
-    // Build context
-    return {
-      overallGoal: scenarioSteps.join('\n'),
-      currentStepGoal,
-      stepNumber,
-      totalSteps,
-      completedSteps: scenarioSteps.slice(0, stepNumber - 1),
-      remainingSteps: scenarioSteps.slice(stepNumber),
-      currentPageInfo,
-      currentURL,
-      recentSteps,
-      experiences: memory.experiences,
-      extractedData: memory.extractedData,
-      previousIterationGuidance: previousReflection,
-      noteFromPreviousIteration  // NEW: Pass tactical note from previous iteration
-    };
-  }
-  
-  /**
-   * Call agent to make decision
-   */
-  private async callAgent(
-    context: AgentContext,
-    jobId: string,
-    stepNumber: number,
-    iteration: number,
-    consecutiveFailures?: number
-  ): Promise<AgentDecision> {
-    // Detect if coordinate mode should be activated
-    // Phase 1: Only 2 tiers (selectors → coordinates), so activate after 3 failures
-    // Phase 2: Will have 3 tiers (selectors → index → coordinates), threshold will be 5
-    const useCoordinateMode = consecutiveFailures !== undefined && consecutiveFailures >= 3;
-    
-    // Build appropriate system prompt based on mode
-    const toolDescriptions = this.toolRegistry.generateToolDescriptions();
-    const systemPrompt = useCoordinateMode 
-      ? OrchestratorPrompts.buildCoordinateSystemPrompt()
-      : OrchestratorPrompts.buildSystemPrompt(toolDescriptions);
-    const userPrompt = OrchestratorPrompts.buildUserPrompt(context, consecutiveFailures);
-    
-    // Log prompt lengths for monitoring
-    const systemLength = systemPrompt.length;
-    const userLength = userPrompt.length;
-    const totalLength = systemLength + userLength;
-    const estimatedTokens = Math.ceil(totalLength / 4); // Rough estimate: 4 chars per token
-    
-    this.logger?.(`[Orchestrator] 📊 Prompt lengths: system=${systemLength} chars, user=${userLength} chars, total=${totalLength} chars (~${estimatedTokens} tokens)`, 'log');
-    
-    try {
-      // Call LLM directly via provider
-      const llmRequest = {
-        model: DEFAULT_MODEL,
-        systemPrompt,
-        userPrompt
-      };
-      
-      const response = await this.llmFacade.llmProvider.callLLM(llmRequest);
-      
-      // Report token usage
-      if (response.usage && this.progressReporter?.onTokensUsed) {
-        const tokenUsage: TokenUsage = {
-          jobId,
-          stepNumber,
-          iteration,
-          inputTokens: response.usage.inputTokens,
-          outputTokens: response.usage.outputTokens,
-          includesImage: false,
-          model: DEFAULT_MODEL,
-          timestamp: Date.now()
-        };
-        this.logger?.(`[Orchestrator] 💰 Reporting token usage: ${tokenUsage.inputTokens} + ${tokenUsage.outputTokens}`, 'log');
-        await this.progressReporter.onTokensUsed(tokenUsage);
-      } else if (!response.usage) {
-        this.logger?.(`[Orchestrator] ⚠ No usage data in LLM response`, 'warn');
-      }
-      
-      // Parse response
-      return this.parseAgentDecision(response.answer);
-      
-    } catch (error: any) {
-      this.logger?.(`[Orchestrator] ✗ Agent call failed: ${error.message}`, 'error');
-      
-      // Return fallback decision
-      return {
-        status: 'stuck',
-        statusReasoning: `Agent call failed: ${error.message}`,
-        reasoning: 'LLM call failed'
-      };
-    }
-  }
-  
- 
-  
-  /**
-   * Parse agent decision from LLM response
-   */
-  private parseAgentDecision(response: string): AgentDecision {
-    try {
-      // Extract JSON from response
-      const jsonMatch = response.match(/\{[\s\S]*\}/);
-      if (!jsonMatch) {
-        this.logger?.(`[Orchestrator] ✗ No JSON found in LLM response`, 'error');
-        this.logger?.(`[Orchestrator] 📄 FULL LLM RESPONSE:\n${response}`, 'error');
-        throw new Error('No JSON found in response');
-      }
-      
-      const parsed = JSON.parse(jsonMatch[0]);
-      
-      // Validate required fields
-      // Accept either "reasoning" or "statusReasoning" (LLMs sometimes only provide one)
-      if (!parsed.status || (!parsed.reasoning && !parsed.statusReasoning)) {
-        this.logger?.(`[Orchestrator] ✗ Missing required fields in parsed JSON`, 'error');
-        this.logger?.(`[Orchestrator] 📄 FULL LLM RESPONSE:\n${response}`, 'error');
-        this.logger?.(`[Orchestrator] 📄 PARSED JSON:\n${JSON.stringify(parsed, null, 2)}`, 'error');
-        this.logger?.(`[Orchestrator] ❌ Has status: ${!!parsed.status}, Has reasoning: ${!!parsed.reasoning}, Has statusReasoning: ${!!parsed.statusReasoning}`, 'error');
-        throw new Error('Missing required fields: status and (reasoning or statusReasoning)');
-      }
-      
-      // Normalize: if reasoning is missing but statusReasoning exists, use statusReasoning as reasoning
-      if (!parsed.reasoning && parsed.statusReasoning) {
-        parsed.reasoning = parsed.statusReasoning;
-      }
-      
-      return parsed as AgentDecision;
-      
-    } catch (error: any) {
-      this.logger?.(`[Orchestrator] ✗ Failed to parse agent decision: ${error.message}`, 'error');
-      
-      // Only log full response if not already logged above
-      if (!error.message.includes('Missing required fields') && !error.message.includes('No JSON found')) {
-        this.logger?.(`[Orchestrator] 📄 FULL LLM RESPONSE:\n${response}`, 'error');
-      }
-      
-      // Return fallback
-      return {
-        status: 'stuck',
-        statusReasoning: 'Failed to parse agent response',
-        reasoning: `Parse error: ${error.message}`
-      };
-    }
-  }
-  
-  /**
-   * Execute tools
-   */
-  private async executeTools(
-    toolCalls: any[],
-    page: any,
-    memory: JourneyMemory,
-    stepNumber: number
-  ): Promise<Record<string, any>> {
-    this.logger?.(`[Orchestrator] 🔧 Executing ${toolCalls.length} tool(s)`);
-    
-    const results: Record<string, any> = {};
-    const toolContext: ToolExecutionContext = {
-      page,
-      memory,
-      stepNumber,
-      logger: this.logger
-    };
-    
-    for (const toolCall of toolCalls.slice(0, this.config.maxToolCallsPerIteration)) {
-      this.logger?.(`[Orchestrator]   ▶ ${toolCall.name}(${JSON.stringify(toolCall.params).substring(0, 50)}...)`);
-      
-      const result = await this.toolRegistry.execute(toolCall, toolContext);
-      results[toolCall.name] = result;
-      
-      if (result.success) {
-        this.logger?.(`[Orchestrator]   ✓ ${toolCall.name} succeeded`);
-      } else {
-        this.logger?.(`[Orchestrator]   ✗ ${toolCall.name} failed: ${result.error}`, 'error');
-      }
-    }
-    
-    return results;
-  }
-  
-  /**
-   * Execute commands sequentially with SHARED context (variables persist across commands)
-   */
-  private async executeCommandsSequentially(
-    commands: string[],
-    page: any,
-    memory: JourneyMemory,
-    stepNumber: number,
-    iteration: number,
-    jobId: string
-  ): Promise<{ executed: string[]; allSucceeded: boolean }> {
-    this.logger?.(`[Orchestrator] 📝 Executing ${commands.length} command(s) in shared context`);
-    
-    const executed: string[] = [];
-    const limitedCommands = commands.slice(0, this.config.maxCommandsPerIteration);
-    
-    // Build execution with shared context (all commands share scope - variables persist)
-    const commandsWithTracking = limitedCommands.map((cmd, i) => {
-      return `
-// Command ${i + 1}/${limitedCommands.length}
-try {
-  ${cmd}
-  __results.push({ index: ${i}, success: true });
-} catch (error) {
-  __results.push({ index: ${i}, success: false, error: error.message });
-  throw error; // Stop on first failure
-}`;
-    }).join('\n');
-    
-    const wrappedCode = `
-const __results = [];
-${commandsWithTracking}
-return __results;
-`;
-    
-    try {
-      // Execute in shared context - variables declared here persist for entire scenario
-      // Pass both page and expect to make Playwright assertions available
-      const func = new Function('page', 'expect', 'return (async () => { ' + wrappedCode + ' })()');
-      const results = await func(page, expect);
-      
-      // Record results for each command
-      for (let i = 0; i < limitedCommands.length; i++) {
-        const cmd = limitedCommands[i];
-        const result = results[i];
-        
-        if (result && result.success) {
-          this.logger?.(`[Orchestrator]   ✓ [${i + 1}/${limitedCommands.length}] Success`);
-          
-          // Record in history
-          memory.history.push({
-            stepNumber,
-            iteration,
-            action: `Command ${i + 1}/${limitedCommands.length}`,
-            code: cmd,
-            result: 'success',
-            observation: 'Executed successfully',
-            url: page.url(),
-            timestamp: Date.now()
-          });
-          
-          executed.push(cmd);
-        }
-      }
-      
-      // Cap history
-      if (memory.history.length > this.config.maxHistorySize) {
-        memory.history = memory.history.slice(-this.config.maxHistorySize);
-      }
-      
-      return { executed, allSucceeded: true };
-      
-    } catch (error: any) {
-      // One of the commands failed - find which one
-      const errorMessage = error.message || String(error);
-      
-      // Capture page state for debug logging
-      let pageStateDebug = '';
-      if (this.debugMode) {
-        try {
-          const pageInfo = await getEnhancedPageInfo(page);
-          pageStateDebug = `
-=== DEBUG: PAGE STATE AT FAILURE ===
-URL: ${page.url()}
-Title: ${pageInfo.title}
-
-INTERACTIVE ELEMENTS:
-${pageInfo.formattedElements}
-
-ARIA SNAPSHOT:
-${JSON.stringify(pageInfo.ariaSnapshot, null, 2)}
-
-====================================`;
-        } catch (debugError: any) {
-          pageStateDebug = `Failed to capture page state: ${debugError.message}`;
-        }
-      }
-      
-      // Record all that succeeded, then the failure
-      for (let i = 0; i < limitedCommands.length; i++) {
-        const cmd = limitedCommands[i];
-        
-        // This is a failed command (error happened here or earlier)
-        if (executed.length <= i) {
-          this.logger?.(`[Orchestrator]   ✗ [${i + 1}/${limitedCommands.length}] Failed: ${errorMessage}`, 'error');
-          
-          // Log detailed debug info
-          if (this.debugMode && pageStateDebug) {
-            this.logger?.(pageStateDebug, 'debug');
-          }
-          
-          memory.history.push({
-            stepNumber,
-            iteration,
-            action: `Command ${i + 1}/${limitedCommands.length} - FAILED`,
-            code: cmd,
-            result: 'failure',
-            observation: `Failed with error: ${errorMessage}. This selector likely doesn't exist or is incorrect.`,
-            error: errorMessage,
-            url: page.url(),
-            timestamp: Date.now()
-          });
-          
-          if (i < limitedCommands.length - 1) {
-            this.logger?.(`[Orchestrator]   ⚠ Skipping remaining ${limitedCommands.length - i - 1} command(s)`, 'warn');
-          }
-          
-          break;
-        }
-      }
-      
-      return { executed, allSucceeded: false };
-    }
-  }
-  
-  /**
-   * Execute a single command
-   */
-  private async executeCommand(cmd: string, page: any): Promise<void> {
-    // Wrap in async function and execute
-    const wrapped = `(async () => { ${cmd} })()`;
-    
-    try {
-      await eval(wrapped);
-    } catch (error: any) {
-      // If eval fails, try direct execution with page context
-      // Pass both page and expect to make Playwright assertions available
-      const func = new Function('page', 'expect', `return (async () => { ${cmd} })()`);
-      await func(page, expect);
-    }
-  }
-  
-  /**
-   * Log agent decision
-   */
-  private logAgentDecision(decision: AgentDecision, iteration: number): void {
-    this.logger?.(`[Orchestrator] 💭 REASONING: ${decision.reasoning}`);
-    
-    if (decision.selfReflection) {
-      this.logger?.(`[Orchestrator] 🧠 SELF-REFLECTION:`);
-      this.logger?.(`[Orchestrator]    Next: ${decision.selfReflection.guidanceForNext}`);
-      if (decision.selfReflection.detectingLoop) {
-        this.logger?.(`[Orchestrator]    🔄 LOOP DETECTED: ${decision.selfReflection.loopReasoning}`, 'warn');
-      }
-    }
-    
-    if (decision.toolCalls && decision.toolCalls.length > 0) {
-      this.logger?.(`[Orchestrator] 🔧 TOOLS: ${decision.toolCalls.map(t => t.name).join(', ')}`);
-      if (decision.toolReasoning) {
-        this.logger?.(`[Orchestrator] 📋 Why: ${decision.toolReasoning}`);
-      }
-    }
-    
-    if (decision.blockerDetected) {
-      this.logger?.(`[Orchestrator] 🚧 BLOCKER: ${decision.blockerDetected.description}`, 'warn');
-      this.logger?.(`[Orchestrator] 🧹 Clearing with ${decision.blockerDetected.clearingCommands.length} command(s)`);
-    }
-    
-    if (decision.stepReEvaluation?.detected) {
-      this.logger?.(`[Orchestrator] 🔍 STEP RE-EVALUATION: ${decision.stepReEvaluation.issue}`, 'warn');
-      this.logger?.(`[Orchestrator] 📝 Explanation: ${decision.stepReEvaluation.explanation}`);
-    }
-    
-    if (decision.commands && decision.commands.length > 0) {
-      this.logger?.(`[Orchestrator] 📝 COMMANDS (${decision.commands.length}):`);
-      decision.commands.slice(0, 3).forEach((cmd, i) => {
-        this.logger?.(`[Orchestrator]    ${i + 1}. ${cmd.substring(0, 80)}...`);
-      });
-      if (decision.commands.length > 3) {
-        this.logger?.(`[Orchestrator]    ... and ${decision.commands.length - 3} more`);
-      }
-      if (decision.commandReasoning) {
-        this.logger?.(`[Orchestrator] 💡 Why: ${decision.commandReasoning}`);
-      }
-    }
-    
-    // Experiences will be logged when added to memory, no need to log here
-  }
-  
-  /**
-   * Report step progress
-   */
-  private async reportStepProgress(
-    jobId: string,
-    stepNumber: number,
-    description: string,
-    decision: AgentDecision,
-    iteration: number
-  ): Promise<void> {
-    if (!this.progressReporter?.onStepProgress) return;
-    
-    await this.progressReporter.onStepProgress({
-      jobId,
-      stepNumber,
-      description,
-      status: decision.status === 'complete' ? StepExecutionStatus.SUCCESS :
-              decision.status === 'stuck' || decision.status === 'infeasible' ? StepExecutionStatus.FAILURE :
-              StepExecutionStatus.IN_PROGRESS,
-      code: decision.commands?.join('\n'),
-      // Include agent metadata for transparency
-      agentIteration: iteration,
-      agentReasoning: decision.reasoning,
-      agentSelfReflection: decision.selfReflection,
-      agentExperiences: decision.experiences,
-      agentToolsUsed: decision.toolCalls?.map(t => t.name),
-      agentStatus: decision.status
-    });
-  }
-}
-
-