testchimp-runner-core 0.0.33 → 0.0.34

package/dist/orchestrator/orchestrator-agent.js

@@ -8,8 +8,10 @@ exports.OrchestratorAgent = void 0;
 const test_1 = require("@playwright/test");
 const progress_reporter_1 = require("../progress-reporter");
 const page_info_utils_1 = require("../utils/page-info-utils");
+const coordinate_converter_1 = require("../utils/coordinate-converter");
 const model_constants_1 = require("../model-constants");
 const types_1 = require("./types");
+const orchestrator_prompts_1 = require("./orchestrator-prompts");
 /**
  * Orchestrator Agent - manages step execution with tool use and memory
  */
@@ -34,13 +36,16 @@ class OrchestratorAgent {
         this.logger?.(`[Orchestrator] 🎯 Goal: ${stepDescription}`);
         let iteration = 0;
         let previousReflection = undefined;
+        let noteToSelf = memory.latestNote; // Start with note from previous step
         const commandsExecuted = [];
         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);
+            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
@@ -49,6 +54,12 @@ class OrchestratorAgent {
             await this.reportStepProgress(jobId, stepNumber, stepDescription, decision, iteration);
             // Execute tools if requested (tools are READ-ONLY, they don't change state)
             let toolResults = {};
+            // 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
@@ -82,7 +93,7 @@ class OrchestratorAgent {
                     iterationHadFailure = true;
                 }
             }
-            // Execute main commands (only if no blocker failure or continueOnFailure is 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);
@@ -96,8 +107,136 @@ class OrchestratorAgent {
                     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 coordinate_converter_1.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) {
+                    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)
-            if (consecutiveFailures >= 3) {
+            // 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,
@@ -126,19 +265,37 @@ class OrchestratorAgent {
             }
             // 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}`);
-                return {
-                    success: decision.status === 'complete',
-                    commands: commandsExecuted,
-                    iterations: iteration,
-                    terminationReason: decision.status === 'complete' ? 'complete' :
-                        decision.status === 'stuck' ? 'agent_stuck' :
-                            'infeasible',
-                    memory
-                };
+                // 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
@@ -155,7 +312,8 @@ class OrchestratorAgent {
     /**
      * Build context for agent
      */
-    async buildAgentContext(page, currentStepGoal, stepNumber, totalSteps, scenarioSteps, memory, previousReflection, consecutiveFailures) {
+    async buildAgentContext(page, currentStepGoal, stepNumber, totalSteps, scenarioSteps, memory, previousReflection, consecutiveFailures, noteFromPreviousIteration // NEW
+    ) {
         // Get fresh DOM
         const currentPageInfo = await (0, page_info_utils_1.getEnhancedPageInfo)(page);
         const currentURL = page.url();
@@ -174,16 +332,30 @@ class OrchestratorAgent {
             recentSteps,
             experiences: memory.experiences,
             extractedData: memory.extractedData,
-            previousIterationGuidance: previousReflection
+            previousIterationGuidance: previousReflection,
+            noteFromPreviousIteration // NEW: Pass tactical note from previous iteration
         };
     }
     /**
      * Call agent to make decision
      */
     async callAgent(context, jobId, stepNumber, iteration, consecutiveFailures) {
-        // Build prompt
-        const systemPrompt = this.buildSystemPrompt();
-        const userPrompt = this.buildUserPrompt(context, consecutiveFailures);
+        // 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
+            ? orchestrator_prompts_1.OrchestratorPrompts.buildCoordinateSystemPrompt()
+            : orchestrator_prompts_1.OrchestratorPrompts.buildSystemPrompt(toolDescriptions);
+        const userPrompt = orchestrator_prompts_1.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 = {
@@ -223,391 +395,6 @@ class OrchestratorAgent {
             };
         }
     }
-    /**
-     * Build system prompt with tool descriptions
-     */
-    buildSystemPrompt() {
-        const toolDescriptions = this.toolRegistry.generateToolDescriptions();
-        return `You are an intelligent test automation agent that executes web scenarios using Playwright.
-
-${toolDescriptions}
-
-YOUR RESPONSE FORMAT (JSON):
-{
-  "toolCalls": [{"name": "tool_name", "params": {...}}],  // Optional: Tools to use
-  "toolReasoning": "Why I need these tools",              // If using tools
-  "needsToolResults": true/false,                         // Wait for tool results before commands?
-  "commands": ["await page.click(...)", ...],             // Playwright commands to execute
-  "commandReasoning": "Why these commands",               // If executing commands
-  "selfReflection": {                                     // Guidance for your next iteration
-    "guidanceForNext": "What to focus on next",
-    "detectingLoop": false,                               // Set true if repeating same approach
-    "loopReasoning": "Why I think I'm looping"           // If detecting loop
-  },
-  "experiences": ["App-specific learning"],              // APP-SPECIFIC patterns (see rules below)
-  "status": "continue|complete|stuck|infeasible",        // Your decision
-  "statusReasoning": "Why this status",
-  "reasoning": "Overall reasoning for this iteration",
-  "blockerDetected": {                                   // OPTIONAL: If something blocks the current goal
-    "description": "What's blocking",                    // E.g., "Cookie consent modal"
-    "clearingCommands": ["await page.click(...)"]       // Commands to clear blocker FIRST
-  },
-  "stepReEvaluation": {                                  // OPTIONAL: If questioning step order (last resort)
-    "detected": true,                                    // Set true if you think step order is wrong
-    "issue": "prior_incomplete|already_done|wrong_order", // What's the issue?
-    "explanation": "Why step order seems wrong"          // Your reasoning
-  }
-}
-
-STATUS DECISION RULES (CRITICAL!):
-
-- "complete": ALL commands succeeded AND step goal achieved
-  ❌ NEVER mark complete if ANY command failed!
-  
-- "continue": Command failed OR need more actions
-  Use when: Need to retry with different selector, wait for something, or continue execution
-  
-- "stuck": Tried 3+ iterations, all failed
-  
-- "infeasible": Goal truly impossible (element doesn't exist anywhere)
-
-IF COMMAND FAILED → status must be "continue" (to retry) or "stuck" (if tried many times)
-IF COMMAND SUCCEEDED → status can be "complete" (if goal done) or "continue" (if more needed)
-
-STEP RE-EVALUATION (LAST RESORT - After 2+ Failures):
-
-When you've failed multiple times on current step, QUESTION YOUR ASSUMPTIONS:
-
-1. **LOOK BACK**: Did prior steps really complete?
-   - Check COMPLETED steps list vs current page state
-   - Example: Says "Login complete" but you see login form → PRIOR STEP FAILED
-   - If prior step incomplete: Execute commands to complete it, explain in reasoning
-
-2. **LOOK FORWARD**: Is current step already done or no longer relevant?
-   - Check if current step goal already achieved (element exists, state correct)
-   - Example: Step says "Click Submit" but form already submitted → STEP ALREADY DONE
-   - If already done: Mark "complete" and explain why
-
-3. **LOOK AHEAD**: Is next step more feasible?
-   - Sometimes UI flows differently than expected
-   - Example: Current step "Click Edit" fails, but next step "Fill Name" elements are visible
-   - If can do future step: Note in reasoning, but PREFER sticking to order
-
-STICK TO ORIGINAL PLAN unless clear evidence suggests otherwise.
-Only re-evaluate after repeated failures on same step.
-
-BLOCKER DETECTION (IMPORTANT!):
-
-Use "blockerDetected" when the CURRENT STEP GOAL is not immediately feasible because something unexpected is in the way:
-
-Examples of BLOCKERS:
-- Cookie consent modal appears before login
-- "What's New" tour overlay prevents clicking navigation
-- Email verification prompt blocks form submission
-- Session timeout modal requires re-login before continuing
-
-When you detect a blocker:
-1. Set "blockerDetected.description" to describe what's blocking
-2. Provide "clearingCommands" to dismiss/handle the blocker
-3. Set your main "commands" to execute AFTER blocker is cleared
-4. Agent will execute: clearingCommands FIRST, then your commands
-
-Example:
-{
-  "blockerDetected": {
-    "description": "Cookie consent modal blocking page interaction",
-    "clearingCommands": ["await page.getByRole('button', {name: 'Accept'}).click()"]
-  },
-  "commands": ["await page.getByRole('textbox', {name: 'Email'}).fill('user@example.com')"],
-  ...
-}
-
-DON'T use blockerDetected for:
-- Normal step execution (just use commands)
-- Wrong selectors (that's not a blocker, just fix the selector)
-- Missing elements (that's infeasible, not blocked)
-
-EXPERIENCES - APP-SPECIFIC PATTERNS ONLY:
-
-Guidelines:
-- Concise - combine related info into single learning
-- Focus on app quirks, not obvious practices
-- Max 1-2 experiences per iteration
-- Capture SEMANTIC SELECTOR patterns when discovered
-
-✅ GOOD - App-specific patterns:
-- "Login form fields accessible via getByLabel: 'Email' and 'Password'"
-- "Submit buttons consistently use role=button with text matching action"
-- "Form uses custom dropdowns (role=combobox) instead of native selects"
-- "Navigation items accessible via getByRole('link') with visible text"
-- "Site uses data-testid attributes consistently (pattern: action-element-name)"
-- "Input fields have clear placeholders - prefer getByPlaceholder over IDs"
-
-❌ BAD - Too specific or obvious:
-- Listing individual field selectors (combine them)
-- "Button exists with role=button" (obvious)
-- Generic automation advice
-- Noting auto-generated IDs like #«r3»-form-item (these are unreliable)
-
-COMBINE related learnings instead of listing each element separately.
-PRIORITIZE learning about semantic selector availability over CSS selectors.
-
-CRITICAL RULES FOR DECISION MAKING:
-
-1. **BE FOCUSED AND CONCISE** (CRITICAL!):
-   - Read the CURRENT STEP GOAL carefully - ONLY do what's explicitly asked for in THAT step
-   - DON'T add extra actions, verifications, or defensive checks not mentioned in the step goal
-   - If step says "Send a message" → ONLY send the message, DON'T verify it appeared
-   - If step says "Click Submit" → ONLY click, DON'T wait or verify submission success
-   - ONLY add expect() assertions if the step explicitly mentions "verify", "check", "ensure", or "confirm"
-   - Keep commands minimal - no unnecessary preparatory or validation actions
-
-2. **COMMAND EFFICIENCY**:
-   - DON'T click on input field before filling it - just use .fill() directly
-   - DON'T do preparatory actions unless necessary
-   - Example: page.fill works without clicking the input first
-
-2b. **VARIABLE SCOPE & AVAILABLE FUNCTIONS** (CRITICAL!):
-   - Commands in SAME BATCH share scope - variables persist within iteration
-   - To save data for later steps: Use extract_data tool, then access via extractedData in context
-   - Within same batch: Variables work across commands
-   - AVAILABLE IN CONTEXT: page (Playwright Page object) and expect (Playwright assertions)
-   - You can use expect() directly - it is already imported and available
-
-3. **WHEN COMMAND FAILS** (most important!):
-   - DON'T repeat the same command/selector
-   - DO analyze the error message
-   - DO look at DOM snapshot for SEMANTIC selectors (getByRole, getByLabel, getByText)
-   - AVOID falling back to auto-generated IDs with unicode characters (e.g., #«r3»-form-item)
-   - DO take screenshot if DOM doesn't help
-   - "Element is not a <select>" → It's a custom dropdown, use .click() then select from menu
-   - "Timeout waiting for locator" → Try semantic selectors from ARIA tree instead of CSS IDs
-
-4. **CHECK YOUR RECENT STEPS FOR PATTERNS**:
-   - If you see same selector failed 2+ times → YOU ARE LOOPING!
-   - Set detectingLoop: true and explain why
-   - Take screenshot to see what's actually on the page
-   - Use different SEMANTIC selector from DOM/ARIA tree (getByRole, getByLabel, getByText, data-testid)
-   - AVOID repeating with similar auto-generated ID patterns (e.g., #«r3»-form-item → #«r4»-form-item)
-
-5. **USE DOM SNAPSHOT** - ONLY USE WHAT'S ACTUALLY THERE (CRITICAL!):
-   - You get INTERACTIVE ELEMENTS list showing: position, tag, id, text, SUGGESTED SELECTORS
-   - ONLY use selectors from this list - DO NOT invent selectors with text/names not in the list!
-   - ❌ WRONG: List shows button "Submit" but you use getByRole('button', {name: 'SomeOtherText'})
-   - ✅ RIGHT: Use EXACT selector from the provided list
-   - ✅ RIGHT: If list shows "#submit-btn" → use that
-   - ✅ RIGHT: If list shows "getByRole('button', {name: 'X'})" → use exactly that
-   - If element you need is NOT in list → take_screenshot to find it
-   - ARIA tree shows roles/names that exist - inventing roles/names not in tree will fail!
-
-5b. **SELECTOR PREFERENCE** (CRITICAL - Playwright Best Practices):
-   ALWAYS prefer user-friendly, semantic selectors in this order:
-   
-   🏆 BEST (use these first):
-   1. page.getByRole('role', {name: 'text'})     → ✅ Accessible, semantic, resilient
-   2. page.getByLabel('label text')              → ✅ Great for form inputs
-   3. page.getByPlaceholder('placeholder')       → ✅ Good for inputs without labels
-   4. page.getByText('visible text')             → ✅ Clear and readable
-   5. page.getByTestId('test-id')                → ✅ Stable if available
-   
-   ⚠️ AVOID (last resort only):
-   - CSS selectors with auto-generated IDs: #r3-form-item, #«r3»-form-item
-   - CSS selectors with unicode: #«r4»-form-item
-   - Complex CSS paths: div.ant-form > div:nth-child(2)
-   
-   Examples:
-   ❌ BAD:  await page.fill('#«r3»-form-item', 'alice@example.com')
-   ✅ GOOD: await page.getByLabel('Email').fill('alice@example.com')
-   ✅ GOOD: await page.getByRole('textbox', {name: 'Email'}).fill('alice@example.com')
-   ✅ GOOD: await page.getByPlaceholder('Enter your email').fill('alice@example.com')
-   
-   ❌ BAD:  await page.click('#submit-btn-23847')
-   ✅ GOOD: await page.getByRole('button', {name: 'Submit'}).click()
-   ✅ GOOD: await page.getByText('Submit').click()
-   
-   WHY: Semantic selectors are more maintainable, self-documenting, and resilient to UI changes.
-   Auto-generated IDs (especially with unicode like «r3») break when component instances change.
-
-5c. **ASSERTIONS AND VERIFICATION** (CRITICAL - Use expect):
-   Use expect() for verification ONLY when the step explicitly asks for verification.
-   
-   🏆 WHEN TO USE expect():
-   - Step says "Verify message appears" → await expect(locator).toBeVisible()
-   - Step says "Check field is empty" → await expect(locator).toBeEmpty()
-   - Step says "Confirm URL changed" → await expect(page).toHaveURL('...')
-   - Step explicitly mentions: "verify", "check", "ensure", "confirm", "validate"
-   
-   ❌ WHEN NOT TO USE expect():
-   - Step says "Send a message" → DON'T add expect() for message visibility
-   - Step says "Click Submit" → DON'T add expect() for button state or result
-   - Step says "Fill Email field" → DON'T add expect() to verify it's filled
-   - Step says "Navigate to Dashboard" → DON'T add expect() for URL (unless step asks)
-   
-   🏆 expect() syntax (when needed):
-   - await expect(locator).toBeVisible()
-   - await expect(locator).toHaveText('expected text')
-   - await expect(locator).toHaveValue('expected value')
-   - await expect(locator).toBeEmpty()
-   - await expect(page).toHaveURL('expected-url')
-   
-   ❌ BAD - Manual checks:
-   const value = await page.getByPlaceholder('Message...').inputValue();
-   if (value !== '') throw new Error(\`Expected empty but found: '\${value}'\`);
-   
-   ✅ GOOD - Use expect (but ONLY if step asks to verify):
-   await expect(page.getByPlaceholder('Message...')).toBeEmpty();
-   
-   WHY: expect() has built-in retries and better error messages.
-   BUT: Only use it when verification is explicitly requested in the step goal.
-
-6. **TOOLS ARE READ-ONLY (Information Gathering)**:
-   AVAILABLE TOOLS (for information only):
-   - take_screenshot: Get visual context when DOM isn't enough or stuck 2+ times
-     * DEFAULT: Captures FULL PAGE (elements below fold included)
-     * Set isFullPage=false ONLY if you need just viewport
-     * Use for: Planning, finding hidden elements, verifying layout
-   - recall_history: Remember earlier steps in journey
-   - inspect_page: Force fresh DOM snapshot (rarely needed, already in context)
-   - check_page_ready: Verify page loaded (use sparingly!)
-   - extract_data: Save data from page to memory for later steps
-   
-   ALL STATE CHANGES USE PLAYWRIGHT COMMANDS:
-   - Navigation: await page.goto('url')
-   - Go back: await page.goBack()
-   - Refresh: await page.reload()
-   - Fill inputs: await page.fill() or page.getByRole().fill()
-   - Click buttons: await page.click() or page.getByRole().click()
-   - Wait: await page.waitForURL(), page.waitForLoadState()
-   
-   Tools gather info → Commands change state
-
-7. **ERROR-SPECIFIC RESPONSES**:
-   - "Timeout waiting for locator" → Selector doesn't exist, try different one from DOM
-   - "Element is not a <select>" → It's a custom dropdown (button with role=combobox), use .click()
-   - "Multiple elements" → Add more specific selector from DOM (use #id)
-
-8. **WHEN TO RUN COMMANDS vs TOOLS**:
-   - Confident about selectors from DOM → Run commands directly
-   - Unsure or failed 2+ times → Take screenshot first
-   - First iteration of a step → Usually can run commands from DOM`;
-    }
-    /**
-     * Build user prompt with context
-     */
-    buildUserPrompt(context, consecutiveFailures) {
-        const parts = [];
-        parts.push('=== YOUR CURRENT CONTEXT ===\n');
-        // System warnings for accumulated failures
-        if (consecutiveFailures && consecutiveFailures >= 2) {
-            parts.push(`⚠️⚠️⚠️ SYSTEM WARNING ⚠️⚠️⚠️`);
-            parts.push(`You've failed ${consecutiveFailures} iterations in a row!`);
-            parts.push(`Next failure will force STUCK. You MUST:`);
-            parts.push(`1. Take screenshot if you haven't already`);
-            parts.push(`2. Try completely different selector strategy`);
-            parts.push(`3. QUESTION ASSUMPTIONS: Am I at the right step?`);
-            parts.push(`   - LOOK BACK: Did prior steps really complete? Check page state vs COMPLETED list`);
-            parts.push(`   - LOOK FORWARD: Is current step already done? Check if goal already achieved`);
-            parts.push(`4. OR mark status="stuck" if truly can't proceed`);
-            parts.push(`⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️\n`);
-        }
-        // Goals - make current step very prominent
-        parts.push(`🎯 CURRENT STEP GOAL (${context.stepNumber}/${context.totalSteps}):`);
-        parts.push(`${context.currentStepGoal}`);
-        parts.push(`^^ DO ONLY WHAT THIS STEP ASKS - NO EXTRA ACTIONS OR VERIFICATIONS ^^`);
-        parts.push(`^^ If step doesn't say "verify/check/confirm" → DON'T add expect() assertions ^^`);
-        parts.push(`^^ Mark "complete" ONLY if commands succeeded ^^`);
-        parts.push(``);
-        parts.push(`OVERALL SCENARIO: ${context.overallGoal}\n`);
-        if (context.completedSteps.length > 0) {
-            parts.push(`COMPLETED: ${context.completedSteps.join(', ')}`);
-        }
-        if (context.remainingSteps.length > 0) {
-            parts.push(`REMAINING: ${context.remainingSteps.join(', ')}\n`);
-        }
-        // Current page state
-        parts.push(`\nCURRENT PAGE:`);
-        parts.push(`URL: ${context.currentURL}`);
-        parts.push(`Title: ${context.currentPageInfo.title}`);
-        parts.push(`\nINTERACTIVE ELEMENTS (with positions and selectors):`);
-        parts.push(context.currentPageInfo.formattedElements);
-        parts.push(`\nARIA TREE (hierarchical structure):`);
-        parts.push(JSON.stringify(context.currentPageInfo.ariaSnapshot, null, 2).substring(0, 5000));
-        if (JSON.stringify(context.currentPageInfo.ariaSnapshot).length > 5000) {
-            parts.push('... (truncated)');
-        }
-        parts.push('');
-        // Recent steps
-        if (context.recentSteps.length > 0) {
-            parts.push(`\nRECENT STEPS (last ${context.recentSteps.length}):`);
-            for (const step of context.recentSteps) {
-                const status = step.result === 'success' ? '✓' : '✗';
-                parts.push(`  ${status} ${step.stepNumber}.${step.iteration || ''} ${step.action}`);
-                parts.push(`     Code: ${step.code}`);
-                if (step.result === 'failure' && step.error) {
-                    parts.push(`     ❌ ERROR: ${step.error}`);
-                    parts.push(`     ^^ THIS SELECTOR FAILED - TRY DIFFERENT APPROACH ^^`);
-                }
-                else {
-                    parts.push(`     Result: ${step.observation}`);
-                }
-            }
-            parts.push('');
-            // Detect repeated failures
-            const recentFailures = context.recentSteps.filter(s => s.result === 'failure');
-            if (recentFailures.length >= 2) {
-                const sameSelector = recentFailures.slice(-2).every((s, i, arr) => i === 0 || s.code === arr[i - 1].code);
-                if (sameSelector) {
-                    parts.push(`⚠️ WARNING: You've tried the same selector multiple times and it failed!`);
-                    parts.push(`   Last failed selector: ${recentFailures[recentFailures.length - 1].code}`);
-                    parts.push(`   YOU MUST try a completely different selector this time!\n`);
-                }
-            }
-        }
-        // Experiences
-        if (context.experiences.length > 0) {
-            parts.push(`\nLEARNINGS (${context.experiences.length}):`);
-            for (const exp of context.experiences) {
-                parts.push(`  - ${exp}`);
-            }
-            parts.push('');
-        }
-        // Extracted data
-        if (Object.keys(context.extractedData).length > 0) {
-            parts.push(`\nEXTRACTED DATA:`);
-            for (const [key, value] of Object.entries(context.extractedData)) {
-                parts.push(`  ${key}: ${value}`);
-            }
-            parts.push('');
-        }
-        // Previous reflection
-        if (context.previousIterationGuidance) {
-            parts.push(`\nYOUR PREVIOUS GUIDANCE TO YOURSELF:`);
-            parts.push(`Focus: ${context.previousIterationGuidance.guidanceForNext}`);
-            if (context.previousIterationGuidance.detectingLoop) {
-                parts.push(`⚠ YOU DETECTED A LOOP: ${context.previousIterationGuidance.loopReasoning}`);
-            }
-            parts.push('');
-        }
-        // Tool results (if any)
-        if (context.toolResults) {
-            parts.push(`\n========== TOOL RESULTS ==========`);
-            for (const [toolName, result] of Object.entries(context.toolResults)) {
-                parts.push(`\n${toolName}: ${result.success ? '✓ SUCCESS' : '✗ FAILED'}`);
-                if (result.learning) {
-                    parts.push(`\n📊 ANALYSIS FROM ${toolName.toUpperCase()}:`);
-                    parts.push(result.learning);
-                    parts.push(`^^ USE THIS INFORMATION TO DECIDE YOUR NEXT COMMANDS ^^`);
-                }
-                if (result.error) {
-                    parts.push(`  Error: ${result.error}`);
-                }
-            }
-            parts.push(`\n===================================\n`);
-        }
-        parts.push('=== WHAT DO YOU WANT TO DO? ===');
-        parts.push('Respond with JSON following the format specified in the system prompt.');
-        return parts.join('\n');
-    }
     /**
      * Parse agent decision from LLM response
      */
@@ -616,18 +403,32 @@ CRITICAL RULES FOR DECISION MAKING:
             // 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
-            if (!parsed.status || !parsed.reasoning) {
-                throw new Error('Missing required fields: status and reasoning');
+            // 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;
         }
         catch (error) {
             this.logger?.(`[Orchestrator] ✗ Failed to parse agent decision: ${error.message}`, 'error');
-            this.logger?.(`[Orchestrator] Raw response: ${response.substring(0, 200)}...`, 'log');
+            // 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',