explorbot 0.1.27 → 0.1.29

package/dist/src/ai/researcher.js

@@ -47,6 +47,12 @@ export class Researcher extends ResearcherBase {
         this.stateManager = explorer.getStateManager();
         this.experienceTracker = this.stateManager.getExperienceTracker();
         this.hooksRunner = new HooksRunner(explorer, explorer.getConfig());
+        const ai = explorer.getConfig().ai;
+        if (ai) {
+            ai.agents ??= {};
+            ai.agents.researcher ??= {};
+            ai.agents.researcher.reasoning ??= 'low';
+        }
     }
     getNavigator() {
         throw new Error('not implemented');
@@ -97,11 +103,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);
@@ -139,7 +145,7 @@ export class Researcher extends ResearcherBase {
             catch (error) {
                 if (!(error instanceof ContextLengthError) || retriesLeft <= 0) {
                     if (error instanceof ContextLengthError) {
-                        tag('warning').log('Output truncated. Try lowering reasoning effort or increasing maxTokens in ai.config.');
+                        tag('warning').log('Output truncated. Try lowering reasoning effort or increasing maxOutputTokens in ai.config.');
                     }
                     throw error;
                 }
@@ -191,7 +197,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 +210,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 +283,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 +291,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 +688,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/rules.js

@@ -147,6 +147,50 @@ export const protectionRule = dedent `
   Do not propose or perform delete/remove/archive actions on the entity that owns the current URL; propose such actions only on disposable children created within the scenario itself.
   </important>
 `;
+export const dataProtectionRules = dedent `
+  <data_protection_rules>
+  ${protectionRule}
+
+  If the user request, scenario, focus, or test instructions explicitly prohibit creating,
+  editing, updating, deleting, removing, or otherwise mutating data, do not perform those
+  actions through the UI, API preconditions, cleanup, fallback steps, or Fisherman.
+
+  Do not use Fisherman or API data preparation to bypass a no-mutation, read-only, search,
+  filter, tab, or list-inspection constraint. Use visible existing data when it is available.
+  If no suitable data exists, report the missing precondition instead of creating data.
+
+  Destructive actions are allowed only against disposable data created by the current scenario
+  or prepared for that scenario by Fisherman/API preconditions. Existing application data must
+  remain unchanged.
+  </data_protection_rules>
+`;
+export const capabilityGroundingRule = dedent `
+  <capability_grounding>
+  When a scenario depends on a named action, menu item, status, option, workflow, or feature,
+  that capability must be visible or explicitly confirmed in the current research/page context
+  for the same target entity type.
+
+  Do not transfer capabilities between similar entities, rows, lists, detail pages, or menus.
+  Do not replace a requested action with a synonym or related action unless the UI explicitly
+  shows that action for the target entity.
+
+  When an action is described as applying to an item, row, card, record, node, or entity,
+  the target must be grounded as that kind of data entity in the current context. Do not use
+  navigation links, filter tabs, counters, breadcrumbs, headings, toolbar controls, or other
+  page controls as the subject of row/entity actions.
+
+  When a scenario asks to open, view, inspect, or navigate to an entity detail view, success
+  requires evidence of that entity detail context. An active filter, selected tab, visible count,
+  or filtered list is not enough to prove an entity detail view opened.
+
+  Do not rewrite a scenario goal to match a similar outcome that happened accidentally. If the
+  requested entity detail/action/workflow was not achieved, report that mismatch instead of
+  passing the test for a related filter, tab, navigation, or status view.
+
+  If the required capability is not available for the target entity after reasonable discovery,
+  record the missing capability and stop instead of repeatedly trying unrelated locators.
+  </capability_grounding>
+`;
 export const focusedElementRule = dedent `
   <focused_element_actions>
   When a text input element is focused (textbox, combobox, contenteditable):

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,17 +4,17 @@ 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";
-import { actionRule, focusedElementRule, formRequirementsRule, locatorRule, multipleTabsRule, protectionRule, sectionContextRule } from "./rules.js";
+import { actionRule, capabilityGroundingRule, dataProtectionRules, focusedElementRule, formRequirementsRule, locatorRule, multipleTabsRule, sectionContextRule } from "./rules.js";
 import { TaskAgent } from "./task-agent.js";
 import { createCodeceptJSTools, createSpecialContextTools } from "./tools.js";
 const debugLog = createDebug('explorbot:tester');
@@ -29,7 +29,7 @@ const SAMPLE_FILES = {
     'MP3 audio': 'sample.mp3',
 };
 export class Tester extends TaskAgent {
-    ACTION_TOOLS = ['click', 'pressKey', 'form'];
+    ACTION_TOOLS = ['click', 'hover', 'pressKey', 'form'];
     SPECIAL_CONTEXT_ACTION_TOOLS = ['exitIframe'];
     emoji = '🧪';
     explorer;
@@ -51,6 +51,8 @@ export class Tester extends TaskAgent {
     hooksRunner;
     seenUiMapUrls = new Set();
     lastAnalyzedStateHash = null;
+    stalledIterations = 0;
+    MAX_STALLED_ITERATIONS = 3;
     constructor(explorer, provider, researcher, navigator, agentTools) {
         super();
         this.explorer = explorer;
@@ -99,6 +101,7 @@ export class Tester extends TaskAgent {
         this.pageActionResult = null;
         this.seenUiMapUrls.clear();
         this.lastAnalyzedStateHash = null;
+        this.stalledIterations = 0;
         this.explorer.getStateManager().clearHistory();
         this.resetFailureCount();
         this.pilot?.reset();
@@ -107,18 +110,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 +138,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 +159,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 +208,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,
@@ -277,6 +296,10 @@ export class Tester extends TaskAgent {
                         task.addNote(`Failed to ${execution.input.explanation} (${execution.toolName})`, TestResult.FAILED);
                     });
                 }
+                if (this.shouldStopForStalledExecution(task, currentState, result?.toolExecutions || [])) {
+                    stop();
+                    return;
+                }
                 if (assertionPerformed) {
                     const message = result?.toolExecutions?.find((execution) => execution.toolName === 'verify')?.output?.message || '';
                     task.addNote(message, wasSuccessful ? TestResult.PASSED : TestResult.FAILED);
@@ -327,20 +350,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 +384,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,
@@ -390,6 +402,28 @@ export class Tester extends TaskAgent {
             return false;
         return true;
     }
+    shouldStopForStalledExecution(task, previousState, toolExecutions) {
+        if (task.hasFinished)
+            return false;
+        const currentState = this.getCurrentState();
+        const stateChanged = previousState.url !== currentState.url || previousState.hash !== currentState.hash;
+        const actionTools = [...this.ACTION_TOOLS, ...this.SPECIAL_CONTEXT_ACTION_TOOLS];
+        const hasSuccessfulAction = toolExecutions.some((execution) => execution.wasSuccessful && actionTools.includes(execution.toolName));
+        const hasSuccessfulAssertion = toolExecutions.some((execution) => execution.wasSuccessful && this.ASSERTION_TOOLS.includes(execution.toolName));
+        if (stateChanged || hasSuccessfulAction || hasSuccessfulAssertion) {
+            this.stalledIterations = 0;
+            return false;
+        }
+        const hasNoBrowserProgress = toolExecutions.length === 0 || toolExecutions.every((execution) => !actionTools.includes(execution.toolName) || !execution.wasSuccessful);
+        if (!hasNoBrowserProgress)
+            return false;
+        this.stalledIterations++;
+        if (this.stalledIterations < this.MAX_STALLED_ITERATIONS)
+            return false;
+        task.addNote('No browser progress after repeated attempts on unchanged page', TestResult.FAILED);
+        task.finish(TestResult.FAILED);
+        return true;
+    }
     async prepareInstructionsForNextStep(task) {
         let outcomeStatus = dedent `
       <task>
@@ -398,6 +432,8 @@ export class Tester extends TaskAgent {
   
       <rules>
       Use tools ${this.ACTION_TOOLS.join(', ')} to interact with the page.
+      Use tool names exactly as listed in this prompt. Do not invent combined tool names, aliases, or names with channel markers such as "commentary".
+      Match each tool input schema exactly. Do not invent parameter names or pass extra fields.
       Do not do unsuccesful clicks again.
       Do not run same tool calls with same parameters again.
       </rules>
@@ -607,6 +643,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>
@@ -640,6 +696,7 @@ export class Tester extends TaskAgent {
     <rules>
     - Refer to UI Map from <page_ui_map> to understand the page structure and its main elements
     - Use only elements that exist in the provided ARIA tree or HTML, <page_aria> and <page_html>
+    - Use tool input schemas exactly as documented. Do not invent parameter names or add fields not listed by the tool schema.
     - Use click() for buttons, links, and clickable elements ONLY - do NOT include I.fillField() or I.type() commands in click() tool
     - click() commands array is for FALLBACK LOCATORS of the SAME element, NOT for clicking different elements in sequence. If you need to click two different elements, make two separate click() calls.
     - Use form() for text input (I.fillField, I.type), dropdown selection (I.selectOption), file uploads (I.attachFile), and multi-step form interactions
@@ -652,6 +709,7 @@ export class Tester extends TaskAgent {
     - NEVER call record(status: "success") if your last verify() or see() call FAILED. A failed check means the outcome is NOT confirmed — use record(status: "fail") instead, or retry with a different approach.
     - Use finish() to complete the test, not record(). record() is for intermediate notes.
     - Call finish(verify) when all goals are achieved — provide an assertion to verify
+    - NEVER call finish() with a negative assertion that says the goal did NOT happen. If the goal cannot be achieved after real attempts, record the blocker and call stop().
     - ONLY call stop() if the scenario itself is completely irrelevant to this page and no expectations can be achieved
     - Use reset() ONLY as a last resort when the current page cannot host the scenario. Never reset after a successful flow just because an assertion or milestone did not match — verify differently or record() the finding instead. Reset is destructive and does not undo server-side side effects.
     - Be precise with locators (CSS or XPath)
@@ -665,6 +723,13 @@ export class Tester extends TaskAgent {
     - When you interact with form with inputs, ensure that you click corresponding button to save its data
     - Follow <locator_priority> rules when selecting locators for all tools
     - Before retrying your actions check maybe they already achived expected results. Use see() tool for that
+    - If the current URL is already a create/edit/new form and the scenario is about creating/editing that entity, fill and submit that form. Do not click the list-page "New" button again from inside the form.
+    - If the scenario is about search/filter/sort/tabs/list inspection and the current URL is a create/edit/new form, go back or reset to the stable list page before interacting with list controls.
+    - When selecting related entities from a list, do not choose rows/options/cards marked as "0 items", "0 tests", or otherwise empty if the scenario requires selecting real content.
+    - In selection pickers, counters such as "Selected 0", "Matched tests 0", or disabled Save/Apply mean the selection did not register. Choose a non-empty item or change filters before submitting.
+    - A passed form/click command only means the command executed. If a required field remains empty, submit stays disabled, or the expected text is not visible, treat the action as not completed and correct the missing field/state.
+    - For filter/tab scenarios, success requires BOTH: the requested filter/tab is visibly active/selected AND the list content matches that filter. Do not finish from only one of these signals.
+    - Empty-state text such as "No matched items" only proves a filter when the requested filter/tab is active and the empty state belongs to the filtered list.
     - When filling complex form with lot of actions performed, use see() to look which fields were filled and which are not
     - When verify() fails, use see() to visually confirm the result — visual confirmation is equally valid evidence
     - For visual state verification (active tabs, selected items, counts, colors), prefer see() over DOM-based verify()
@@ -693,6 +758,10 @@ export class Tester extends TaskAgent {
 
     ${formRequirementsRule}
 
+    ${capabilityGroundingRule}
+
+    ${dataProtectionRules}
+
     ${this.provider.getSystemPromptForAgent('tester', this.explorer.getStateManager().getCurrentState()?.url) || ''}
     `;
     }
@@ -714,10 +783,13 @@ export class Tester extends TaskAgent {
       Try to achieve as many goals as possible.
       If goal is not achievable, log that and skip to next one.
       Do not hallucinate that goal was achieved when it was not.
+      If the scenario action could not be completed, do not finish with a verification of the failure state.
       When creating or editing items via form() or type() you should include ${task.sessionName} in the value (if it is not restricted by the application logic)
       Initial page URL: ${actionResult.url}
 
-      ${protectionRule}
+      ${capabilityGroundingRule}
+
+      ${dataProtectionRules}
 
       ${this.buildDeletionScope(task)}
 
@@ -842,12 +914,13 @@ export class Tester extends TaskAgent {
             }),
             stop: tool({
                 description: dedent `
-          Stop the current test because the scenario is fundamentally incompatible with the page.
-          Use this ONLY when the scenario cannot be executed on the current page or application.
-          Do NOT use this for failures — use reset() and retry instead.
+          Stop the current test because it cannot be completed in the current session.
+          Use this when the scenario is incompatible, required UI/data is absent, or repeated varied attempts
+          show that automation cannot complete the workflow.
+          Do NOT use this immediately after the first failed action — retry with a materially different approach first.
         `,
                 inputSchema: z.object({
-                    reason: z.string().describe('Explanation why the scenario is incompatible'),
+                    reason: z.string().describe('Explanation why the scenario cannot be completed'),
                 }),
                 execute: async ({ reason }) => {
                     task.addNote(`Stop requested: ${reason}`);
@@ -881,6 +954,7 @@ export class Tester extends TaskAgent {
           Provide a specific assertion to verify the final state.
           The assertion MUST prove that YOUR ACTIONS changed the page state.
           Do NOT verify something that was already true before you started testing.
+          Do NOT provide an assertion that verifies absence, failure, an empty state, or that the goal did not happen.
 
           Examples of good assertions:
           - "New user 'john@example.com' is visible in the users list"
@@ -991,4 +1065,45 @@ 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.stalledIterations = 0;
+        }
+        else if (this.shouldStopAfterStalledLoopError(task)) {
+            return 'stop';
+        }
+        this.currentConversation?.addUserText(result.message);
+        return 'continue';
+    }
+    shouldStopAfterStalledLoopError(task) {
+        if (task.hasFinished)
+            return false;
+        this.stalledIterations++;
+        if (this.stalledIterations < this.MAX_STALLED_ITERATIONS)
+            return false;
+        task.addNote('No browser progress after repeated execution errors', TestResult.FAILED);
+        task.finish(TestResult.FAILED);
+        return true;
+    }
+    async cleanupStartedTest(task) {
+        await this.finishTest(task);
+        await this.explorer.stopTest(task, {
+            startUrl: task.startUrl,
+            style: task.style,
+            sessionName: task.sessionName,
+        });
+    }
 }