explorbot 0.1.31 → 0.2.0

package/dist/src/ai/quartermaster.js

@@ -1,7 +1,7 @@
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { z } from 'zod';
-import { ConfigParser } from "../config.js";
+import { outputPath } from "../config.js";
 import { createDebug, tag } from "../utils/logger.js";
 import { isCodeceptToolName } from "../utils/step-analyzer.js";
 const debugLog = createDebug('explorbot:quartermaster');
@@ -16,12 +16,11 @@ export class Quartermaster {
     constructor(provider, options) {
         this.provider = provider;
         this.model = options?.model;
-        const configParser = ConfigParser.getInstance();
-        this.outputDir = join(configParser.getOutputDir(), 'a11y');
+        this.outputDir = outputPath('a11y');
     }
     start(playwrightHelper, stateManager) {
         this.playwrightHelper = playwrightHelper;
-        this.ensureDirectory();
+        mkdirSync(this.outputDir, { recursive: true });
         this.unsubscribe = stateManager.onStateChange((event) => {
             this.onPageChange(event);
         });
@@ -34,11 +33,6 @@ export class Quartermaster {
         }
         debugLog('Quartermaster stopped');
     }
-    ensureDirectory() {
-        if (!existsSync(this.outputDir)) {
-            mkdirSync(this.outputDir, { recursive: true });
-        }
-    }
     onPageChange(event) {
         const state = event.toState;
         if (!state?.hash)

package/dist/src/ai/rerunner.d.ts

@@ -0,0 +1,48 @@
+import type { ExperienceTracker } from '../experience-tracker.js';
+import type Explorer from '../explorer.js';
+import type { KnowledgeTracker } from '../knowledge-tracker.js';
+import { Test } from '../test-plan.js';
+import type { Agent } from './agent.js';
+import type { Navigator } from './navigator.js';
+import { Provider } from './provider.js';
+import { TaskAgent } from './task-agent.js';
+export declare class Rerunner extends TaskAgent implements Agent {
+    readonly ACTION_TOOLS: string[];
+    emoji: string;
+    explorer: Explorer;
+    provider: Provider;
+    agentTools: any;
+    healedSteps: Array<{
+        original: string;
+        healed: string;
+    }>;
+    traceDir: string;
+    static pluginsWired: boolean;
+    constructor(explorer: Explorer, provider: Provider, agentTools?: any);
+    getNavigator(): Navigator;
+    getExperienceTracker(): ExperienceTracker;
+    getKnowledgeTracker(): KnowledgeTracker;
+    getProvider(): Provider;
+    get rerunnerConfig(): Record<string, any>;
+    get healLimit(): number;
+    get healMaxIterations(): number;
+    rerun(filePath: string, options?: {
+        testIndices?: number[];
+    }): Promise<RerunResult>;
+    getCurrentTask(testMap: Map<string, Test>): Test | undefined;
+    setupPlugins(): void;
+    teardownHealing(): void;
+    healStep(step: any, error: Error): Promise<((deps: {
+        I: any;
+    }) => Promise<void>) | null>;
+    getHealSystemPrompt(): string;
+    getHealUserPrompt(failedCode: string, error: Error): string;
+    printResults(result: RerunResult): void;
+}
+interface RerunResult {
+    total: number;
+    passed: number;
+    failed: number;
+    healed: number;
+}
+export {};

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";
@@ -31,6 +31,7 @@ export class Rerunner extends TaskAgent {
     agentTools;
     healedSteps = [];
     traceDir = '';
+    static pluginsWired = false;
     constructor(explorer, provider, agentTools) {
         super();
         this.explorer = explorer;
@@ -58,9 +59,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 +189,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 +199,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 +252,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 +263,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) {
@@ -378,7 +378,7 @@ 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}`));
         };
     }
@@ -419,15 +419,7 @@ export class Rerunner extends TaskAgent {
     getHealUserPrompt(failedCode, error) {
         const state = this.explorer.getStateManager().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.d.ts

@@ -0,0 +1,6 @@
+export declare function clearResearchCache(): void;
+export declare function getCachedResearch(hash: string): string;
+export declare function getPreviousResearch(hash: string): string;
+export declare function saveResearch(hash: string, text: string, combinedHtml?: string): string;
+export declare function findSimilarResearch(combinedHtml: string): Promise<string | null>;
+export declare function findSimilarStateHash(combinedHtml: string): Promise<string | null>;

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.d.ts

@@ -0,0 +1,56 @@
+import type { Page } from 'playwright';
+import type { ActionResult } from '../../action-result.js';
+import type Explorer from '../../explorer.js';
+import type { Provider } from '../provider.js';
+import { type Constructor } from './mixin.js';
+import type { ResearchResult } from './research-result.js';
+export declare function visuallyAnnotateContainers(page: Page, containers: Array<{
+    css: string;
+    label: string;
+}>): Promise<number>;
+export declare function WithCoordinates<T extends Constructor>(Base: T): {
+    new (...args: any[]): {
+        explorer: Explorer;
+        provider: Provider;
+        actionResult: ActionResult | undefined;
+        analyzeScreenshotForVisualProps(): Promise<VisualAnalysisResult>;
+        visuallyAnnotateElements(opts?: {
+            containers?: Array<{
+                css: string;
+                label: string;
+            }>;
+        }): Promise<number>;
+        _analyzeScreenshotForVisualProps(): Promise<VisualAnalysisResult>;
+        mergeVisualData(result: ResearchResult, visualData: Map<string, {
+            coordinates: string | null;
+            color: string | null;
+            icon: string | null;
+        }>): Promise<void>;
+        backfillCoordinates(result: ResearchResult): Promise<void>;
+    };
+} & T;
+export interface VisualAnalysisResult {
+    elements: Map<string, {
+        coordinates: string | null;
+        color: string | null;
+        icon: string | null;
+    }>;
+    pagePurpose: string | null;
+    primaryActions: string[] | null;
+    focusedSection: string | null;
+}
+export interface CoordinateMethods {
+    analyzeScreenshotForVisualProps(): Promise<VisualAnalysisResult>;
+    mergeVisualData(result: ResearchResult, visualData: Map<string, {
+        coordinates: string | null;
+        color: string | null;
+        icon: string | null;
+    }>): Promise<void>;
+    backfillCoordinates(result: ResearchResult): Promise<void>;
+    visuallyAnnotateElements(opts?: {
+        containers?: Array<{
+            css: string;
+            label: string;
+        }>;
+    }): Promise<number>;
+}

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

@@ -0,0 +1,74 @@
+import { ActionResult, type Diff } from '../../action-result.js';
+import type Explorer from '../../explorer.js';
+import type { StateManager } from '../../state-manager.js';
+import { WebPageState } from '../../state-manager.js';
+import type { Provider } from '../provider.js';
+import { type Constructor } from './mixin.js';
+import { type ResearchElement } from './parser.js';
+import type { ResearchResult } from './research-result.js';
+export declare function WithDeepAnalysis<T extends Constructor>(Base: T): {
+    new (...args: any[]): {
+        explorer: Explorer;
+        provider: Provider;
+        stateManager: StateManager;
+        actionResult: ActionResult | undefined;
+        performDeepAnalysis(state: WebPageState, result: ResearchResult): Promise<void>;
+        researchOverlay(current: ActionResult, previous: ActionResult, pageStateHash: string): Promise<string | null>;
+        _loadPreviousExtendedSections(hash: string): PreviousSection[];
+        _replayPreviousSections(state: WebPageState, prevSections: PreviousSection[], maxClicks: number): Promise<{
+            verified: string[];
+            verifiedCodes: string[];
+            missing: PreviousSection[];
+        }>;
+        _appendExtendedResearch(result: ResearchResult, expandedSections: string[], navigationLinks: Array<{
+            code: string;
+            url: string;
+        }>): void;
+        _discoverExpandables(researchText: string, missing?: PreviousSection[], verifiedCodes?: string[]): Promise<ExpandableElement[]>;
+        _buildClickCommands(el: ExpandableElement): string[];
+        _selectExpandables(expandables: ExpandableElement[], url: string, maxClicks: number): Promise<ExpandableElement[]>;
+        _clickExpandableElements(elements: Array<{
+            commands: string[];
+            description: string;
+        }>, state: WebPageState, expandedSections: string[], navigationLinks: Array<{
+            code: string;
+            url: string;
+        }>): Promise<void>;
+        _executeAndAnalyze(commands: string[], description: string, state: WebPageState, originalAria: string, alreadyExpanded: string[]): Promise<ExpansionOutcome>;
+        _restorePageState(url: string, originalAria: string): Promise<void>;
+        _analyzeExpandedAction(code: string, description: string, diff: Diff, alreadyExpanded: string[]): Promise<string | null>;
+        _deduplicateExpandedSections(sections: string[]): string[];
+        _summarizeExpanded(expandedSections: string[]): string[];
+        _sectionFingerprint(sectionMarkdown: string): string | null;
+        _parseSectionKeys(sectionMarkdown: string): {
+            name: string;
+            keys: string[];
+        } | null;
+    };
+} & T;
+interface ExpandableElement extends ResearchElement {
+    container: string | null;
+}
+interface PreviousSection {
+    name: string;
+    code: string;
+}
+type ExpansionOutcome = {
+    status: 'revealed';
+    code: string;
+    sectionMarkdown: string;
+} | {
+    status: 'navigated';
+    code: string;
+    url: string;
+} | {
+    status: 'none';
+    code: string;
+} | {
+    status: 'failed';
+};
+export interface DeepAnalysisMethods {
+    performDeepAnalysis(state: WebPageState, result: ResearchResult): Promise<void>;
+    researchOverlay(current: ActionResult, previous: ActionResult, pageStateHash: string): Promise<string | null>;
+}
+export {};

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

@@ -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.attemptAction(hoverCmd, undefined);
                         await new Promise((r) => setTimeout(r, 500));
                         await this.explorer.capturePageState();
                         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) {
@@ -355,7 +353,7 @@ export function WithDeepAnalysis(Base) {
             let clickCode = null;
             const action = this.explorer.createAction();
             for (const cmd of commands) {
-                if (await action.attempt(cmd, undefined, false)) {
+                if (await action.attempt(cmd, undefined)) {
                     clickCode = cmd;
                     break;
                 }
@@ -370,7 +368,6 @@ export function WithDeepAnalysis(Base) {
                 await this.explorer.createAction().capturePageState();
                 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}`);
@@ -399,7 +396,7 @@ export function WithDeepAnalysis(Base) {
                 await this.cancelInUi();
                 await this.explorer.capturePageState();
                 const currentAria = this.stateManager.getCurrentState()?.ariaSnapshot || '';
-                if (!diffAriaSnapshots(originalAria, currentAria))
+                if (!diffAriaSnapshots(originalAria, currentAria).text)
                     return;
             }
             catch (err) {

package/dist/src/ai/researcher/fingerprint-worker.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,8 @@
+import type { Page } from 'playwright';
+import type { ResearchSection } from './parser.js';
+import type { ResearchResult } from './research-result.js';
+export declare const FOCUSED_MARKER = "> **Focused**";
+export declare function hasFocusedSection(text: string): boolean;
+export declare function detectFocusedSection(page: Page, sections: ResearchSection[]): Promise<string | null>;
+export declare function markSectionAsFocused(result: ResearchResult, sectionName: string): void;
+export declare function pickDefaultFocusedSection(sections: ResearchSection[]): string | null;

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

@@ -0,0 +1,36 @@
+import type { ActionResult } from '../../action-result.js';
+import type Explorer from '../../explorer.js';
+import type { Conversation } from '../conversation.js';
+import type { Provider } from '../provider.js';
+import { type Constructor } from './mixin.js';
+import { parseResearchSections } from './parser.js';
+import type { ResearchResult } from './research-result.js';
+export declare const DYNAMIC_ID_PATTERN: RegExp;
+export declare const isForbiddenLocator: (s: string) => boolean;
+export declare function WithLocators<T extends Constructor>(Base: T): {
+    new (...args: any[]): {
+        explorer: Explorer;
+        provider: Provider;
+        actionResult: ActionResult | undefined;
+        testLocators(locators: Locator[]): Promise<void>;
+        fixBrokenSections(result: ResearchResult, conversation: Conversation): Promise<void>;
+        backfillBrokenLocators(result: ResearchResult): Promise<void>;
+        validateContainers(result: ResearchResult): Promise<void>;
+        updateSectionContainer(result: ResearchResult, section: ReturnType<typeof parseResearchSections>[0], newCss: string | null): void;
+    };
+} & T;
+export interface Locator {
+    section: string;
+    container: string | null;
+    element: string;
+    type: 'css' | 'xpath' | 'aria';
+    locator: string;
+    valid: boolean | null;
+    error: string | null;
+    pwLocator: string | null;
+}
+export interface LocatorMethods {
+    testLocators(locators: Locator[]): Promise<void>;
+    fixBrokenSections(result: ResearchResult, conversation: Conversation): Promise<void>;
+    backfillBrokenLocators(result: ResearchResult): Promise<void>;
+}

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

@@ -0,0 +1,2 @@
+export type Constructor<T = object> = new (...args: any[]) => T;
+export declare const debugLog: (...args: any[]) => void;

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

@@ -0,0 +1,35 @@
+export interface ResearchElement {
+    name: string;
+    type: string | null;
+    aria: {
+        role: string;
+        text: string;
+    } | null;
+    css: string | null;
+    xpath: string | null;
+    coordinates: string | null;
+    color: string | null;
+    icon: string | null;
+    eidx: string | null;
+}
+export interface ResearchSection {
+    name: string;
+    containerCss: string | null;
+    elements: ResearchElement[];
+    rawMarkdown: string;
+    isExtended: boolean;
+}
+export declare const RESEARCH_COLUMN_ORDER: string[];
+export declare function mapRowToElement(row: Record<string, string>): ResearchElement | null;
+export declare function extractContainerFromBlockquote(sectionMarkdown: string): string | null;
+export declare function parseResearchSections(markdown: string): ResearchSection[];
+export declare function extractValidContainers(researchText: string, opts?: {
+    exclude?: string[];
+}): Array<{
+    css: string;
+    label: string;
+}>;
+export declare function rebuildSectionMarkdown(section: ResearchSection): string;
+export declare function formatResearchSummary(text: string, opts?: {
+    visionUsed?: boolean;
+}): string;

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

@@ -0,0 +1,15 @@
+import type { Locator } from './locators.js';
+import { type ResearchSection } from './parser.js';
+export declare class ResearchResult {
+    text: string;
+    url: string;
+    createdAt: Date;
+    locators: Locator[];
+    constructor(text: string, url: string);
+    parseLocators(): void;
+    get containers(): string[];
+    get containerLocators(): Locator[];
+    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

@@ -0,0 +1,19 @@
+import type { ActionResult } from '../../action-result.js';
+import type Explorer from '../../explorer.js';
+import type { StateManager } from '../../state-manager.js';
+import type { Provider } from '../provider.js';
+import type { Constructor } from './mixin.js';
+export interface SectionMethods {
+    researchBySections(): Promise<string>;
+}
+export declare function WithSections<T extends Constructor>(Base: T): {
+    new (...args: any[]): {
+        explorer: Explorer;
+        provider: Provider;
+        stateManager: StateManager;
+        actionResult: ActionResult | undefined;
+        researchBySections(): Promise<string>;
+        _detectFocusCss(): Promise<string | null>;
+        _researchSingleSection(name: string, description: string, ariaSnapshot: string, focusCss: string | null): Promise<string>;
+    };
+} & T;

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

@@ -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}