explorbot 0.1.20 → 0.1.22

package/dist/src/ai/navigator.js

@@ -1,4 +1,6 @@
+import { tool } from 'ai';
 import dedent from 'dedent';
+import { z } from 'zod';
 import { ActionResult } from '../action-result.js';
 import { ExperienceTracker, renderExperienceToc } from '../experience-tracker.js';
 import { KnowledgeTracker } from '../knowledge-tracker.js';
@@ -68,6 +70,12 @@ class Navigator {
         this.experienceTracker = experienceTracker || new ExperienceTracker();
         this.hooksRunner = new HooksRunner(explorer, explorer.getConfig());
     }
+    get verifyAttempts() {
+        return this.explorer.getConfig().ai?.agents?.navigator?.verifyAttempts ?? 3;
+    }
+    get verifyTimeout() {
+        return this.explorer.getConfig().ai?.agents?.navigator?.verifyTimeout ?? 1500;
+    }
     getBaseOrigin() {
         const baseUrl = this.explorer.getConfig().playwright.url;
         try {
@@ -213,7 +221,27 @@ class Navigator {
     `;
         const conversation = this.provider.startConversation(this.systemPrompt, 'navigator');
         conversation.addUserText(prompt);
-        const tools = undefined;
+        let stopReason = null;
+        const tools = {
+            stop: tool({
+                description: dedent `
+          Stop the navigation because no locator or strategy change can reach the goal.
+          Use this when reaching the goal requires something only the user can supply or that the
+          page cannot grant from the current state — for example: an authentication failure you
+          cannot guess past, a captcha or human-verification step, a permission the test cannot
+          satisfy, a piece of data not present in the available knowledge / hint context, or a
+          blocking error or dialog you cannot dismiss.
+          Do NOT use this for locator or strategy problems — for those, emit new code blocks instead.
+        `,
+                inputSchema: z.object({
+                    reason: z.string().describe('Short user-facing explanation. Quote what you observed (alert text, dialog title, status message, validation note) and name what is missing or required.'),
+                }),
+                execute: async ({ reason }) => {
+                    stopReason = reason;
+                    return { success: true, message: 'Recorded. Navigator will stop and surface the reason.' };
+                },
+            }),
+        };
         let codeBlocks = [];
         let htmlContextAdded = false;
         let codeBlockIndex = 0;
@@ -226,6 +254,12 @@ class Navigator {
                 const result = await this.provider.invokeConversation(conversation, tools);
                 if (!result)
                     return;
+                if (stopReason) {
+                    tag('error').log(`Navigator stopped: ${stopReason}`);
+                    resolved = false;
+                    stop();
+                    return;
+                }
                 const aiResponse = result?.response?.text;
                 debugLog('AI:', aiResponse?.split('\n')[0]);
                 debugLog('Received AI response:', aiResponse?.length ?? 0, 'characters');
@@ -245,14 +279,40 @@ class Navigator {
                 tag('substep').log('Feeding failures back to AI for a new batch...');
                 let contextMsg = 'Previous solutions did not work. Analyze the failures and try DIFFERENT strategies (not syntactic variants of the same locator).\n\n';
                 if (batchFailures.length > 0) {
-                    const lines = batchFailures.map((f) => `- \`${f.code.split('\n')[0]}\` → ${f.error}`).join('\n');
+                    const lines = batchFailures
+                        .map((f) => {
+                        const head = `- \`${f.code.split('\n')[0]}\` → ${f.error}`;
+                        if (!f.ariaChanges)
+                            return head;
+                        const trimmed = f.ariaChanges.split('\n').slice(0, 12).join('\n    ');
+                        return `${head}\n  • ARIA changes after the action:\n    ${trimmed}`;
+                    })
+                        .join('\n');
                     contextMsg += `<previous_failures>\n${lines}\n</previous_failures>\n\n`;
                 }
                 if (!htmlContextAdded) {
                     htmlContextAdded = true;
                     contextMsg += `Full HTML context:\n\n<page_html>\n${await actionResult.combinedHtml()}\n</page_html>\n\n`;
                 }
-                contextMsg += 'Propose new solutions. If errors mention "intercepts pointer events" or timeouts on visible elements, an overlay is blocking — dismiss it first (Escape, click outside, Close button) before retrying the original action.';
+                const pageReacted = batchFailures.some((f) => f.ariaChanges);
+                if (pageReacted) {
+                    contextMsg += dedent `
+              Some steps in the previous batch did not throw, but the URL did not change to the expected target and the page changed in other ways — the ARIA diff for each such step is listed in <previous_failures> above.
+
+              Read those diffs and judge what each step actually triggered. Different action types produce different reactions; the diff is your only evidence of what happened. A diff might show, for example: a new alert / alertdialog / status / validation message appearing near a field or at page level; a modal, dialog, or wizard step opening; a banner, toast, or notification region appearing; a section expanding or collapsing; a tab or accordion switching content. A diff might also be empty or unrelated to the step — that is also a signal.
+
+              Choose exactly ONE path based on what the diffs actually show — do not assume the previous step submitted any particular kind of data:
+
+              A. The diff indicates the application requires something only the user can supply — for example: an authentication failure you cannot guess past, a captcha, a permission the test cannot satisfy, or knowledge that is not present in the provided context. Call the stop() tool and quote what you saw in the diff and what is needed.
+
+              B. The diff indicates the next step is something you can perform from the existing knowledge / hint context — for example: re-emit a step with a value that exists in the knowledge but was used incorrectly; dismiss an unexpected modal; accept a confirmation; take a follow-up step the page now requires. Emit code blocks for that next step. Do NOT change the locator of a step that already produced a reaction.
+
+              C. The diff is empty or unrelated to your step — the action likely missed its target. Propose a different locator strategy.
+            `;
+                }
+                else {
+                    contextMsg += 'Propose new solutions. If errors mention "intercepts pointer events" or timeouts on visible elements, an overlay is blocking — dismiss it first (Escape, click outside, Close button) before retrying the original action.';
+                }
                 conversation.addUserText(contextMsg);
                 codeBlocks = [];
                 batchFailures.length = 0;
@@ -261,7 +321,8 @@ class Navigator {
             codeBlockIndex++;
             totalAttempts++;
             await this.explorer.switchToMainFrame();
-            const prevHash = action.actionResult?.getStateHash() ?? actionResult.getStateHash();
+            const prevActionResult = action.actionResult ?? actionResult;
+            const prevHash = prevActionResult.getStateHash();
             debugLog(`Attempting resolution: ${codeBlock}`);
             const attemptOk = await action.attempt(codeBlock, message);
             const page = action.playwrightHelper?.page;
@@ -294,6 +355,23 @@ class Navigator {
                 const stateChanged = freshState.getStateHash() !== actionResult.getStateHash();
                 resolved = urlMatches && stateChanged;
                 if (!resolved && attemptOk) {
+                    let ariaChanges = null;
+                    if (freshState.getStateHash() !== prevHash) {
+                        try {
+                            const diff = await freshState.diff(prevActionResult);
+                            await diff.calculate();
+                            ariaChanges = diff.ariaChanged;
+                        }
+                        catch (err) {
+                            debugLog('Failed to compute pageDiff for failed URL verification:', err);
+                        }
+                    }
+                    batchFailures.push({
+                        code: codeBlock,
+                        error: `URL did not change (still ${freshState.url})`,
+                        ariaChanges,
+                        urlAfter: freshState.url,
+                    });
                     tag('warning').log(`URL verification failed: expected ${expectedUrl}, got ${freshState.url}`);
                 }
                 if (freshState.getStateHash() !== prevHash && (attemptOk || urlMatches)) {
@@ -343,11 +421,15 @@ class Navigator {
                 tag('success').log('Navigation resolved after delayed redirect');
             }
         }
-        if (!resolved && totalAttempts > 0) {
+        if (!resolved && stopReason) {
+            tag('error').log(`Navigator stopped: ${stopReason}`);
+        }
+        else if (!resolved && totalAttempts > 0) {
             tag('error').log(`Navigation failed after ${totalAttempts} attempts`);
         }
         if (!resolved && isInteractive()) {
-            const userInput = await pause(`Navigator failed to resolve. Current: ${action.stateManager.getCurrentState()?.url}\n` + `Target: ${expectedUrl ?? '(none)'}\nEnter CodeceptJS commands (or press Enter to skip):`);
+            const stopLine = stopReason ? `Navigator stopped: ${stopReason}\n` : '';
+            const userInput = await pause(`${stopLine}Navigator failed to resolve. Current: ${action.stateManager.getCurrentState()?.url}\n` + `Target: ${expectedUrl ?? '(none)'}\nEnter CodeceptJS commands (or press Enter to skip):`);
             if (userInput?.trim()) {
                 resolved = await action.attempt(userInput, message);
                 if (resolved && expectedUrl) {
@@ -489,6 +571,11 @@ class Navigator {
     async verifyState(message, actionResult) {
         tag('info').log('AI Navigator verifying state at', actionResult.url);
         debugLog('Verification message:', message);
+        const cachedVerification = actionResult.getVerification(message);
+        if (cachedVerification !== null) {
+            tag('substep').log(`Reusing cached verification: ${cachedVerification ? 'PASS' : 'FAIL'}`);
+            return { verified: cachedVerification, successfulCodes: [], assertionSteps: [], totalAttempted: 0 };
+        }
         let knowledge = '';
         let experience = '';
         const relevantKnowledge = this.knowledgeTracker.getRelevantKnowledge(actionResult);
@@ -508,6 +595,20 @@ class Navigator {
                 experience = renderExperienceToc(toc);
             }
         }
+        const priorVerifications = Object.entries(actionResult.verifications ?? {});
+        let verificationContext = '';
+        if (priorVerifications.length > 0) {
+            const lines = priorVerifications.map(([claim, passed]) => `- "${claim}" → ${passed ? 'passed' : 'failed'}`).join('\n');
+            verificationContext = dedent `
+        <already_verified>
+        These claims were already checked on this page:
+        ${lines}
+
+        If the claim to verify has the same meaning as one above (even if worded differently), do NOT write any assertion code.
+        Respond with a single line and nothing else: ALREADY_VERIFIED: <exact text of the matching claim>
+        </already_verified>
+      `;
+        }
         const prompt = dedent `
       <message>
         ${message}
@@ -521,11 +622,13 @@ class Navigator {
         </page_html>
       </page>
 
+      ${verificationContext}
+
       <task>
         Identify what assertion the user wants to verify on the page.
-        Propose different CodeceptJS assertion code blocks to verify the expected state.
+        Propose 2-3 strong, distinct CodeceptJS assertion code blocks that each directly prove the claim.
         Use only data from the <page> context to plan the verification.
-        Try various locators and approaches to verify the assertion.
+        Prefer the fewest, most specific assertions over many variants of the same locator.
 
         IMPORTANT: Each code block must verify the SPECIFIC claim in the message, not just a generic aspect of it.
         Bad: I.seeElement({"role":"button","aria-pressed":"true"}) — matches ANY button, not the specific one
@@ -544,50 +647,83 @@ class Navigator {
         tag('debug').log('Prompt:', prompt);
         const conversation = this.provider.startConversation(this.systemPrompt, 'navigator');
         conversation.addUserText(prompt);
+        let alreadyVerified = false;
         const tools = this.buildExperienceTools();
         let codeBlocks = [];
         const successfulCodes = [];
         const assertionSteps = [];
         const action = this.explorer.createAction();
-        await loop(async ({ stop, iteration }) => {
-            if (codeBlocks.length === 0) {
-                const result = await this.provider.invokeConversation(conversation, tools);
-                if (!result)
+        let failures = 0;
+        const page = this.explorer.playwrightHelper?.page;
+        const originalTimeout = this.explorer.playwrightHelper?.options?.timeout ?? 3000;
+        page?.setDefaultTimeout(this.verifyTimeout);
+        try {
+            await loop(async ({ stop, iteration }) => {
+                if (codeBlocks.length === 0) {
+                    const result = await this.provider.invokeConversation(conversation, tools);
+                    if (!result)
+                        return;
+                    const aiResponse = result?.response?.text ?? '';
+                    debugLog('Received AI response:', aiResponse.length, 'characters');
+                    tag('step').log('Verifying assertion...');
+                    if (this.checkAlreadyVerified(aiResponse, actionResult)) {
+                        alreadyVerified = true;
+                        stop();
+                        return;
+                    }
+                    codeBlocks = extractCodeBlocks(aiResponse);
+                }
+                if (codeBlocks.length === 0) {
                     return;
-                const aiResponse = result?.response?.text;
-                debugLog('Received AI response:', aiResponse?.length ?? 0, 'characters');
-                tag('step').log('Verifying assertion...');
-                codeBlocks = extractCodeBlocks(aiResponse ?? '');
-            }
-            if (codeBlocks.length === 0) {
-                return;
-            }
-            const codeBlock = codeBlocks[iteration - 1];
-            if (!codeBlock) {
-                stop();
-                return;
-            }
-            await this.explorer.switchToMainFrame();
-            const verified = await action.attempt(codeBlock, message, false);
-            if (verified) {
-                tag('success').log('Verification passed');
-                successfulCodes.push(codeBlock);
-                assertionSteps.push(...action.assertionSteps);
-            }
-        }, {
-            maxAttempts: this.MAX_ATTEMPTS,
-            observability: {
-                agent: 'navigator',
-            },
-            catch: async (error) => {
-                debugLog(error);
-            },
-        });
-        const totalAttempted = Math.min(codeBlocks.length, this.MAX_ATTEMPTS);
-        const verified = totalAttempted <= 1 ? successfulCodes.length > 0 : successfulCodes.length > totalAttempted / 2;
+                }
+                const codeBlock = codeBlocks[iteration - 1];
+                if (!codeBlock) {
+                    stop();
+                    return;
+                }
+                await this.explorer.switchToMainFrame();
+                const verified = await action.attempt(codeBlock, message, false);
+                if (verified) {
+                    tag('success').log('Verification passed');
+                    successfulCodes.push(codeBlock);
+                    assertionSteps.push(...action.assertionSteps);
+                }
+                else {
+                    failures++;
+                }
+                const target = Math.min(codeBlocks.length, this.verifyAttempts);
+                const majorityNeeded = Math.floor(target / 2) + 1;
+                if (successfulCodes.length >= majorityNeeded || failures > target - majorityNeeded) {
+                    stop();
+                }
+            }, {
+                maxAttempts: this.verifyAttempts,
+                observability: {
+                    agent: 'navigator',
+                },
+                catch: async (error) => {
+                    debugLog(error);
+                },
+            });
+        }
+        finally {
+            page?.setDefaultTimeout(originalTimeout);
+        }
+        const totalAttempted = Math.min(codeBlocks.length, this.verifyAttempts);
+        const majorityNeeded = Math.floor(totalAttempted / 2) + 1;
+        let verified = successfulCodes.length >= majorityNeeded;
+        if (alreadyVerified)
+            verified = true;
         actionResult.addVerification(message, verified);
         this.explorer.getStateManager().updateState(actionResult);
         return { verified, successfulCodes, assertionSteps, totalAttempted };
     }
+    checkAlreadyVerified(aiResponse, actionResult) {
+        const verifiedMatch = aiResponse.match(/ALREADY_VERIFIED:\s*(.+)/i);
+        if (!verifiedMatch)
+            return false;
+        const claim = verifiedMatch[1].trim().replace(/^["']|["']$/g, '');
+        return actionResult.getVerification(claim) === true;
+    }
 }
 export { Navigator };

package/dist/src/ai/pilot.js

@@ -279,6 +279,12 @@ export class Pilot {
       - "Delete X" → X must be gone. Clicking delete is NOT enough.
       - "Edit X" → updated value must be persisted (visible in list/detail). Opening edit is NOT enough; redirect after save with the new value visible IS enough.
       - Negative tests ("without a name", "invalid", "duplicate", "unauthorized") → success means the system PREVENTED the action with validation/error.
+      - Navigation-prefixed titles ("Access/Open/Go to X to <do Y>") → the goal is <do Y>; reaching X is
+        only a milestone. A satisfied milestone (tab active, panel/prompt visible, list shown) is NEVER a pass
+        if <do Y> did not occur this run.
+      - If the page reveals the goal cannot be performed here — required control absent, integration not
+        connected, or only a setup/connect/empty-state prompt is shown — vote "skipped" (prerequisites unmet),
+        never "pass".
 
       PROVENANCE: the entity you cite as proof must appear by name in <notes> or
       <session_log> tool inputs for THIS run. Name absent from tester activity = stale

package/dist/src/commands/index.js

@@ -24,6 +24,7 @@ import { PlanEditCommand } from './plan-edit-command.js';
 import { PlanLoadCommand } from './plan-load-command.js';
 import { PlanReloadCommand } from './plan-reload-command.js';
 import { PlanSaveCommand } from './plan-save-command.js';
+import { PlansCommand } from './plans-command.js';
 import { RerunCommand } from './rerun-command.js';
 import { ResearchCommand } from './research-command.js';
 import { RunsCommand } from './runs-command.js';
@@ -42,6 +43,7 @@ const commandClasses = [
     PlanCommand,
     PlanSaveCommand,
     PlanLoadCommand,
+    PlansCommand,
     PlanReloadCommand,
     PlanClearCommand,
     PlanEditCommand,

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

@@ -29,6 +29,15 @@ const config = {
     // agentic model for decision making
     agenticModel: openrouter('minimax/minimax-m2.5:nitro'),
   },
+
+  reporter: {
+    // Save a local HTML report after each run.
+    html: true,
+    // Save a local markdown report after each run.
+    markdown: true,
+    // Group runs by title in Testomat.io / HTML reports. Defaults to today's date — customize or remove.
+    runGroup: new Date().toISOString().slice(0, 10),
+  },
 };
 
 export default config;

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

@@ -0,0 +1,83 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { Plan } from '../test-plan.js';
+import { getCliName } from '../utils/cli-name.js';
+import { tag } from '../utils/logger.js';
+import { relativeToCwd } from '../utils/next-steps.js';
+import { BaseCommand } from './base-command.js';
+export class PlansCommand extends BaseCommand {
+    name = 'plans';
+    description = 'List saved plans and show their test scenarios';
+    options = [{ flags: '--from-plan <file>', description: 'Plan file to show' }];
+    async execute(args) {
+        const { opts, args: remaining } = this.parseArgs(args);
+        const files = this.getPlanFiles();
+        const target = String(opts.fromPlan || remaining[0] || '').trim();
+        if (!target) {
+            this.printPlans(files);
+            return;
+        }
+        const file = this.resolvePlanFile(target, files);
+        const plan = Plan.fromMarkdown(file.path);
+        this.printPlanDetails(plan, file);
+    }
+    getPlanFiles() {
+        const plansDir = this.explorBot.getPlansDir();
+        if (!existsSync(plansDir))
+            return [];
+        return readdirSync(plansDir)
+            .filter((file) => file.endsWith('.md'))
+            .map((file) => {
+            const filePath = path.join(plansDir, file);
+            const stat = statSync(filePath);
+            return {
+                name: file,
+                path: filePath,
+                modifiedAt: stat.mtimeMs,
+            };
+        })
+            .sort((left, right) => right.modifiedAt - left.modifiedAt);
+    }
+    printPlans(files) {
+        if (files.length === 0) {
+            tag('info').log(`No saved plans found in ${relativeToCwd(this.explorBot.getPlansDir())}`);
+            return;
+        }
+        tag('info').log('Saved plans:');
+        for (let i = 0; i < files.length; i++) {
+            const file = files[i];
+            const plan = Plan.fromMarkdown(file.path);
+            tag('info').log(`${i + 1}. ${plan.title} (${plan.tests.length} tests) - ${file.name}`);
+        }
+        tag('info').log('');
+        tag('info').log(`View plan tests: ${getCliName()} plans <number>`);
+    }
+    printPlanDetails(plan, file) {
+        tag('info').log(`${plan.title} (${plan.tests.length} tests)`);
+        for (let i = 0; i < plan.tests.length; i++) {
+            const test = plan.tests[i];
+            tag('info').log(`${i + 1}. ${test.scenario}`);
+        }
+        tag('info').log('');
+        tag('info').log('Run test from this plan as:');
+        tag('info').log(`${getCliName()} test 1 --from-plan ${file.name}`);
+    }
+    resolvePlanFile(target, files) {
+        const index = Number.parseInt(target, 10);
+        if (!Number.isNaN(index) && String(index) === target) {
+            const file = files[index - 1];
+            if (!file)
+                throw new Error(`Plan #${target} not found. Available: 1-${files.length}`);
+            return file;
+        }
+        const resolved = this.explorBot.resolvePlanPath(target);
+        if (!existsSync(resolved)) {
+            throw new Error(`Plan file not found: ${resolved}`);
+        }
+        return {
+            name: path.basename(resolved),
+            path: resolved,
+            modifiedAt: statSync(resolved).mtimeMs,
+        };
+    }
+}

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

@@ -5,12 +5,18 @@ import { BaseCommand } from './base-command.js';
 export class TestCommand extends BaseCommand {
     name = 'test';
     description = 'Launch tester agent to execute test scenarios';
+    options = [{ flags: '--from-plan <file>', description: 'Load plan file before selecting tests' }];
     suggestions = [
         { command: 'test', hint: 'run next test' },
         { command: 'plan', hint: 'create new plan' },
     ];
     async execute(args) {
+        const { opts, args: remaining } = this.parseArgs(args);
+        if (opts.fromPlan) {
+            this.explorBot.loadPlan(String(opts.fromPlan));
+        }
         const plan = this.explorBot.getCurrentPlan();
+        const selector = remaining.join(' ');
         Stats.mode = 'test';
         Stats.focus = plan?.title;
         const toExecute = [];
@@ -19,25 +25,25 @@ export class TestCommand extends BaseCommand {
                 throw new Error('No plan found. Please run /plan first to create test scenarios.');
             return plan;
         };
-        if (!args) {
+        if (!selector) {
             const pending = requirePlan().getPendingTests();
             if (pending.length === 0) {
                 throw new Error('All tests are already complete. Please run /plan to create new test scenarios.');
             }
             toExecute.push(pending[0]);
         }
-        else if (args === '*' || args === 'all') {
+        else if (selector === '*' || selector === 'all') {
             toExecute.push(...requirePlan().getPendingTests());
         }
-        else if (args.match(/^[\d,\-\s]+$/)) {
+        else if (selector.match(/^[\d,\-\s]+$/)) {
             const visible = requirePlan().tests.filter((t) => t.enabled);
-            const indices = parseTestIndices(args, visible.length);
+            const indices = parseTestIndices(selector, visible.length);
             for (const idx of indices) {
                 toExecute.push(visible[idx]);
             }
         }
         else {
-            const matching = plan?.getPendingTests().filter((test) => test.scenario.toLowerCase().includes(args.toLowerCase())) || [];
+            const matching = plan?.getPendingTests().filter((test) => test.scenario.toLowerCase().includes(selector.toLowerCase())) || [];
             if (matching.length > 0) {
                 toExecute.push(...matching);
             }
@@ -46,13 +52,13 @@ export class TestCommand extends BaseCommand {
                 if (!state) {
                     throw new Error('No page loaded. Please navigate to a page first.');
                 }
-                const newTest = new Test(args, 'unknown', [], state.url);
+                const newTest = new Test(selector, 'unknown', [], state.url);
                 if (plan) {
                     plan.addTest(newTest);
-                    tag('info').log(`Created new test: "${args}" and added to current plan.`);
+                    tag('info').log(`Created new test: "${selector}" and added to current plan.`);
                 }
                 else {
-                    tag('info').log(`Created ad-hoc test: "${args}"`);
+                    tag('info').log(`Created ad-hoc test: "${selector}"`);
                 }
                 toExecute.push(newTest);
             }

package/dist/src/playwright-recorder.js

@@ -1,6 +1,5 @@
+import { createRequire } from 'node:module';
 import { readFile } from 'node:fs/promises';
-// @ts-ignore — package ships a .js re-export without typings for this sub-path
-import * as playwrightUtils from 'playwright-core/lib/utils';
 import { createDebug } from "./utils/logger.js";
 const debugLog = createDebug('explorbot:playwright-recorder');
 const RECORDABLE = {
@@ -8,11 +7,26 @@ const RECORDABLE = {
     Page: new Set(['goBack', 'goForward', 'reload', 'keyboardPress', 'keyboardType', 'keyboardDown', 'keyboardUp', 'keyboardInsertText', 'mouseClick', 'mouseDblclick', 'mouseMove', 'mouseDown', 'mouseUp', 'mouseWheel']),
 };
 const PLAYWRIGHT_INCOMPATIBLE = "Playwright output is not compatible with this Playwright version (playwright-core/lib/utils does not expose asLocator). Use output.framework: 'codeceptjs' instead, or pin Playwright to a version shipping lib/utils/isomorphic/locatorGenerators.js.";
+let cachedAsLocator = null;
+let asLocatorLoadAttempted = false;
+const nodeRequire = typeof require === 'function' ? require : createRequire(import.meta.url);
 function getAsLocator() {
-    const fn = playwrightUtils?.asLocator;
-    if (typeof fn !== 'function')
+    if (cachedAsLocator)
+        return cachedAsLocator;
+    if (asLocatorLoadAttempted)
         throw new Error(PLAYWRIGHT_INCOMPATIBLE);
-    return fn;
+    asLocatorLoadAttempted = true;
+    try {
+        const mod = nodeRequire('playwright-core/lib/utils');
+        if (typeof mod?.asLocator === 'function') {
+            cachedAsLocator = mod.asLocator;
+            return cachedAsLocator;
+        }
+    }
+    catch {
+        // Module not exported or not found
+    }
+    throw new Error(PLAYWRIGHT_INCOMPATIBLE);
 }
 export class PlaywrightRecorder {
     context = null;

package/dist/src/reporter.js

@@ -11,7 +11,7 @@ export class Reporter {
     constructor(config, stateManager) {
         this.reporterEnabled = Reporter.resolveEnabled(config);
         this.stateManager = stateManager;
-        if (this.reporterEnabled && (!process.env.TESTOMATIO || config?.html)) {
+        if (this.reporterEnabled && config?.html) {
             this.configureHtmlPipe();
         }
         if (this.reporterEnabled && config?.markdown) {
@@ -45,6 +45,8 @@ export class Reporter {
             return true;
         if (config?.enabled === false)
             return false;
+        if (config?.html || config?.markdown)
+            return true;
         return Boolean(process.env.TESTOMATIO);
     }
     configureHtmlPipe() {
@@ -68,13 +70,9 @@ export class Reporter {
     configureRunGroup(runGroup) {
         if (process.env.TESTOMATIO_RUNGROUP_TITLE)
             return;
-        if (runGroup === null)
-            return;
-        if (runGroup) {
-            process.env.TESTOMATIO_RUNGROUP_TITLE = runGroup;
+        if (!runGroup)
             return;
-        }
-        process.env.TESTOMATIO_RUNGROUP_TITLE = `Explorbot ${new Date().toISOString().slice(0, 10)}`;
+        process.env.TESTOMATIO_RUNGROUP_TITLE = runGroup;
     }
     async startRun() {
         if (this.isRunStarted) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "explorbot",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "description": "CLI app built with React Ink, CodeceptJS, and Playwright",
   "license": "Elastic-2.0",
   "type": "module",
@@ -82,7 +82,7 @@
     "@opentelemetry/sdk-trace-base": "^2.2.0",
     "@opentelemetry/semantic-conventions": "^1.38.0",
     "@scalar/openapi-parser": "^0.25.6",
-    "@testomatio/reporter": "^2.7.9-beta.3-markdown",
+    "@testomatio/reporter": "^2.8.4",
     "ai": "^6.0.6",
     "axe-core": "^4.11.1",
     "bash-tool": "^1.3.15",
@@ -108,7 +108,7 @@
     "micromatch": "^4.0.8",
     "ora-classic": "^5.4.2",
     "parse5": "^8.0.0",
-    "playwright": "^1.59.0",
+    "playwright": "^1.60",
     "react": "^19.1.1",
     "strip-ansi": "^7.1.2",
     "turndown": "^7.2.1",

package/src/action-result.ts

@@ -207,6 +207,17 @@ export class ActionResult implements ActionResultData {
     this.verifications[assertion] = passed;
   }
 
+  getVerification(message: string | RegExp): boolean | null {
+    if (!this.verifications) return null;
+    if (typeof message === 'string') {
+      return this.verifications[message] ?? null;
+    }
+    for (const [assertion, passed] of Object.entries(this.verifications)) {
+      if (message.test(assertion)) return passed;
+    }
+    return null;
+  }
+
   isSameUrl(state: WebPageState): boolean {
     if (!this.url || this.url === '') {
       return false;