explorbot 0.1.10 → 0.1.12

package/dist/src/commands/clean-command.js

@@ -7,6 +7,7 @@ export const CLEAN_TARGETS = {
     states: { description: 'page states', getDir: () => outputPath('states') },
     research: { description: 'research cache', getDir: () => outputPath('research') },
     plans: { description: 'test plans', getDir: () => outputPath('plans') },
+    tests: { description: 'generated tests', getDir: () => outputPath('tests') },
     experiences: { description: 'experience files', getDir: () => getExperienceDir() },
     output: { description: 'all output files', getDir: () => outputPath() },
 };
@@ -38,7 +39,7 @@ function cleanDirectoryContents(dirPath) {
 }
 export class CleanCommand extends BaseCommand {
     name = 'clean';
-    description = 'Clean files: clean [states|research|plans|experiences|output]';
+    description = 'Clean files: clean [states|research|plans|tests|experiences|output]';
     suggestions = Object.entries(CLEAN_TARGETS).map(([name, target]) => ({ command: `clean ${name}`, hint: `clean ${target.description}` }));
     async execute(args) {
         const target = args.trim().toLowerCase();

package/dist/src/commands/explore-command.js

@@ -1,11 +1,13 @@
-import path from 'node:path';
 import figureSet from 'figures';
 import { getStyles } from '../ai/planner/styles.js';
+import { outputPath } from '../config.js';
 import { Stats } from '../stats.js';
 import { getCliName } from "../utils/cli-name.js";
 import { ErrorPageError } from "../utils/error-page.js";
 import { tag } from '../utils/logger.js';
 import { jsonToTable } from '../utils/markdown-parser.js';
+import { printNextSteps, relativeToCwd } from "../utils/next-steps.js";
+import { safeFilename } from "../utils/strings.js";
 import { BaseCommand } from './base-command.js';
 export class ExploreCommand extends BaseCommand {
     name = 'explore';
@@ -65,8 +67,8 @@ export class ExploreCommand extends BaseCommand {
         if (mainUrl)
             await this.explorBot.visit(mainUrl);
         const savedPath = this.explorBot.savePlans(this.completedPlans);
-        this.printResults(savedPath);
-        this.printRerunSuggestions();
+        this.printResults();
+        this.printNextSteps(savedPath);
     }
     async runAllStyles(pageUrl, feature, parentPlan, completedPlans) {
         let fresh = true;
@@ -97,7 +99,7 @@ export class ExploreCommand extends BaseCommand {
             tag('warning').log(`Planning style '${opts.style}' failed after retry, skipping`);
         }
     }
-    printResults(savedPath) {
+    printResults() {
         const allTests = this.completedPlans.flatMap((plan) => plan.tests.filter((t) => t.startTime != null).map((test) => ({ test, planTitle: plan.title })));
         if (allTests.length === 0)
             return;
@@ -128,20 +130,46 @@ export class ExploreCommand extends BaseCommand {
             columns.push('Plan');
         tag('multiline').log(jsonToTable(rows, columns));
         tag('info').log(`${figureSet.tick} ${allTests.length} tests completed`);
-        if (savedPath) {
-            const relativePath = path.relative(process.cwd(), savedPath);
-            tag('info').log(`Re-run tests: ${getCliName()} test ${relativePath} <index>`);
-        }
     }
-    printRerunSuggestions() {
+    printNextSteps(savedPlanPath) {
+        const cli = getCliName();
+        const sections = [];
+        if (savedPlanPath) {
+            const relPlan = relativeToCwd(savedPlanPath);
+            sections.push({
+                label: 'Plan',
+                path: savedPlanPath,
+                commands: [
+                    { label: 'Re-run', command: `${cli} test ${relPlan} 1` },
+                    { label: 'Run all', command: `${cli} test ${relPlan} *` },
+                    { label: 'Run range', command: `${cli} test ${relPlan} 1-3` },
+                ],
+            });
+        }
         const savedFiles = this.explorBot.agentHistorian().getSavedFiles();
-        if (savedFiles.length === 0)
-            return;
-        for (const filePath of savedFiles) {
-            tag('info').log(`Generated: ${path.basename(filePath)}`);
+        const screencasts = savedFiles.filter((f) => f.endsWith('.webm'));
+        const testFiles = savedFiles.filter((f) => !f.endsWith('.webm'));
+        if (testFiles.length > 0) {
+            const commands = testFiles.map((f) => ({ label: '', command: `${cli} rerun ${relativeToCwd(f)}` }));
+            commands.push({ label: 'List tests', command: `${cli} runs` });
+            sections.push({
+                label: `Generated tests (${testFiles.length})`,
+                commands,
+            });
+        }
+        if (screencasts.length > 0) {
+            const commands = screencasts.map((f) => ({ label: '', command: relativeToCwd(f) }));
+            const screencastDir = relativeToCwd(outputPath('screencasts'));
+            const planSlugs = [...new Set(this.completedPlans.map((p) => safeFilename(p.title)).filter(Boolean))];
+            for (const slug of planSlugs) {
+                commands.push({ label: 'Browse plan', command: `ls ${screencastDir}/${slug}-*` });
+            }
+            sections.push({
+                label: `Screencasts (${screencasts.length})`,
+                commands,
+            });
         }
-        tag('info').log(`List tests: ${getCliName()} runs`);
-        tag('info').log(`Re-run with healing: ${getCliName()} rerun <filename> [index]`);
+        printNextSteps(sections);
     }
     isLimitReached() {
         return this.maxTests != null && this.testsRun >= this.maxTests;

package/dist/src/commands/init-command.js

@@ -4,6 +4,7 @@ import chalk from 'chalk';
 import dedent from 'dedent';
 import { getCliName } from "../utils/cli-name.js";
 import { log, tag } from '../utils/logger.js';
+import { relativeToCwd } from "../utils/next-steps.js";
 const DEFAULT_CONFIG_TEMPLATE = `import { createOpenRouter } from '@openrouter/ai-sdk-provider';
 // import { '<your provider here>' } from '<your provider package here>';
 
@@ -57,10 +58,10 @@ export function runInitCommand(options) {
         const dir = resolve(customPath);
         if (!existsSync(dir)) {
             mkdirSync(dir, { recursive: true });
-            log(`Created directory: ${dir}`);
+            log(`Created directory: ${relativeToCwd(dir)}`);
         }
         process.chdir(dir);
-        log(`Working in directory: ${dir}`);
+        log(`Working in directory: ${relativeToCwd(dir)}`);
     }
     try {
         let outPath = resolve(configPath);
@@ -73,22 +74,22 @@ export function runInitCommand(options) {
         const dir = dirname(outPath);
         if (!existsSync(dir)) {
             mkdirSync(dir, { recursive: true });
-            log(`Created directory: ${dir}`);
+            log(`Created directory: ${relativeToCwd(dir)}`);
         }
         if (existsSync(outPath) && !force) {
-            log(`Config file already exists: ${outPath}`);
+            log(`Config file already exists: ${relativeToCwd(outPath)}`);
             log('Use --force to overwrite existing file');
             process.exit(1);
         }
         writeFileSync(outPath, DEFAULT_CONFIG_TEMPLATE, 'utf8');
-        log(`Created config file: ${outPath}`);
+        log(`Created config file: ${relativeToCwd(outPath)}`);
         const envPath = resolve(process.cwd(), '.env');
         if (!existsSync(envPath)) {
             writeFileSync(envPath, `${DEFAULT_ENV_TEMPLATE}\n`, 'utf8');
-            log(`Created env file: ${envPath}`);
+            log(`Created env file: ${relativeToCwd(envPath)}`);
         }
         else {
-            log(`Env file already exists: ${envPath}`);
+            log(`Env file already exists: ${relativeToCwd(envPath)}`);
         }
         log('');
         log('Next steps:');
@@ -102,7 +103,7 @@ export function runInitCommand(options) {
         tag('substep').log(chalk.yellow(`${getCliName()} start /dashboard`));
         if (!existsSync('./output')) {
             mkdirSync('./output', { recursive: true });
-            log('Created directory: ./output');
+            log('Created directory: output');
         }
     }
     catch (error) {

package/dist/src/commands/plan-command.js

@@ -1,7 +1,9 @@
 import path from 'node:path';
 import chalk from 'chalk';
 import figureSet from 'figures';
+import { getCliName } from "../utils/cli-name.js";
 import { tag } from '../utils/logger.js';
+import { printNextSteps, relativeToCwd } from "../utils/next-steps.js";
 import { BaseCommand } from './base-command.js';
 export class PlanCommand extends BaseCommand {
     name = 'plan';
@@ -34,6 +36,36 @@ export class PlanCommand extends BaseCommand {
         }
         this.printPlanSummary();
         this.updateSuggestions();
+        this.printNextSteps();
+    }
+    printNextSteps() {
+        const savedPath = this.explorBot.lastSavedPlanPath;
+        if (!savedPath)
+            return;
+        const cli = getCliName();
+        const relPlan = relativeToCwd(savedPath);
+        const sections = [
+            {
+                label: 'Plan',
+                path: savedPath,
+                commands: [
+                    { label: 'Re-run', command: `${cli} test ${relPlan} 1` },
+                    { label: 'Run all', command: `${cli} test ${relPlan} *` },
+                    { label: 'Run range', command: `${cli} test ${relPlan} 1-3` },
+                    { label: 'Reload', command: `/plan:load ${relPlan}` },
+                ],
+            },
+        ];
+        const suite = this.explorBot.getSuite();
+        const files = suite && suite.automatedTestCount > 0 ? suite.getAutomatedTestFiles() : [];
+        if (files.length > 0) {
+            const commands = files.map((f) => ({ label: '', command: `${cli} rerun ${relativeToCwd(f)}` }));
+            sections.push({
+                label: `Automated tests (${files.length})`,
+                commands,
+            });
+        }
+        printNextSteps(sections);
     }
     printPlanSummary() {
         const suite = this.explorBot.getSuite();

package/dist/src/commands/plan-save-command.js

@@ -1,5 +1,5 @@
-import path from 'node:path';
-import { tag } from '../utils/logger.js';
+import { getCliName } from "../utils/cli-name.js";
+import { printNextSteps, relativeToCwd } from "../utils/next-steps.js";
 import { BaseCommand } from './base-command.js';
 export class PlanSaveCommand extends BaseCommand {
     name = 'plan:save';
@@ -12,10 +12,22 @@ export class PlanSaveCommand extends BaseCommand {
         }
         const filename = args.trim() || undefined;
         const savedPath = this.explorBot.savePlan(filename);
-        if (savedPath) {
-            const relativePath = path.relative(process.cwd(), savedPath);
-            tag('success').log(`Plan saved to: ${relativePath}`);
-            tag('info').log(`Run /plan:load ${relativePath} to reload it`);
-        }
+        if (!savedPath)
+            return;
+        const cli = getCliName();
+        const relPlan = relativeToCwd(savedPath);
+        const sections = [
+            {
+                label: 'Plan',
+                path: savedPath,
+                commands: [
+                    { label: 'Re-run', command: `${cli} test ${relPlan} 1` },
+                    { label: 'Run all', command: `${cli} test ${relPlan} *` },
+                    { label: 'Run range', command: `${cli} test ${relPlan} 1-3` },
+                    { label: 'Reload', command: `/plan:load ${relPlan}` },
+                ],
+            },
+        ];
+        printNextSteps(sections);
     }
 }

package/dist/src/commands/rerun-command.js

@@ -19,6 +19,10 @@ export class RerunCommand extends BaseCommand {
         if (!existsSync(filePath)) {
             filePath = resolve(ConfigParser.getInstance().getTestsDir(), filename);
         }
+        if (filePath.endsWith('.spec.ts') || filePath.endsWith('.spec.js')) {
+            tag('error').log(`Rerun does not support Playwright tests. Run them with: npx playwright test ${filePath}`);
+            return;
+        }
         const testIndices = indexArg ? parseTestIndices(indexArg) : undefined;
         await this.explorBot.agentRerunner().rerun(filePath, { testIndices });
     }

package/dist/src/components/App.js

@@ -72,16 +72,27 @@ export function App({ explorBot, initialShowInput = false, exitOnEmptyInput = fa
             setInterruptPrompt(prompt);
             setShowInput(true);
             return new Promise((resolve) => {
-                interruptResolveRef.current = resolve;
+                interruptResolveRef.current = (value) => {
+                    interruptResolveRef.current = null;
+                    setInterruptPrompt(null);
+                    resolve(value);
+                };
             });
         });
         const handleIdle = () => {
             setShowInput(true);
         };
+        const handleInterrupt = () => {
+            if (interruptResolveRef.current) {
+                interruptResolveRef.current(null);
+            }
+        };
         executionController.on('idle', handleIdle);
+        executionController.on('interrupt', handleInterrupt);
         setInputCallbackReady(true);
         return () => {
             executionController.off('idle', handleIdle);
+            executionController.off('interrupt', handleInterrupt);
             executionController.reset();
         };
     }, []);
@@ -244,9 +255,10 @@ export function App({ explorBot, initialShowInput = false, exitOnEmptyInput = fa
             return;
         }
         if (isCommand) {
-            setInterruptPrompt(null);
+            if (interruptResolveRef.current) {
+                interruptResolveRef.current(null);
+            }
             setShowInput(false);
-            interruptResolveRef.current = null;
             executionController.startExecution();
             try {
                 await commandHandler.executeCommand(trimmed);
@@ -264,8 +276,6 @@ export function App({ explorBot, initialShowInput = false, exitOnEmptyInput = fa
         }
         if (interruptResolveRef.current) {
             interruptResolveRef.current(input);
-            interruptResolveRef.current = null;
-            setInterruptPrompt(null);
             setShowInput(false);
             return;
         }

package/dist/src/execution-controller.js

@@ -7,6 +7,7 @@ export class ExecutionController extends EventEmitter {
     inputCallback = null;
     interruptResolvers = [];
     abortController = null;
+    awaitingInput = false;
     constructor() {
         super();
     }
@@ -39,6 +40,9 @@ export class ExecutionController extends EventEmitter {
         this.interruptResolvers = [];
         this.emit('idle');
     }
+    isAwaitingInput() {
+        return this.awaitingInput;
+    }
     isInterrupted() {
         return this.interrupted;
     }
@@ -64,10 +68,16 @@ export class ExecutionController extends EventEmitter {
         return userInput;
     }
     async requestInput(prompt) {
-        if (this.inputCallback) {
+        if (!this.inputCallback) {
+            return await this.readlineInput(prompt);
+        }
+        this.awaitingInput = true;
+        try {
             return await this.inputCallback(prompt);
         }
-        return await this.readlineInput(prompt);
+        finally {
+            this.awaitingInput = false;
+        }
     }
     async readlineInput(prompt) {
         const rl = readline.createInterface({
@@ -86,6 +96,7 @@ export class ExecutionController extends EventEmitter {
         this.interrupted = false;
         this.interruptResolvers = [];
         this.abortController = null;
+        this.awaitingInput = false;
     }
 }
 export const executionController = ExecutionController.getInstance();

package/dist/src/experience-tracker.js

@@ -13,15 +13,17 @@ export const RECENT_WINDOW_DAYS = 30;
 /**
  * Stores and reads per-page experience files (`./experience/<stateHash>.md`).
  *
- * Format rules (enforced by writeFlow/writeAction — the only supported writers):
+ * Two writers, two contracts:
  *
- *   ## FLOW: <imperative title>        multi-step, `*` bullets + optional ```js``` + `>` discovery, ends with `---`
- *   ## ACTION: <imperative title>      single-step, optional `Solution:` line + one ```js``` code block
+ *   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.
- * - Title is an imperative verb phrase, lowercase-first, no trailing punctuation.
- *   Writers normalize automatically (strip own `FLOW:` / `ACTION:` prefix if the caller included it,
- *   lowercase first char, trim trailing `.!?,;:`).
  * - On read (getSuccessfulExperience), headings are rendered as
  *   `## HOW to <title> (multi-step|single-step)` so prompts get natural phrasing.
  */
@@ -159,27 +161,25 @@ export class ExperienceTracker {
         this.writeExperienceFile(stateHash, updatedContent, data);
         tag('substep').log(` Added ACTION to: ${stateHash}.md`);
     }
-    writeFlow(state, flow) {
+    writeFlow(state, body, relatedUrls) {
         if (this.disabled || this.isWritingDisabled(state))
             return;
-        if (!flow.steps?.length)
+        if (!body?.trim())
             return;
         this.ensureExperienceFile(state);
         const stateHash = state.getStateHash();
         const { content, data } = this.readExperienceFile(stateHash);
-        if (flow.relatedUrls?.length) {
+        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, ...flow.relatedUrls])];
+            const allRelated = [...new Set([...existingRelated, ...relatedUrls])];
             data.related = allRelated.filter((url) => url !== currentPath);
         }
-        const title = normalizeTitle(flow.scenario);
-        if (!title)
-            return;
-        const sessionContent = this.trimSessionContent(generateFlowContent(title, flow.steps));
-        if (!sessionContent)
-            return;
-        const updatedContent = `${sessionContent}\n${content}`;
+        const updatedContent = `${body}\n${content}`;
         this.writeExperienceFile(stateHash, updatedContent, data);
         tag('substep').log(`Added FLOW to: ${stateHash}.md`);
     }
@@ -245,33 +245,6 @@ export class ExperienceTracker {
         // Clear any in-memory state if needed
         // The actual files will be cleaned up by test cleanup
     }
-    trimSessionContent(content) {
-        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, options) {
         const records = this.getRelevantExperience(state, {
             includeDescendantExperience: options?.includeDescendants,
@@ -469,7 +442,9 @@ export function renderExperienceToc(toc) {
         return '';
     const lines = [];
     lines.push('<experience>');
-    lines.push('Past experience for this page — reusable recipes recorded from prior successful runs.');
+    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('');
@@ -513,25 +488,6 @@ function generateActionContent(title, code, explanation) {
     lines.push('');
     return lines.join('\n');
 }
-function generateFlowContent(title, steps) {
-    let content = `## FLOW: ${title}\n\n`;
-    for (const step of 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;
-}
 function renderAsHowTo(content) {
     const tokens = marked.lexer(content);
     let result = '';

package/dist/src/explorbot.js

@@ -36,6 +36,7 @@ export class ExplorBot {
     currentPlan;
     planFeature;
     lastPlanError = null;
+    lastSavedPlanPath = null;
     agents = {};
     constructor(options = {}) {
         this.options = options;
@@ -214,10 +215,13 @@ export class ExplorBot {
         return this.agents.quartermaster;
     }
     agentHistorian() {
-        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, {
+                recorder: explorer.getPlaywrightRecorder(),
+                helper: explorer.playwrightHelper,
+            });
         }));
     }
     agentRerunner() {
@@ -314,12 +318,7 @@ export class ExplorBot {
                 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;
     }
     getPlansDir() {
@@ -341,6 +340,7 @@ export class ExplorBot {
         const planFilename = filename || this.generatePlanFilename();
         const planPath = path.join(plansDir, planFilename);
         Plan.saveMultipleToMarkdown(plans, planPath);
+        this.lastSavedPlanPath = planPath;
         return planPath;
     }
     generatePlanFilename() {

package/dist/src/explorer.js

@@ -12,6 +12,7 @@ import { RequestStore } from "./api/request-store.js";
 import { XhrCapture } from "./api/xhr-capture.js";
 import { ConfigParser, outputPath } from './config.js';
 import { KnowledgeTracker } from './knowledge-tracker.js';
+import { PlaywrightRecorder } from "./playwright-recorder.js";
 import { Reporter } from "./reporter.js";
 import { StateManager } from './state-manager.js';
 import { createDebug, log, tag } from './utils/logger.js';
@@ -35,6 +36,7 @@ class Explorer {
     _activeTest = null;
     xhrCapture = null;
     requestStore = null;
+    playwrightRecorder = new PlaywrightRecorder();
     constructor(config, aiProvider, options) {
         this.config = config;
         this.aiProvider = aiProvider;
@@ -89,7 +91,7 @@ class Explorer {
             tag('substep').log(debugInfo);
         }
         const PlaywrightConfig = {
-            timeout: 1000,
+            timeout: 3000,
             highlightElement: true,
             waitForAction: 500,
             ...playwrightConfig,
@@ -188,6 +190,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)}`);
@@ -216,7 +219,10 @@ class Explorer {
         await this.playwrightHelper._startBrowser();
     }
     createAction() {
-        return new Action(this.actor, this.stateManager);
+        return new Action(this.actor, this.stateManager, this.playwrightRecorder);
+    }
+    getPlaywrightRecorder() {
+        return this.playwrightRecorder;
     }
     async visit(url) {
         await this.closeOtherTabs();
@@ -411,6 +417,7 @@ class Explorer {
         if (this.xhrCapture && this.playwrightHelper?.page) {
             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))
@@ -605,6 +612,7 @@ function toCodeceptjsTest(test) {
     codeceptjsTest.fullTitle = () => `${parent.title} ${test.scenario}`;
     codeceptjsTest.state = 'pending';
     codeceptjsTest.notes = test.getPrintableNotes();
+    codeceptjsTest._explorbotTest = test;
     return codeceptjsTest;
 }
 const REF_LINE_PATTERN = /^(\s*)-\s+(\w+)\s*(?:"([^"]*)")?.*?\[ref=(e\d+)\]/;
@@ -622,7 +630,7 @@ function parseAriaRefs(ariaSnapshot) {
     return entries;
 }
 export async function annotatePageElements(page) {
-    const ariaSnapshot = await page.locator('body').ariaSnapshot({ forAI: true });
+    const ariaSnapshot = await page.locator('body').ariaSnapshot({ mode: 'ai' });
     const refEntries = parseAriaRefs(ariaSnapshot);
     const byRole = new Map();
     for (const { role, name, ref } of refEntries) {