explorbot 0.5.10 → 0.6.0

package/dist/src/ai/researcher.js

@@ -10,8 +10,10 @@ import { ErrorPageError, detectPageCondition } from "../utils/error-page.js";
 import { isBodyEmpty } from "../utils/html.js";
 import { createDebug, tag } from '../utils/logger.js';
 import { mdq } from "../utils/markdown-query.js";
+import { waitForDomChange, waitForPageReadiness } from "../utils/page-readiness.js";
 import { RulesLoader } from "../utils/rules-loader.js";
 import { annotatePageElements } from "../utils/web-annotate.js";
+import { UNDECIDED, pageEvidence } from "./judge.js";
 import { ContextLengthError } from './provider.js';
 import { findSimilarResearch, getCachedResearch, getPreviousResearch, reportResearch, saveResearch } from "./researcher/cache.js";
 import { WithCoordinates } from "./researcher/coordinates.js";
@@ -25,6 +27,7 @@ import { WithSections } from "./researcher/sections.js";
 import { locatorRule as generalLocatorRuleText } from './rules.js';
 import { TaskAgent } from "./task-agent.js";
 const debugLog = createDebug('explorbot:researcher');
+const HIDDEN_CONTENT_STATEMENT = 'The page has collapsed or hidden content behind controls that open or expand it.';
 export const POSSIBLE_SECTIONS = {
     overlay: 'dialog, modal, drawer, popup, or active form overlay',
     list: 'list area (items collection, table, cards, or list view)',
@@ -106,7 +109,9 @@ export class Researcher extends ResearcherBase {
             if (light)
                 tag('info').log('Light research: single pass, locator verification skipped');
             setActivity(`${this.emoji} Researching...`, 'action');
-            await this.ensureNavigated(displayUrl, screenshot && this.provider.hasVision());
+            const retrying = opts._retriesLeft !== undefined;
+            if (!retrying)
+                await this.ensureNavigated(displayUrl, screenshot && this.provider.hasVision());
             await this.hooksRunner.runBeforeHook('researcher', state.url);
             const { elements: annotatedElements } = await this.explorer.withPage(annotatePageElements);
             debugLog(`Annotated ${annotatedElements.length} interactive elements with eidx`);
@@ -116,7 +121,7 @@ export class Researcher extends ResearcherBase {
                 tag('warning').log(`Detected error page at ${state.url}`);
                 throw new ErrorPageError(state.url, this.actionResult.title, this.actionResult.httpStatus);
             }
-            if (condition === 'loading') {
+            if (condition === 'loading' && !retrying) {
                 const settled = await this.waitUntilSettled(screenshot);
                 if (!settled) {
                     tag('warning').log(`Page at ${state.url} did not finish loading within timeout, continuing with best-effort research`);
@@ -243,7 +248,7 @@ export class Researcher extends ResearcherBase {
                 if (fallback)
                     markSectionAsFocused(result, fallback);
             }
-            if (!interrupted() && deep) {
+            if (!interrupted() && deep && (await this.hasHiddenContent())) {
                 try {
                     await this.performDeepAnalysis(researchState, result);
                 }
@@ -307,34 +312,49 @@ export class Researcher extends ResearcherBase {
     }
     async waitUntilSettled(screenshot) {
         const errorPageTimeout = this.settings.errorPageTimeout ?? 10;
-        if (errorPageTimeout <= 0)
-            return false;
-        const includeScreenshot = screenshot && this.provider.hasVision();
-        try {
-            await this.explorer.withPage((page) => page.waitForLoadState('networkidle', { timeout: errorPageTimeout * 1000 }));
-        }
-        catch { }
-        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);
-        }
-        if (condition === 'ok')
-            return true;
-        for (let i = 0; i < 3; i++) {
-            await new Promise((r) => setTimeout(r, 1000));
+        const deadline = Date.now() + errorPageTimeout * 1000;
+        for (let remaining = errorPageTimeout * 1000; remaining > 0; remaining = deadline - Date.now()) {
+            const rendered = await this.explorer.withPage((page) => waitForPageReadiness(page, { timeout: remaining, spinnerSelectors: this.config.playwright.spinnerSelectors }));
             await this.explorer.withPage(annotatePageElements);
-            this.actionResult = await this.explorer.capture({ screenshot: includeScreenshot });
-            condition = detectPageCondition(this.actionResult);
-            if (condition === 'error') {
+            this.actionResult = await this.explorer.capture({ screenshot: screenshot && this.provider.hasVision() });
+            const condition = await this.pageCondition(rendered);
+            if (condition === 'error')
                 throw new ErrorPageError(this.actionResult.url, this.actionResult.title, this.actionResult.httpStatus);
-            }
             if (condition === 'ok')
                 return true;
+            tag('step').log('Page is still loading, waiting for content...');
+            if (!(await this.explorer.withPage((page) => waitForDomChange(page, deadline - Date.now()))))
+                return false;
         }
         return false;
     }
+    async pageCondition(rendered) {
+        const condition = detectPageCondition(this.actionResult);
+        if (condition !== 'loading')
+            return condition;
+        if (!this.judge && rendered)
+            return 'ok';
+        if (!this.judge)
+            return condition;
+        const conditions = {
+            'still loading: blank, splash screen, skeleton or loading placeholder': 'loading',
+            'error page: shows an error instead of the requested content': 'error',
+            'loaded: the main content is rendered': 'ok',
+        };
+        const decision = await this.judge.decide('The page was blank or barely rendered when it opened. What state is it in now?', [...Object.keys(conditions), UNDECIDED], pageEvidence(this.actionResult));
+        return conditions[decision.value ?? ''] || 'ok';
+    }
+    async hasHiddenContent() {
+        const captured = await this.explorer.capture({ screenshot: true });
+        const hidden = await this.provider.oracle(HIDDEN_CONTENT_STATEMENT, pageEvidence(captured), { agentName: 'researcher', screenshot: captured.screenshot, telemetry: { functionId: 'researcher.hasHiddenContent' } });
+        if (hidden === null) {
+            tag('warning').log('Could not check the page for hidden content, running deep analysis');
+            return true;
+        }
+        if (!hidden)
+            tag('step').log('Nothing to expand on this page, skipping deep analysis');
+        return hidden;
+    }
     getConfiguredSections() {
         const configSections = this.settings.sections;
         if (!configSections?.length)

package/dist/src/ai/rules.js

@@ -41,7 +41,7 @@ const locatorStrategyRule = dedent `
   3. Use ARIA snapshot to identify element state (focused, visible, selected, expanded, etc.)
   4. Match semantic proximity - elements near fields you just interacted with
 
-  Once the correct element is identified pick the best unique locator following priority: ARIA → CSS → XPath
+  Once the correct element is identified pick the best unique locator following priority: ARIA → text → CSS → XPath
   </disambiguation>
 
   ARIA locators must specify role. Specify locator type as JSON string with role and text keys.
@@ -97,7 +97,7 @@ const locatorStrategyRule = dedent `
   <xpath_rules>
   XPath locators must start with //.
   XPath may use positional indices [1], [2] and contains(., "text") as a last-resort disambiguator when attribute/text strategies are exhausted.
-  XPath should rely less on class names — prefer element hierarchy, position, and text content.
+  XPath should rely less on class names — prefer element hierarchy, attributes, and text content.
   XPath and CSS MUST provide different strategies for finding the same element.
   </xpath_rules>
 
@@ -114,7 +114,7 @@ const locatorStrategyRule = dedent `
 
   <bad locator example>
     'a.filter-tab:nth-of-type(1)' // WRONG: positional in CSS, use :has-text("Active") instead
-    '//a[contains(@class,"filter-tab") and contains(@class,"active")]' // WRONG: XPath repeats CSS approach, provide a different strategy e.g. //a[contains(@class,"filter-tab")][1]
+    '//a[contains(@class,"filter-tab") and contains(@class,"active")]' // WRONG: XPath repeats CSS approach, provide a different strategy e.g. //a[normalize-space()="Active"]
     '//table//tbody/tr[1]//button[contains(@onclick,'fn()')]' // onclick is not semantic attribute
     '//html/body/vue-button-123' // vue-framework specific locator
     'link "New Item"'  // WRONG: malformed string, use {"role":"link","text":"New Item"}
@@ -212,7 +212,7 @@ export const focusedElementRule = dedent `
   When a text input element is focused (textbox, combobox, contenteditable):
 
   To CLEAR the field before typing:
-  - I.pressKey(['Meta', 'a']);  // Select all (use 'Control' on Windows/Linux)
+  - I.pressKey(['CommandOrControl', 'a']);  // Select all
   - I.pressKey('Backspace');    // Delete selection
 
   To TYPE into the focused element:
@@ -402,8 +402,7 @@ export const actionRule = dedent `
     I.pressKey('Escape');          // Press Escape key
     I.pressKey('Tab');             // Press Tab key
     I.pressKey('Backspace');       // Press Backspace key
-    I.pressKey(['Control', 'a']); // Select all (Ctrl+A)
-    I.pressKey(['Meta', 'a']);    // Select all on Mac (Cmd+A)
+    I.pressKey(['CommandOrControl', 'a']); // Select all
     I.pressKey(['Shift', 'Tab']); // Shift+Tab to go back
     I.pressKey('ArrowDown');      // Navigate dropdown options
   </example>
@@ -500,7 +499,7 @@ export const actionRule = dedent `
     I.seeClipboardEquals('ABC-123');
   </example>
 
-  [DO NEVER USE OTHER CODECEPTJS COMMANDS THAN PROPOSED HERE]
+  [Prefer the commands listed here; use other CodeceptJS I.* commands when none of these fits]
   [INTERACT ONLY WITH ELEMENTS THAT ARE ON THE PAGE HTML]
   [DO NOT USE WAIT FUNCTIONS]
 

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

@@ -12,10 +12,20 @@ export declare class Scout implements Agent {
     runSession(corpus: ScoutCorpus, query: ScoutQuery): Promise<string | null>;
     buildSystemPrompt(toolNames: string[], corpus: ScoutCorpus, query: ScoutQuery, scanner: 'rg' | 'grep'): string;
     buildTaskPrompt(query: ScoutQuery): string;
+    saveDigest(query: ScoutQuery, digest: string): string;
+    digestPath(query: ScoutQuery): string;
+    loadCachedDigest(query: ScoutQuery): string | null;
 }
-export interface ScoutQuery {
+export declare class ScoutQuery {
     url?: string;
     title?: string;
     feature?: string;
-    excludeUrls: string[];
+    excludeUrls?: string[];
+    constructor(init?: Partial<ScoutQuery>);
+    static fromState(state: {
+        url?: string;
+        title?: string;
+    }): ScoutQuery;
+    get exclude(): string[] | undefined;
+    set exclude(value: string[] | undefined);
 }

package/dist/src/ai/scout.js

@@ -1,11 +1,18 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
 import dedent from 'dedent';
+import matter from 'gray-matter';
+import { outputPath } from "../config.js";
 import { tag } from "../utils/logger.js";
 import { loop } from "../utils/loop.js";
+import { sanitizeFilename } from "../utils/strings.js";
 import { createScoutTools, excludeCorpusUrls } from "./scout/tools.js";
 const MAX_ITERATIONS = 3;
 const MAX_TOOL_ROUNDTRIPS = 5;
 const CACHE_LIMIT = 40;
 const URL_LISTING_LIMIT = 40;
+const CACHE_TTL_MS = 6 * 60 * 60 * 1000;
 export class Scout {
     provider;
     corpus;
@@ -21,11 +28,18 @@ export class Scout {
     async collectDocs(query) {
         if (!this.isAvailable())
             return '';
-        const cacheKey = `${query.url || ''}|${query.feature || ''}|${query.excludeUrls.join(',')}`;
+        const cacheKey = `${query.url || ''}|${query.feature || ''}|${(query.excludeUrls || []).join(',')}`;
         const cached = this.cache.get(cacheKey);
         if (cached !== undefined)
             return cached;
-        const corpus = excludeCorpusUrls(this.corpus, query.excludeUrls);
+        const fileCached = this.loadCachedDigest(query);
+        if (fileCached !== null) {
+            if (this.cache.size > CACHE_LIMIT)
+                this.cache.clear();
+            this.cache.set(cacheKey, fileCached);
+            return fileCached;
+        }
+        const corpus = excludeCorpusUrls(this.corpus, query.excludeUrls || []);
         if (corpus.files.length === 0)
             return '';
         const result = await this.runSession(corpus, query);
@@ -76,9 +90,14 @@ export class Scout {
             return null;
         const digest = getResult();
         if (digest) {
-            const preview = digest.slice(0, 600);
-            const ellipsis = digest.length > 600 ? '…' : '';
-            tag('info').log(`Scout digest:\n${preview}${ellipsis}`);
+            const filePath = this.saveDigest(query, digest);
+            const words = digest.split(/\s+/).filter(Boolean).length;
+            tag('info').log(`Scout found relevant docs: ${words} words → ${filePath}`);
+            const lines = digest.split('\n').slice(0, 5).join('\n');
+            tag('substep').log(lines);
+        }
+        else {
+            tag('info').log(`Scout found no relevant docs for ${query.feature || query.url || 'the current page'}`);
         }
         return digest;
     }
@@ -114,7 +133,7 @@ export class Scout {
       ${pagesListing}
 
       These pages are already provided to the planner in full — do not re-report them:
-      ${query.excludeUrls.map((url) => `- ${url}`).join('\n') || '- none'}
+      ${(query.excludeUrls || []).map((url) => `- ${url}`).join('\n') || '- none'}
 
       AVAILABLE TOOLS:
       ${toolNames.join(', ')}.
@@ -129,12 +148,32 @@ export class Scout {
       2. Read the files whose hits look most relevant
       3. Report the digest as your final message — no tool call is needed to finish
 
-      RULES:
+      <rules>
       - Report only what the documentation states. Never fill gaps with assumptions about the application
       - Keep verified capabilities and unverified possibilities distinguishable, the way the documentation marks them
       - Name the page URL each item belongs to, so scenarios anchor to real routes
-      - Explore briefly: a few scans and reads are enough, then report
       - A short accurate digest beats a long loose one; reporting that nothing relevant exists is a valid answer
+      - For vague terms such as valid, supported, recent, all, or available, seek exact definitions and provide example of valid/invalid values.
+      - Follow relevant references for missing rules, shared policies, exceptions, and conflicting claims.
+      </rules>
+
+      Look for facts we need to collect for testing the related feature:
+
+      <facts>
+      - **Actors/access:** Find exact roles, permissions, ownership, scope, and denial behavior. Distinguish hidden, disabled, forbidden, and redirected.
+      - **Prerequisites:** Find required data, settings, integrations, plans, flags, and dependencies.
+      - **Actions/navigation:** Find entry points, available operations, destinations, confirmations, and cancellation behavior.
+      - **Inputs/validation:** Find accepted values, formats, defaults, required fields, exact limits/units, normalization, and error messages. Distinguish omitted, empty, whitespace, and unchanged.
+      - **Duplicates:** Find identity rules, uniqueness scope, and whether matches are rejected, reused, merged, or updated.
+      - **Conditions/states:** Find guards, exceptions, state transitions, prohibited actions, and intentional no-ops.
+      - **Outcomes:** Find visible feedback, persistent changes, side effects, and subsequent places where results appear.
+      - **Failures:** Find retained changes, rollback, partial success, recovery, and retry behavior. Never assume an error means nothing changed.
+      - **Async/time:** Find start versus completion, progress indicators, refresh behavior, delays, expiry, schedules, and retry limits.
+      - **Lists/bulk actions:** Find search/filter semantics, sorting, pagination, count definitions, selection scope, and skipped-item behavior.
+      - **Relationships/deletion:** Find inheritance, cascades, copy versus reference, unlink versus delete, restoration, and irreversible effects.
+      - **Files/integrations:** Find supported formats, mappings, processing limits, sync direction, overwrite precedence, and unavailable-service behavior.
+      - **Variants:** Find differences by role, plan, configuration, deployment, browser, or channel. Keep browser and API behavior separate.
+      </facts>
     `;
         const customPrompt = this.provider.getSystemPromptForAgent('scout');
         if (customPrompt)
@@ -150,7 +189,63 @@ export class Scout {
       Report the documented capabilities, states and transitions a test planner could turn into scenarios.
     `;
     }
+    saveDigest(query, digest) {
+        const filePath = this.digestPath(query);
+        const dir = outputPath('scout');
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        const frontmatter = {};
+        if (query.url)
+            frontmatter.url = query.url;
+        if (query.feature)
+            frontmatter.feature = query.feature;
+        if (query.excludeUrls?.length)
+            frontmatter.excludeUrls = query.excludeUrls;
+        frontmatter.cachedAt = new Date().toISOString();
+        const content = matter.stringify(digest, frontmatter);
+        writeFileSync(filePath, content, 'utf8');
+        tag('data').log('scout', { path: filePath, content: digest });
+        return filePath;
+    }
+    digestPath(query) {
+        const cacheKey = `${query.url || ''}|${query.feature || ''}|${(query.excludeUrls || []).join(',')}`;
+        const hash = createHash('sha1').update(cacheKey).digest('hex').slice(0, 8);
+        const raw = query.feature || query.url || 'general';
+        const name = sanitizeFilename(raw) || 'general';
+        return join(outputPath('scout'), `digest-${name}-${hash}.md`);
+    }
+    loadCachedDigest(query) {
+        const filePath = this.digestPath(query);
+        if (!existsSync(filePath))
+            return null;
+        if (Date.now() - statSync(filePath).mtimeMs > CACHE_TTL_MS)
+            return null;
+        const content = matter(readFileSync(filePath, 'utf8')).content;
+        const words = content.split(/\s+/).filter(Boolean).length;
+        tag('info').log(`Scout found previous spec digest in ${relative(process.cwd(), filePath)}`);
+        tag('multiline').log(content);
+        return content;
+    }
 }
 function toPosix(path) {
     return path.split('\\').join('/');
 }
+export class ScoutQuery {
+    url;
+    title;
+    feature;
+    excludeUrls;
+    constructor(init) {
+        if (init)
+            Object.assign(this, init);
+    }
+    static fromState(state) {
+        return new ScoutQuery({ url: state.url, title: state.title });
+    }
+    get exclude() {
+        return this.excludeUrls;
+    }
+    set exclude(value) {
+        this.excludeUrls = value;
+    }
+}

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

@@ -3,7 +3,6 @@ import type { RequestStore } from '../api/request-store.js';
 import type { TestRun } from '../explorer.js';
 import { type Test } from '../test-plan.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';
@@ -18,7 +17,7 @@ export declare class Tester extends TaskAgent implements Agent {
     testRun: TestRun | null;
     currentConversation: Conversation | null;
     pilot: Pilot | null;
-    captain: Captain | null;
+    supervisor: Supervisor | null;
     MAX_ITERATIONS: number;
     MAX_EXTENSIONS: number;
     ASSERTION_TOOLS: string[];
@@ -40,7 +39,7 @@ export declare class Tester extends TaskAgent implements Agent {
     constructor(deps: AgentDeps, researcher: Researcher, navigator: Navigator, agentTools?: any);
     getNavigator(): Navigator;
     setPilot(pilot: Pilot): void;
-    setCaptain(captain: Captain): void;
+    setSupervisor(supervisor: Supervisor): void;
     getCurrentState(): ActionResult;
     get progressCheckInterval(): number;
     getConversation(): Conversation | null;
@@ -65,7 +64,7 @@ export declare class Tester extends TaskAgent implements Agent {
     getDeletableSessionNames(task: Test): string[];
     buildAvailableFiles(): string;
     buildDeletionScope(task: Test): string;
-    createTestFlowTools(task: Test, currentState: ActionResult, conversation: Conversation): {
+    createTestFlowTools(task: Test, conversation: Conversation): {
         reset: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
             reason?: string;
         }, any, import("@ai-sdk/provider-utils").Context>>;
@@ -92,12 +91,17 @@ export declare class Tester extends TaskAgent implements Agent {
         }, import("@ai-sdk/provider-utils").Context>>;
     };
     handleLoopError(task: Test, error: unknown): Promise<'continue' | 'stop'>;
-    shouldStopAfterStalledLoopError(task: Test): boolean;
+    shouldStopAfterStall(task: Test, note: string): boolean;
     cleanupStartedTest(task: Test): Promise<void>;
 }
 interface TestSessionHandlers {
     offFailedRequest?: () => void;
 }
+export type Supervisor = (input: string, test: Test) => Promise<SupervisorAction>;
+export interface SupervisorAction {
+    action: 'inject' | 'stop' | 'pass' | 'skip';
+    message: string;
+}
 export interface TestOptions {
     startOnCurrentPage?: boolean;
     deadline?: number;

package/dist/src/ai/tester.js

@@ -9,10 +9,12 @@ import { Observability } from "../observability.js";
 import { normalizeUrl } from "../state-manager.js";
 import { Stats } from "../stats.js";
 import { TestResult } from "../test-plan.js";
-import { ErrorPageError, isErrorPage } from "../utils/error-page.js";
+import { ErrorPageError, TestStartBlockedError, isErrorPage } from "../utils/error-page.js";
 import { createDebug, tag } from "../utils/logger.js";
 import { loop } from "../utils/loop.js";
 import { compactErrorMessage } from "../utils/strings.js";
+import { isSamePageIgnoringQuery } from "../utils/url-matcher.js";
+import { pageEvidence } from "./judge.js";
 import { actionRule, capabilityGroundingRule, dataProtectionRules, focusedElementRule, formRequirementsRule, locatorRule, multipleTabsRule, sectionContextRule } from "./rules.js";
 import { TaskAgent } from "./task-agent.js";
 import { createCodeceptJSTools, createIframeTools, withdrawVisionTools } from "./tools.js";
@@ -36,7 +38,7 @@ export class Tester extends TaskAgent {
     testRun = null;
     currentConversation = null;
     pilot = null;
-    captain = null;
+    supervisor = null;
     MAX_ITERATIONS = 30;
     MAX_EXTENSIONS = 2;
     ASSERTION_TOOLS = ['verify'];
@@ -73,8 +75,8 @@ export class Tester extends TaskAgent {
     setPilot(pilot) {
         this.pilot = pilot;
     }
-    setCaptain(captain) {
-        this.captain = captain;
+    setSupervisor(supervisor) {
+        this.supervisor = supervisor;
     }
     getCurrentState() {
         return ActionResult.fromState(this.stateManager.getCurrentState());
@@ -102,7 +104,6 @@ export class Tester extends TaskAgent {
         this.previousRegionPresent = null;
         this.regionTransitioned = false;
         this.stateManager.clearHistory();
-        this.resetFailureCount();
         this.pilot?.reset();
         const requestStore = this.requestStore;
         requestStore.clear();
@@ -132,6 +133,11 @@ export class Tester extends TaskAgent {
             offFailedRequest?.();
             return await this.abortStartedTestOnErrorPage(task, initialState);
         }
+        const startEvidence = { ...pageEvidence(initialState), scenario: task.scenario, expected: task.expected, plannedSteps: task.plannedSteps, notes: task.notesToString() };
+        if ((await this.judge?.assert('This is the right page to start the test', startEvidence)) === false) {
+            offFailedRequest?.();
+            throw new TestStartBlockedError(task.scenario, task.startUrl, initialState.url || '');
+        }
         const conversation = this.provider.startConversation(this.getSystemMessage(), 'tester');
         conversation.markLastMessageCacheable();
         this.currentConversation = conversation;
@@ -225,7 +231,7 @@ export class Tester extends TaskAgent {
         let shouldContinue = true;
         while (shouldContinue) {
             shouldContinue = false;
-            await loop(async ({ stop, pause, iteration, userInput }) => {
+            await loop(async ({ stop, iteration, userInput }) => {
                 if (opts.deadline != null && Date.now() >= opts.deadline) {
                     deadlineReached = true;
                     task.addNote('Time budget reached. Stopped');
@@ -233,16 +239,10 @@ export class Tester extends TaskAgent {
                     return;
                 }
                 debugLog('iteration', iteration);
-                if (!(await this.explorer.recover()).ok) {
-                    task.addNote('Browser page is unavailable');
-                    task.finish(TestResult.FAILED);
-                    stop();
-                    return;
-                }
                 const currentState = this.getCurrentState();
                 const tools = {
                     ...codeceptjsTools,
-                    ...this.createTestFlowTools(task, currentState, conversation),
+                    ...this.createTestFlowTools(task, conversation),
                     ...this.agentTools,
                 };
                 if (currentState.isInsideIframe) {
@@ -275,7 +275,7 @@ export class Tester extends TaskAgent {
                 conversation.cleanupTag('page_ui_map_overlay', '...cleaned UI overlay...', 1);
                 conversation.compactToolResults(2);
                 if (iteration > 1) {
-                    const isNewPage = this.previousUrl !== null && this.previousUrl !== currentState.url;
+                    const isNewPage = this.previousUrl !== null && !isSamePageIgnoringQuery(this.previousUrl, currentState.url);
                     let nextStep = '';
                     nextStep += await this.reinjectContextIfNeeded(iteration, currentState);
                     nextStep += await this.prepareInstructionsForNextStep(task);
@@ -294,7 +294,6 @@ export class Tester extends TaskAgent {
                         }
                         if (guidance)
                             nextStep += `\n\n${guidance}`;
-                        this.consecutiveFailures = 0;
                         this.lastAnalyzedStateHash = currentState.hash;
                     }
                     conversation.addUserText(nextStep);
@@ -315,12 +314,6 @@ export class Tester extends TaskAgent {
                 const actionPerformed = !!allToolNames.find((toolName) => this.ACTION_TOOLS.includes(toolName));
                 assertionPerformed = !!successfulToolNames.find((toolName) => this.ASSERTION_TOOLS.includes(toolName));
                 const wasSuccessful = result?.toolExecutions?.every((execution) => execution.wasSuccessful);
-                this.trackToolExecutions(result?.toolExecutions || []);
-                if (this.consecutiveEmptyResults >= 5) {
-                    task.addNote('AI model is not responding with actions. Stopped');
-                    stop();
-                    return;
-                }
                 if (actionPerformed && !wasSuccessful) {
                     const noted = new Set(Object.values(task.notes).map((note) => note.message));
                     result?.toolExecutions
@@ -372,11 +365,11 @@ export class Tester extends TaskAgent {
             }, {
                 maxAttempts: this.MAX_ITERATIONS,
                 interruptPrompt: 'Test interrupted. Enter new instruction (or "stop" to cancel):',
-                onInterrupt: this.captain
+                onInterrupt: this.supervisor
                     ? async (userInput, context) => {
                         if (!userInput)
                             return;
-                        const result = await this.captain.processSupervisorInterrupt(userInput, task);
+                        const result = await this.supervisor(userInput, task);
                         tag('info').log(`🧑‍✈️ Supervisor: ${result.action} — ${result.message}`);
                         const terminalResults = {
                             stop: TestResult.FAILED,
@@ -450,11 +443,9 @@ export class Tester extends TaskAgent {
         return true;
     }
     get isStruggling() {
-        return this.consecutiveFailures >= 3 || this.consecutiveEmptyResults >= 2;
+        return this.stalledIterations >= this.MAX_STALLED_ITERATIONS - 1;
     }
     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.DELEGATED_ACTION_TOOLS, ...this.SPECIAL_CONTEXT_ACTION_TOOLS];
@@ -464,14 +455,7 @@ export class Tester extends TaskAgent {
             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 further browser progress on unchanged page; requesting final review');
-        return true;
+        return this.shouldStopAfterStall(task, 'No further browser progress on unchanged page; requesting final review');
     }
     async prepareInstructionsForNextStep(task) {
         let outcomeStatus = dedent `
@@ -871,9 +855,8 @@ export class Tester extends TaskAgent {
         }
         return '';
     }
-    createTestFlowTools(task, currentState, conversation) {
+    createTestFlowTools(task, conversation) {
         const resetUrl = task.startUrl;
-        const visitedUrls = task.getVisitedUrls();
         return {
             reset: tool({
                 description: dedent `
@@ -1070,8 +1053,6 @@ export class Tester extends TaskAgent {
                             task.finish(hasPassed ? TestResult.PASSED : TestResult.FAILED);
                         }
                     }
-                    const remainingExpectations = task.getRemainingExpectations();
-                    // const suggestion = input.status !== null && remainingExpectations.length > 0 ? `Continue testing to check the remaining expected outcomes: ${remainingExpectations.join(', ')}` : 'Continue with your testing strategy based on these findings.';
                     return {
                         success: true,
                         action: 'record',
@@ -1095,24 +1076,23 @@ export class Tester extends TaskAgent {
             return 'stop';
         }
         if (result.recovered) {
-            this.resetFailureCount();
             this.previousUrl = null;
             this.previousStateHash = null;
             this.stalledIterations = 0;
         }
-        else if (this.shouldStopAfterStalledLoopError(task)) {
+        else if (this.shouldStopAfterStall(task, 'No browser progress after repeated execution errors; requesting final review')) {
             return 'stop';
         }
         this.currentConversation?.addUserText(result.message);
         return 'continue';
     }
-    shouldStopAfterStalledLoopError(task) {
+    shouldStopAfterStall(task, note) {
         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; requesting final review');
+        task.addNote(note);
         return true;
     }
     async cleanupStartedTest(task) {