explorbot 0.2.0 → 0.2.1

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/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;
             }

package/dist/src/ai/researcher.js

@@ -7,11 +7,11 @@ import { Observability } from "../observability.js";
 import { Stats } from "../stats.js";
 import { diffAriaSnapshots } from "../utils/aria.js";
 import { ErrorPageError, detectPageCondition } from "../utils/error-page.js";
-import { HooksRunner } from "../utils/hooks-runner.js";
 import { isBodyEmpty } from "../utils/html.js";
 import { createDebug, tag } from '../utils/logger.js';
 import { mdq } from "../utils/markdown-query.js";
 import { RulesLoader } from "../utils/rules-loader.js";
+import { annotatePageElements } from "../utils/web-annotate.js";
 import { ContextLengthError } from './provider.js';
 import { findSimilarResearch, getCachedResearch, saveResearch } from "./researcher/cache.js";
 import { WithCoordinates } from "./researcher/coordinates.js";
@@ -39,15 +39,10 @@ export class Researcher extends ResearcherBase {
     emoji = '🔍';
     experienceTracker;
     hasScreenshotToAnalyze = false;
-    hooksRunner;
-    constructor(explorer, provider) {
-        super();
-        this.explorer = explorer;
-        this.provider = provider;
-        this.stateManager = explorer.getStateManager();
-        this.experienceTracker = this.stateManager.getExperienceTracker();
-        this.hooksRunner = new HooksRunner(explorer, explorer.getConfig());
-        const ai = explorer.getConfig().ai;
+    constructor(deps) {
+        super(deps);
+        this.experienceTracker = deps.stateManager.getExperienceTracker();
+        const ai = deps.config.ai;
         if (ai) {
             ai.agents ??= {};
             ai.agents.researcher ??= {};
@@ -57,15 +52,6 @@ export class Researcher extends ResearcherBase {
     getNavigator() {
         throw new Error('not implemented');
     }
-    getExperienceTracker() {
-        return this.experienceTracker;
-    }
-    getKnowledgeTracker() {
-        return this.explorer.getKnowledgeTracker();
-    }
-    getProvider() {
-        return this.provider;
-    }
     static getCachedResearch(state) {
         return getCachedResearch(state.hash || '');
     }
@@ -82,7 +68,7 @@ export class Researcher extends ResearcherBase {
     }
     async research(state, opts = {}) {
         const { screenshot = false, force = false, deep = false, data = false, fix = true } = opts;
-        const maxRetries = this.explorer.getConfig().ai?.agents?.researcher?.retries ?? 2;
+        const maxRetries = this.config.ai?.agents?.researcher?.retries ?? 2;
         let retriesLeft = opts._retriesLeft ?? maxRetries;
         this.actionResult = ActionResult.fromState(state);
         const stateHash = state.hash || this.actionResult.getStateHash();
@@ -101,9 +87,9 @@ export class Researcher extends ResearcherBase {
             setActivity(`${this.emoji} Researching...`, 'action');
             await this.ensureNavigated(displayUrl, screenshot && this.provider.hasVision());
             await this.hooksRunner.runBeforeHook('researcher', state.url);
-            const annotatedElements = await this.explorer.annotateElements();
+            const { elements: annotatedElements } = await this.explorer.withPage(annotatePageElements);
             debugLog(`Annotated ${annotatedElements.length} interactive elements with eidx`);
-            this.actionResult = await this.explorer.capturePageState({ includeScreenshot: screenshot && this.provider.hasVision() });
+            this.actionResult = await this.explorer.capture({ screenshot: screenshot && this.provider.hasVision() });
             const condition = detectPageCondition(this.actionResult);
             if (condition === 'error') {
                 tag('warning').log(`Detected error page at ${state.url}`);
@@ -165,11 +151,10 @@ export class Researcher extends ResearcherBase {
                 return this.research(state, { ...opts, force: true, _retriesLeft: retriesLeft - 1 });
             }
             if (!interrupted()) {
-                const containerLocs = result.containerLocators;
-                await this.testLocators(containerLocs);
-                const brokenContainers = containerLocs.filter((l) => l.valid === false);
-                if (containerLocs.length > 0 && brokenContainers.length === containerLocs.length && retriesLeft > 0) {
-                    tag('warning').log(`All ${containerLocs.length} containers broken, retrying research (${maxRetries - retriesLeft + 1}/${maxRetries})...`);
+                const brokenContainers = await this.resolveContainers(result);
+                const containerCount = result.containers.length;
+                if (containerCount > 0 && brokenContainers.length === containerCount && retriesLeft > 0) {
+                    tag('warning').log(`All ${containerCount} containers broken, retrying research (${maxRetries - retriesLeft + 1}/${maxRetries})...`);
                     await new Promise((r) => setTimeout(r, 2000));
                     return this.research(state, { ...opts, force: true, _retriesLeft: retriesLeft - 1 });
                 }
@@ -181,13 +166,6 @@ export class Researcher extends ResearcherBase {
                 }
                 const toTest = result.locators.filter((l) => l.valid === null);
                 await this.testLocators(toTest);
-                const brokenCount = result.locators.filter((l) => l.valid === false).length;
-                const brokenRatio = result.locators.length > 0 ? brokenCount / result.locators.length : 0;
-                if (brokenRatio > 0.8 && retriesLeft > 0) {
-                    tag('warning').log(`${Math.round(brokenRatio * 100)}% locators broken, waiting 3s and retrying research (${maxRetries - retriesLeft + 1}/${maxRetries})...`);
-                    await new Promise((r) => setTimeout(r, 3000));
-                    return this.research(state, { ...opts, force: true, _retriesLeft: retriesLeft - 1 });
-                }
             }
             // Stage 3: Fix broken sections via AI conversation continuation
             if (!interrupted() && fix && result.locators.some((l) => l.valid === false)) {
@@ -197,7 +175,7 @@ export class Researcher extends ResearcherBase {
             // Must run BEFORE visuallyAnnotateContainers — annotation overlays inject z-index 99998+ which would pollute the scoring.
             if (!interrupted() && this.hasScreenshotToAnalyze) {
                 const sections = parseResearchSections(result.text);
-                const focused = await this.explorer.runWithBrowserRecovery('detectFocusedSection', () => detectFocusedSection(this.explorer.playwrightHelper.page, sections));
+                const focused = await this.explorer.withPage((page) => detectFocusedSection(page, sections));
                 if (focused)
                     markSectionAsFocused(result, focused);
             }
@@ -206,11 +184,11 @@ export class Researcher extends ResearcherBase {
                 const validContainers = extractValidContainers(result.text);
                 result.parseLocators();
                 const freshContainerLocs = result.containerLocators;
-                await this.testLocators(freshContainerLocs);
+                await this.testLocators(freshContainerLocs, { scope: true });
                 const freshBroken = freshContainerLocs.filter((l) => l.valid === false).map((l) => l.locator);
                 const containers = validContainers.filter((c) => !freshBroken.includes(c.css));
                 await this.visuallyAnnotateElements({ containers });
-                this.actionResult = await this.explorer.capturePageWithScreenshot();
+                this.actionResult = await this.explorer.capture({ screenshot: true });
                 const visualResult = await this.analyzeScreenshotForVisualProps();
                 if (visualResult.elements.size > 0) {
                     await this.mergeVisualData(result, visualResult.elements);
@@ -280,8 +258,7 @@ export class Researcher extends ResearcherBase {
     async ensureNavigated(url, screenshot) {
         if (!this.actionResult) {
             debugLog('No action result, navigating to URL');
-            await this.explorer.visit(url);
-            this.actionResult = await this.explorer.capturePageState({ includeScreenshot: screenshot });
+            this.actionResult = await this.explorer.visit(url, { screenshot });
             return;
         }
         const isOnCurrentState = this.actionResult.getStateHash() === this.stateManager.getCurrentState()?.hash;
@@ -289,34 +266,32 @@ export class Researcher extends ResearcherBase {
         const isEmpty = isBodyEmpty(stateHtml);
         if (!isEmpty && isOnCurrentState) {
             if ((!this.actionResult.screenshot && screenshot) || !this.actionResult.ariaSnapshot) {
-                this.actionResult = await this.explorer.capturePageState({ includeScreenshot: screenshot });
+                this.actionResult = await this.explorer.capture({ screenshot });
             }
             return;
         }
         if (isEmpty && isOnCurrentState) {
             debugLog('HTML body empty on current URL, waiting for content');
             tag('step').log('Page body is empty, waiting for content...');
-            await this.explorer.visit(url);
-            this.actionResult = await this.explorer.capturePageState({ includeScreenshot: screenshot ?? false });
+            this.actionResult = await this.explorer.visit(url, { screenshot: screenshot ?? false });
             await this.waitUntilSettled(screenshot ?? false);
             return;
         }
         debugLog('Not on current state, navigating to URL');
         tag('step').log('Navigating to URL...');
-        await this.explorer.visit(url);
-        this.actionResult = await this.explorer.capturePageState({ includeScreenshot: screenshot ?? false });
+        this.actionResult = await this.explorer.visit(url, { screenshot: screenshot ?? false });
     }
     async waitUntilSettled(screenshot) {
-        const errorPageTimeout = this.explorer.getConfig().ai?.agents?.researcher?.errorPageTimeout ?? 10;
+        const errorPageTimeout = this.config.ai?.agents?.researcher?.errorPageTimeout ?? 10;
         if (errorPageTimeout <= 0)
             return false;
         const includeScreenshot = screenshot && this.provider.hasVision();
         try {
-            await this.explorer.runWithBrowserRecovery('waitUntilSettled', () => this.explorer.playwrightHelper.page?.waitForLoadState('networkidle', { timeout: errorPageTimeout * 1000 }));
+            await this.explorer.withPage((page) => page.waitForLoadState('networkidle', { timeout: errorPageTimeout * 1000 }));
         }
         catch { }
-        await this.explorer.annotateElements();
-        this.actionResult = await this.explorer.capturePageState({ includeScreenshot });
+        await this.explorer.withPage(annotatePageElements);
+        this.actionResult = await this.explorer.capture({ screenshot: includeScreenshot });
         let condition = detectPageCondition(this.actionResult);
         if (condition === 'error') {
             throw new ErrorPageError(this.actionResult.url, this.actionResult.title, this.actionResult.httpStatus);
@@ -325,8 +300,8 @@ export class Researcher extends ResearcherBase {
             return true;
         for (let i = 0; i < 3; i++) {
             await new Promise((r) => setTimeout(r, 1000));
-            await this.explorer.annotateElements();
-            this.actionResult = await this.explorer.capturePageState({ includeScreenshot });
+            await this.explorer.withPage(annotatePageElements);
+            this.actionResult = await this.explorer.capture({ screenshot: includeScreenshot });
             condition = detectPageCondition(this.actionResult);
             if (condition === 'error') {
                 throw new ErrorPageError(this.actionResult.url, this.actionResult.title, this.actionResult.httpStatus);
@@ -337,7 +312,7 @@ export class Researcher extends ResearcherBase {
         return false;
     }
     getConfiguredSections() {
-        const configSections = this.explorer.getConfig().ai?.agents?.researcher?.sections;
+        const configSections = this.config.ai?.agents?.researcher?.sections;
         if (!configSections?.length)
             return POSSIBLE_SECTIONS;
         const filtered = {};
@@ -404,7 +379,7 @@ export class Researcher extends ResearcherBase {
         if (!this.actionResult)
             throw new Error('actionResult is not set');
         const html = await this.actionResult.combinedHtml();
-        const knowledge = this.explorer.getKnowledgeTracker().renderRelevantKnowledge(this.actionResult);
+        const knowledge = this.knowledgeTracker.renderRelevantKnowledge(this.actionResult);
         const ariaSnapshot = this.actionResult.getCompactARIA();
         return dedent `
       Analyze this web page and provide a comprehensive research report in markdown format.
@@ -651,9 +626,9 @@ export class Researcher extends ResearcherBase {
     }
     async cancelInUi() {
         const beforeAria = this.stateManager.getCurrentState()?.ariaSnapshot || null;
-        await this.explorer.executeAction('I.clickXY(0, 0)');
+        await this.explorer.action().execute('I.clickXY(0, 0)');
         if (diffAriaSnapshots(beforeAria, this.stateManager.getCurrentState()?.ariaSnapshot || null).text)
             return;
-        await this.explorer.executeAction(`I.pressKey('Escape')`);
+        await this.explorer.action().execute(`I.pressKey('Escape')`);
     }
 }

package/dist/src/ai/task-agent.d.ts

@@ -1,27 +1,40 @@
 import type { ActionResult } from '../action-result.js';
+import type { ExplorbotConfig } from '../config.js';
 import type { ExperienceTracker } from '../experience-tracker.js';
+import type Explorer from '../explorer.js';
 import type { KnowledgeTracker } from '../knowledge-tracker.js';
+import type { StateManager } from '../state-manager.js';
+import { HooksRunner } from '../utils/hooks-runner.js';
+import type { AgentDeps, ToolDeps } from './agent.js';
 import { Historian } from './historian.js';
 import type { Navigator } from './navigator.js';
 import type { Provider } from './provider.js';
 import { Quartermaster } from './quartermaster.js';
 export declare function isInteractive(): boolean;
 export declare abstract class TaskAgent {
+    explorer: Explorer;
+    provider: Provider;
+    config: ExplorbotConfig;
+    stateManager: StateManager;
+    knowledgeTracker: KnowledgeTracker;
+    hooksRunner: HooksRunner;
     consecutiveFailures: number;
     consecutiveEmptyResults: number;
     recentToolCalls: any[];
     readonly ACTION_TOOLS: string[];
     _historian: Historian | null;
     _quartermaster: Quartermaster | null;
+    constructor(deps?: AgentDeps);
+    setHistorian(historian: Historian): void;
+    setQuartermaster(quartermaster: Quartermaster): void;
     abstract getNavigator(): Navigator;
-    abstract getExperienceTracker(): ExperienceTracker;
-    abstract getKnowledgeTracker(): KnowledgeTracker;
-    abstract getProvider(): Provider;
+    get toolDeps(): ToolDeps;
+    getExperienceTracker(): ExperienceTracker;
+    getKnowledgeTracker(): KnowledgeTracker;
+    getProvider(): Provider;
     getKnowledge(actionResult: ActionResult): string;
     getExperience(actionResult: ActionResult): string;
-    setHistorian(historian: Historian): void;
     getHistorian(): Historian;
-    setQuartermaster(quartermaster: Quartermaster): void;
     getQuartermaster(): Quartermaster;
     trackToolExecutions(toolExecutions: any[]): void;
     resetFailureCount(): void;

package/dist/src/ai/task-agent.js

@@ -1,3 +1,4 @@
+import { HooksRunner } from "../utils/hooks-runner.js";
 export function isInteractive() {
     return process.env.INK_RUNNING === 'true';
 }
@@ -7,29 +8,57 @@ function createNullProxy() {
     });
 }
 export class TaskAgent {
+    explorer;
+    provider;
+    config;
+    stateManager;
+    knowledgeTracker;
+    hooksRunner;
     consecutiveFailures = 0;
     consecutiveEmptyResults = 0;
     recentToolCalls = [];
     ACTION_TOOLS = [];
     _historian = null;
     _quartermaster = null;
+    constructor(deps) {
+        if (!deps)
+            return;
+        this.explorer = deps.explorer;
+        this.provider = deps.ai;
+        this.config = deps.config;
+        this.stateManager = deps.stateManager;
+        this.knowledgeTracker = deps.knowledgeTracker;
+        this.hooksRunner = new HooksRunner(deps.explorer, deps.config);
+    }
+    setHistorian(historian) {
+        this._historian = historian;
+    }
+    setQuartermaster(quartermaster) {
+        this._quartermaster = quartermaster;
+    }
+    get toolDeps() {
+        return { explorer: this.explorer, stateManager: this.stateManager, ai: this.provider };
+    }
+    getExperienceTracker() {
+        return this.stateManager.getExperienceTracker();
+    }
+    getKnowledgeTracker() {
+        return this.knowledgeTracker;
+    }
+    getProvider() {
+        return this.provider;
+    }
     getKnowledge(actionResult) {
         return this.getKnowledgeTracker().renderRelevantKnowledge(actionResult);
     }
     getExperience(actionResult) {
         return this.getExperienceTracker().renderExperienceTocFor(actionResult);
     }
-    setHistorian(historian) {
-        this._historian = historian;
-    }
     getHistorian() {
         if (this._historian)
             return this._historian;
         return createNullProxy();
     }
-    setQuartermaster(quartermaster) {
-        this._quartermaster = quartermaster;
-    }
     getQuartermaster() {
         if (this._quartermaster)
             return this._quartermaster;

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

@@ -1,22 +1,20 @@
 import { ActionResult } from '../action-result.js';
-import type { ExperienceTracker } from '../experience-tracker.js';
-import type Explorer from '../explorer.js';
+import type { RequestStore } from '../api/request-store.js';
+import type { TestRun } from '../explorer.js';
 import { type Test } from '../test-plan.js';
-import { HooksRunner } from '../utils/hooks-runner.js';
-import type { Agent } from './agent.js';
+import type { Agent, AgentDeps } from './agent.js';
 import type { Captain } from './captain.js';
 import type { Conversation } from './conversation.js';
 import { Navigator } from './navigator.js';
 import type { Pilot } from './pilot.js';
-import { Provider } from './provider.js';
 import { Researcher } from './researcher.js';
 import { TaskAgent } from './task-agent.js';
 export declare class Tester extends TaskAgent implements Agent {
     readonly ACTION_TOOLS: string[];
     readonly SPECIAL_CONTEXT_ACTION_TOOLS: string[];
     emoji: string;
-    explorer: Explorer;
-    provider: Provider;
+    requestStore: RequestStore;
+    testRun: TestRun | null;
     currentConversation: Conversation | null;
     pilot: Pilot | null;
     captain: Captain | null;
@@ -30,16 +28,12 @@ export declare class Tester extends TaskAgent implements Agent {
     previousStateHash: string | null;
     pageStateHash: string | null;
     pageActionResult: ActionResult | null;
-    hooksRunner: HooksRunner;
     seenUiMapUrls: Set<string>;
     lastAnalyzedStateHash: string | null;
     stalledIterations: number;
     readonly MAX_STALLED_ITERATIONS = 3;
-    constructor(explorer: Explorer, provider: Provider, researcher: Researcher, navigator: Navigator, agentTools?: any);
+    constructor(deps: AgentDeps, researcher: Researcher, navigator: Navigator, agentTools?: any);
     getNavigator(): Navigator;
-    getExperienceTracker(): ExperienceTracker;
-    getKnowledgeTracker(): import("../knowledge-tracker.js").KnowledgeTracker;
-    getProvider(): Provider;
     setPilot(pilot: Pilot): void;
     setCaptain(captain: Captain): void;
     getCurrentState(): ActionResult;