testchimp-runner-core 0.0.34 → 0.0.35

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

@@ -0,0 +1,928 @@
+# 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. This reuses existing infrastructure (tools, memory, command execution) with modified prompting strategies.
+
+**Key Principle**: The orchestrator fires `onStepComplete` for each autonomous action, so test-based-explorer doesn't know or care if steps were pre-defined or autonomously decided. All analytics, bug capture, and screen state detection work identically.
+
+---
+
+## 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;           // High-level goal: "Explore all menu options"
+  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 needed** - existing `JourneyMemory` fields are sufficient:
+
+- **`history`**: Agent reviews to understand visited screens/areas
+- **`experiences`**: Used for BOTH app patterns AND exploration progress
+  - Examples: "Dashboard fully explored - tested all widgets"
+  - Examples: "Discovered Admin menu but not explored yet"
+- **`extractedData`**: Store discovered areas with special keys
+  - Examples: `{ "menuItems": "Dashboard,Settings,Admin,Profile" }`
+  - Examples: `{ "explored": "Dashboard,Settings" }`
+- **`latestNote`**: Tactical memory for exploration strategy
+
+The exploratory prompts guide the agent to use these fields appropriately.
+
+---
+
+## Phase 2: Add Exploratory Prompts
+
+### 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. **GOAL-DRIVEN EXPLORATION**: Follow the exploration prompt as your north star
+   - "Explore all menu options" → Extract menu items, visit each one systematically
+   - "Test dashboard features" → Discover widgets/interactions, test them thoroughly
+   - "Find bugs in settings" → Navigate to settings, try various configurations
+
+2. **AUTONOMOUS DISCOVERY**: You decide what to explore next based on:
+   - The exploration prompt (main goal)
+   - Current page state (what's available now)
+   - Journey history (what's been explored - check history, experiences, extractedData)
+   - Discovered but unvisited areas (stored in extractedData or experiences)
+
+3. **SYSTEMATIC EXPLORATION**: 
+   - Use extract_data tool to discover elements (menus, buttons, links)
+   - Store discoveries in extractedData: { "menuItems": "Dashboard,Settings,Admin" }
+   - Track progress in experiences: "Explored Dashboard - all widgets working"
+   - Check history to avoid re-visiting same areas
+   - Prioritize unexplored areas
+
+4. **CREATIVE TESTING**: Test functionality, don't just navigate
+   - Try different input combinations
+   - Explore edge cases (empty inputs, max lengths, special characters)
+   - Verify features work as expected
+   - 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
+
+6. **STATUS DECISIONS** (CRITICAL):
+   - "continue": More exploration needed to achieve goal
+   - "complete": Exploration goal ACHIEVED (all menus explored, features tested, OR budget running low)
+   - "stuck": Cannot proceed (auth permanently blocked, critical error)
+   
+   You should mark "complete" when:
+   - You've achieved the exploration goal (e.g., all menus explored)
+   - You've made good progress and are approaching budget limit
+   - Further exploration would be repetitive
+   
+   DON'T wait to hit maxExplorationSteps - stop when goal is met!
+
+7. **MEMORY USAGE**:
+   - experiences: Both app patterns AND exploration notes
+     Example: "Settings menu requires admin role to access"
+     Example: "Explored Dashboard completely - 5 widgets all functional"
+   - extractedData: Discovered elements and tracking
+     Example: { "menuItems": "Dashboard,Settings,Admin,Profile" }
+     Example: { "exploredMenus": "Dashboard,Settings" }
+   - history: Review to see what actions were taken
+   - 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
+
+CRITICAL: You're fully autonomous - no step-by-step instructions will be provided.
+YOU decide the exploration path based on the goal, 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('=== EXPLORATION CONTEXT ===\n');
+  parts.push(`🎯 EXPLORATION GOAL: ${explorationPrompt}`);
+  
+  if (testDataPrompt) {
+    parts.push(`📋 TEST DATA/CREDENTIALS: ${testDataPrompt}`);
+  }
+  
+  if (stepNumber && maxSteps) {
+    parts.push(`📊 PROGRESS: Step ${stepNumber}/${maxSteps} (you can complete earlier if goal met)\n`);
+  }
+  
+  // Show what's been explored (from extractedData and experiences)
+  if (context.extractedData && Object.keys(context.extractedData).length > 0) {
+    parts.push(`\n💾 DISCOVERED DATA:`);
+    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 EXPLORATION 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 EXPLORATION ACTION:`);
+  parts.push(`1. What does the exploration goal require?`);
+  parts.push(`2. What's available on the current page?`);
+  parts.push(`3. What have you already explored? (check history, experiences, extractedData)`);
+  parts.push(`4. What should you explore next to achieve the goal?`);
+  parts.push(`5. Is the goal achieved? If yes, mark status="complete" (don't wait for max steps)`);
+  
+  return parts.join('\n');
+}
+```
+
+---
+
+## Phase 3: Extend OrchestratorAgent for Exploration
+
+### 3.1 Add Exploration Execution Method
+
+**File**: `runner-core/src/orchestrator/orchestrator-agent.ts`
+
+Add new method that runs exploration loop (similar to executeStep but for autonomous exploration):
+
+```typescript
+/**
+ * Execute exploration mode - agent autonomously explores based on prompt
+ * Fires callbacks for each autonomous action (transparent to caller)
+ */
+async executeExploration(
+  page: any,
+  explorationConfig: ExplorationMode,
+  progressReporter: ProgressReporter | undefined,
+  jobId: string
+): Promise<OrchestratorStepResult> {
+  this.logger?.(`\n[Orchestrator] ========== EXPLORATORY MODE ==========`);
+  this.logger?.(`[Orchestrator] 🎯 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 progress via callback (CRITICAL - this is how test-based-explorer tracks steps)
+    if (progressReporter?.onStepProgress) {
+      await progressReporter.onStepProgress({
+        stepNumber,
+        stepId: `exploration-${stepNumber}`,
+        description: decision.reasoning,
+        code: decision.commands?.join('\n') || '',
+        status: StepExecutionStatus.IN_PROGRESS,
+        wasRepaired: false
+      });
+    }
+    
+    // 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 test-based-explorer callbacks)
+    if (progressReporter?.onStepProgress) {
+      await progressReporter.onStepProgress({
+        stepNumber,
+        stepId: `exploration-${stepNumber}`,
+        description: decision.reasoning,
+        code: decision.commands?.join('\n') || '',
+        status: commandsSucceeded ? StepExecutionStatus.SUCCESS : StepExecutionStatus.FAILED,
+        error: commandsSucceeded ? undefined : 'Command execution failed',
+        wasRepaired: false
+      });
+    }
+    
+    // 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] ✅ 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 in exploratory mode
+    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 context
+    stepNumber,
+    context.totalSteps
+  );
+  
+  // Call LLM (same as regular mode)
+  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: Wire Through ScenarioService & Worker
+
+### 4.1 Update ScenarioService Interface
+
+**File**: `runner-core/src/scenario-service.ts`
+
+Add explorationMode parameter to processScenario (if using orchestrator):
+
+```typescript
+processScenario(
+  scenario: string, 
+  testName?: string, 
+  config?: PlaywrightConfig, 
+  model?: string, 
+  scenarioFileName?: string,
+  existingBrowser?: any,
+  existingContext?: any,
+  existingPage?: any,
+  explorationMode?: ExplorationMode  // NEW parameter
+): string {
+  const jobId = `scenario_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  
+  const job: ScenarioRunJob = {
+    id: jobId,
+    scenario,
+    testName,
+    playwrightConfig: config,
+    model,
+    scenarioFileName,
+    existingBrowser,
+    existingContext,
+    existingPage,
+    explorationMode  // NEW: Pass through
+  };
+
+  this.jobQueue.push(job);
+  this.processNextJob();
+  
+  return jobId;
+}
+```
+
+### 4.2 Update ScenarioWorker
+
+**File**: `runner-core/src/scenario-worker-class.ts`
+
+Handle explorationMode in processScenarioJob - when exploration mode is enabled and orchestrator is active, call executeExploration instead of building a scenario script.
+
+---
+
+## Phase 5: Extend SmartTestRunnerCoreV2
+
+### 5.1 Pass Exploration Config to Runner-Core
+
+**File**: `scriptservice/smart-test-runner-core-v2.ts`
+
+Modify constructor to accept explorationMode:
+
+```typescript
+export interface RunnerConfig {
+  playwrightConfig?: string;
+  model?: string;
+  repairFlexibility?: number;
+  callbacks?: RunnerLifecycleCallbacks;
+  page?: Page;
+  browser?: Browser;
+  context?: BrowserContext;
+  maxRetriesPerStep?: number;
+  explorationMode?: ExplorationMode;  // NEW
+}
+
+constructor(config: RunnerConfig) {
+  this.config = config;
+  // ... existing code
+  
+  // Initialize runner-core with exploration mode if provided
+  this.runnerCore = new TestChimpService(
+    undefined,
+    undefined,
+    undefined,
+    1,
+    llmProvider,
+    progressReporter,
+    {
+      useOrchestrator: true,  // Enable orchestrator for exploration
+      orchestratorConfig: {
+        explorationMode: config.explorationMode  // Pass exploration config
+      }
+    }
+  );
+}
+```
+
+Add exploration execution method:
+
+```typescript
+/**
+ * Run exploration mode - agent autonomously explores based on prompt
+ * Delegates to runner-core's orchestrator which fires onStepComplete for each action
+ */
+async runExploration(jobId?: string): Promise<RunExactlyResult> {
+  try {
+    logger.info(`SmartTestRunnerCoreV2.runExploration: Starting`);
+    
+    if (!this.config.explorationMode?.enabled) {
+      throw new Error('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,
+      this.config.explorationMode,
+      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.runExploration: 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 6: Minimal Changes to Test-Based-Explorer
+
+### 6.1 Extend TestBasedExplorationTask
+
+**File**: `scriptservice/utils/models.ts`
+
+Add exploration mode fields:
+
+```typescript
+export interface TestBasedExplorationTask {
+  // ... existing fields
+  
+  // NEW: Exploration mode support
+  explorationMode?: {
+    enabled: boolean;
+    explorationPrompt: string;
+    testDataPrompt?: string;
+  };
+}
+```
+
+### 6.2 Update Test-Based-Explorer Constructor
+
+**File**: `scriptservice/workers/test-based-explorer.ts`
+
+Store exploration config:
+
+```typescript
+private explorationMode?: { enabled: boolean; explorationPrompt: string; testDataPrompt?: string; };
+
+constructor(task: TestBasedExplorationTask, ...callbacks) {
+  // ... existing code
+  this.explorationMode = task.explorationMode;
+}
+```
+
+### 6.3 Modify run() Method - Minimal Changes
+
+**File**: `scriptservice/workers/test-based-explorer.ts`
+
+Change around line 420-690:
+
+```typescript
+public async run() {
+  let testFullName = `${this.testName?.suite}#${this.testName?.name}`;
+  try {
+    logger.info("Running test...");
+    await this.setup();
+    await this.journeyReporter?.startJourney()
+  } catch (error) {
+    logger.error("Exception in worker:", error);
+    await updateJourneyExecutionStatus(this.invocationId, JourneyExecutionStatus.EXCEPTION_IN_JOURNEY_EXECUTION);
+    return {
+      status: 'error',
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+
+  let startTimeMillis: number = Date.now();
+  let endReason = "";
+  
+  try {
+    // Parse test steps OR use empty array for exploration
+    let codeUnits: CodeUnit[] = [];
+    if (!this.explorationMode?.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));
+    } else {
+      // EXPLORATION mode: No pre-defined steps
+      logger.info(`EXPLORATION MODE: ${this.explorationMode.explorationPrompt}`);
+    }
+
+    // Convert to TestStepWithId format
+    const stepsWithId: TestStepWithId[] = codeUnits.map(cu => ({
+      stepId: cu.id || uuidv4(),
+      description: cu.description,
+      code: cu.code,
+    }));
+
+    // Track state for step callbacks (SAME FOR BOTH MODES)
+    let stepTimestamps = new Map<string, number>();
+
+    // Define callbacks (IDENTICAL FOR BOTH TEST-BASED AND EXPLORATION)
+    const handleBeforeStartTest = async (page: Page, browser: Browser, context: BrowserContext) => {
+      await this.initializeWatcherAndListeners();
+      logger.info('Test setup complete, starting execution');
+    };
+
+    const handleBeforeStepStart = async (step: TestStepWithId, page: Page) => {
+      const stepId = step.stepId || '';
+      const stepTimestamp = Date.now();
+      stepTimestamps.set(stepId, stepTimestamp);
+      this.journeyReporter?.startStep(stepId);
+      this.currentStepCodeExecutions = [];
+    };
+
+    const handleStepComplete = async (step: TestStepWithId, isRepairStep: boolean, repairForStepId: string | undefined, error: string | undefined, page: Page) => {
+      // ... EXISTING CODE (lines 466-648) - NO CHANGES
+      // All analytics, screenshot, bug capture, screen state detection - IDENTICAL
+    };
+
+    const handleAfterEndTest = async (status: 'passed' | 'failed', error: string | undefined, page: Page) => {
+      // ... EXISTING CODE (lines 650-666) - NO CHANGES
+    };
+
+    // 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,
+      explorationMode: this.explorationMode,  // NEW: Pass exploration config
+      callbacks: {
+        beforeStartTest: handleBeforeStartTest,
+        beforeStepStart: handleBeforeStepStart,
+        onStepComplete: handleStepComplete,
+        afterEndTest: handleAfterEndTest
+      }
+    };
+
+    // Create runner (SAME FOR BOTH MODES)
+    const runner = new SmartTestRunnerCoreV2(runnerConfig);
+    logger.info(`test-based-explorer: using SmartTestRunnerCoreV2 (runner-core)`);
+
+    // Execute based on mode
+    let result;
+    if (this.explorationMode?.enabled) {
+      // EXPLORATION: Let orchestrator decide next steps autonomously
+      result = await runner.runExploration(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 - NO CHANGES
+  } finally {
+    // ... EXISTING CLEANUP - NO CHANGES
+  }
+}
+```
+
+**That's it!** Only ~10 lines of changes in test-based-explorer:
+1. Store explorationMode in constructor
+2. Skip parsing steps if exploration mode
+3. Pass explorationMode to RunnerConfig
+4. Call runExploration() instead of runWithRepair()
+
+All callbacks remain identical - orchestrator fires them for each autonomous action.
+
+---
+
+## Phase 7: Wire Up AppExplorer
+
+### 7.1 Handle PromptConfig in AppExplorer
+
+**File**: `scriptservice/workers/app-explorer.ts`
+
+Modify around line 154:
+
+```typescript
+if (this.config.promptConfig) {
+  // Prompt-based exploration - use test-based-explorer with exploration mode
+  logger.info("Running prompt-based exploration");
+  await this.runPromptBasedExploration();
+}
+
+// Add new method
+private async runPromptBasedExploration(): Promise<void> {
+  const promptConfig = this.config.promptConfig!;
+  
+  // Create exploration task (reuses TestBasedExplorationTask)
+  const task: TestBasedExplorationTask = {
+    invocationId: uuidv4(),
+    invocationBatchId: this.explorationId,
+    projectId: this.task.projectId,
+    appReleaseId: this.config.webappReleaseVersion ?? "default",
+    autohealEnabled: false,  // Not needed for exploration
+    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,
+    
+    // NEW: Enable exploration mode
+    explorationMode: {
+      enabled: true,
+      explorationPrompt: promptConfig.explorePrompt || "Explore the application",
+      testDataPrompt: promptConfig.testDataPrompt
+    }
+  };
+  
+  // Use test-based-explorer (it handles both modes transparently)
+  const explorer = new TestBasedExplorer(
+    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 explorer.run();
+}
+```
+
+---
+
+## Summary
+
+This plan enables exploratory mode with minimal changes:
+
+1. **Runner-Core Extensions**: 
+   - Add `ExplorationMode` type (removed `explorationStrategy`)
+   - Rename `explorationContext` to `testDataPrompt`
+   - Reuse existing `JourneyMemory` fields
+   - Add exploratory prompts that guide agent to use memory creatively
+   - Add `executeExploration` method to orchestrator
+
+2. **Autonomous Decision-Making**: 
+   - Agent decides next actions based on: exploration prompt + page state + memory
+   - Agent can stop early when goal achieved (doesn't wait for maxSteps)
+   - Agent tracks progress using existing memory fields (experiences, extractedData)
+
+3. **Reuse Infrastructure**: 
+   - Same tools (extract_data, screenshot, recall_history)
+   - Same command execution
+   - Same callback system (onStepComplete fires for each autonomous action)
+
+4. **Minimal Test-Based-Explorer Changes** (~10 lines):
+   - Check if explorationMode enabled
+   - Skip step parsing if exploration
+   - Pass explorationMode to runner config
+   - Call runExploration() vs runWithRepair()
+   - **All callbacks identical** - works transparently
+
+5. **Preserve Analytics**: 
+   - All bug capture, screenshot analysis, screen state detection, console/network analytics work identically
+   - test-based-explorer doesn't know if steps were pre-defined or autonomous
+
+### Implementation Order
+
+1. Add types to runner-core (`ExplorationMode`, extend `AgentConfig`)
+2. Add exploratory prompts to orchestrator-prompts.ts
+3. Add `executeExploration` to orchestrator-agent.ts
+4. Add `explorationMode` to `RunnerConfig` in SmartTestRunnerCoreV2
+5. Add `runExploration` method to SmartTestRunnerCoreV2
+6. Add `explorationMode` field to `TestBasedExplorationTask`
+7. Modify test-based-explorer.ts `run()` method (~10 lines)
+8. Add `runPromptBasedExploration` to app-explorer.ts
+9. Test with sample exploration prompts
+