explorbot 0.1.26 → 0.1.28

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

@@ -2,9 +2,10 @@ import dedent from 'dedent';
 import { ActionResult } from '../../action-result.js';
 import { executionController } from "../../execution-controller.js";
 import { detectFocusArea, diffAriaSnapshots } from "../../utils/aria.js";
+import { extractCodeBlocks } from "../../utils/code-extractor.js";
 import { tag } from '../../utils/logger.js';
 import { mdq } from "../../utils/markdown-query.js";
-import { getCachedResearch, saveResearch } from "./cache.js";
+import { getCachedResearch, getPreviousResearch, saveResearch } from "./cache.js";
 import { debugLog } from "./mixin.js";
 import { parseResearchSections } from "./parser.js";
 const DEFAULT_MAX_EXPANDABLE_CLICKS = 10;
@@ -13,13 +14,26 @@ export function WithDeepAnalysis(Base) {
         async performDeepAnalysis(state, result) {
             tag('info').log('Starting deep analysis of expandable elements');
             await this.navigateTo(state.fullUrl || state.url);
-            let expandables = await this._discoverExpandables(result.text);
-            if (expandables.length === 0) {
-                tag('info').log('No expandable elements identified by AI');
-                return;
-            }
-            tag('substep').log(`Identified ${expandables.length} expandable elements`);
             const maxClicks = this.explorer.getConfig().ai?.agents?.researcher?.maxExpandableClicks ?? DEFAULT_MAX_EXPANDABLE_CLICKS;
+            const expandedSections = [];
+            const navigationLinks = [];
+            let verifiedCodes = [];
+            let missing = [];
+            const previousSections = this._loadPreviousExtendedSections(state.hash || '');
+            if (previousSections.length > 0) {
+                tag('substep').log(`Replaying ${previousSections.length} previously discovered sections`);
+                const replay = await this._replayPreviousSections(state, previousSections, maxClicks);
+                expandedSections.push(...replay.verified);
+                verifiedCodes = replay.verifiedCodes;
+                missing = replay.missing;
+                tag('info').log(`Reused ${replay.verified.length}/${previousSections.length} previous sections, ${missing.length} to re-discover`);
+                if (missing.length === 0 && replay.verified.length >= maxClicks) {
+                    tag('info').log('Page appears unchanged, reusing previous sections and skipping discovery');
+                    this._appendExtendedResearch(result, expandedSections, navigationLinks);
+                    return;
+                }
+            }
+            let expandables = await this._discoverExpandables(result.text, missing, verifiedCodes);
             if (expandables.length > maxClicks) {
                 expandables = await this._selectExpandables(expandables, state.fullUrl || state.url, maxClicks);
                 tag('substep').log(`Selected ${expandables.length} expandables to click (max: ${maxClicks})`);
@@ -29,9 +43,11 @@ export function WithDeepAnalysis(Base) {
                 commands: this._buildClickCommands(el),
                 description: el.name,
             }))
-                .filter((el) => el.commands.length > 0);
+                .filter((el) => el.commands.length > 0)
+                .filter((el) => !el.commands.some((cmd) => verifiedCodes.includes(cmd)));
             if (elements.length === 0) {
-                tag('info').log('No expandables with valid locators');
+                tag('info').log('No new expandable elements to click');
+                this._appendExtendedResearch(result, expandedSections, navigationLinks);
                 return;
             }
             const expandableRows = elements.map((el) => `| ${el.description} | \`${el.commands[0]}\` |`).join('\n');
@@ -39,21 +55,9 @@ export function WithDeepAnalysis(Base) {
             for (const el of elements)
                 debugLog(`Expandable: ${el.description} → ${el.commands[0]}`);
             tag('substep').log(`Clicking ${elements.length} expandable elements`);
-            const expandedSections = [];
-            const navigationLinks = [];
             await this._clickExpandableElements(elements, state, expandedSections, navigationLinks);
             tag('info').log(`Deep analysis complete. Sections: ${expandedSections.length}, navigation links: ${navigationLinks.length}`);
-            const dedupedSections = this._deduplicateExpandedSections(expandedSections);
-            if (dedupedSections.length !== expandedSections.length) {
-                tag('substep').log(`Deduplicated ${expandedSections.length} → ${dedupedSections.length} extended sections`);
-            }
-            if (dedupedSections.length > 0) {
-                result.text += `\n\n# Extended Research\n\n${dedupedSections.join('\n\n---\n\n')}`;
-            }
-            if (navigationLinks.length > 0) {
-                const links = navigationLinks.map((l) => `- \`${l.code}\` opens ${l.url}`).join('\n');
-                result.text += `\n\n## Navigation Links\n\n${links}`;
-            }
+            this._appendExtendedResearch(result, expandedSections, navigationLinks);
         }
         async researchOverlay(current, previous, pageStateHash) {
             const focusArea = detectFocusArea(current.ariaSnapshot);
@@ -97,7 +101,66 @@ export function WithDeepAnalysis(Base) {
             tag('substep').log(`Overlay research appended: ${focusArea.name}`);
             return sectionMarkdown;
         }
-        async _discoverExpandables(researchText) {
+        _loadPreviousExtendedSections(hash) {
+            if (!hash)
+                return [];
+            const previous = getPreviousResearch(hash);
+            if (!previous)
+                return [];
+            const sections = [];
+            for (const section of parseResearchSections(previous)) {
+                if (!section.isExtended)
+                    continue;
+                const code = extractCodeBlocks(section.rawMarkdown)[0];
+                if (!code)
+                    continue;
+                sections.push({ name: section.name, code });
+            }
+            return sections;
+        }
+        async _replayPreviousSections(state, prevSections, maxClicks) {
+            const originalAria = state.ariaSnapshot || '';
+            const verified = [];
+            const verifiedCodes = [];
+            const missing = [];
+            for (const section of prevSections.slice(0, maxClicks)) {
+                if (executionController.isInterrupted())
+                    break;
+                let outcome;
+                try {
+                    outcome = await this._executeAndAnalyze([section.code], section.name, state, originalAria, this._summarizeExpanded(verified));
+                }
+                catch (err) {
+                    tag('warning').log(`Replay failed for "${section.name}": ${err instanceof Error ? err.message : err}`);
+                    await this._restorePageState(state.url, originalAria).catch(() => { });
+                    missing.push(section);
+                    continue;
+                }
+                if (outcome.status === 'revealed') {
+                    verified.push(outcome.sectionMarkdown);
+                    verifiedCodes.push(section.code);
+                    debugLog(`Replayed and verified section: ${section.name}`);
+                    continue;
+                }
+                debugLog(`Could not replay previous section: ${section.name}`);
+                missing.push(section);
+            }
+            return { verified, verifiedCodes, missing };
+        }
+        _appendExtendedResearch(result, expandedSections, navigationLinks) {
+            const dedupedSections = this._deduplicateExpandedSections(expandedSections);
+            if (dedupedSections.length !== expandedSections.length) {
+                tag('substep').log(`Deduplicated ${expandedSections.length} → ${dedupedSections.length} extended sections`);
+            }
+            if (dedupedSections.length > 0) {
+                result.text += `\n\n# Extended Research\n\n${dedupedSections.join('\n\n---\n\n')}`;
+            }
+            if (navigationLinks.length > 0) {
+                const links = navigationLinks.map((l) => `- \`${l.code}\` opens ${l.url}`).join('\n');
+                result.text += `\n\n## Navigation Links\n\n${links}`;
+            }
+        }
+        async _discoverExpandables(researchText, missing = [], verifiedCodes = []) {
             const allElements = new Map();
             for (const section of parseResearchSections(researchText)) {
                 for (const el of section.elements) {
@@ -108,6 +171,15 @@ export function WithDeepAnalysis(Base) {
             if (allElements.size === 0)
                 return [];
             const eidxList = [...allElements.keys()].join(', ');
+            let missingHint = '';
+            if (missing.length > 0) {
+                const list = missing.map((s) => `- "${s.name}" (previously revealed via ${s.code})`).join('\n');
+                missingHint = dedent `
+
+          These sections were present on a previous visit but their trigger could not be replayed now — the element may have moved or been renamed. Prioritize finding the element that now reveals each:
+          ${list}
+        `;
+            }
             const textPrompt = dedent `
         From this UI research, identify elements that could reveal hidden UI when clicked
         (dropdown menus, popups, expandable panels, accordion sections, overflow menus, tab switches).
@@ -115,6 +187,7 @@ export function WithDeepAnalysis(Base) {
         Available eidx refs: ${eidxList}
 
         ${researchText}
+        ${missingHint}
 
         Rules:
         - Only pick elements that HIDE content until clicked (menus, dropdowns, accordions, tabs)
@@ -136,6 +209,7 @@ export function WithDeepAnalysis(Base) {
 
           Look for: overflow/ellipsis menus, chevron dropdowns, hamburger menus,
           gear/settings buttons, accordion toggles, tab switches, filter buttons.
+          ${missingHint}
 
           Rules:
           - For repeated icons (same icon on every list row), pick only the FIRST one
@@ -238,10 +312,9 @@ export function WithDeepAnalysis(Base) {
                     const isCoordinateClick = el.commands[0].startsWith('I.clickXY(');
                     if (!isCoordinateClick) {
                         const hoverCmd = el.commands[0].replace('I.click(', 'I.moveCursorTo(');
-                        const hoverAction = this.explorer.createAction();
-                        await hoverAction.attempt(hoverCmd, undefined, false);
+                        await this.explorer.attemptAction(hoverCmd, undefined, false);
                         await new Promise((r) => setTimeout(r, 500));
-                        await this.explorer.createAction().capturePageState();
+                        await this.explorer.capturePageState();
                         const hoverAR = ActionResult.fromState(this.stateManager.getCurrentState());
                         const hoverDiff = await hoverAR.diff(previousState);
                         await hoverDiff.calculate();
@@ -258,48 +331,15 @@ export function WithDeepAnalysis(Base) {
                             await this._restorePageState(state.url, originalAria);
                         }
                     }
-                    let clickCode = null;
-                    const action = this.explorer.createAction();
-                    for (const cmd of el.commands) {
-                        if (await action.attempt(cmd, undefined, false)) {
-                            clickCode = cmd;
-                            break;
-                        }
-                    }
-                    if (!clickCode) {
-                        debugLog(`Click failed: ${el.description.slice(0, 80)}`);
+                    const outcome = await this._executeAndAnalyze(el.commands, el.description, state, originalAria, this._summarizeExpanded(expandedSections));
+                    if (outcome.status === 'navigated') {
+                        navigationLinks.push({ code: outcome.code, url: outcome.url });
                         continue;
                     }
-                    await new Promise((r) => setTimeout(r, 500));
-                    let diff;
-                    try {
-                        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}`);
-                        await this._restorePageState(state.url, originalAria);
-                        continue;
-                    }
-                    if (diff.urlHasChanged()) {
-                        debugLog(`Click navigated to ${this.stateManager.getCurrentState()?.url}`);
-                        navigationLinks.push({ code: clickCode, url: this.stateManager.getCurrentState()?.url || '' });
-                        await this.navigateTo(state.url);
-                        continue;
-                    }
-                    const clickHtmlSize = diff.htmlParts.reduce((sum, p) => sum + p.subtree.length, 0);
-                    if (!diff.ariaChanged && clickHtmlSize <= 150) {
-                        debugLog(`No changes from: ${el.description.slice(0, 80)}`);
-                        continue;
-                    }
-                    const sectionMarkdown = await this._analyzeExpandedAction(clickCode, el.description, diff, this._summarizeExpanded(expandedSections));
-                    if (sectionMarkdown) {
-                        expandedSections.push(sectionMarkdown);
+                    if (outcome.status === 'revealed') {
+                        expandedSections.push(outcome.sectionMarkdown);
                         debugLog(`Captured section from: ${el.description.slice(0, 80)}`);
                     }
-                    await this._restorePageState(state.url, originalAria);
                 }
                 catch (err) {
                     tag('warning').log(`Expandable click failed for "${el.description.slice(0, 80)}": ${err instanceof Error ? err.message : err}`);
@@ -310,10 +350,54 @@ 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();
+            for (const cmd of commands) {
+                if (await action.attempt(cmd, undefined, false)) {
+                    clickCode = cmd;
+                    break;
+                }
+            }
+            if (!clickCode) {
+                debugLog(`Click failed: ${description.slice(0, 80)}`);
+                return { status: 'failed' };
+            }
+            await new Promise((r) => setTimeout(r, 500));
+            let diff;
+            try {
+                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}`);
+                await this._restorePageState(state.url, originalAria);
+                return { status: 'failed' };
+            }
+            if (diff.urlHasChanged()) {
+                const url = this.stateManager.getCurrentState()?.url || '';
+                debugLog(`Click navigated to ${url}`);
+                await this.navigateTo(state.url);
+                return { status: 'navigated', code: clickCode, url };
+            }
+            const clickHtmlSize = diff.htmlParts.reduce((sum, p) => sum + p.subtree.length, 0);
+            if (!diff.ariaChanged && clickHtmlSize <= 150) {
+                debugLog(`No changes from: ${description.slice(0, 80)}`);
+                return { status: 'none', code: clickCode };
+            }
+            const sectionMarkdown = await this._analyzeExpandedAction(clickCode, description, diff, alreadyExpanded);
+            await this._restorePageState(state.url, originalAria);
+            if (!sectionMarkdown)
+                return { status: 'none', code: clickCode };
+            return { status: 'revealed', code: clickCode, sectionMarkdown };
+        }
         async _restorePageState(url, originalAria) {
             try {
                 await this.cancelInUi();
-                await this.explorer.createAction().capturePageState();
+                await this.explorer.capturePageState();
                 const currentAria = this.stateManager.getCurrentState()?.ariaSnapshot || '';
                 if (!diffAriaSnapshots(originalAria, currentAria))
                     return;

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

@@ -173,8 +173,7 @@ export function WithLocators(Base) {
                 }
             }
             if (needsXpath.length > 0) {
-                const page = this.explorer.playwrightHelper.page;
-                const webElements = await WebElement.fromEidxList(page, needsXpath);
+                const webElements = await this.explorer.runWithBrowserRecovery('backfillBrokenLocators', () => WebElement.fromEidxList(this.explorer.playwrightHelper.page, needsXpath));
                 const changedSections = new Set();
                 for (const w of webElements) {
                     const entry = needsXpathEls.get(w.eidx);

package/dist/src/ai/researcher.js

@@ -97,11 +97,11 @@ export class Researcher extends ResearcherBase {
             await this.hooksRunner.runBeforeHook('researcher', state.url);
             const annotatedElements = await this.explorer.annotateElements();
             debugLog(`Annotated ${annotatedElements.length} interactive elements with eidx`);
-            this.actionResult = await this.explorer.createAction().capturePageState({ includeScreenshot: screenshot && this.provider.hasVision() });
+            this.actionResult = await this.explorer.capturePageState({ includeScreenshot: screenshot && this.provider.hasVision() });
             const condition = detectPageCondition(this.actionResult);
             if (condition === 'error') {
                 tag('warning').log(`Detected error page at ${state.url}`);
-                throw new ErrorPageError(state.url, this.actionResult.title);
+                throw new ErrorPageError(state.url, this.actionResult.title, this.actionResult.httpStatus);
             }
             if (condition === 'loading') {
                 const settled = await this.waitUntilSettled(screenshot);
@@ -191,7 +191,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 detectFocusedSection(this.explorer.playwrightHelper.page, sections);
+                const focused = await this.explorer.runWithBrowserRecovery('detectFocusedSection', () => detectFocusedSection(this.explorer.playwrightHelper.page, sections));
                 if (focused)
                     markSectionAsFocused(result, focused);
             }
@@ -204,7 +204,7 @@ export class Researcher extends ResearcherBase {
                 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.createAction().caputrePageWithScreenshot();
+                this.actionResult = await this.explorer.capturePageWithScreenshot();
                 const visualResult = await this.analyzeScreenshotForVisualProps();
                 if (visualResult.elements.size > 0) {
                     await this.mergeVisualData(result, visualResult.elements);
@@ -277,7 +277,7 @@ export class Researcher extends ResearcherBase {
         if (!this.actionResult) {
             debugLog('No action result, navigating to URL');
             await this.explorer.visit(url);
-            this.actionResult = await this.explorer.createAction().capturePageState({ includeScreenshot: screenshot });
+            this.actionResult = await this.explorer.capturePageState({ includeScreenshot: screenshot });
             return;
         }
         const isOnCurrentState = this.actionResult.getStateHash() === this.stateManager.getCurrentState()?.hash;
@@ -285,46 +285,47 @@ 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.createAction().capturePageState({ includeScreenshot: screenshot });
+                this.actionResult = await this.explorer.capturePageState({ includeScreenshot: 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 });
             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.createAction().capturePageState({ includeScreenshot: screenshot ?? false });
+        this.actionResult = await this.explorer.capturePageState({ includeScreenshot: screenshot ?? false });
     }
     async waitUntilSettled(screenshot) {
         const errorPageTimeout = this.explorer.getConfig().ai?.agents?.researcher?.errorPageTimeout ?? 10;
         if (errorPageTimeout <= 0)
             return false;
-        const page = this.explorer.playwrightHelper.page;
         const includeScreenshot = screenshot && this.provider.hasVision();
         try {
-            await page?.waitForLoadState('networkidle', { timeout: errorPageTimeout * 1000 });
+            await this.explorer.runWithBrowserRecovery('waitUntilSettled', () => this.explorer.playwrightHelper.page?.waitForLoadState('networkidle', { timeout: errorPageTimeout * 1000 }));
         }
         catch { }
         await this.explorer.annotateElements();
-        this.actionResult = await this.explorer.createAction().capturePageState({ includeScreenshot });
+        this.actionResult = await this.explorer.capturePageState({ includeScreenshot });
         let condition = detectPageCondition(this.actionResult);
         if (condition === 'error') {
-            throw new ErrorPageError(this.actionResult.url, this.actionResult.title);
+            throw new ErrorPageError(this.actionResult.url, this.actionResult.title, this.actionResult.httpStatus);
         }
         if (condition === 'ok')
             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.createAction().capturePageState({ includeScreenshot });
+            this.actionResult = await this.explorer.capturePageState({ includeScreenshot });
             condition = detectPageCondition(this.actionResult);
             if (condition === 'error') {
-                throw new ErrorPageError(this.actionResult.url, this.actionResult.title);
+                throw new ErrorPageError(this.actionResult.url, this.actionResult.title, this.actionResult.httpStatus);
             }
             if (condition === 'ok')
                 return true;
@@ -681,15 +682,13 @@ export class Researcher extends ResearcherBase {
             .join('\n\n');
     }
     async navigateTo(url) {
-        const action = this.explorer.createAction();
-        await action.execute(`I.amOnPage("${url}")`);
+        await this.explorer.visit(url);
     }
     async cancelInUi() {
         const beforeAria = this.stateManager.getCurrentState()?.ariaSnapshot || null;
-        const action = this.explorer.createAction();
-        await action.execute('I.clickXY(0, 0)');
+        await this.explorer.executeAction('I.clickXY(0, 0)');
         if (diffAriaSnapshots(beforeAria, this.stateManager.getCurrentState()?.ariaSnapshot || null))
             return;
-        await action.execute(`I.pressKey('Escape')`);
+        await this.explorer.executeAction(`I.pressKey('Escape')`);
     }
 }

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

@@ -14,6 +14,7 @@ export class TaskAgent {
     consecutiveFailures = 0;
     consecutiveEmptyResults = 0;
     recentToolCalls = [];
+    ACTION_TOOLS = [];
     _historian = null;
     _quartermaster = null;
     getKnowledge(actionResult) {

package/dist/src/ai/tester.js

@@ -4,13 +4,13 @@ import { tool } from 'ai';
 import dedent from 'dedent';
 import { z } from 'zod';
 import { ActionResult } from "../action-result.js";
-import { setActivity } from "../activity.js";
+import { clearActivity, setActivity } from "../activity.js";
 import { ConfigParser } from "../config.js";
 import { Observability } from "../observability.js";
 import { Stats } from "../stats.js";
 import { TestResult } from "../test-plan.js";
 import { detectFocusArea, extractFocusedElement } from "../utils/aria.js";
-import { ErrorPageError } from "../utils/error-page.js";
+import { ErrorPageError, isErrorPage } from "../utils/error-page.js";
 import { HooksRunner } from "../utils/hooks-runner.js";
 import { createDebug, tag } from "../utils/logger.js";
 import { loop } from "../utils/loop.js";
@@ -107,18 +107,13 @@ export class Tester extends TaskAgent {
         const offFailedRequest = requestStore?.onFailedRequest((r) => {
             task.addNote(`Network error: ${r.method} ${r.path} → ${r.status}`, TestResult.FAILED);
         });
-        const page = this.explorer.playwrightHelper?.page;
-        const onPageError = (err) => {
-            task.addNote(`Console error: ${err.message}`, TestResult.FAILED);
-        };
-        const onConsoleMessage = (msg) => {
-            if (msg.type() !== 'error')
-                return;
-            task.addNote(`Console error: ${msg.text()}`, TestResult.FAILED);
-        };
-        page?.on('pageerror', onPageError);
-        page?.on('console', onConsoleMessage);
         const initialState = ActionResult.fromState(state);
+        if (isErrorPage(initialState)) {
+            task.start();
+            await this.explorer.startTest(task);
+            offFailedRequest?.();
+            return await this.abortStartedTestOnErrorPage(task, initialState);
+        }
         const conversation = this.provider.startConversation(this.getSystemMessage(), 'tester');
         conversation.markLastMessageCacheable();
         this.currentConversation = conversation;
@@ -140,17 +135,15 @@ export class Tester extends TaskAgent {
                 startUrl: task.startUrl,
                 expected: task.expected,
             },
-        }, async () => this.runTestSession(task, initialState, conversation, { offFailedRequest, page, onPageError, onConsoleMessage }));
+        }, async () => this.runTestSession(task, initialState, conversation, { offFailedRequest }));
     }
     async runTestSession(task, initialState, conversation, handlers) {
-        const { offFailedRequest, page, onPageError, onConsoleMessage } = handlers;
+        const { offFailedRequest } = handlers;
         if (this.pilot) {
             try {
                 const plan = await this.pilot.planTest(task, initialState);
                 if (task.hasFinished) {
                     offFailedRequest?.();
-                    page?.off('pageerror', onPageError);
-                    page?.off('console', onConsoleMessage);
                     return { success: task.isSuccessful };
                 }
                 if (plan) {
@@ -163,19 +156,36 @@ export class Tester extends TaskAgent {
                 task.addNote(`Planning failed: ${message}`, TestResult.FAILED);
                 task.finish(TestResult.FAILED);
                 offFailedRequest?.();
-                page?.off('pageerror', onPageError);
-                page?.off('console', onConsoleMessage);
                 return { success: false };
             }
         }
         debugLog('Starting test execution with tools');
-        task.start();
-        await this.explorer.startTest(task);
+        if (!(await this.explorer.startTest(task))) {
+            offFailedRequest?.();
+            await this.cleanupStartedTest(task);
+            return { success: task.isSuccessful };
+        }
         debugLog(`Navigating to ${task.startUrl}`);
-        await this.explorer.visit(task.startUrl);
+        try {
+            await this.explorer.visit(task.startUrl);
+        }
+        catch (error) {
+            const result = await this.handleLoopError(task, error);
+            if (result === 'stop') {
+                offFailedRequest?.();
+                await this.cleanupStartedTest(task);
+                return { success: task.isSuccessful };
+            }
+        }
         const startState = this.explorer.getStateManager().getCurrentState();
-        if (startState)
+        if (startState) {
             task.addUrlNote(startState);
+            const startActionResult = ActionResult.fromState(startState);
+            if (isErrorPage(startActionResult)) {
+                offFailedRequest?.();
+                return await this.abortStartedTestOnErrorPage(task, startActionResult);
+            }
+        }
         const currentUrl = startState?.url || task.startUrl || '';
         await this.hooksRunner.runBeforeHook('tester', currentUrl);
         const offStateChange = this.explorer.getStateManager().onStateChange((event) => {
@@ -195,6 +205,12 @@ export class Tester extends TaskAgent {
             shouldContinue = false;
             await loop(async ({ stop, pause, iteration, userInput }) => {
                 debugLog('iteration', iteration);
+                if (!(await this.explorer.ensurePageAvailable())) {
+                    task.addNote('Browser page is unavailable');
+                    task.finish(TestResult.FAILED);
+                    stop();
+                    return;
+                }
                 const currentState = this.getCurrentState();
                 const tools = {
                     ...codeceptjsTools,
@@ -327,20 +343,15 @@ export class Tester extends TaskAgent {
                     }
                     : undefined,
                 catch: async ({ error, stop }) => {
-                    tag('error').log(`Test execution error: ${error}`);
-                    const message = error instanceof Error ? error.message : String(error);
-                    if (!task.hasFinished) {
-                        task.addNote(`Execution error: ${message}`);
-                    }
-                    if (error instanceof Error && error.name === 'AbortError') {
+                    const result = await this.handleLoopError(task, error);
+                    if (result === 'stop')
                         stop();
-                        return;
-                    }
-                    conversation.addUserText(`Previous AI call failed: ${message}. Take a different approach on the next step.`);
                 },
             });
             if (task.hasFinished)
                 break;
+            if (!(await this.explorer.ensurePageAvailable()))
+                break;
             const finalState = this.getCurrentState();
             const wantsContinue = await this.pilot.finalReview(task, finalState, conversation, this.navigator);
             if (!wantsContinue || task.hasFinished)
@@ -366,14 +377,8 @@ export class Tester extends TaskAgent {
         await this.getQuartermaster().analyzeSession(task, initialState, conversation);
         offStateChange();
         offFailedRequest?.();
-        page?.off('pageerror', onPageError);
-        page?.off('console', onConsoleMessage);
         await this.finishTest(task);
-        await this.explorer.stopTest(task, {
-            startUrl: task.startUrl,
-            style: task.style,
-            sessionName: task.sessionName,
-        });
+        await this.explorer.stopTest(task, this.buildStopTestMeta(task));
         return {
             success: task.isSuccessful,
             ...task,
@@ -607,6 +612,26 @@ export class Tester extends TaskAgent {
             tag('warning').log(`Test with no result: ${task.scenario}`);
         }
     }
+    async abortStartedTestOnErrorPage(task, actionResult) {
+        const error = new ErrorPageError(actionResult.url || task.startUrl || '', actionResult.title, actionResult.httpStatus);
+        tag('warning').log(error.message);
+        task.addNote(error.message, TestResult.FAILED, actionResult.screenshotFile, actionResult.fullUrl || actionResult.url);
+        task.finish(TestResult.FAILED);
+        this.finishTest(task);
+        await this.explorer.stopTest(task, this.buildStopTestMeta(task));
+        clearActivity(true);
+        return { success: false };
+    }
+    buildStopTestMeta(task) {
+        const meta = {
+            startUrl: task.startUrl,
+        };
+        if (task.style)
+            meta.style = task.style;
+        if (task.sessionName)
+            meta.sessionName = task.sessionName;
+        return meta;
+    }
     getSystemMessage() {
         return dedent `
     <role>
@@ -991,4 +1016,31 @@ export class Tester extends TaskAgent {
             }),
         };
     }
+    async handleLoopError(task, error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!task.hasFinished)
+            task.addNote(`Execution error: ${message}`);
+        const result = await this.explorer.handleExecutionError(error);
+        tag('info').log(`Browser supervisor: ${result.action} - ${result.message}`);
+        task.addNote(result.message);
+        if (result.action === 'stop') {
+            task.finish(TestResult.FAILED);
+            return 'stop';
+        }
+        if (result.recovered) {
+            this.resetFailureCount();
+            this.previousUrl = null;
+            this.previousStateHash = null;
+        }
+        this.currentConversation?.addUserText(result.message);
+        return 'continue';
+    }
+    async cleanupStartedTest(task) {
+        await this.finishTest(task);
+        await this.explorer.stopTest(task, {
+            startUrl: task.startUrl,
+            style: task.style,
+            sessionName: task.sessionName,
+        });
+    }
 }