explorbot 0.1.32-beta.1 → 0.2.1

package/dist/src/ai/rerunner.js

@@ -14,10 +14,10 @@ import { ActionResult } from "../action-result.js";
 import { setActivity } from "../activity.js";
 import { Stats } from "../stats.js";
 import { Task, Test, TestResult } from "../test-plan.js";
+import { formatHeadings } from "../utils/context-formatter.js";
 import { createDebug, tag } from "../utils/logger.js";
 import { loop } from "../utils/loop.js";
 import { RulesLoader } from "../utils/rules-loader.js";
-import { loadTestSuites, printTestList } from "../utils/test-files.js";
 import { toolExecutionLabel } from "./conversation.js";
 import { actionRule, locatorRule, sectionContextRule } from "./rules.js";
 import { TaskAgent } from "./task-agent.js";
@@ -26,31 +26,19 @@ const debugLog = createDebug('explorbot:rerunner');
 export class Rerunner extends TaskAgent {
     ACTION_TOOLS = ['click', 'pressKey', 'form'];
     emoji = '🔄';
-    explorer;
-    provider;
     agentTools;
     healedSteps = [];
     traceDir = '';
-    constructor(explorer, provider, agentTools) {
-        super();
-        this.explorer = explorer;
-        this.provider = provider;
+    static pluginsWired = false;
+    constructor(deps, agentTools) {
+        super(deps);
         this.agentTools = agentTools;
     }
     getNavigator() {
         throw new Error('Rerunner does not use Navigator');
     }
-    getExperienceTracker() {
-        return this.explorer.getStateManager().getExperienceTracker();
-    }
-    getKnowledgeTracker() {
-        return this.explorer.getKnowledgeTracker();
-    }
-    getProvider() {
-        return this.provider;
-    }
     get rerunnerConfig() {
-        return this.explorer.getConfig().ai?.agents?.rerunner || {};
+        return this.config.ai?.agents?.rerunner || {};
     }
     get healLimit() {
         return this.rerunnerConfig.healLimit ?? 3;
@@ -58,9 +46,6 @@ export class Rerunner extends TaskAgent {
     get healMaxIterations() {
         return this.rerunnerConfig.healMaxIterations ?? 3;
     }
-    listTests(testsDir) {
-        printTestList(loadTestSuites(testsDir));
-    }
     async rerun(filePath, options) {
         const absPath = resolve(filePath);
         if (!existsSync(absPath)) {
@@ -191,7 +176,6 @@ export class Rerunner extends TaskAgent {
     }
     setupPlugins() {
         const healMod = heal.default || heal;
-        healMod.connectToEvents();
         healMod.addRecipe('explorbot-ai-healer', {
             priority: 10,
             fn: async (context) => {
@@ -202,20 +186,26 @@ export class Rerunner extends TaskAgent {
         for (const [name, recipe] of Object.entries(userRecipes)) {
             healMod.addRecipe(name, recipe);
         }
+        const outputDir = global.output_dir || 'output';
+        this.traceDir = `${outputDir}/rerun-traces`;
+        if (Rerunner.pluginsWired)
+            return;
+        Rerunner.pluginsWired = true;
+        healMod.connectToEvents();
         let currentTest = null;
         let healTries = 0;
         let isHealing = false;
         let caughtError = null;
-        const healLimit = this.healLimit;
         codeceptjs.event.dispatcher.on('test.before', (test) => {
             currentTest = test;
             healTries = 0;
             caughtError = null;
+            isHealing = false;
         });
         codeceptjs.event.dispatcher.on('step.after', (step) => {
             if (isHealing)
                 return;
-            if (healTries >= healLimit)
+            if (healTries >= this.healLimit)
                 return;
             if (!healMod.hasCorrespondingRecipes(step))
                 return;
@@ -249,9 +239,6 @@ export class Rerunner extends TaskAgent {
             maxTimeout: 5000,
             factor: 1.5,
         });
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
-        const outputDir = global.output_dir || 'output';
-        this.traceDir = `${outputDir}/rerun_${timestamp}`;
         const aiTrace = aiTracePlugin.default || aiTracePlugin;
         aiTrace(this.rerunnerConfig.aiTrace || { output: this.traceDir });
         import('@testomatio/reporter/codecept')
@@ -263,9 +250,9 @@ export class Rerunner extends TaskAgent {
     }
     teardownHealing() {
         const healMod = heal.default || heal;
-        healMod.recipes['explorbot-ai-healer'] = undefined;
+        Reflect.deleteProperty(healMod.recipes, 'explorbot-ai-healer');
         for (const name of Object.keys(this.rerunnerConfig.recipes || {})) {
-            healMod.recipes[name] = undefined;
+            Reflect.deleteProperty(healMod.recipes, name);
         }
     }
     async healStep(step, error) {
@@ -282,7 +269,7 @@ export class Rerunner extends TaskAgent {
                 },
             });
             const healTask = new Task(`Heal: ${failedCode}`);
-            const codeceptTools = createCodeceptJSTools(this.explorer, healTask);
+            const codeceptTools = createCodeceptJSTools(this.toolDeps, healTask);
             let healed = false;
             let healedCommand = '';
             const tools = {
@@ -300,9 +287,9 @@ export class Rerunner extends TaskAgent {
                             healTask.addNote(note);
                             tag('substep').log(note);
                         }
-                        const action = this.explorer.createAction();
+                        const action = this.explorer.action();
                         await action.execute(`I.wait(${seconds})`);
-                        const state = this.explorer.getStateManager().getCurrentState();
+                        const state = this.stateManager.getCurrentState();
                         const ar = state ? ActionResult.fromState(state) : null;
                         return {
                             success: true,
@@ -378,13 +365,13 @@ export class Rerunner extends TaskAgent {
             if (!healed) {
                 throw new Error(`Could not heal: ${failedCode}`);
             }
-            this.healedSteps.push({ test: '', original: failedCode, healed: healedCommand });
+            this.healedSteps.push({ original: failedCode, healed: healedCommand });
             console.log(chalk.green(`    ${figureSet.tick} Healed: ${healedCommand}`));
         };
     }
     getHealSystemPrompt() {
-        const customRules = this.provider.getSystemPromptForAgent('rerunner', this.explorer.getStateManager().getCurrentState()?.url) || '';
-        const currentUrl = this.explorer.getStateManager().getCurrentState()?.url || '';
+        const customRules = this.provider.getSystemPromptForAgent('rerunner', this.stateManager.getCurrentState()?.url) || '';
+        const currentUrl = this.stateManager.getCurrentState()?.url || '';
         const approach = RulesLoader.loadRules('rerunner', ['healing-approach'], currentUrl);
         return dedent `
       <role>
@@ -417,17 +404,9 @@ export class Rerunner extends TaskAgent {
     `;
     }
     getHealUserPrompt(failedCode, error) {
-        const state = this.explorer.getStateManager().getCurrentState();
+        const state = this.stateManager.getCurrentState();
         const actionResult = state ? ActionResult.fromState(state) : null;
-        const headings = [];
-        if (state?.h1)
-            headings.push(`H1: ${state.h1}`);
-        if (state?.h2)
-            headings.push(`H2: ${state.h2}`);
-        if (state?.h3)
-            headings.push(`H3: ${state.h3}`);
-        if (state?.h4)
-            headings.push(`H4: ${state.h4}`);
+        const headings = formatHeadings(state || {});
         return dedent `
       A test step failed and needs healing.
 

package/dist/src/ai/researcher/cache.js

@@ -2,14 +2,14 @@ import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'no
 import { join } from 'node:path';
 import { Worker } from 'node:worker_threads';
 import { outputPath } from "../../config.js";
+import { TTLCache } from "../../utils/cache.js";
 import { computeHtmlFingerprint } from "../../utils/html-diff.js";
 import { debugLog } from "./mixin.js";
 const CACHE_TTL_MS = 6 * 60 * 60 * 1000; // 6 hours
 const FINGERPRINT_MAX_AGE_MS = 60 * 60 * 1000; // 1 hour
 const FINGERPRINT_WORKER_TIMEOUT_MS = 10_000;
 const SIMILARITY_THRESHOLD = 90;
-const memoryCache = {};
-const memoryCacheTimestamps = {};
+const memoryCache = new TTLCache(CACHE_TTL_MS);
 let fingerprintWorker = null;
 function getStatesDir() {
     return outputPath('states');
@@ -22,29 +22,23 @@ function getFingerprintWorker() {
     return fingerprintWorker;
 }
 export function clearResearchCache() {
-    for (const key of Object.keys(memoryCache))
-        delete memoryCache[key];
-    for (const key of Object.keys(memoryCacheTimestamps))
-        delete memoryCacheTimestamps[key];
+    memoryCache.clear();
 }
 export function getCachedResearch(hash) {
     if (!hash)
         return '';
-    const now = Date.now();
-    const timestamp = memoryCacheTimestamps[hash];
-    if (timestamp && now - timestamp <= CACHE_TTL_MS) {
-        return memoryCache[hash] || '';
-    }
+    const cached = memoryCache.get(hash);
+    if (cached !== undefined)
+        return cached;
     const researchFile = outputPath('research', `${hash}.md`);
     if (!existsSync(researchFile))
         return '';
     const stats = statSync(researchFile);
-    if (now - stats.mtimeMs > CACHE_TTL_MS)
+    if (Date.now() - stats.mtimeMs > CACHE_TTL_MS)
         return '';
-    const cached = readFileSync(researchFile, 'utf8');
-    memoryCache[hash] = cached;
-    memoryCacheTimestamps[hash] = now;
-    return cached;
+    const fromDisk = readFileSync(researchFile, 'utf8');
+    memoryCache.set(hash, fromDisk);
+    return fromDisk;
 }
 export function getPreviousResearch(hash) {
     if (!hash)
@@ -60,8 +54,7 @@ export function saveResearch(hash, text, combinedHtml) {
     if (!existsSync(researchDir))
         mkdirSync(researchDir, { recursive: true });
     writeFileSync(researchFile, text);
-    memoryCache[hash] = text;
-    memoryCacheTimestamps[hash] = Date.now();
+    memoryCache.set(hash, text);
     debugLog(`Research saved to ${researchFile}`);
     if (combinedHtml) {
         const statesDir = getStatesDir();

package/dist/src/ai/researcher/coordinates.js

@@ -1,6 +1,7 @@
 import dedent from 'dedent';
 import { tag } from '../../utils/logger.js';
 import { mdq } from "../../utils/markdown-query.js";
+import { eidxByLocator } from "../../utils/web-eidx.js";
 import { WebElement } from "../../utils/web-element.js";
 import { debugLog } from "./mixin.js";
 import { parseResearchSections } from "./parser.js";
@@ -67,7 +68,7 @@ export function WithCoordinates(Base) {
             return this._analyzeScreenshotForVisualProps();
         }
         async visuallyAnnotateElements(opts) {
-            return this.explorer.visuallyAnnotateElements(opts);
+            return this.explorer.withPage((page) => visuallyAnnotateContainers(page, opts?.containers || []));
         }
         async _analyzeScreenshotForVisualProps() {
             const elements = new Map();
@@ -160,7 +161,7 @@ export function WithCoordinates(Base) {
                     if (!eidx) {
                         const locator = el.css || el.xpath || (el.aria ? `role=${el.aria.role}[name="${el.aria.text}"]` : null);
                         if (locator)
-                            eidx = await this.explorer.getEidxByLocator(locator, section.containerCss);
+                            eidx = await this.explorer.withPage((page) => eidxByLocator(page, locator, section.containerCss));
                     }
                     if (!eidx)
                         continue;
@@ -187,7 +188,7 @@ export function WithCoordinates(Base) {
             }
             if (eidxWithoutCoords.length === 0)
                 return;
-            const webElements = await this.explorer.runWithBrowserRecovery('backfillCoordinates', () => WebElement.fromEidxList(this.explorer.playwrightHelper.page, eidxWithoutCoords));
+            const webElements = await this.explorer.withPage((page) => WebElement.fromEidxList(page, eidxWithoutCoords));
             if (webElements.length === 0)
                 return;
             const rectMap = new Map(webElements.map((w) => [w.eidx, w]));

package/dist/src/ai/researcher/deep-analysis.d.ts

@@ -1,4 +1,5 @@
 import { ActionResult, type Diff } from '../../action-result.js';
+import type { ExplorbotConfig } from '../../config.js';
 import type Explorer from '../../explorer.js';
 import type { StateManager } from '../../state-manager.js';
 import { WebPageState } from '../../state-manager.js';
@@ -11,6 +12,7 @@ export declare function WithDeepAnalysis<T extends Constructor>(Base: T): {
         explorer: Explorer;
         provider: Provider;
         stateManager: StateManager;
+        config: ExplorbotConfig;
         actionResult: ActionResult | undefined;
         performDeepAnalysis(state: WebPageState, result: ResearchResult): Promise<void>;
         researchOverlay(current: ActionResult, previous: ActionResult, pageStateHash: string): Promise<string | null>;

package/dist/src/ai/researcher/deep-analysis.js

@@ -14,7 +14,7 @@ export function WithDeepAnalysis(Base) {
         async performDeepAnalysis(state, result) {
             tag('info').log('Starting deep analysis of expandable elements');
             await this.navigateTo(state.fullUrl || state.url);
-            const maxClicks = this.explorer.getConfig().ai?.agents?.researcher?.maxExpandableClicks ?? DEFAULT_MAX_EXPANDABLE_CLICKS;
+            const maxClicks = this.config.ai?.agents?.researcher?.maxExpandableClicks ?? DEFAULT_MAX_EXPANDABLE_CLICKS;
             const expandedSections = [];
             const navigationLinks = [];
             let verifiedCodes = [];
@@ -74,7 +74,6 @@ export function WithDeepAnalysis(Base) {
                 return null;
             }
             const diff = await current.diff(previous);
-            await diff.calculate();
             if (!diff.ariaChanged && diff.htmlParts.length === 0) {
                 debugLog(`No diff between current and previous state for overlay "${focusArea.name}"`);
                 return null;
@@ -312,12 +311,11 @@ export function WithDeepAnalysis(Base) {
                     const isCoordinateClick = el.commands[0].startsWith('I.clickXY(');
                     if (!isCoordinateClick) {
                         const hoverCmd = el.commands[0].replace('I.click(', 'I.moveCursorTo(');
-                        await this.explorer.attemptAction(hoverCmd, undefined, false);
+                        await this.explorer.action().attempt(hoverCmd);
                         await new Promise((r) => setTimeout(r, 500));
-                        await this.explorer.capturePageState();
+                        await this.explorer.capture();
                         const hoverAR = ActionResult.fromState(this.stateManager.getCurrentState());
                         const hoverDiff = await hoverAR.diff(previousState);
-                        await hoverDiff.calculate();
                         const hoverHtmlSize = hoverDiff.htmlParts.reduce((sum, p) => sum + p.subtree.length, 0);
                         const hoverRevealed = hoverDiff.ariaChanged && hoverHtmlSize > 500;
                         if (hoverRevealed) {
@@ -353,9 +351,9 @@ export function WithDeepAnalysis(Base) {
         async _executeAndAnalyze(commands, description, state, originalAria, alreadyExpanded) {
             const previousState = ActionResult.fromState(this.stateManager.getCurrentState());
             let clickCode = null;
-            const action = this.explorer.createAction();
+            const action = this.explorer.action();
             for (const cmd of commands) {
-                if (await action.attempt(cmd, undefined, false)) {
+                if (await action.attempt(cmd, undefined)) {
                     clickCode = cmd;
                     break;
                 }
@@ -367,10 +365,9 @@ export function WithDeepAnalysis(Base) {
             await new Promise((r) => setTimeout(r, 500));
             let diff;
             try {
-                await this.explorer.createAction().capturePageState();
+                await this.explorer.capture();
                 const currAR = ActionResult.fromState(this.stateManager.getCurrentState());
                 diff = await currAR.diff(previousState);
-                await diff.calculate();
             }
             catch (err) {
                 tag('warning').log(`State capture failed after click: ${err instanceof Error ? err.message : err}`);
@@ -397,9 +394,9 @@ export function WithDeepAnalysis(Base) {
         async _restorePageState(url, originalAria) {
             try {
                 await this.cancelInUi();
-                await this.explorer.capturePageState();
+                await this.explorer.capture();
                 const currentAria = this.stateManager.getCurrentState()?.ariaSnapshot || '';
-                if (!diffAriaSnapshots(originalAria, currentAria))
+                if (!diffAriaSnapshots(originalAria, currentAria).text)
                     return;
             }
             catch (err) {

package/dist/src/ai/researcher/locators.d.ts

@@ -12,9 +12,13 @@ export declare function WithLocators<T extends Constructor>(Base: T): {
         explorer: Explorer;
         provider: Provider;
         actionResult: ActionResult | undefined;
-        testLocators(locators: Locator[]): Promise<void>;
+        testLocators(locators: Locator[], opts?: {
+            scope?: boolean;
+        }): Promise<void>;
         fixBrokenSections(result: ResearchResult, conversation: Conversation): Promise<void>;
         backfillBrokenLocators(result: ResearchResult): Promise<void>;
+        resolveContainers(result: ResearchResult): Promise<Locator[]>;
+        recoverContainerFromChildren(result: ResearchResult, css: string): Promise<boolean>;
         validateContainers(result: ResearchResult): Promise<void>;
         updateSectionContainer(result: ResearchResult, section: ReturnType<typeof parseResearchSections>[0], newCss: string | null): void;
     };
@@ -30,7 +34,10 @@ export interface Locator {
     pwLocator: string | null;
 }
 export interface LocatorMethods {
-    testLocators(locators: Locator[]): Promise<void>;
+    testLocators(locators: Locator[], opts?: {
+        scope?: boolean;
+    }): Promise<void>;
     fixBrokenSections(result: ResearchResult, conversation: Conversation): Promise<void>;
     backfillBrokenLocators(result: ResearchResult): Promise<void>;
+    resolveContainers(result: ResearchResult): Promise<Locator[]>;
 }

package/dist/src/ai/researcher/locators.js

@@ -4,6 +4,7 @@ import { parseAriaLocator } from "../../utils/aria.js";
 import { tag } from '../../utils/logger.js';
 import { mdq } from "../../utils/markdown-query.js";
 import { WebElement } from "../../utils/web-element.js";
+import { isDynamicId } from "../../utils/xpath.js";
 import { locatorRule as generalLocatorRuleText } from '../rules.js';
 import { FOCUSED_MARKER } from "./focus.js";
 import { debugLog } from "./mixin.js";
@@ -26,7 +27,7 @@ function buildPwLocatorString(loc) {
 }
 export function WithLocators(Base) {
     return class extends Base {
-        async testLocators(locators) {
+        async testLocators(locators, opts = {}) {
             let broken = 0;
             for (const loc of locators) {
                 if (executionController.isInterrupted())
@@ -40,21 +41,23 @@ export function WithLocators(Base) {
                     continue;
                 }
                 try {
-                    const count = await this.explorer.playwrightLocatorCount((page) => {
+                    const count = await this.explorer.withPage((page) => {
                         const base = loc.container ? page.locator(loc.container) : page;
                         if (loc.type === 'aria') {
                             const parsed = parseAriaLocator(loc.locator);
                             if (!parsed)
-                                return page.locator('__invalid__');
-                            return base.getByRole(parsed.role, { name: parsed.text });
+                                return page.locator('__invalid__').count();
+                            return base.getByRole(parsed.role, { name: parsed.text }).count();
                         }
                         const converted = loc.locator.replace(/:contains\(/g, ':has-text(');
                         if (converted !== loc.locator) {
                             loc.locator = converted;
                         }
-                        return base.locator(loc.locator);
+                        return base.locator(loc.locator).count();
                     });
                     loc.valid = count === 1;
+                    if (opts.scope && count > 1)
+                        loc.valid = true;
                     loc.pwLocator = buildPwLocatorString(loc);
                     if (!loc.valid) {
                         loc.error = count === 0 ? '0 elements' : `${count} elements`;
@@ -173,7 +176,7 @@ export function WithLocators(Base) {
                 }
             }
             if (needsXpath.length > 0) {
-                const webElements = await this.explorer.runWithBrowserRecovery('backfillBrokenLocators', () => WebElement.fromEidxList(this.explorer.playwrightHelper.page, needsXpath));
+                const webElements = await this.explorer.withPage((page) => WebElement.fromEidxList(page, needsXpath));
                 const changedSections = new Set();
                 for (const w of webElements) {
                     const entry = needsXpathEls.get(w.eidx);
@@ -188,6 +191,60 @@ export function WithLocators(Base) {
             }
             await this.validateContainers(result);
         }
+        async resolveContainers(result) {
+            const containerLocs = result.containerLocators;
+            await this.testLocators(containerLocs, { scope: true });
+            for (const loc of containerLocs.filter((l) => l.valid === false)) {
+                if (await this.recoverContainerFromChildren(result, loc.locator))
+                    loc.valid = true;
+            }
+            return containerLocs.filter((l) => l.valid === false);
+        }
+        async recoverContainerFromChildren(result, css) {
+            const sections = parseResearchSections(result.text).filter((s) => s.containerCss === css);
+            let recovered = 0;
+            for (const section of sections) {
+                const eidxList = section.elements.map((el) => el.eidx).filter(Boolean);
+                if (eidxList.length < 2)
+                    continue;
+                const ancestor = await this.explorer.runWithBrowserRecovery('recoverContainerFromChildren', () => WebElement.commonAncestor(this.explorer.playwrightHelper.page, eidxList));
+                if (!ancestor)
+                    continue;
+                const candidates = [];
+                const id = ancestor.attrs.id;
+                if (id && !isDynamicId(id))
+                    candidates.push(`#${id}`);
+                for (const cls of ancestor.filteredClasses) {
+                    if (!/^[\w-]+$/.test(cls))
+                        continue;
+                    candidates.push(`${ancestor.tag}.${cls}`);
+                }
+                let unique = null;
+                let multiple = null;
+                for (const candidate of candidates) {
+                    let count = 0;
+                    try {
+                        count = await this.explorer.playwrightLocatorCount((page) => page.locator(candidate));
+                    }
+                    catch { }
+                    if (count === 1) {
+                        unique = candidate;
+                        break;
+                    }
+                    if (count > 1 && !multiple)
+                        multiple = candidate;
+                }
+                const newCss = unique || multiple;
+                if (!newCss)
+                    continue;
+                debugLog(`Recovered container: '${css}' → '${newCss}' in "${section.name}"`);
+                this.updateSectionContainer(result, section, newCss);
+                recovered++;
+            }
+            if (recovered > 0 && recovered < sections.length)
+                debugLog(`Container '${css}' recovered in ${recovered}/${sections.length} sections, still broken for the rest`);
+            return recovered > 0 && recovered === sections.length;
+        }
         async validateContainers(result) {
             const sections = parseResearchSections(result.text);
             for (const section of sections) {
@@ -195,7 +252,7 @@ export function WithLocators(Base) {
                     continue;
                 let count = 0;
                 try {
-                    count = await this.explorer.playwrightLocatorCount((page) => page.locator(section.containerCss));
+                    count = await this.explorer.withPage((page) => page.locator(section.containerCss).count());
                 }
                 catch { }
                 if (count >= 1)
@@ -204,7 +261,7 @@ export function WithLocators(Base) {
                 if (simplified) {
                     let simplifiedCount = 0;
                     try {
-                        simplifiedCount = await this.explorer.playwrightLocatorCount((page) => page.locator(simplified));
+                        simplifiedCount = await this.explorer.withPage((page) => page.locator(simplified).count());
                     }
                     catch { }
                     if (simplifiedCount >= 1) {

package/dist/src/ai/researcher/parser.js

@@ -69,7 +69,7 @@ export function extractContainerFromBlockquote(sectionMarkdown) {
     return css;
 }
 export function parseResearchSections(markdown) {
-    const hasExtendedResearch = markdown.includes('\n# Extended Research') || markdown.startsWith('# Extended Research');
+    const hasExtendedResearch = mdq(markdown).query('section1(~"Extended Research")').count() > 0;
     return parseSections(markdown)
         .filter((s) => !SKIP_SECTIONS.has(s.name.toLowerCase()) && !s.name.toLowerCase().includes('data:'))
         .map((section) => {

package/dist/src/ai/researcher/research-result.d.ts

@@ -9,7 +9,6 @@ export declare class ResearchResult {
     parseLocators(): void;
     get containers(): string[];
     get containerLocators(): Locator[];
-    updateSection(sectionName: string, locators: Locator[]): void;
     rebuildSectionInText(section: ResearchSection): void;
     cleanup(): void;
     reorderColumns(columns: string[]): string[];

package/dist/src/ai/researcher/research-result.js

@@ -42,25 +42,6 @@ export class ResearchResult {
             pwLocator: null,
         }));
     }
-    updateSection(sectionName, locators) {
-        const sections = parseResearchSections(this.text);
-        const section = sections.find((s) => s.name === sectionName);
-        if (!section)
-            return;
-        for (const el of section.elements) {
-            const elLocators = locators.filter((l) => l.element === el.name);
-            for (const loc of elLocators) {
-                const value = loc.valid === false ? null : loc.locator || null;
-                if (loc.type === 'css')
-                    el.css = value;
-                if (loc.type === 'xpath')
-                    el.xpath = value;
-                if (loc.type === 'aria')
-                    el.aria = value ? parseAriaLocator(value) : null;
-            }
-        }
-        this.rebuildSectionInText(section);
-    }
     rebuildSectionInText(section) {
         if (section.elements.length === 0)
             return;

package/dist/src/ai/researcher/sections.d.ts

@@ -1,4 +1,5 @@
 import type { ActionResult } from '../../action-result.js';
+import type { ExplorbotConfig } from '../../config.js';
 import type Explorer from '../../explorer.js';
 import type { StateManager } from '../../state-manager.js';
 import type { Provider } from '../provider.js';
@@ -11,6 +12,7 @@ export declare function WithSections<T extends Constructor>(Base: T): {
         explorer: Explorer;
         provider: Provider;
         stateManager: StateManager;
+        config: ExplorbotConfig;
         actionResult: ActionResult | undefined;
         researchBySections(): Promise<string>;
         _detectFocusCss(): Promise<string | null>;

package/dist/src/ai/researcher/sections.js

@@ -50,11 +50,11 @@ export function WithSections(Base) {
             return focused.text;
         }
         async _detectFocusCss() {
-            const focusSections = this.explorer.getConfig().ai?.agents?.researcher?.focusSections;
+            const focusSections = this.config.ai?.agents?.researcher?.focusSections;
             if (!focusSections?.length)
                 return null;
             for (const css of focusSections) {
-                const count = await this.explorer.playwrightLocatorCount((page) => page.locator(css)).catch(() => 0);
+                const count = await this.explorer.withPage((page) => page.locator(css).count()).catch(() => 0);
                 if (count > 0)
                     return css;
             }
@@ -89,9 +89,13 @@ export function WithSections(Base) {
         </section_format>
 
         <rules>
-        - Every element with eidx MUST appear in the table.
+        - List only elements physically inside this section's declared container.
+        - Do not copy global toolbar, navigation, list, or detail elements into this section unless they are descendants of this section container.
+        - Every element with eidx inside this section's container MUST appear in the table.
         - Every row needs CSS; ARIA may be "-" for icon-only buttons.
         - ARIA locator JSON uses keys "role" and "text" (NOT "name").
+        - Elements marked data-explorbot-hit="covered" or "offscreen" are not directly actionable; describe the covering or focused UI first.
+        - In split-pane pages, entity detail panels are active detail context; include close/back/pin controls in the detail panel section when present.
         </rules>
 
         ${generalLocatorRuleText}