testchimp-runner-core 0.0.33 → 0.0.35

package/plandocs/exploratory-mode-support-v2.plan.md

@@ -0,0 +1,953 @@
+# Add Exploratory Mode Support to Runner-Core
+
+## Overview
+
+Enable runner-core's orchestrator to support exploratory mode where the agent autonomously decides next actions based on a high-level exploration prompt, rather than following pre-defined test steps.
+
+**Architecture:**
+- **AppExplorer**: Multi-journey orchestrator - decides WHAT journeys to run
+  - Test-based: picks tests from test tree (existing)
+  - **Prompt-based (NEW)**: LLM generates journey-specific prompts based on overall goal + learnings from prior journeys
+  
+- **JourneyRunner** (renamed from TestBasedExplorer): Single-journey executor - executes ONE journey
+  - Test-based: follows pre-defined test steps (existing)
+  - **Prompt-based (NEW)**: autonomous exploration with journey-specific focus prompt via runner-core orchestrator
+
+**Key Principle**: JourneyRunner fires `onStepComplete` for each action (whether pre-defined or autonomous), so all analytics, bug capture, and screen state detection work identically for both modes.
+
+---
+
+## Phase 1: Extend Runner-Core Types & Config
+
+### 1.1 Add Exploration Mode Types
+
+**File**: `runner-core/src/orchestrator/types.ts`
+
+Add new interface:
+
+```typescript
+/**
+ * Exploration mode configuration
+ */
+export interface ExplorationMode {
+  enabled: boolean;                    // Whether exploration mode is active
+  explorationPrompt: string;           // Journey-specific focus: "Explore Dashboard and test all widgets"
+  testDataPrompt?: string;             // Test data, credentials context
+  maxExplorationSteps?: number;        // Budget limit (default: 50) - agent can stop earlier
+}
+```
+
+Add to `AgentConfig`:
+
+```typescript
+export interface AgentConfig {
+  // ... existing fields
+  
+  // Exploration mode (NEW)
+  explorationMode?: ExplorationMode;
+}
+```
+
+Update `DEFAULT_AGENT_CONFIG`:
+
+```typescript
+export const DEFAULT_AGENT_CONFIG: Required<AgentConfig> = {
+  // ... existing defaults
+  
+  explorationMode: {
+    enabled: false,
+    explorationPrompt: '',
+    testDataPrompt: undefined,
+    maxExplorationSteps: 50
+  }
+};
+```
+
+### 1.2 Reuse Existing Journey Memory
+
+**No code changes** - existing `JourneyMemory` fields work perfectly:
+
+- **`history`**: Agent reviews to understand visited screens/areas
+- **`experiences`**: Used for BOTH app patterns AND exploration progress
+  - Examples: "Dashboard fully explored - tested all 5 widgets successfully"
+  - Examples: "Discovered Admin menu (locked - requires admin role)"
+- **`extractedData`**: Store discovered areas with special keys
+  - Examples: `{ "menuItems": "Dashboard,Settings,Admin,Profile" }`
+  - Examples: `{ "exploredMenus": "Dashboard,Settings" }`
+- **`latestNote`**: Tactical memory for exploration strategy
+
+Exploratory prompts guide the agent to use these fields appropriately.
+
+---
+
+## Phase 2: Add Exploratory Prompts to Runner-Core
+
+### 2.1 Create Exploratory System Prompt
+
+**File**: `runner-core/src/orchestrator/orchestrator-prompts.ts`
+
+Add new method:
+
+```typescript
+static buildExploratorySystemPrompt(toolDescriptions: string): string {
+  return `You are an autonomous exploration agent that discovers and tests web application features.
+
+${toolDescriptions}
+
+YOUR RESPONSE FORMAT - Output JSON matching this interface:
+
+interface AgentDecisionLLMResponse {
+  status: string;              // "continue" | "complete" | "stuck"
+  reasoning: string;           // What you're exploring and why
+  commands?: string[];         // Playwright commands to execute
+  commandReasoning?: string;   // Why these commands
+  toolCalls?: Array<{          // Tools to call (extract_data for menus, etc.)
+    name: string;
+    params: Record<string, any>;
+  }>;
+  toolReasoning?: string;
+  needsToolResults?: boolean;
+  noteToFutureSelf?: string;
+  coordinateAction?: { ... };
+  experiences?: string[];      // Use for BOTH app patterns AND exploration progress
+  blockerDetected?: { ... };
+}
+
+EXPLORATION MODE GUIDELINES:
+
+1. **JOURNEY-FOCUSED EXPLORATION**: Follow the exploration prompt as your goal for THIS journey
+   - Example prompt: "Explore Dashboard and test all widgets"
+   - You should systematically test dashboard widgets, not wander off to other sections
+   - Stay focused on the given journey goal
+
+2. **AUTONOMOUS DISCOVERY**: You decide HOW to explore based on:
+   - The journey exploration prompt (your specific goal for this journey)
+   - Current page state (what's available now)
+   - Journey history (what's been explored already in THIS journey)
+   - Discovered but unvisited areas (stored in extractedData or experiences)
+
+3. **SYSTEMATIC EXPLORATION**: 
+   - Use extract_data tool to discover elements (menus, buttons, links, widgets)
+   - Store discoveries in extractedData: { "dashboardWidgets": "Sales,Analytics,Tasks,Calendar,Reports" }
+   - Track progress in experiences: "Explored Sales widget - chart renders correctly"
+   - Check history to avoid re-visiting same areas within this journey
+   - Prioritize unexplored areas related to journey goal
+
+4. **CREATIVE TESTING**: Test functionality thoroughly, don't just navigate
+   - Try different input combinations
+   - Explore edge cases (empty inputs, max lengths, special characters)
+   - Verify features work as expected (data loads, actions complete, errors handled)
+   - Look for visual bugs, console errors, broken functionality
+
+5. **BLOCKER HANDLING**: Clear obstacles autonomously
+   - Cookie modals → dismiss with blockerDetected.clearingCommands
+   - Tour popups → close them
+   - Login required → use credentials from test data prompt
+   - Navigation blockers → clear before continuing exploration
+
+6. **STATUS DECISIONS** (CRITICAL):
+   - "continue": More exploration needed to achieve THIS journey's goal
+   - "complete": Journey goal ACHIEVED (e.g., "All dashboard widgets tested") OR budget running low
+   - "stuck": Cannot proceed (auth permanently blocked, critical error preventing goal)
+   
+   **Mark "complete" when**:
+   - You've achieved the journey-specific exploration goal
+   - You've made good progress and are approaching step budget
+   - Further exploration would be repetitive or off-topic for this journey
+   
+   **DON'T** wait to hit maxExplorationSteps - complete when journey goal is met!
+
+7. **MEMORY USAGE**:
+   - experiences: BOTH app patterns AND exploration notes
+     Example: "Settings menu requires admin role to access"
+     Example: "Dashboard Analytics widget - tested filtering, all variants work correctly"
+   - extractedData: Discovered elements and tracking
+     Example: { "discoveredWidgets": "Sales,Analytics,Tasks,Calendar,Reports" }
+     Example: { "testedWidgets": "Sales,Analytics" }
+   - history: Review to see what actions were taken in this journey
+   - noteToFutureSelf: Tactical plans for next iteration
+
+8. **TOOLS FOR EXPLORATION**:
+   - extract_data: Discover menus, links, interactive elements
+   - take_screenshot: Understand visual layout when DOM unclear
+   - recall_history: Check what was already explored in this journey
+
+CRITICAL: You're fully autonomous for THIS journey - no step-by-step instructions provided.
+YOU decide the exploration path to meet the journey goal based on: journey prompt, current state, and memory.`;
+}
+```
+
+### 2.2 Create Exploratory User Prompt
+
+Add method to `OrchestratorPrompts`:
+
+```typescript
+static buildExploratoryUserPrompt(
+  context: AgentContext,
+  explorationPrompt: string,
+  testDataPrompt?: string,
+  stepNumber?: number,
+  maxSteps?: number
+): string {
+  const parts: string[] = [];
+  
+  parts.push('=== JOURNEY EXPLORATION CONTEXT ===\n');
+  parts.push(`🎯 THIS JOURNEY'S GOAL: ${explorationPrompt}`);
+  parts.push(`   (Focus on THIS specific goal - don't wander to unrelated areas)\n`);
+  
+  if (testDataPrompt) {
+    parts.push(`📋 TEST DATA/CREDENTIALS: ${testDataPrompt}`);
+  }
+  
+  if (stepNumber && maxSteps) {
+    parts.push(`📊 PROGRESS: Step ${stepNumber}/${maxSteps} (you can complete earlier if journey goal met)\n`);
+  }
+  
+  // Show discovered and tracked data from extractedData
+  if (context.extractedData && Object.keys(context.extractedData).length > 0) {
+    parts.push(`\n💾 DISCOVERED DATA (this journey):`);
+    for (const [key, value] of Object.entries(context.extractedData)) {
+      parts.push(`  ${key}: ${value}`);
+    }
+  }
+  
+  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)');
+  }
+  
+  // Recent actions
+  if (context.recentSteps.length > 0) {
+    parts.push(`\nRECENT ACTIONS (last ${context.recentSteps.length}):`);
+    for (const step of context.recentSteps) {
+      const status = step.result === 'success' ? '✓' : '✗';
+      parts.push(`  ${status} ${step.action}`);
+      parts.push(`     ${step.observation}`);
+    }
+  }
+  
+  // Learnings and exploration progress
+  if (context.experiences && context.experiences.length > 0) {
+    parts.push(`\nEXPLORATION NOTES & APP PATTERNS:`);
+    for (const exp of context.experiences) {
+      parts.push(`  • ${exp}`);
+    }
+  }
+  
+  // Note from previous iteration
+  if (context.noteFromPreviousIteration) {
+    parts.push(`\n📝 YOUR NOTE FROM LAST ITERATION:`);
+    parts.push(`   ${context.noteFromPreviousIteration.content}`);
+  }
+  
+  parts.push(`\n🤔 DECIDE YOUR NEXT ACTION TO ACHIEVE THIS JOURNEY'S GOAL:`);
+  parts.push(`1. What does THIS journey's goal require?`);
+  parts.push(`2. What's available on the current page relevant to the goal?`);
+  parts.push(`3. What have you already explored in this journey? (check history, experiences, extractedData)`);
+  parts.push(`4. What should you explore/test next?`);
+  parts.push(`5. Is THIS journey's goal achieved? If yes, mark status="complete"`);
+  
+  return parts.join('\n');
+}
+```
+
+---
+
+## Phase 3: Add Exploration Execution to OrchestratorAgent
+
+### 3.1 Add executeExploration Method
+
+**File**: `runner-core/src/orchestrator/orchestrator-agent.ts`
+
+Add method that runs one journey's exploration loop:
+
+```typescript
+/**
+ * Execute exploration mode - agent autonomously explores to achieve journey goal
+ * Fires onStepProgress callbacks for each autonomous action (transparent to caller)
+ */
+async executeExploration(
+  page: any,
+  explorationConfig: ExplorationMode,
+  jobId: string
+): Promise<OrchestratorStepResult> {
+  this.logger?.(`\n[Orchestrator] ========== EXPLORATION MODE ==========`);
+  this.logger?.(`[Orchestrator] 🎯 Journey Goal: ${explorationConfig.explorationPrompt}`);
+  if (explorationConfig.testDataPrompt) {
+    this.logger?.(`[Orchestrator] 📋 Test Data: ${explorationConfig.testDataPrompt}`);
+  }
+  
+  const memory: JourneyMemory = {
+    history: [],
+    experiences: [],
+    extractedData: {}
+  };
+  
+  const maxSteps = explorationConfig.maxExplorationSteps || 50;
+  let stepNumber = 0;
+  const commandsExecuted: string[] = [];
+  
+  while (stepNumber < maxSteps) {
+    stepNumber++;
+    
+    this.logger?.(`\n[Orchestrator] === Exploration Step ${stepNumber}/${maxSteps} ===`);
+    
+    // Build exploratory context
+    const context = await this.buildExploratoryContext(
+      page,
+      explorationConfig.explorationPrompt,
+      explorationConfig.testDataPrompt,
+      memory,
+      stepNumber,
+      maxSteps
+    );
+    
+    // Call agent with exploratory prompt
+    const decision = await this.callExploratoryAgent(
+      context,
+      jobId,
+      stepNumber
+    );
+    
+    this.logAgentDecision(decision, stepNumber);
+    
+    // Report step start (CRITICAL - fires JourneyRunner's beforeStepStart callback)
+    if (this.progressReporter?.onStepProgress) {
+      // Note: We fire onStepProgress with IN_PROGRESS first, then again with SUCCESS/FAILED
+      // This allows journey-runner to call beforeStepStart, then onStepComplete
+      // The stepId format allows journey-runner to track these as autonomous exploration steps
+      const stepInfo = {
+        stepNumber,
+        stepId: `exploration-${stepNumber}-${Date.now()}`,
+        description: decision.reasoning,
+        code: '',  // Will be filled after commands execute
+        status: StepExecutionStatus.IN_PROGRESS,
+        wasRepaired: false
+      };
+      await this.progressReporter.onStepProgress(stepInfo);
+    }
+    
+    // Execute tools if requested
+    if (decision.toolCalls && decision.toolCalls.length > 0) {
+      const toolResults = await this.executeTools(decision.toolCalls, page, memory, stepNumber);
+      
+      // If needs tool results, call agent again
+      if (decision.needsToolResults) {
+        const updatedContext = { ...context, toolResults };
+        const continuedDecision = await this.callExploratoryAgent(updatedContext, jobId, stepNumber);
+        
+        decision.commands = continuedDecision.commands || decision.commands;
+        decision.commandReasoning = continuedDecision.commandReasoning || decision.commandReasoning;
+        decision.status = continuedDecision.status;
+      }
+    }
+    
+    // Handle blocker clearing
+    if (decision.blockerDetected && decision.blockerDetected.clearingCommands) {
+      this.logger?.(`[Orchestrator] 🚧 Clearing blocker: ${decision.blockerDetected.description}`);
+      const blockerResult = await this.executeCommandsSequentially(
+        decision.blockerDetected.clearingCommands,
+        page,
+        memory,
+        stepNumber,
+        1,
+        jobId
+      );
+      commandsExecuted.push(...blockerResult.executed);
+    }
+    
+    // Execute exploration commands
+    let commandsSucceeded = true;
+    if (decision.commands && decision.commands.length > 0) {
+      const executeResult = await this.executeCommandsSequentially(
+        decision.commands,
+        page,
+        memory,
+        stepNumber,
+        1,
+        jobId
+      );
+      commandsExecuted.push(...executeResult.executed);
+      commandsSucceeded = executeResult.allSucceeded;
+    }
+    
+    // Report step completion (CRITICAL - fires JourneyRunner's onStepComplete callback)
+    if (this.progressReporter?.onStepProgress) {
+      const stepInfo = {
+        stepNumber,
+        stepId: `exploration-${stepNumber}-${Date.now()}`,
+        description: decision.reasoning,
+        code: decision.commands?.join('\n') || '',
+        status: commandsSucceeded ? StepExecutionStatus.SUCCESS : StepExecutionStatus.FAILED,
+        error: commandsSucceeded ? undefined : 'Command execution failed',
+        wasRepaired: false
+      };
+      await this.progressReporter.onStepProgress(stepInfo);
+    }
+    
+    // Add experiences (both app patterns AND exploration progress)
+    if (decision.experiences) {
+      memory.experiences.push(...decision.experiences);
+      if (memory.experiences.length > this.config.maxExperiences) {
+        memory.experiences = memory.experiences.slice(-this.config.maxExperiences);
+      }
+    }
+    
+    // Store note for next iteration
+    if (decision.noteToFutureSelf) {
+      memory.latestNote = {
+        fromIteration: stepNumber,
+        content: decision.noteToFutureSelf
+      };
+    }
+    
+    // Check termination
+    if (decision.status === 'complete') {
+      this.logger?.(`[Orchestrator] ✅ Journey exploration complete: ${decision.statusReasoning}`);
+      return {
+        success: true,
+        commands: commandsExecuted,
+        iterations: stepNumber,
+        terminationReason: 'complete',
+        memory
+      };
+    } else if (decision.status === 'stuck') {
+      this.logger?.(`[Orchestrator] ❌ Exploration stuck: ${decision.statusReasoning}`);
+      return {
+        success: false,
+        commands: commandsExecuted,
+        iterations: stepNumber,
+        terminationReason: 'agent_stuck',
+        memory,
+        error: decision.statusReasoning
+      };
+    }
+  }
+  
+  // Hit max steps - not necessarily a failure
+  this.logger?.(`[Orchestrator] ⚠ Maximum exploration steps reached (budget limit)`);
+  return {
+    success: true,  // Not a failure - just budget limit
+    commands: commandsExecuted,
+    iterations: stepNumber,
+    terminationReason: 'system_limit',
+    memory
+  };
+}
+
+private async buildExploratoryContext(
+  page: any,
+  explorationPrompt: string,
+  testDataPrompt: string | undefined,
+  memory: JourneyMemory,
+  stepNumber: number,
+  maxSteps: number
+): Promise<AgentContext> {
+  const currentPageInfo = await getEnhancedPageInfo(page);
+  const currentURL = page.url();
+  const recentSteps = memory.history.slice(-this.config.recentStepsCount);
+  
+  return {
+    overallGoal: explorationPrompt,
+    currentStepGoal: explorationPrompt,  // Same as overall for single journey
+    stepNumber,
+    totalSteps: maxSteps,
+    completedSteps: [],
+    remainingSteps: [],
+    currentPageInfo,
+    currentURL,
+    recentSteps,
+    experiences: memory.experiences,
+    extractedData: memory.extractedData,
+    noteFromPreviousIteration: memory.latestNote
+  };
+}
+
+private async callExploratoryAgent(
+  context: AgentContext,
+  jobId: string,
+  stepNumber: number
+): Promise<AgentDecision> {
+  const toolDescriptions = this.toolRegistry.generateToolDescriptions();
+  const systemPrompt = OrchestratorPrompts.buildExploratorySystemPrompt(toolDescriptions);
+  const userPrompt = OrchestratorPrompts.buildExploratoryUserPrompt(
+    context,
+    context.overallGoal,
+    undefined,  // testDataPrompt already in explorationConfig
+    stepNumber,
+    context.totalSteps
+  );
+  
+  const llmRequest = {
+    model: DEFAULT_MODEL,
+    systemPrompt,
+    userPrompt
+  };
+  
+  const response = await this.llmFacade.llmProvider.callLLM(llmRequest);
+  
+  // Report token usage
+  if (response.usage && this.progressReporter?.onTokensUsed) {
+    await this.progressReporter.onTokensUsed({
+      jobId,
+      stepNumber,
+      iteration: 1,
+      inputTokens: response.usage.inputTokens,
+      outputTokens: response.usage.outputTokens,
+      includesImage: false,
+      model: DEFAULT_MODEL,
+      timestamp: Date.now()
+    });
+  }
+  
+  // Parse response (same JSON format as regular mode)
+  const decision = this.parseAgentDecision(response.content);
+  return decision;
+}
+```
+
+---
+
+## Phase 4: Extend SmartTestRunnerCoreV2
+
+### 4.1 Add Exploration Mode Support
+
+**File**: `scriptservice/smart-test-runner-core-v2.ts`
+
+Add explorationMode to config:
+
+```typescript
+export interface RunnerConfig {
+  playwrightConfig?: string;
+  model?: string;
+  repairFlexibility?: number;
+  callbacks?: RunnerLifecycleCallbacks;
+  page?: Page;
+  browser?: Browser;
+  context?: BrowserContext;
+  maxRetriesPerStep?: number;
+  journeyExplorationMode?: {         // NEW
+    enabled: boolean;
+    journeyFocusPrompt: string;
+    testDataPrompt?: string;
+    maxExplorationSteps?: number;
+  };
+}
+```
+
+Add exploration execution method:
+
+```typescript
+/**
+ * Run exploration mode - agent autonomously explores to achieve journey goal
+ * Delegates to runner-core's orchestrator which fires onStepComplete for each action
+ */
+async runJourneyExploration(jobId?: string): Promise<RunExactlyResult> {
+  try {
+    logger.info(`SmartTestRunnerCoreV2.runJourneyExploration: Starting`);
+    
+    if (!this.config.journeyExplorationMode?.enabled) {
+      throw new Error('Journey exploration mode not enabled in config');
+    }
+    
+    // Call beforeStartTest
+    if (this.config.callbacks?.beforeStartTest) {
+      await this.config.callbacks.beforeStartTest(this.page, this.browser, this.context);
+    }
+    
+    // Call runner-core's orchestrator in exploration mode
+    // Orchestrator will autonomously explore and fire onStepComplete for each action
+    const result = await this.runnerCore.executeExploration(
+      this.page,
+      {
+        enabled: true,
+        explorationPrompt: this.config.journeyExplorationMode.journeyFocusPrompt,
+        testDataPrompt: this.config.journeyExplorationMode.testDataPrompt,
+        maxExplorationSteps: this.config.journeyExplorationMode.maxExplorationSteps || 50
+      },
+      jobId || ''
+    );
+    
+    // Call afterEndTest
+    if (this.config.callbacks?.afterEndTest) {
+      const status = result.success ? 'passed' : 'failed';
+      await this.config.callbacks.afterEndTest(status, result.error, this.page);
+    }
+    
+    return {
+      success: result.success,
+      error: result.error
+    };
+  } catch (error: any) {
+    logger.error(`SmartTestRunnerCoreV2.runJourneyExploration: Error - ${error.message}`);
+    
+    if (this.config.callbacks?.afterEndTest) {
+      await this.config.callbacks.afterEndTest('failed', error.message, this.page);
+    }
+    
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+```
+
+---
+
+## Phase 5: Rename and Extend JourneyRunner (minimal changes)
+
+### 5.1 Rename Files and Types
+
+**Renames:**
+- `test-based-explorer.ts` → `journey-runner.ts`
+- `TestBasedExplorer` class → `JourneyRunner`
+- `TestBasedExplorationTask` → `JourneyTask`
+
+### 5.2 Extend JourneyTask Model
+
+**File**: `scriptservice/utils/models.ts`
+
+```typescript
+export interface JourneyTask {
+  // ... all existing fields
+  
+  // NEW: Journey-specific exploration mode
+  journeyExplorationMode?: {
+    enabled: boolean;
+    journeyFocusPrompt: string;       // Journey-specific focus prompt
+    testDataPrompt?: string;
+  };
+}
+```
+
+### 5.3 Update JourneyRunner.run() - Minimal Changes
+
+**File**: `scriptservice/workers/journey-runner.ts`
+
+Only ~15 lines of changes:
+
+```typescript
+// Constructor - store exploration mode
+private journeyExplorationMode?: { enabled: boolean; journeyFocusPrompt: string; testDataPrompt?: string; };
+
+constructor(task: JourneyTask, ...callbacks) {
+  // ... existing code
+  this.journeyExplorationMode = task.journeyExplorationMode;
+}
+
+public async run() {
+  // ... existing setup code (unchanged)
+  
+  try {
+    // Parse test steps OR use empty array for exploration
+    let codeUnits: CodeUnit[] = [];
+    if (!this.journeyExplorationMode?.enabled) {
+      // TEST-BASED mode: Parse smart test into code units
+      if (!this.testId) {
+        logger.error('No testId provided');
+        return { result: null };
+      }
+      codeUnits = await this.parseSmartTestIntoCodeUnits();
+      if (codeUnits.length === 0) {
+        logger.error(`No codeUnits found for test ${this.testId}`);
+        return { result: null };
+      }
+      codeUnits = codeUnits.filter(cu => !isNonActionCodeUnit(cu));
+      logger.info('Running TEST-BASED journey');
+    } else {
+      // EXPLORATION mode: No pre-defined steps
+      logger.info(`Running PROMPT-BASED journey with focus: ${this.journeyExplorationMode.journeyFocusPrompt}`);
+    }
+
+    const stepsWithId: TestStepWithId[] = codeUnits.map(cu => ({ ... }));
+
+    // Define callbacks (IDENTICAL FOR BOTH MODES - all existing code)
+    const handleBeforeStartTest = async (...) => { /* existing code */ };
+    const handleBeforeStepStart = async (...) => { /* existing code */ };
+    const handleStepComplete = async (...) => { /* existing code - ALL analytics */ };
+    const handleAfterEndTest = async (...) => { /* existing code */ };
+
+    // Create runner config (SAME FOR BOTH MODES)
+    const runnerConfig: RunnerConfig = {
+      page: this.page!,
+      browser: this.browser!,
+      context: this.context!,
+      maxRetriesPerStep: 3,
+      repairFlexibility: this.aiHealingSettings?.freedomLevel,
+      journeyExplorationMode: this.journeyExplorationMode,  // NEW: Pass through
+      callbacks: { ... }  // Same callbacks
+    };
+
+    // Create runner (SAME FOR BOTH MODES)
+    const runner = new SmartTestRunnerCoreV2(runnerConfig);
+
+    // Execute based on mode
+    let result;
+    if (this.journeyExplorationMode?.enabled) {
+      // EXPLORATION: Orchestrator decides next steps autonomously
+      result = await runner.runJourneyExploration(this.invocationId);
+    } else {
+      // TEST-BASED: Execute predefined steps with repair
+      result = await runner.runWithRepair(stepsWithId, this.invocationId, false, 0);
+    }
+    
+    if (!result.success) {
+      throw new Error(`Execution failed: ${result.error}`);
+    }
+
+  } catch (error) {
+    // ... existing error handling
+  } finally {
+    // ... existing cleanup
+  }
+}
+```
+
+**That's it!** Only ~15 lines of changes:
+1. Store `journeyExplorationMode` in constructor
+2. Skip step parsing if exploration mode enabled
+3. Pass `journeyExplorationMode` to `RunnerConfig`
+4. Call `runJourneyExploration()` vs `runWithRepair()`
+
+All callbacks unchanged - they fire identically for both modes.
+
+---
+
+## Phase 6: Extend AppExplorer for Prompt-Based Journey Orchestration
+
+### 6.1 Add Journey-Prompt Generation
+
+**File**: `scriptservice/workers/app-explorer.ts`
+
+Modify `run()` around line 154:
+
+```typescript
+if (this.config.promptConfig) {
+  // Prompt-based exploration - orchestrate multiple journeys
+  logger.info("Running prompt-based exploration (multi-journey)");
+  await this.runPromptBasedMultiJourneyExploration();
+}
+```
+
+Add new method:
+
+```typescript
+/**
+ * Prompt-based exploration: Orchestrate multiple journeys
+ * Uses LLM to generate journey-specific prompts based on overall goal and learnings
+ */
+private async runPromptBasedMultiJourneyExploration(): Promise<void> {
+  const promptConfig = this.config.promptConfig!;
+  const overallExplorationGoal = promptConfig.explorePrompt || "Explore the application";
+  const testDataPrompt = promptConfig.testDataPrompt;
+  
+  logger.info(`Overall exploration goal: ${overallExplorationGoal}`);
+  logger.info(`Max journeys: ${this.config.maxJourneys}, Max credits: ${this.config.maxCredits}`);
+  
+  let journeysCompleted = 0;
+  const maxJourneys = this.config.maxJourneys || 10;
+  
+  while (journeysCompleted < maxJourneys && this.creditsUsed < (this.config.maxCredits || 100)) {
+    journeysCompleted++;
+    
+    logger.info(`\n=== Journey ${journeysCompleted}/${maxJourneys} ===`);
+    
+    // Use LLM to decide next journey focus based on:
+    // - Overall exploration goal
+    // - Mindmap (what's been explored via getExploredScreenStates())
+    // - Learnings from previous journeys
+    const journeyFocusPrompt = await this.generateNextJourneyPrompt(
+      overallExplorationGoal,
+      journeysCompleted,
+      maxJourneys
+    );
+    
+    if (!journeyFocusPrompt) {
+      logger.info('No more journeys needed - exploration goal met');
+      break;
+    }
+    
+    logger.info(`Journey ${journeysCompleted} focus: ${journeyFocusPrompt}`);
+    
+    // Run this journey
+    await this.runSinglePromptBasedJourney(journeyFocusPrompt, testDataPrompt);
+    
+    // Update mindmap and progress
+    await this.updateMindMapFromJourney();
+  }
+  
+  logger.info(`Prompt-based exploration complete: ${journeysCompleted} journeys, ${this.creditsUsed} credits used`);
+}
+
+/**
+ * Use LLM to generate next journey-specific prompt
+ * Based on overall goal, mindmap, and learnings from prior journeys
+ */
+private async generateNextJourneyPrompt(
+  overallGoal: string,
+  journeyNumber: number,
+  maxJourneys: number
+): Promise<string | null> {
+  // Get explored screen states from mindmap
+  const exploredScreens = this.getExploredScreenStates();
+  const unexploredScreens = this.getUnexploredScreenStates();
+  
+  // Build prompt for LLM to decide next journey
+  const prompt = `You are planning the next exploration journey for a web application.
+
+OVERALL EXPLORATION GOAL: ${overallGoal}
+
+PROGRESS SO FAR:
+- Journey ${journeyNumber}/${maxJourneys}
+- Credits used: ${this.creditsUsed}/${this.config.maxCredits}
+- Explored screens: ${exploredScreens.map(s => s.name).join(', ') || 'None yet'}
+- Unexplored screens: ${unexploredScreens.map(s => s.name).join(', ') || 'None discovered'}
+
+LEARNINGS FROM PREVIOUS JOURNEYS:
+${this.getJourneyLearnings()}
+
+YOUR TASK: Decide what to explore in the NEXT journey.
+- Generate a specific, focused exploration prompt for ONE journey
+- Example: "Explore Dashboard and test all widgets (Sales, Analytics, Tasks)"
+- Example: "Navigate to Settings and test user profile management"
+- If the overall goal is largely met or no clear next journey, return empty string
+
+OUTPUT FORMAT (JSON):
+{
+  "journeyFocusPrompt": "Specific prompt for next journey" OR "",
+  "reasoning": "Why this journey focus"
+}`;
+
+  try {
+    const result = await callLLM(prompt);
+    const parsed = JSON.parse(result);
+    
+    if (!parsed.journeyFocusPrompt || parsed.journeyFocusPrompt.trim() === '') {
+      return null;
+    }
+    
+    logger.info(`Next journey reasoning: ${parsed.reasoning}`);
+    return parsed.journeyFocusPrompt;
+  } catch (error) {
+    logger.error(`Failed to generate journey prompt: ${error}`);
+    return null;
+  }
+}
+
+/**
+ * Execute a single prompt-based journey with given focus
+ */
+private async runSinglePromptBasedJourney(
+  journeyFocusPrompt: string,
+  testDataPrompt?: string
+): Promise<void> {
+  // Create journey task
+  const task: JourneyTask = {
+    invocationId: uuidv4(),
+    invocationBatchId: this.explorationId,
+    projectId: this.task.projectId,
+    appReleaseId: this.config.webappReleaseVersion ?? "default",
+    autohealEnabled: false,
+    sessionRecordApiKey: this.task.sessionRecordApiKey,
+    ingressEndpoint: await ConfigService.get('test_service_endpoint'),
+    enableTestchimpSdkOnExec: false,
+    urlRegexToCapture: ".*",
+    playwrightConfig: this.config.playwrightConfig,
+    creditBudget: this.getCreditsForNextJourney(),
+    bugCaptureSettings: this.config.bugCaptureSettings,
+    viewportConfig: this.config.viewportConfig,
+    
+    // Enable journey exploration mode with focused prompt
+    journeyExplorationMode: {
+      enabled: true,
+      journeyFocusPrompt,       // Journey-specific focus
+      testDataPrompt
+    }
+  };
+  
+  // Use JourneyRunner (handles both test-based and prompt-based)
+  const runner = new JourneyRunner(
+    task,
+    this.onBugsDiscovered.bind(this),
+    this.onScreenStateVisited.bind(this),
+    this.shouldVisualAnalyzeScreen?.bind(this),
+    this.getVisualAnalysisDecision?.bind(this),
+    this.shouldAnalyzeApiCall?.bind(this),
+    this.reportVisualAnalyzedScreen?.bind(this),
+    this.reportVisualAnalyzedScreenshot?.bind(this),
+    this.reportAnalyzedApiCalls?.bind(this),
+    this.getKnownScreenStates?.bind(this),
+    this.updateInputValueCombinations?.bind(this),
+    this.reportPageNavigation?.bind(this),
+    this.onTokensUsed?.bind(this),
+    this.updateLatestScreenshot?.bind(this)
+  );
+  
+  await runner.run();
+}
+
+// Helper methods
+private getExploredScreenStates(): ScreenState[] {
+  // Return screens that have been explored (from mindmap)
+  // Implementation depends on existing mindmap structure
+  return this.screenStateRegistry.filter(s => s.explorationStatus === 'EXPLORED');
+}
+
+private getUnexploredScreenStates(): ScreenState[] {
+  return this.screenStateRegistry.filter(s => s.explorationStatus === 'NOT_EXPLORED');
+}
+
+private getJourneyLearnings(): string {
+  // Aggregate learnings from completed journeys
+  // Could be stored in AppExplorer state as journeys complete
+  return this.journeyLearnings.join('\n') || 'No learnings yet';
+}
+
+private async updateMindMapFromJourney(): Promise<void> {
+  // Update mindmap based on journey results
+  // Existing mindmap update logic can be reused
+}
+```
+
+---
+
+## Summary
+
+This plan enables prompt-based exploration with proper multi-journey orchestration:
+
+1. **Runner-Core Extensions**: 
+   - Add `ExplorationMode` type (journey-specific)
+   - Reuse existing `JourneyMemory` fields
+   - Add exploratory prompts to guide autonomous exploration
+   - Add `executeExploration` to orchestrator
+
+2. **JourneyRunner** (formerly TestBasedExplorer - minimal changes ~15 lines):
+   - Rename for clarity
+   - Accept `journeyExplorationMode` config
+   - Skip step parsing if exploration mode
+   - Call `runJourneyExploration()` vs `runWithRepair()`
+   - **All callbacks identical** - transparent to analytics
+
+3. **AppExplorer** (prompt-based multi-journey orchestration - NEW):
+   - Loop through journeys (up to maxJourneys / maxCredits)
+   - Use LLM to generate journey-specific prompts based on:
+     - Overall exploration goal
+     - Mindmap (explored vs unexplored screens)
+     - Learnings from prior journeys
+   - Run each journey via JourneyRunner with focused prompt
+   - Update mindmap and learnings after each journey
+
+4. **Key Insight**: 
+   - **AppExplorer** = Creative journey planning (WHAT to explore next)
+   - **JourneyRunner** = Journey execution (HOW to explore it)
+   - **Runner-Core Orchestrator** = Autonomous action decisions within journey
+
+All analytics, bug capture, screen state detection work identically for both test-based and prompt-based modes.
+