explorbot 0.1.12 → 0.1.13

package/src/ai/pilot.ts

@@ -89,15 +89,16 @@ export class Pilot implements Agent {
     const notes = task.notesToString() || 'No notes recorded.';
 
     let visualAnalysis = '';
+    let screenshotState: ActionResult | null = null;
     if (this.provider.hasVision()) {
       try {
         const action = this.explorer.createAction();
-        const screenshotState = await action.caputrePageWithScreenshot();
+        screenshotState = await action.caputrePageWithScreenshot();
         if (screenshotState.screenshot) {
           visualAnalysis = (await this.researcher.answerQuestionAboutScreenshot(screenshotState, `Describe current page state relevant to: ${task.scenario}`)) || '';
         }
       } catch {
-        // vision not available, continue without
+        screenshotState = null;
       }
     }
 
@@ -167,26 +168,23 @@ export class Pilot implements Agent {
         return false;
       }
 
-      if (result.requestVerification && navigator) {
+      if (result.decision === 'pass' && result.requestVerification && navigator) {
         tag('substep').log(`Pilot requesting verification: ${result.requestVerification}`);
-        try {
-          const verifyResult = await navigator.verifyState(result.requestVerification, currentState);
-          if (verifyResult.verified) {
-            if (verifyResult.assertionSteps?.length) {
-              this.explorer.getPlaywrightRecorder().recordVerification(verifyResult.assertionSteps);
-            }
-            tag('substep').log(`Pilot verified: ${result.requestVerification}`);
-          } else {
-            tag('substep').log(`Pilot verification failed: ${result.requestVerification}`);
-            if (result.decision === 'pass') {
-              const flipMessage = `Verification "${result.requestVerification}" did not match the page. Adjust approach and re-verify before finishing.`;
-              result.decision = 'continue';
-              result.reason = flipMessage;
-              result.guidance = result.guidance ?? flipMessage;
-            }
+        const verifyResult = await navigator.verifyState(result.requestVerification, currentState).catch(() => null);
+        if (verifyResult?.verified) {
+          if (verifyResult.assertionSteps?.length) {
+            this.explorer.getPlaywrightRecorder().recordVerification(verifyResult.assertionSteps);
+          }
+        } else {
+          let answer: string | null = null;
+          if (screenshotState?.screenshot) {
+            answer = await this.researcher.answerQuestionAboutScreenshot(screenshotState, `Does the screen confirm: "${result.requestVerification}"? Answer YES or NO only.`);
+          }
+          if (!(answer || '').trim().toUpperCase().startsWith('YES')) {
+            task.addNote(`Pilot: verification failed — ${result.requestVerification}`, TestResult.FAILED);
+            task.finish(TestResult.FAILED);
+            return false;
           }
-        } catch (verifyErr: any) {
-          tag('warning').log(`Pilot verification errored: ${verifyErr.message}`);
         }
       }
 
@@ -389,6 +387,8 @@ export class Pilot implements Agent {
       - If no verification was done → prefer "continue" with guidance telling tester what to verify.
       - If verify assertion describes a state that was ALREADY TRUE before the test started, the verification proves nothing — reject with "continue".
 
+      requestVerification — pick assertions DOM can actually express. Some content is not assertable via DOM (iframe text, canvas, custom widgets, Monaco/CodeMirror editors). When the scenario goal lives in such a region, target a STABLE LANDMARK (container element, ARIA role, the parent that wraps the widget) rather than literal text inside it. Your "pass" verdict is honored even if the DOM assertion can't be made — pick the strongest landmark you can.
+
       GUIDANCE FIELD: When decision is "continue", you MUST provide "guidance" — a specific actionable instruction:
       - If evidence is insufficient: tell tester to verify with see()/verify(), specify WHAT to check
       - If approach was wrong: tell tester to try a different method, suggest which one
@@ -470,7 +470,7 @@ export class Pilot implements Agent {
     );
   }
 
-  async reviewNewPage(task: Test, currentState: ActionResult): Promise<string> {
+  async reviewNewPage(task: Test, currentState: ActionResult, testerConversation: Conversation): Promise<string> {
     if (!this.conversation) return '';
 
     tag('substep').log('Pilot reviewing new page...');
@@ -481,8 +481,14 @@ export class Pilot implements Agent {
     if (!pageSummary) return '';
 
     const stateContext = this.buildStateContext(currentState);
+    const toolCalls = testerConversation
+      .getToolExecutions()
+      .filter((t: any) => t.wasSuccessful)
+      .slice(-this.stepsToReview);
+    const actionsContext = this.formatActions(toolCalls);
 
     this.conversation.cleanupTag('page_summary', '...trimmed...', 1);
+    this.conversation.cleanupTag('recent_actions', '...trimmed...', 2);
 
     return this.sendToPilot(
       dedent`
@@ -497,6 +503,10 @@ export class Pilot implements Agent {
         ${pageSummary}
         </page_summary>
 
+        <recent_actions>
+        ${actionsContext || 'None'}
+        </recent_actions>
+
         ${this.formatExpectations(task)}
 
         First: evaluate whether this navigation makes sense for the scenario goal. If the page is unrelated, instruct Tester to back() or reset(). Then plan next steps.

package/src/ai/rules.ts

@@ -282,11 +282,9 @@ export const actionRule = dedent`
     I.fillField('Description', 'Hello world', '.editor'); // works for rich text / code editors too
   </example>
 
-  I.fillField handles plain inputs, textareas, contenteditable regions, and rich text / code editors
-  (Monaco, ProseMirror, CodeMirror, TipTap, Quill, Draft.js, Slate, etc.) transparently.
-  ALWAYS use I.fillField for rich editors — target the editor container or its nearest label/heading with a normal locator.
-  Do NOT open the editor with raw JS (executeScript, page.evaluate), do NOT dispatch synthetic events,
-  do NOT call the editor's own API (monaco.editor.setValue, view.dispatch, etc.) to write text.
+  I.fillField handles plain inputs, textareas, contenteditable regions, and rich text / code editors transparently.
+  ALWAYS use I.fillField for rich text / code editors — target the editor container or its nearest label/heading with a normal locator.
+  If I.fillField does not work, I.type into the focused element is the fallback.
 
   ### I.type
 

package/src/ai/session-analyst.ts

@@ -0,0 +1,133 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import dedent from 'dedent';
+import { outputPath } from '../config.ts';
+import { Stats } from '../stats.ts';
+import type { Test } from '../test-plan.ts';
+import type { Agent } from './agent.ts';
+import type { Provider } from './provider.ts';
+
+export class SessionAnalyst implements Agent {
+  emoji = '🧐';
+  private provider: Provider;
+
+  constructor(provider: Provider) {
+    this.provider = provider;
+  }
+
+  async analyze(tests: Test[]): Promise<string> {
+    const eligible = tests.filter((t) => t.startTime != null);
+    if (eligible.length === 0) return '';
+
+    const model = this.provider.getModelForAgent('analyst');
+    const customPrompt = this.provider.getSystemPromptForAgent('analyst', undefined);
+
+    const systemPrompt = dedent`
+      You write a brief end-of-session report after autonomous exploratory testing. Your reader is a developer who needs to know in seconds: what is broken, how to reproduce it, and which results were inconclusive.
+
+      Output MARKDOWN. No JSON, no preamble, no closing remarks. Start with the heading.
+
+      ## Clustering
+      Group by ROOT CAUSE, not by scenario. If three tests fail for the same dropdown, that is ONE defect listing all three test refs (#3, #5, #7). Do not produce one cluster per test.
+
+      ## Bucketing
+      Use the FINAL verdict (the test's \`result\` field) as the starting point. Mid-test errors that the automation recovered from do NOT make a passed test unreliable.
+
+      - **Defect** — real product bug. \`result: failed\` AND the failure reflects the app misbehaving (not the automation). The automation completed its interactions, the app contradicted the expected outcome. Severity required.
+      - **UX issue** — app works but the UI is ambiguous, controls are hidden, or labels are unclear. Worth flagging to design.
+      - **Execution issue** — the FINAL verdict is unreliable. Only two cases:
+        1. \`result: failed\` AND the failure was automation, environment, or UI/UX (locator missing, timeout, AI loop, navigation stuck, modal trapped focus, no accessible label) — i.e. the test could not conclude whether the app works.
+        2. \`result: passed\` AND clear evidence in the log shows the user-visible goal was NOT achieved (no confirmation visible, no state change verified, the assertion was vacuous).
+
+      A test that passed and shows no contrary evidence belongs in NO section. Do not list passed tests just because the log contains intermediate retries or recovered failures.
+
+      ## Severity emoji (defects only)
+      - 🔴 critical or high — core flow blocked, data loss, security
+      - 🟡 medium — partial breakage with workaround
+      - 🟢 low — cosmetic
+
+      ## Required format
+
+      # Session Analysis
+
+      <one sentence: total tests, defect count, headline finding>
+
+      ## Defects
+
+      ### 🔴 <plain-English title of the BUG, not the scenario name>
+      Affects: #3, #5, #7
+      Reproduce:
+        1. <concrete UI step a person can replay>
+        2. <next step>
+      Evidence: <one short observation from the test log>
+
+      ### 🟡 <next defect>
+      ...
+
+      ## UX issues
+
+      - **<title>** — #4
+        <one short evidence line>
+
+      ## Execution Issues
+
+      - **<short test name or scenario phrase>** — <plain-English one-liner: what made the result unreliable>
+      - **<…>** — <…>
+
+      ## Rules
+      - Defects first, sorted by severity descending. Omit any section that has zero entries.
+      - Defect title describes the BUG ("Run-type dropdown does not filter"), never the scenario name.
+      - Reproduce steps are concrete UI actions derived from the log: URL + clicks + inputs. Imperative, one short line each.
+      - Evidence is the smallest factual observation from notes/steps that supports the claim — what was OBSERVED in the page (HTML, message, missing element). Never quote the test's \`result\` field as evidence; that is a tautology.
+      - **Execution Issues** entries must explain what actually went wrong in concrete terms a human understands: "could not find a Submit button after navigation", "page reloaded before the assertion ran", "passed without ever seeing a confirmation message", "marked failed but the new item appears in the list", "modal trapped focus and tests could not click outside", "ARIA tree had no labelled controls". Avoid jargon like "locator failed" without context. Never write category prefixes ("execution:", "false-positive:") — the section header already says it. No emoji on these entries.
+      - Do NOT include a passed test in any section unless evidence proves its goal was not achieved. Intermediate retries or recovered errors in the log are not grounds for listing a passed test.
+      - No editorialising, no restating the scenario verbatim, no closing summary.
+
+      ${customPrompt || ''}
+    `;
+
+    const userPayload = dedent`
+      ${eligible.length} tests were executed in this session.
+
+      ${eligible.map((t, i) => this.serializeTest(t, i + 1)).join('\n\n')}
+    `;
+
+    const response = await this.provider.chat(
+      [
+        { role: 'system', content: systemPrompt },
+        { role: 'user', content: userPayload },
+      ],
+      model,
+      { agentName: 'analyst' }
+    );
+
+    return (response?.text || '').trim();
+  }
+
+  writeReport(markdown: string): string {
+    const filePath = outputPath('reports', `${Stats.sessionLabel()}.md`);
+    const dir = path.dirname(filePath);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(filePath, markdown);
+    return filePath;
+  }
+
+  private serializeTest(test: Test, ref: number): string {
+    const log = test
+      .getLog()
+      .slice(-30)
+      .map((entry) => `  - [${entry.type}] ${entry.content}`)
+      .join('\n');
+
+    return dedent`
+      <test ref="#${ref}">
+      url: ${test.startUrl || '/'}
+      scenario: ${test.scenario}
+      result: ${test.result || 'unknown'}
+      expected: ${test.expected.join(' | ') || '(none)'}
+      log:
+      ${log}
+      </test>
+    `;
+  }
+}

package/src/ai/tester.ts

@@ -268,7 +268,7 @@ export class Tester extends TaskAgent implements Agent {
             nextStep += await this.prepareInstructionsForNextStep(task);
 
             if (isNewPage && this.pilot) {
-              const guidance = await this.pilot.reviewNewPage(task, currentState);
+              const guidance = await this.pilot.reviewNewPage(task, currentState, conversation);
               if (guidance) nextStep += `\n\n${guidance}`;
             } else if ((iteration % this.progressCheckInterval === 0 || this.consecutiveFailures >= 3 || this.consecutiveEmptyResults >= 2) && this.pilot) {
               const guidance = await this.pilot.analyzeProgress(task, currentState, conversation);
@@ -463,6 +463,8 @@ export class Tester extends TaskAgent implements Agent {
 
     let context = '';
 
+    const focusArea = detectFocusArea(currentState.ariaSnapshot);
+
     const focusedElement = extractFocusedElement(currentState.ariaSnapshot);
     if (focusedElement) {
       const isTextInput = ['textbox', 'combobox', 'searchbox'].includes(focusedElement.role);
@@ -480,6 +482,18 @@ export class Tester extends TaskAgent implements Agent {
       `;
     }
 
+    if (focusArea.detected) {
+      const areaName = focusArea.name ? ` "${focusArea.name}"` : '';
+      context += dedent`
+        <focus_scope>
+        A ${focusArea.type}${areaName} is currently open above the page.
+        Scope all interactions to elements inside this ${focusArea.type}.
+        Page navigation, filters, and tabs that exist outside it are not actionable while it is open and may share names or roles with elements inside it — prefer the locator inside the ${focusArea.type}.
+        Use <page_aria> to confirm the element you target is actually inside the ${focusArea.type}.
+        </focus_scope>
+      `;
+    }
+
     if (currentState.isInsideIframe) {
       const iframeInfo = currentState.iframeURL || this.explorer.getCurrentIframeInfo() || 'iframe context active';
       context += dedent`
@@ -539,7 +553,6 @@ export class Tester extends TaskAgent implements Agent {
       return context;
     }
 
-    const focusArea = detectFocusArea(currentState.ariaSnapshot);
     if (focusArea.detected && focusArea.name && this.pageStateHash && this.pageActionResult) {
       const overlaySection = await this.researcher.researchOverlay(currentState, this.pageActionResult, this.pageStateHash);
       if (overlaySection) {

package/src/commands/base-command.ts

@@ -38,17 +38,17 @@ export abstract class BaseCommand {
   printSuggestions(): void {
     if (this.suggestions.length === 0) return;
     const prefix = isInteractive() ? '/' : `${getCliName()} `;
-    tag('info').log('');
-    tag('info').log(chalk.bold('Suggested:'));
+    const commandWidth = this.suggestions.reduce((max, s) => (s.command ? Math.max(max, prefix.length + s.command.length) : max), 0);
+    const lines = [chalk.bold('Suggested:')];
     for (const { command, hint } of this.suggestions) {
-      tag('info').log('');
       if (!command) {
-        tag('info').log(chalk.dim(hint));
+        lines.push(`  ${chalk.dim(hint)}`);
         continue;
       }
-      tag('info').log(chalk.dim(`${hint}:`));
-      tag('info').log(`  ${chalk.yellow(`${prefix}${command}`)}`);
+      const cmd = `${prefix}${command}`.padEnd(commandWidth);
+      lines.push(`  ${chalk.yellow(cmd)}  ${chalk.dim(hint)}`);
     }
+    tag('info').log(lines.join('\n'));
   }
 
   protected parseArgs(args: string): { opts: Record<string, string | boolean>; args: string[] } {

package/src/commands/drill-command.ts

@@ -3,6 +3,7 @@ import { BaseCommand, type Suggestion } from './base-command.js';
 export class DrillCommand extends BaseCommand {
   name = 'drill';
   description = 'Drill all components on current page to learn interactions';
+  aliases = ['driller'];
   suggestions: Suggestion[] = [
     { command: 'research', hint: 'see UI map first' },
     { command: 'navigate <page>', hint: 'go to another page' },
@@ -17,7 +18,7 @@ export class DrillCommand extends BaseCommand {
       throw new Error('No active page to drill');
     }
 
-    await this.explorBot.agentBosun().drill({
+    await this.explorBot.agentDriller().drill({
       knowledgePath,
       maxComponents,
       interactive: true,
@@ -30,7 +31,7 @@ export class DrillCommand extends BaseCommand {
   }
 
   private parseMaxArg(args: string): number | undefined {
-    const match = args.match(/--max\s+(\d+)/);
+    const match = args.match(/--max-components\s+(\d+)/);
     return match ? Number.parseInt(match[1], 10) : undefined;
   }
 }

package/src/commands/exit-command.ts

@@ -10,6 +10,7 @@ export class ExitCommand extends BaseCommand {
   aliases = ['quit'];
 
   async execute(_args: string): Promise<void> {
+    await this.explorBot.printSessionAnalysis();
     await this.explorBot.getExplorer().stop();
 
     if (Stats.hasActivity()) {

package/src/commands/explore-command.ts

@@ -73,6 +73,7 @@ export class ExploreCommand extends BaseCommand {
     if (mainUrl) await this.explorBot.visit(mainUrl);
     const savedPath = this.explorBot.savePlans(this.completedPlans);
     this.printResults();
+    await this.explorBot.printSessionAnalysis();
     this.printNextSteps(savedPath);
   }
 

package/src/components/AddRule.tsx

@@ -5,7 +5,7 @@ import React, { useEffect, useState } from 'react';
 import { AddRuleCommand } from '../commands/add-rule-command.js';
 import InputReadline from './InputReadline.js';
 
-const KNOWN_AGENTS = ['researcher', 'tester', 'planner', 'pilot', 'captain', 'bosun', 'navigator'];
+const KNOWN_AGENTS = ['researcher', 'tester', 'planner', 'pilot', 'captain', 'driller', 'navigator'];
 
 interface AddRuleProps {
   initialAgent?: string;

package/src/config.ts

@@ -123,6 +123,7 @@ interface AgentsConfig {
   researcher?: ResearcherAgentConfig;
   planner?: PlannerAgentConfig;
   pilot?: PilotAgentConfig;
+  driller?: AgentConfig;
   'experience-compactor'?: AgentConfig;
   captain?: AgentConfig;
   quartermaster?: AgentConfig;
@@ -131,6 +132,7 @@ interface AgentsConfig {
   chief?: AgentConfig;
   curler?: AgentConfig;
   rerunner?: RerunnerAgentConfig;
+  analyst?: AgentConfig;
 }
 
 interface AIConfig {
@@ -179,6 +181,8 @@ interface ActionConfig {
 interface ReporterConfig {
   enabled?: boolean;
   html?: boolean;
+  markdown?: boolean;
+  runGroup?: string | null;
 }
 
 type ApiHookFn = (ctx: { headers: Record<string, string>; baseEndpoint: string }) => Promise<Record<string, string> | undefined> | Record<string, string> | undefined;

package/src/explorbot.ts

@@ -1,8 +1,8 @@
 import { existsSync, mkdirSync } from 'node:fs';
 import path from 'node:path';
 import { ActionResult } from './action-result.ts';
-import { Bosun } from './ai/bosun.ts';
 import { Captain } from './ai/captain.ts';
+import { Driller } from './ai/driller.ts';
 import { ExperienceCompactor } from './ai/experience-compactor.ts';
 import { Fisherman } from './ai/fisherman.ts';
 import { Historian } from './ai/historian.ts';
@@ -13,6 +13,7 @@ import { AIProvider } from './ai/provider.ts';
 import { Quartermaster } from './ai/quartermaster.ts';
 import { Rerunner } from './ai/rerunner.ts';
 import { Researcher } from './ai/researcher.ts';
+import { SessionAnalyst } from './ai/session-analyst.ts';
 import { Tester } from './ai/tester.ts';
 import { createAgentTools } from './ai/tools.ts';
 import { ApiClient } from './api/api-client.ts';
@@ -25,8 +26,9 @@ import Explorer from './explorer.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 { Plan, type Test } from './test-plan.ts';
 import { setVerboseMode, tag } from './utils/logger.ts';
+import { relativeToCwd } from './utils/next-steps.ts';
 import { sanitizeFilename } from './utils/strings.ts';
 
 export interface ExplorBotOptions {
@@ -55,6 +57,8 @@ export class ExplorBot {
   lastPlanError: Error | null = null;
   lastSavedPlanPath: string | null = null;
   private agents: Record<string, any> = {};
+  private sessionPlans: Plan[] = [];
+  private lastReportedTestCount = 0;
 
   constructor(options: ExplorBotOptions = {}) {
     this.options = options;
@@ -284,15 +288,17 @@ export class ExplorBot {
     return this.agents.rerunner;
   }
 
-  agentBosun(): Bosun {
-    return (this.agents.bosun ||= this.createAgent(({ ai, explorer }) => {
-      const researcher = this.agentResearcher();
+  agentDriller(): Driller {
+    return (this.agents.driller ||= this.createAgent(({ ai, explorer }) => {
       const navigator = this.agentNavigator();
-      const tools = createAgentTools({ explorer, researcher, navigator });
-      return new Bosun(explorer, ai, researcher, navigator, tools);
+      return new Driller(explorer, ai, navigator);
     }));
   }
 
+  agentSessionAnalyst(): SessionAnalyst {
+    return (this.agents.sessionAnalyst ||= this.createAgent(({ ai }) => new SessionAnalyst(ai)));
+  }
+
   agentFisherman(): Fisherman | null {
     const fishermanConfig = this.config.ai?.agents?.fisherman;
     const hasApiConfig = !!this.config.api;
@@ -365,7 +371,7 @@ export class ExplorBot {
     }
     this.lastPlanError = null;
     try {
-      this.currentPlan = await planner.plan(feature, opts.style, opts.extend, opts.completedPlans);
+      this.setCurrentPlan(await planner.plan(feature, opts.style, opts.extend, opts.completedPlans));
     } catch (err) {
       this.lastPlanError = err instanceof Error ? err : new Error(String(err));
       tag('warning').log(`Planning failed: ${this.lastPlanError.message}`);
@@ -436,11 +442,50 @@ export class ExplorBot {
       throw new Error(`Plan file not found: ${planPath}`);
     }
 
-    this.currentPlan = Plan.fromMarkdown(planPath);
-    return this.currentPlan;
+    this.setCurrentPlan(Plan.fromMarkdown(planPath));
+    return this.currentPlan!;
   }
 
   setCurrentPlan(plan?: Plan): void {
     this.currentPlan = plan;
+    if (plan && !this.sessionPlans.includes(plan)) {
+      this.sessionPlans.push(plan);
+    }
+  }
+
+  getSessionTests(): Test[] {
+    return this.sessionPlans.flatMap((p) => p.tests.filter((t) => t.startTime != null));
+  }
+
+  async printSessionAnalysis(): Promise<void> {
+    const analystConfig = this.config.ai?.agents?.analyst;
+    if (analystConfig?.enabled === false) return;
+
+    const tests = this.getSessionTests();
+    if (tests.length === 0) return;
+    if (tests.length === this.lastReportedTestCount) return;
+
+    try {
+      const markdown = await this.agentSessionAnalyst().analyze(tests);
+      if (!markdown) {
+        this.lastReportedTestCount = tests.length;
+        return;
+      }
+
+      tag('multiline').log(markdown);
+
+      const filePath = this.agentSessionAnalyst().writeReport(markdown);
+      tag('info').log(`Session report saved: ${relativeToCwd(filePath)}`);
+
+      const reporter = this.explorer?.getReporter();
+      if (reporter?.isEnabled()) {
+        await reporter.setRunDescription(markdown);
+      }
+
+      this.lastReportedTestCount = tests.length;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      tag('warning').log(`Session analysis failed: ${message}`);
+    }
   }
 }

package/src/explorer.ts

@@ -19,8 +19,9 @@ import { PlaywrightRecorder } from './playwright-recorder.ts';
 import { Reporter } from './reporter.ts';
 import { StateManager } from './state-manager.js';
 import { Test } from './test-plan.ts';
+import { ELEMENT_EXTRACTION_CONFIG, getElementDataExtractorSource } from './utils/html.ts';
 import { createDebug, log, tag } from './utils/logger.js';
-import { WebElement, extractElementData } from './utils/web-element.ts';
+import { WebElement } from './utils/web-element.ts';
 
 declare global {
   namespace NodeJS {
@@ -337,11 +338,11 @@ class Explorer {
   async getEidxInContainer(containerCss: string | null): Promise<string[]> {
     const page = this.playwrightHelper.page;
     try {
-      const selector = containerCss ? `${containerCss} [data-explorbot-eidx]` : '[data-explorbot-eidx]';
+      const selector = containerCss ? `${containerCss} [${ELEMENT_EXTRACTION_CONFIG.attrs.eidx}]` : `[${ELEMENT_EXTRACTION_CONFIG.attrs.eidx}]`;
       const elements = await page.locator(selector).all();
       const result: string[] = [];
       for (const el of elements) {
-        const attr = await el.getAttribute('data-explorbot-eidx');
+        const attr = await el.getAttribute(ELEMENT_EXTRACTION_CONFIG.attrs.eidx);
         if (attr) result.push(attr);
       }
       return result;
@@ -359,7 +360,7 @@ class Explorer {
       const page = this.playwrightHelper.page;
       const base = container ? page.locator(container) : page;
       const el = locator.startsWith('//') ? base.locator(`xpath=${locator}`) : base.locator(locator);
-      return await el.first().getAttribute('data-explorbot-eidx');
+      return await el.first().getAttribute(ELEMENT_EXTRACTION_CONFIG.attrs.eidx);
     } catch (error) {
       if (this.isFatalBrowserError(error)) {
         tag('warning').log(`getEidxByLocator: ${error instanceof Error ? error.message : error}`);
@@ -751,20 +752,20 @@ export async function annotatePageElements(page: any): Promise<{ ariaSnapshot: s
   for (const [role, entries] of byRole) {
     try {
       const rawList = await page.getByRole(role).evaluateAll(
-        (domElements: Element[], [data, extractFnStr]: [Array<{ name: string; ref: string }>, string]) => {
+        (domElements: Element[], [data, extractFnStr, config]: [Array<{ name: string; ref: string }>, string, typeof ELEMENT_EXTRACTION_CONFIG]) => {
           const extract = new Function(`return ${extractFnStr}`)() as (el: Element) => any;
           const results: any[] = [];
           let ariaIdx = 0;
           for (const el of domElements) {
             if (ariaIdx >= data.length) break;
-            el.setAttribute('data-explorbot-eidx', data[ariaIdx].ref);
-            const elData = extract(el);
+            el.setAttribute(config.attrs.eidx, data[ariaIdx].ref);
+            const elData = extract(el, config);
             if (elData) results.push(elData);
             ariaIdx++;
           }
           return results;
         },
-        [entries, extractElementData.toString()]
+        [entries, getElementDataExtractorSource(), ELEMENT_EXTRACTION_CONFIG]
       );
       for (const raw of rawList) {
         elements.push(WebElement.fromRawData(raw, role));