explorbot 0.1.9 → 0.1.11

package/src/execution-controller.ts

@@ -10,6 +10,7 @@ export class ExecutionController extends EventEmitter {
   private inputCallback: InputCallback | null = null;
   private interruptResolvers: Array<() => void> = [];
   private abortController: AbortController | null = null;
+  private awaitingInput = false;
 
   private constructor() {
     super();
@@ -48,6 +49,10 @@ export class ExecutionController extends EventEmitter {
     this.emit('idle');
   }
 
+  isAwaitingInput(): boolean {
+    return this.awaitingInput;
+  }
+
   isInterrupted(): boolean {
     return this.interrupted;
   }
@@ -77,11 +82,16 @@ export class ExecutionController extends EventEmitter {
   }
 
   async requestInput(prompt: string): Promise<string | null> {
-    if (this.inputCallback) {
-      return await this.inputCallback(prompt);
+    if (!this.inputCallback) {
+      return await this.readlineInput(prompt);
     }
 
-    return await this.readlineInput(prompt);
+    this.awaitingInput = true;
+    try {
+      return await this.inputCallback(prompt);
+    } finally {
+      this.awaitingInput = false;
+    }
   }
 
   private async readlineInput(prompt: string): Promise<string | null> {
@@ -103,6 +113,7 @@ export class ExecutionController extends EventEmitter {
     this.interrupted = false;
     this.interruptResolvers = [];
     this.abortController = null;
+    this.awaitingInput = false;
   }
 }
 

package/src/experience-tracker.ts

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
 import matter from 'gray-matter';
-import { marked, type Tokens } from 'marked';
+import { type Tokens, marked } from 'marked';
 import type { ActionResult } from './action-result.js';
 import { ConfigParser } from './config.js';
 import { KnowledgeTracker } from './knowledge-tracker.js';
@@ -13,6 +13,25 @@ import { extractStatePath } from './utils/url-matcher.js';
 const debugLog = createDebug('explorbot:experience');
 const DEFAULT_MAX_EXPERIENCE_LINES = 100;
 
+export const RECENT_WINDOW_DAYS = 30;
+
+/**
+ * Stores and reads per-page experience files (`./experience/<stateHash>.md`).
+ *
+ * Two writers, two contracts:
+ *
+ *   writeFlow(state, body, relatedUrls?)  — caller hands in a fully-formatted
+ *                                            `## FLOW: <imperative title>` block (multi-step,
+ *                                            `*` bullets + optional ```js``` + `>` discovery,
+ *                                            ends with `---`). Tracker dedups + prepends.
+ *   writeAction(state, ActionInput)        — `## ACTION: <imperative title>`, single-step,
+ *                                            optional `Solution:` line + one ```js``` code block.
+ *                                            Title normalized via normalizeTitle().
+ *
+ * - Always h2. Never h3 for FLOW/ACTION.
+ * - On read (getSuccessfulExperience), headings are rendered as
+ *   `## HOW to <title> (multi-step|single-step)` so prompts get natural phrasing.
+ */
 export class ExperienceTracker {
   private experienceDir: string;
   private disabled: boolean;
@@ -144,35 +163,57 @@ export class ExperienceTracker {
     return this.knowledgeTracker.getRelevantKnowledge(state).some((k) => k.noExperienceWriting === true || k.noExperienceWriting === 'true');
   }
 
-  async saveSuccessfulResolution(state: ActionResult, originalMessage: string, code: string, explanation?: string): Promise<void> {
+  writeAction(state: ActionResult, action: ActionInput): void {
     if (this.disabled || this.isWritingDisabled(state)) return;
+    if (!action.code?.trim()) return;
 
     this.ensureExperienceFile(state);
     const stateHash = state.getStateHash();
     const { content, data } = this.readExperienceFile(stateHash);
-    if (content.includes(code)) {
-      debugLog('Skipping duplicate successful resolution', code);
+    if (content.includes(action.code)) {
+      debugLog('Skipping duplicate action', action.code);
       return;
     }
 
-    const filteredCode = code.replace(/I\.amOnPage\s*\([^)]*\)/gs, '');
-    const newEntryContent = `### SUCCEEDED: ${originalMessage.split('\n')[0]}
+    const title = normalizeTitle(action.title.split('\n')[0]);
+    if (!title) return;
 
-${explanation ? `Solution: ${explanation}` : ''}
+    const filteredCode = action.code.replace(/I\.amOnPage\s*\([^)]*\)/gs, '');
+    const newEntry = generateActionContent(title, filteredCode, action.explanation);
+    const updatedContent = `${newEntry}\n\n${content}`;
+    this.writeExperienceFile(stateHash, updatedContent, data);
+
+    tag('substep').log(` Added ACTION to: ${stateHash}.md`);
+  }
+
+  writeFlow(state: ActionResult, body: string, relatedUrls?: string[]): void {
+    if (this.disabled || this.isWritingDisabled(state)) return;
+    if (!body?.trim()) return;
 
-\`\`\`javascript
-${filteredCode}
-\`\`\`
-`;
+    this.ensureExperienceFile(state);
+    const stateHash = state.getStateHash();
+    const { content, data } = this.readExperienceFile(stateHash);
+
+    if (content.includes(body)) {
+      debugLog('Skipping duplicate flow body');
+      return;
+    }
+
+    if (relatedUrls?.length) {
+      const currentPath = extractStatePath(state.url || '');
+      const existingRelated = Array.isArray(data.related) ? data.related : [];
+      const allRelated = [...new Set([...existingRelated, ...relatedUrls])];
+      data.related = allRelated.filter((url) => url !== currentPath);
+    }
 
-    const updatedContent = `${newEntryContent}\n\n${content}`;
+    const updatedContent = `${body}\n${content}`;
     this.writeExperienceFile(stateHash, updatedContent, data);
 
-    tag('substep').log(` Added successful resolution to: ${stateHash}.md`);
+    tag('substep').log(`Added FLOW to: ${stateHash}.md`);
   }
 
-  getAllExperience(): { filePath: string; data: any; content: string }[] {
-    const allFiles: { filePath: string; data: any; content: string }[] = [];
+  getAllExperience(): ExperienceFile[] {
+    const allFiles: ExperienceFile[] = [];
 
     for (const experienceDir of this.getExperienceDirectories()) {
       if (!existsSync(experienceDir)) {
@@ -188,10 +229,12 @@ ${filteredCode}
           try {
             const content = readFileSync(file, 'utf8');
             const parsed = matter(content);
+            const mtime = statSync(file).mtime;
             allFiles.push({
               filePath: file,
               data: parsed.data,
               content: parsed.content,
+              mtime,
             });
           } catch (error) {
             debugLog(`Failed to read experience file ${file}:`, error);
@@ -205,7 +248,7 @@ ${filteredCode}
     return allFiles;
   }
 
-  getRelevantExperience(state: ActionResult, options?: { includeDescendantExperience?: boolean }): { filePath: string; data: any; content: string }[] {
+  getRelevantExperience(state: ActionResult, options?: { includeDescendantExperience?: boolean }): ExperienceFile[] {
     const relevantKnowledge = this.knowledgeTracker.getRelevantKnowledge(state);
     const readingDisabled = relevantKnowledge.some((knowledge) => knowledge.noExperienceReading === true || knowledge.noExperienceReading === 'true');
     if (readingDisabled) {
@@ -236,79 +279,6 @@ ${filteredCode}
     // The actual files will be cleaned up by test cleanup
   }
 
-  saveSessionExperience(state: ActionResult, entry: SessionExperienceEntry): void {
-    if (this.disabled || this.isWritingDisabled(state)) return;
-
-    this.ensureExperienceFile(state);
-    const stateHash = state.getStateHash();
-    const { content, data } = this.readExperienceFile(stateHash);
-
-    if (entry.relatedUrls?.length) {
-      const currentPath = extractStatePath(state.url || '');
-      const existingRelated = Array.isArray(data.related) ? data.related : [];
-      const allRelated = [...new Set([...existingRelated, ...entry.relatedUrls])];
-      data.related = allRelated.filter((url) => url !== currentPath);
-    }
-
-    const sessionContent = this.trimSessionContent(this.generateSessionContent(entry));
-    if (!sessionContent) return;
-    const updatedContent = `${sessionContent}\n${content}`;
-    this.writeExperienceFile(stateHash, updatedContent, data);
-
-    tag('substep').log(`Added session experience to: ${stateHash}.md`);
-  }
-
-  private generateSessionContent(entry: SessionExperienceEntry): string {
-    let content = `## Successful Flow: ${entry.scenario}\n\n`;
-
-    for (const step of entry.steps) {
-      content += `* ${step.message}\n\n`;
-      if (step.code) {
-        content += '```js\n';
-        content += `${step.code}\n`;
-        content += '```\n\n';
-      }
-      if (step.discovery) {
-        const discoveries = step.discovery.split('\n').filter((d) => d.trim());
-        for (const discovery of discoveries) {
-          content += `> ${discovery.trim()}\n\n`;
-        }
-      }
-    }
-
-    content += '---\n';
-    return content;
-  }
-
-  private trimSessionContent(content: string): string | null {
-    const q = mdq(content);
-    if (q.query('heading').count() === 0) return null;
-    if (q.query('code').count() === 0) return null;
-
-    let result = content;
-    const codeBlocks = q.query('code').each();
-    if (codeBlocks.length > 2) {
-      for (const block of codeBlocks.slice(2)) {
-        result = result.replace(block.text(), '');
-      }
-    }
-
-    const blockquotes = mdq(result).query('blockquote').each();
-    if (blockquotes.length > 5) {
-      for (const bq of blockquotes.slice(5)) {
-        result = result.replace(bq.text(), '');
-      }
-    }
-
-    const lines = result.split('\n');
-    if (lines.length > 40) {
-      result = lines.slice(0, 40).join('\n');
-    }
-
-    if (!result.trim()) return null;
-    return result;
-  }
-
   getSuccessfulExperience(state: ActionResult, options?: { includeDescendants?: boolean; stripCode?: boolean }): string[] {
     const records = this.getRelevantExperience(state, {
       includeDescendantExperience: options?.includeDescendants,
@@ -318,12 +288,14 @@ ${filteredCode}
     for (const record of records) {
       if (!record.content) continue;
 
-      const successFlows = mdq(record.content).query('section(~"Successful Flow")').text();
-      const succeeded = mdq(record.content).query('section(~"SUCCEEDED")').text();
-      let combined = [successFlows, succeeded].filter(Boolean).join('\n\n');
+      const flows = mdq(record.content).query('section(~"FLOW:")').text();
+      const actions = mdq(record.content).query('section(~"ACTION:")').text();
+      let combined = [flows, actions].filter(Boolean).join('\n\n');
 
       if (!combined.trim()) continue;
 
+      combined = renderAsHowTo(combined);
+
       if (options?.stripCode) {
         combined = mdq(combined).query('code').replace('');
       }
@@ -383,6 +355,72 @@ ${filteredCode}
     }
     return null;
   }
+
+  listAllExperienceToc(filter?: string, options?: { recency?: 'recent' | 'old' }): ExperienceTocEntry[] {
+    const records = this.getAllExperience();
+    if (records.length === 0) return [];
+
+    const trimmed = filter?.trim();
+    let matching = records;
+
+    if (trimmed) {
+      if (trimmed.endsWith('.md')) {
+        const bare = trimmed.slice(0, -3);
+        const byFilename = records.find((record) => basename(record.filePath, '.md') === bare);
+        matching = byFilename ? [byFilename] : [];
+      } else {
+        const lower = trimmed.toLowerCase();
+        matching = records.filter((record) => {
+          const url = ((record.data as WebPageState)?.url || '').toLowerCase();
+          if (!url) return false;
+          return url.includes(lower);
+        });
+      }
+    }
+
+    if (options?.recency) {
+      const cutoff = Date.now() - RECENT_WINDOW_DAYS * 24 * 60 * 60 * 1000;
+      matching = matching.filter((record) => {
+        const isRecent = record.mtime.getTime() >= cutoff;
+        return options.recency === 'recent' ? isRecent : !isRecent;
+      });
+    }
+
+    const sorted = matching.sort((a, b) => {
+      const aUrl = (a.data as WebPageState)?.url || '';
+      const bUrl = (b.data as WebPageState)?.url || '';
+      return aUrl.localeCompare(bUrl);
+    });
+
+    const toc: ExperienceTocEntry[] = [];
+    for (let i = 0; i < sorted.length; i++) {
+      const record = sorted[i];
+      const sections = listTocHeadings(record.content);
+      if (sections.length === 0) continue;
+      toc.push({
+        fileTag: indexToLetters(toc.length),
+        fileHash: basename(record.filePath, '.md'),
+        url: (record.data as WebPageState)?.url || '',
+        sections,
+      });
+    }
+    return toc;
+  }
+
+  getExperienceSectionByTag(fileTag: string, sectionIndex: number, filter?: string): { title: string; url: string; content: string; fileHash: string } | null {
+    const toc = this.listAllExperienceToc(filter);
+    const entry = toc.find((e) => e.fileTag === fileTag);
+    if (!entry) return null;
+
+    const filePath = this.findExperienceFileByHash(entry.fileHash);
+    if (!filePath) return null;
+
+    const { content } = this.readExperienceFile(entry.fileHash);
+    const extracted = extractHeadingSection(content, sectionIndex);
+    if (!extracted) return null;
+
+    return { title: extracted.title, url: entry.url, content: extracted.body, fileHash: entry.fileHash };
+  }
 }
 
 function listTocHeadings(content: string): { index: number; level: 2 | 3; title: string }[] {
@@ -448,7 +486,11 @@ export function renderExperienceToc(toc: ExperienceTocEntry[]): string {
 
   const lines: string[] = [];
   lines.push('<experience>');
-  lines.push('Past experience for this page. Call learn_experience({ fileTag, sectionIndex }) to read a section.');
+  lines.push('Past experience for this page — recipes recorded from prior successful runs.');
+  lines.push('Locators and step ordering worked then; the page may have changed since.');
+  lines.push('Treat as a starting hypothesis, not ground truth. If a step fails, fall back to ARIA/UI-map.');
+  lines.push('FLOW: = multi-step recipe (bullets + code + discovery). ACTION: = single-step snippet (one code block).');
+  lines.push('Call learn_experience({ fileTag, sectionIndex }) to read a section when it looks relevant to the current step.');
   lines.push('');
   for (const entry of toc) {
     lines.push(`File ${entry.fileTag} ${entry.url}:`);
@@ -462,6 +504,69 @@ export function renderExperienceToc(toc: ExperienceTocEntry[]): string {
   return lines.join('\n');
 }
 
+function normalizeTitle(raw: string): string {
+  let t = (raw || '').trim();
+  for (const p of ['FLOW:', 'ACTION:']) {
+    if (t.toLowerCase().startsWith(p.toLowerCase())) {
+      t = t.slice(p.length).trim();
+      break;
+    }
+  }
+  while (t.length > 0 && '.!?,;:'.includes(t[t.length - 1])) {
+    t = t.slice(0, -1);
+  }
+  if (t.length > 0) t = t[0].toLowerCase() + t.slice(1);
+  return t;
+}
+
+function generateActionContent(title: string, code: string, explanation?: string): string {
+  const lines: string[] = [];
+  lines.push(`## ACTION: ${title}`);
+  lines.push('');
+  if (explanation) {
+    lines.push(`Solution: ${explanation}`);
+    lines.push('');
+  }
+  lines.push('```javascript');
+  lines.push(code);
+  lines.push('```');
+  lines.push('');
+  return lines.join('\n');
+}
+
+function renderAsHowTo(content: string): string {
+  const tokens = marked.lexer(content);
+  let result = '';
+  for (const token of tokens) {
+    if (token.type === 'heading' && (token as Tokens.Heading).depth === 2) {
+      const text = (token as Tokens.Heading).text.trim();
+      if (text.startsWith('FLOW:')) {
+        result += `## HOW to ${text.slice(5).trim()} (multi-step)\n\n`;
+        continue;
+      }
+      if (text.startsWith('ACTION:')) {
+        result += `## HOW to ${text.slice(7).trim()} (single-step)\n\n`;
+        continue;
+      }
+    }
+    result += (token as any).raw || '';
+  }
+  return result;
+}
+
+export interface ExperienceFile {
+  filePath: string;
+  data: { url?: string; title?: string; [key: string]: any };
+  content: string;
+  mtime: Date;
+}
+
+export interface ActionInput {
+  title: string;
+  code: string;
+  explanation?: string;
+}
+
 export interface SessionStep {
   message: string;
   status: 'passed' | 'failed' | 'neutral';
@@ -470,13 +575,6 @@ export interface SessionStep {
   discovery?: string;
 }
 
-export interface SessionExperienceEntry {
-  scenario: string;
-  result: 'success' | 'partial' | 'failed';
-  steps: SessionStep[];
-  relatedUrls?: string[];
-}
-
 export interface ExperienceTocEntry {
   fileTag: string;
   fileHash: string;

package/src/explorbot.ts

@@ -1,9 +1,6 @@
 import { existsSync, mkdirSync } from 'node:fs';
 import path from 'node:path';
 import { ActionResult } from './action-result.ts';
-import { ApiClient } from './api/api-client.ts';
-import { RequestStore } from './api/request-store.ts';
-import { loadSpec } from './api/spec-reader.ts';
 import { Bosun } from './ai/bosun.ts';
 import { Captain } from './ai/captain.ts';
 import { ExperienceCompactor } from './ai/experience-compactor.ts';
@@ -14,16 +11,20 @@ import { Pilot } from './ai/pilot.ts';
 import { Planner } from './ai/planner.ts';
 import { AIProvider } from './ai/provider.ts';
 import { Quartermaster } from './ai/quartermaster.ts';
-import { Researcher } from './ai/researcher.ts';
 import { Rerunner } from './ai/rerunner.ts';
+import { Researcher } from './ai/researcher.ts';
 import { Tester } from './ai/tester.ts';
 import { createAgentTools } from './ai/tools.ts';
+import { ApiClient } from './api/api-client.ts';
+import { RequestStore } from './api/request-store.ts';
+import { loadSpec } from './api/spec-reader.ts';
 import type { ExplorbotConfig } from './config.js';
 import { ConfigParser } from './config.ts';
+import { ExperienceTracker } from './experience-tracker.ts';
 import Explorer from './explorer.ts';
-import type { Suite } from './suite.ts';
 import { KnowledgeTracker } from './knowledge-tracker.ts';
 import { WebPageState } from './state-manager.ts';
+import type { Suite } from './suite.ts';
 import { Plan } from './test-plan.ts';
 import { setVerboseMode, tag } from './utils/logger.ts';
 import { sanitizeFilename } from './utils/strings.ts';
@@ -51,6 +52,8 @@ export class ExplorBot {
   public needsInput = false;
   private currentPlan?: Plan;
   private planFeature?: string;
+  lastPlanError: Error | null = null;
+  lastSavedPlanPath: string | null = null;
   private agents: Record<string, any> = {};
 
   constructor(options: ExplorBotOptions = {}) {
@@ -76,13 +79,11 @@ export class ExplorBot {
     }
 
     try {
-      this.config = await this.configParser.loadConfig(this.options);
-      this.provider = new AIProvider(this.config.ai);
-      await this.provider.validateConnection();
+      await this.startProviderOnly();
       this.explorer = new Explorer(this.config, this.provider, this.options);
       await this.explorer.start();
       if (!this.options.incognito) {
-        await this.agentExperienceCompactor().compactAllExperiences();
+        await this.agentExperienceCompactor().autocompact();
       }
       if (this.userResolveFn) this.explorer.setUserResolve(this.userResolveFn);
     } catch (error) {
@@ -92,9 +93,16 @@ export class ExplorBot {
     }
   }
 
+  async startProviderOnly(): Promise<void> {
+    if (this.provider) return;
+    this.config = await this.configParser.loadConfig(this.options);
+    this.provider = new AIProvider(this.config.ai);
+    await this.provider.validateConnection();
+  }
+
   async stop(): Promise<void> {
     this.agents.quartermaster?.stop();
-    await this.explorer.stop();
+    await this.explorer?.stop();
   }
 
   async visitInitialState(): Promise<void> {
@@ -125,6 +133,13 @@ export class ExplorBot {
     return new KnowledgeTracker();
   }
 
+  getExperienceTracker(): ExperienceTracker {
+    if (this.explorer) {
+      return this.explorer.getStateManager().getExperienceTracker();
+    }
+    return new ExperienceTracker();
+  }
+
   getConfig(): ExplorbotConfig {
     return this.config;
   }
@@ -227,10 +242,7 @@ export class ExplorBot {
   }
 
   agentExperienceCompactor(): ExperienceCompactor {
-    return (this.agents.experienceCompactor ||= this.createAgent(({ ai, explorer }) => {
-      const experienceTracker = explorer.getStateManager().getExperienceTracker();
-      return new ExperienceCompactor(ai, experienceTracker);
-    }));
+    return (this.agents.experienceCompactor ||= new ExperienceCompactor(this.provider, this.getExperienceTracker()));
   }
 
   agentQuartermaster(): Quartermaster | null {
@@ -247,10 +259,10 @@ export class ExplorBot {
   }
 
   agentHistorian(): Historian {
-    return (this.agents.historian ||= this.createAgent(({ ai, explorer }) => {
+    return (this.agents.historian ||= this.createAgent(({ ai, explorer, config }) => {
       const experienceTracker = explorer.getStateManager().getExperienceTracker();
       const reporter = explorer.getReporter();
-      return new Historian(ai, experienceTracker, reporter, explorer.getStateManager());
+      return new Historian(ai, experienceTracker, reporter, explorer.getStateManager(), config, explorer.getPlaywrightRecorder());
     }));
   }
 
@@ -348,20 +360,17 @@ export class ExplorBot {
     if (this.currentPlan) {
       planner.setPlan(this.currentPlan);
     }
+    this.lastPlanError = null;
     try {
       this.currentPlan = await planner.plan(feature, opts.style, opts.extend, opts.completedPlans);
     } catch (err) {
-      tag('warning').log(`Planning failed: ${err instanceof Error ? err.message : err}`);
+      this.lastPlanError = err instanceof Error ? err : new Error(String(err));
+      tag('warning').log(`Planning failed: ${this.lastPlanError.message}`);
       if (!this.currentPlan) return undefined;
       return this.currentPlan;
     }
 
-    const savedPath = this.savePlan();
-    if (savedPath) {
-      const relativePath = path.relative(process.cwd(), savedPath);
-      tag('info').log(`Plan saved to: ${relativePath}`);
-      tag('info').log(`Edit the plan file and run /plan:load ${relativePath} to reload it`);
-    }
+    this.savePlan();
 
     return this.currentPlan;
   }
@@ -387,6 +396,7 @@ export class ExplorBot {
     const planFilename = filename || this.generatePlanFilename();
     const planPath = path.join(plansDir, planFilename);
     Plan.saveMultipleToMarkdown(plans, planPath);
+    this.lastSavedPlanPath = planPath;
     return planPath;
   }
 

package/src/explorer.ts

@@ -9,15 +9,16 @@ import { ActionResult } from './action-result.ts';
 import Action from './action.js';
 import { AIProvider } from './ai/provider.js';
 import { visuallyAnnotateContainers } from './ai/researcher/coordinates.ts';
+import { RequestStore } from './api/request-store.ts';
+import { XhrCapture } from './api/xhr-capture.ts';
 import type { ExplorbotConfig } from './config.js';
 import { ConfigParser, outputPath } from './config.js';
 import type { UserResolveFunction } from './explorbot.js';
 import { KnowledgeTracker } from './knowledge-tracker.js';
+import { PlaywrightRecorder } from './playwright-recorder.ts';
 import { Reporter } from './reporter.ts';
 import { StateManager } from './state-manager.js';
 import { Test } from './test-plan.ts';
-import { RequestStore } from './api/request-store.ts';
-import { XhrCapture } from './api/xhr-capture.ts';
 import { createDebug, log, tag } from './utils/logger.js';
 import { WebElement, extractElementData } from './utils/web-element.ts';
 
@@ -60,6 +61,7 @@ class Explorer {
   private _activeTest: Test | null = null;
   private xhrCapture: XhrCapture | null = null;
   private requestStore: RequestStore | null = null;
+  private playwrightRecorder: PlaywrightRecorder = new PlaywrightRecorder();
 
   constructor(config: ExplorbotConfig, aiProvider: AIProvider, options?: { show?: boolean; headless?: boolean; incognito?: boolean; session?: string }) {
     this.config = config;
@@ -68,7 +70,7 @@ class Explorer {
     this.initializeContainer();
     this.stateManager = new StateManager({ incognito: this.options?.incognito });
     this.knowledgeTracker = new KnowledgeTracker();
-    this.reporter = new Reporter(config.reporter);
+    this.reporter = new Reporter(config.reporter, this.stateManager);
   }
 
   private initializeContainer() {
@@ -123,7 +125,7 @@ class Explorer {
       tag('substep').log(debugInfo);
     }
     const PlaywrightConfig = {
-      timeout: 1000,
+      timeout: 3000,
       highlightElement: true,
       waitForAction: 500,
       ...playwrightConfig,
@@ -237,6 +239,7 @@ class Explorer {
     const hasSession = this.options?.session && existsSync(this.options.session);
     const contextOptions = hasSession ? { storageState: this.options!.session } : undefined;
     await this.playwrightHelper._createContextPage(contextOptions);
+    await this.playwrightRecorder.start(this.playwrightHelper.browserContext);
     this.setupXhrCapture();
     if (hasSession) {
       tag('info').log(`Session restored from ${path.relative(process.cwd(), this.options!.session!)}`);
@@ -273,7 +276,11 @@ class Explorer {
   }
 
   createAction() {
-    return new Action(this.actor, this.stateManager);
+    return new Action(this.actor, this.stateManager, this.playwrightRecorder);
+  }
+
+  getPlaywrightRecorder(): PlaywrightRecorder {
+    return this.playwrightRecorder;
   }
 
   async visit(url: string) {
@@ -489,6 +496,8 @@ class Explorer {
       this.xhrCapture.detach(this.playwrightHelper.page);
     }
 
+    await this.playwrightRecorder.stop();
+
     if (this.options?.session && this.playwrightHelper?.browserContext) {
       const dir = path.dirname(this.options.session);
       if (!existsSync(dir)) mkdirSync(dir, { recursive: true });