explorbot 0.3.0 → 0.3.2

package/dist/src/ai/tester.js

@@ -6,9 +6,9 @@ import { z } from 'zod';
 import { ActionResult } from "../action-result.js";
 import { clearActivity, setActivity } from "../activity.js";
 import { Observability } from "../observability.js";
+import { normalizeUrl } from "../state-manager.js";
 import { Stats } from "../stats.js";
 import { TestResult } from "../test-plan.js";
-import { detectFocusArea } from "../utils/aria.js";
 import { ErrorPageError, isErrorPage } from "../utils/error-page.js";
 import { createDebug, tag } from "../utils/logger.js";
 import { loop } from "../utils/loop.js";
@@ -78,7 +78,7 @@ export class Tester extends TaskAgent {
     }
     async test(task, opts = {}) {
         Stats.tests++;
-        const state = this.stateManager.getCurrentState();
+        let state = this.stateManager.getCurrentState();
         if (!state)
             throw new Error('No state found');
         setActivity(`🧪 Testing: ${task.scenario}`, 'action');
@@ -97,7 +97,23 @@ export class Tester extends TaskAgent {
         const offFailedRequest = requestStore.onFailedRequest((r) => {
             task.addObservation(`Network error: ${r.method} ${r.path} → ${r.status}`);
         });
-        const initialState = ActionResult.fromState(state);
+        let initialState = ActionResult.fromState(state);
+        const currentUrl = state.fullUrl || state.url;
+        let startOnCurrentPage = opts.startOnCurrentPage;
+        if (isErrorPage(initialState) && !startOnCurrentPage && task.startUrl && normalizeUrl(currentUrl) !== normalizeUrl(task.startUrl)) {
+            debugLog(`Recovering from error page at ${currentUrl} by navigating to ${task.startUrl}`);
+            try {
+                await this.explorer.visit(task.startUrl);
+                state = this.stateManager.getCurrentState();
+                if (!state)
+                    throw new Error('No state found after navigating to test start URL');
+                initialState = ActionResult.fromState(state);
+                startOnCurrentPage = true;
+            }
+            catch (error) {
+                debugLog(`Could not recover from error page: ${compactErrorMessage(error)}`);
+            }
+        }
         if (isErrorPage(initialState)) {
             task.start();
             this.testRun = await this.explorer.beginTest(task);
@@ -122,7 +138,7 @@ export class Tester extends TaskAgent {
                 startUrl: task.startUrl,
                 expected: task.expected,
             },
-        }, async () => this.runTestSession(task, initialState, conversation, { offFailedRequest }, opts));
+        }, async () => this.runTestSession(task, initialState, conversation, { offFailedRequest }, { ...opts, startOnCurrentPage }));
     }
     async runTestSession(task, initialState, conversation, handlers, opts) {
         const { offFailedRequest } = handlers;
@@ -421,7 +437,7 @@ export class Tester extends TaskAgent {
       <rules>
       Use tools ${this.ACTION_TOOLS.join(', ')} to interact with the page.
       Fall back to interact() when those fail, when the step needs a sequence of actions, or when your context is not enough to locate the element.
-      Use tool names exactly as listed in this prompt. Do not invent combined tool names, aliases, or names with channel markers such as "commentary".
+      Use tool names exactly as listed in this prompt. Do not invent combined tool names or aliases.
       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.
@@ -449,7 +465,7 @@ export class Tester extends TaskAgent {
         this.previousUrl = currentUrl;
         this.previousStateHash = currentStateHash;
         let context = '';
-        const focusArea = detectFocusArea(currentState.ariaSnapshot);
+        const focusArea = currentState.overlay;
         const focusedElement = currentState.focusedElement;
         if (focusedElement) {
             const isTextInput = ['textbox', 'combobox', 'searchbox'].includes(focusedElement.role);

package/dist/src/commands/exit-command.js

@@ -9,7 +9,7 @@ export class ExitCommand extends BaseCommand {
     aliases = ['quit'];
     async execute(_args) {
         await this.explorBot.printSessionAnalysis();
-        await this.explorBot.getExplorer().stop();
+        await this.explorBot.stop();
         if (Stats.hasActivity()) {
             await new Promise((resolve) => {
                 const { unmount } = render(React.createElement(StatusPane, {

package/dist/src/commands/explore-command.js

@@ -59,25 +59,30 @@ export class ExploreCommand extends BaseCommand {
             tag('warning').log(error.message);
             return;
         }
-        if (cfg.enabled) {
-            await this.runReuseMode(mainUrl, feature, cfg);
-        }
-        else {
-            await this.runFreshMode(mainUrl, feature, cfg.styles);
-        }
-        const mainPlan = this.completedPlans[0];
-        if (mainPlan)
-            this.explorBot.setCurrentPlan(mainPlan);
-        if (this.dryRun) {
+        try {
+            if (cfg.enabled) {
+                await this.runReuseMode(mainUrl, feature, cfg);
+            }
+            else {
+                await this.runFreshMode(mainUrl, feature, cfg.styles);
+            }
+            const mainPlan = this.completedPlans[0];
+            if (mainPlan)
+                this.explorBot.setCurrentPlan(mainPlan);
+            if (this.dryRun) {
+                this.printResults();
+                return;
+            }
+            if (mainUrl)
+                await this.explorBot.visit(mainUrl).catch((err) => tag('warning').log(`Could not return to ${mainUrl}: ${browserErrorMessage(err)}`));
+            const savedPath = this.explorBot.savePlans(this.completedPlans);
             this.printResults();
-            return;
+            this.printNextSteps(savedPath);
+        }
+        finally {
+            if (!this.dryRun)
+                await this.explorBot.printSessionAnalysis();
         }
-        if (mainUrl)
-            await this.explorBot.visit(mainUrl).catch((err) => tag('warning').log(`Could not return to ${mainUrl}: ${browserErrorMessage(err)}`));
-        const savedPath = this.explorBot.savePlans(this.completedPlans);
-        this.printResults();
-        await this.explorBot.printSessionAnalysis();
-        this.printNextSteps(savedPath);
     }
     originLabel(test) {
         return this.oldTestRefs.has(test) ? 'OLD' : 'NEW';

package/dist/src/config.d.ts

@@ -151,8 +151,9 @@ interface AIConfig {
     vision?: boolean;
     visionModel?: any;
     agenticModel?: any;
-    maxAttempts?: number;
+    retryAttempts?: number;
     retryDelay?: number;
+    maxParallelRequests?: number;
     agents?: AgentsConfig;
 }
 interface HtmlConfig {

package/dist/src/explorbot.js

@@ -114,6 +114,7 @@ export class ExplorBot {
     async stop() {
         this.agents.quartermaster?.stop();
         await this.explorer?.stop();
+        await this.provider?.stop();
     }
     async visitInitialState() {
         await this.visit(this.options.from || '/');

package/dist/src/state-manager.d.ts

@@ -1,6 +1,7 @@
 import { ActionResult, type FocusedElement } from './action-result.js';
 import type { ExperienceTracker } from './experience-tracker.js';
 import type { Knowledge, KnowledgeTracker } from './knowledge-tracker.js';
+import { Overlay } from './utils/overlay.js';
 export interface Link {
     title: string;
     url: string;
@@ -40,6 +41,7 @@ export interface WebPageState {
     focusedElement?: FocusedElement | null;
     links?: Link[];
     verifications?: Record<string, boolean>;
+    overlay?: Overlay;
 }
 export interface StateTransition {
     /** Previous state (null if this is the first state) */

package/dist/src/state-manager.js

@@ -1,6 +1,6 @@
 import { ActionResult } from './action-result.js';
-import { detectFocusArea } from './utils/aria.js';
 import { createDebug, tag } from './utils/logger.js';
+import { Overlay } from './utils/overlay.js';
 import { slugify } from './utils/strings.js';
 import { extractStatePath } from './utils/url-matcher.js';
 const debugLog = createDebug('explorbot:state');
@@ -114,8 +114,8 @@ export class StateManager {
         return newState;
     }
     hasDialogAppeared(previousState, newState) {
-        const prevFocus = detectFocusArea(previousState?.ariaSnapshot ?? null);
-        const newFocus = detectFocusArea(newState.ariaSnapshot ?? null);
+        const prevFocus = previousState?.overlay ?? Overlay.fromAria(previousState?.ariaSnapshot ?? null);
+        const newFocus = newState.overlay ?? Overlay.fromAria(newState.ariaSnapshot ?? null);
         return !prevFocus.detected && newFocus.detected;
     }
     /**

package/dist/src/utils/html.d.ts

@@ -14,7 +14,6 @@ export declare const HTML_SELECTORS: {
     readonly interactiveControl: "button, a[href], input, select, textarea, [role=\"button\"], [role=\"link\"], [role=\"checkbox\"], [role=\"radio\"], [role=\"switch\"], [role=\"tab\"], [role=\"menuitem\"]";
     readonly labelLike: "h1, h2, h3, h4, h5, h6, legend, caption, label, [role=\"heading\"], [class*=\"title\"], [class*=\"label\"], [class*=\"header\"], [class*=\"name\"]";
     readonly semanticContextContainer: "section, article, form, fieldset, li, tr, td, th, [role=\"group\"], [role=\"tabpanel\"], [role=\"region\"], [class*=\"card\"], [class*=\"panel\"], [class*=\"item\"], [class*=\"usage\"], [class*=\"group\"]";
-    readonly semanticOverlays: readonly ["[role=\"dialog\"]", "[role=\"listbox\"]", "[role=\"menu\"]", "[role=\"tooltip\"]:not([style*=\"display: none\"]):not([style*=\"visibility: hidden\"])"];
 };
 export declare const HTML_VISIBILITY_LIMITS: {
     readonly maxViewportOverlayRatio: 0.95;
@@ -67,7 +66,9 @@ export type VisibleOverlayExtractionConfig = {
     interactiveContentSelector: string;
     limits: typeof HTML_EXTRACTION_LIMITS;
     overlaySelectors: readonly string[];
+    overlaySemanticSelector: string;
     visibilityLimits: typeof HTML_VISIBILITY_LIMITS;
+    geometryFallback?: boolean;
 };
 export type ComponentScopeExtractionConfig = {
     eidxAttr: string;

package/dist/src/utils/html.js

@@ -79,7 +79,6 @@ export const HTML_SELECTORS = {
     interactiveControl: 'button, a[href], input, select, textarea, [role="button"], [role="link"], [role="checkbox"], [role="radio"], [role="switch"], [role="tab"], [role="menuitem"]',
     labelLike: 'h1, h2, h3, h4, h5, h6, legend, caption, label, [role="heading"], [class*="title"], [class*="label"], [class*="header"], [class*="name"]',
     semanticContextContainer: 'section, article, form, fieldset, li, tr, td, th, [role="group"], [role="tabpanel"], [role="region"], [class*="card"], [class*="panel"], [class*="item"], [class*="usage"], [class*="group"]',
-    semanticOverlays: ['[role="dialog"]', '[role="listbox"]', '[role="menu"]', '[role="tooltip"]:not([style*="display: none"]):not([style*="visibility: hidden"])'],
 };
 export const HTML_VISIBILITY_LIMITS = {
     maxViewportOverlayRatio: 0.95,
@@ -447,8 +446,12 @@ export function extractVisibleOverlayHtml(config) {
         const { interactiveCount, text } = getUsefulContent(element);
         return interactiveCount > 0 || text.length > 0;
     }
-    const overlays = [];
+    function isFloatingOverlay(element) {
+        const style = window.getComputedStyle(element);
+        return style.position === 'fixed' || style.position === 'absolute' || Number.parseInt(style.zIndex || '0', 10) > 0;
+    }
     const seen = new Set();
+    const collected = [];
     for (const selector of config.overlaySelectors) {
         for (const element of Array.from(document.querySelectorAll(selector))) {
             if (seen.has(element))
@@ -456,13 +459,16 @@ export function extractVisibleOverlayHtml(config) {
             seen.add(element);
             if (!isVisible(element))
                 continue;
+            if (!element.matches(config.overlaySemanticSelector) && !isFloatingOverlay(element))
+                continue;
             const { interactiveCount, text } = getUsefulContent(element);
             if (interactiveCount === 0 && text.length === 0)
                 continue;
-            overlays.push(element.outerHTML.slice(0, config.limits.overlayHtmlLength));
+            collected.push(element);
         }
     }
-    if (overlays.length === 0) {
+    const overlays = collected.filter((element) => !collected.some((other) => other !== element && element.contains(other))).map((element) => element.outerHTML.slice(0, config.limits.overlayHtmlLength));
+    if (overlays.length === 0 && config.geometryFallback !== false) {
         const floatingCandidates = Array.from(document.body.querySelectorAll('*'))
             .filter((element) => !seen.has(element) && isVisible(element) && isLikelyFloatingOverlay(element))
             .sort((left, right) => {

package/dist/src/utils/overlay.d.ts

@@ -0,0 +1,24 @@
+import { type VisibleOverlayExtractionConfig } from './html.js';
+export declare const OVERLAY_SELECTORS: {
+    readonly semanticOverlays: readonly ["[role=\"dialog\"]", "[role=\"listbox\"]", "[role=\"menu\"]", "[role=\"tooltip\"]:not([style*=\"display: none\"]):not([style*=\"visibility: hidden\"])", "[class*=\"modal\"]", "[class*=\"dialog\"]", "[class*=\"overlay\"]", "[class*=\"popup\"]", "[class*=\"drawer\"]", "[class*=\"lightbox\"]"];
+    readonly modalOverlays: readonly ["[role=\"dialog\"]", "[role=\"alertdialog\"]", "[aria-modal=\"true\"]", "[class*=\"modal\"]", "[class*=\"dialog\"]", "[class*=\"overlay\"]", "[class*=\"popup\"]", "[class*=\"drawer\"]", "[class*=\"lightbox\"]"];
+    readonly overlaySemanticSelector: "[role=\"dialog\"], [role=\"alertdialog\"], [aria-modal=\"true\"], [role=\"listbox\"], [role=\"menu\"], [role=\"tooltip\"]";
+};
+export type OverlayData = {
+    type?: 'dialog' | 'modal' | null;
+    name?: string | null;
+};
+export declare class Overlay {
+    readonly type: 'dialog' | 'modal' | null;
+    readonly name: string | null;
+    constructor(data?: OverlayData);
+    get detected(): boolean;
+    static fromHtml(html: string): Overlay;
+    static fromAria(snapshot: string | null): Overlay;
+    static resolve(data: {
+        overlayHtml?: string;
+        overlay?: OverlayData | null;
+        ariaSnapshot?: string | null;
+    }): Overlay;
+    static captureConfig(): VisibleOverlayExtractionConfig;
+}

package/dist/src/utils/overlay.js

@@ -0,0 +1,43 @@
+import { detectFocusArea } from './aria.js';
+import { HTML_EXTRACTION_LIMITS, HTML_SELECTORS, HTML_VISIBILITY_LIMITS, extractHeadings } from './html.js';
+export const OVERLAY_SELECTORS = {
+    semanticOverlays: ['[role="dialog"]', '[role="listbox"]', '[role="menu"]', '[role="tooltip"]:not([style*="display: none"]):not([style*="visibility: hidden"])', '[class*="modal"]', '[class*="dialog"]', '[class*="overlay"]', '[class*="popup"]', '[class*="drawer"]', '[class*="lightbox"]'],
+    modalOverlays: ['[role="dialog"]', '[role="alertdialog"]', '[aria-modal="true"]', '[class*="modal"]', '[class*="dialog"]', '[class*="overlay"]', '[class*="popup"]', '[class*="drawer"]', '[class*="lightbox"]'],
+    overlaySemanticSelector: '[role="dialog"], [role="alertdialog"], [aria-modal="true"], [role="listbox"], [role="menu"], [role="tooltip"]',
+};
+export class Overlay {
+    type;
+    name;
+    constructor(data = {}) {
+        this.type = data.type ?? null;
+        this.name = data.name ?? null;
+    }
+    get detected() {
+        return this.type !== null;
+    }
+    static fromHtml(html) {
+        const headings = extractHeadings(html);
+        const name = [headings.h1, headings.h2, headings.h3, headings.h4].filter(Boolean).join(' ');
+        return new Overlay({ type: 'modal', name: name || null });
+    }
+    static fromAria(snapshot) {
+        return new Overlay(detectFocusArea(snapshot));
+    }
+    static resolve(data) {
+        if (data.overlayHtml)
+            return Overlay.fromHtml(data.overlayHtml);
+        if (data.overlay)
+            return new Overlay(data.overlay);
+        return Overlay.fromAria(data.ariaSnapshot ?? null);
+    }
+    static captureConfig() {
+        return {
+            interactiveContentSelector: HTML_SELECTORS.interactiveContent,
+            limits: HTML_EXTRACTION_LIMITS,
+            overlaySelectors: OVERLAY_SELECTORS.modalOverlays,
+            overlaySemanticSelector: OVERLAY_SELECTORS.overlaySemanticSelector,
+            visibilityLimits: HTML_VISIBILITY_LIMITS,
+            geometryFallback: false,
+        };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "explorbot",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "CLI app built with React Ink, CodeceptJS, and Playwright",
   "license": "Elastic-2.0",
   "type": "module",

package/src/action-result.ts

@@ -7,6 +7,7 @@ import { TTLCache } from './utils/cache.ts';
 import { type HtmlDiffPart, type HtmlDiffResult, htmlDiff, liveRegionMessages } from './utils/html-diff.ts';
 import { extractHeadings, extractLinks, extractTargetedHtml, htmlCombinedSnapshot, htmlMinimalUISnapshot, htmlTextSnapshot, minifyHtml } from './utils/html.ts';
 import { createDebug } from './utils/logger.ts';
+import { Overlay } from './utils/overlay.ts';
 import { slugify } from './utils/strings.ts';
 import { extractStatePath, matchesUrl } from './utils/url-matcher.ts';
 
@@ -34,6 +35,7 @@ interface ActionResultData extends WebPageState {
   focusedElement?: FocusedElement | null;
   iframeURL?: string;
   links?: Link[];
+  overlayHtml?: string;
 }
 
 export interface PageDiff {
@@ -86,6 +88,7 @@ export class ActionResult implements ActionResultData {
   notes: string[] = [];
   public links: Link[] = [];
   public verifications?: Record<string, boolean>;
+  public overlay: Overlay = new Overlay();
 
   constructor(data: ActionResultData) {
     this.id = data.id;
@@ -131,6 +134,8 @@ export class ActionResult implements ActionResultData {
       this._ariaSnapshot = data.ariaSnapshot;
     }
 
+    this.overlay = Overlay.resolve(data);
+
     if (!this.fullUrl && this.url) {
       this.fullUrl = this.url;
     }

package/src/action.ts

@@ -11,8 +11,9 @@ import { Observability } from './observability.ts';
 import type { PlaywrightRecorder } from './playwright-recorder.ts';
 import type { StateManager } from './state-manager.js';
 import { browserErrorMessage, isFatalBrowserError, isNavigationTransitionError } from './utils/browser-errors.ts';
-import { captureHtmlForSnapshot, htmlCombinedSnapshot, minifyHtml } from './utils/html.js';
+import { captureHtmlForSnapshot, getVisibleOverlayHtmlExtractorSource, htmlCombinedSnapshot, minifyHtml } from './utils/html.js';
 import { createDebug, setStepSpanParent, tag } from './utils/logger.js';
+import { Overlay } from './utils/overlay.js';
 import { sleep, waitForPageReadiness } from './utils/page-readiness.ts';
 import { safeFilename } from './utils/strings.ts';
 import { codeceptJSSandbox, hasPlaywrightCommands, playwrightSandbox, sanitizeCodeBlock } from './utils/web-sandbox.ts';
@@ -144,11 +145,13 @@ class Action {
       let ariaSnapshot: string | null = null;
       let ariaSnapshotFile: string | undefined = undefined;
       let focusedElement: FocusedElement | null = null;
+      let overlayHtml = '';
 
       try {
         const page = this.playwrightHelper.page;
         ariaSnapshot = await page.locator('body').ariaSnapshot();
         focusedElement = await page.evaluate(readFocusedElement);
+        if (!frame) overlayHtml = await this.captureOverlayHtml();
       } catch (err) {
         debugLog('ARIA snapshot failed:', err instanceof Error ? `${err.message}\n${err.stack}` : err);
       }
@@ -177,6 +180,7 @@ class Action {
         ariaSnapshot,
         ariaSnapshotFile,
         focusedElement,
+        overlayHtml: overlayHtml || undefined,
         iframeURL: frame ? frame.url?.() || 'iframe' : undefined,
       });
       this.stateManager.updateState(result, codeBlock);
@@ -190,6 +194,16 @@ class Action {
     }
   }
 
+  private async captureOverlayHtml(): Promise<string> {
+    return this.playwrightHelper.page.evaluate(
+      ({ extractorSource, config }: { extractorSource: string; config: any }) => {
+        const extract = new Function(`return ${extractorSource}`)() as (config: any) => string;
+        return extract(config);
+      },
+      { extractorSource: getVisibleOverlayHtmlExtractorSource(), config: Overlay.captureConfig() }
+    );
+  }
+
   private async captureMainDocumentStatus(): Promise<number | undefined> {
     if (this.mainDocumentStatus) return this.mainDocumentStatus;
 

package/src/ai/conversation.ts

@@ -17,6 +17,8 @@ export function toolExecutionLabel(input: Record<string, any> | undefined): stri
   return input?.explanation || input?.assertion || input?.reason || input?.request || '';
 }
 
+export const NARRATION_TOOL = 'commentary';
+
 const AUTO_COMPACT_ARIA_CHANGES_CUTOFF = 500;
 const AUTO_COMPACT_TARGETED_HTML_CUTOFF = 500;
 
@@ -227,6 +229,7 @@ export class Conversation {
       if (!Array.isArray(message.content)) continue;
       for (const part of message.content) {
         if (part.type !== 'tool-result') continue;
+        if (part.toolName === NARRATION_TOOL) continue;
         executions.push(toToolExecution(part.toolName, toolCalls.get(part.toolCallId) || {}, part.output));
       }
     }

package/src/ai/driller.ts

@@ -22,6 +22,7 @@ import {
 } from '../utils/html.ts';
 import { createDebug, tag } from '../utils/logger.ts';
 import { loop, pause } from '../utils/loop.ts';
+import { OVERLAY_SELECTORS } from '../utils/overlay.ts';
 import { annotatePageElements } from '../utils/web-annotate.ts';
 import { eidxInContainer } from '../utils/web-eidx.ts';
 import { WebElement } from '../utils/web-element.ts';
@@ -682,7 +683,8 @@ export class Driller extends TaskAgent implements Agent {
           config: {
             interactiveContentSelector: HTML_SELECTORS.interactiveContent,
             limits: HTML_EXTRACTION_LIMITS,
-            overlaySelectors: HTML_SELECTORS.semanticOverlays,
+            overlaySelectors: OVERLAY_SELECTORS.semanticOverlays,
+            overlaySemanticSelector: OVERLAY_SELECTORS.overlaySemanticSelector,
             visibilityLimits: HTML_VISIBILITY_LIMITS,
           },
         }

package/src/ai/fisherman.ts

@@ -196,7 +196,7 @@ export class Fisherman implements Agent {
 
       AVAILABLE TOOLS:
       ${toolNames.join(', ')}.
-      Use tool names exactly as listed. Do not invent aliases, combined names, or names with channel markers such as "commentary".
+      Use tool names exactly as listed. Do not invent aliases or combined names.
       Match each tool input schema exactly. Do not invent parameter names or pass extra fields.
 
       WORKFLOW:

package/src/ai/pilot.ts

@@ -9,7 +9,7 @@ import type { PlaywrightRecorder } from '../playwright-recorder.ts';
 import type { StateManager } from '../state-manager.ts';
 import { Stats } from '../stats.ts';
 import { type Test, TestResult } from '../test-plan.ts';
-import { collectInteractiveNodes, detectFocusArea } from '../utils/aria.ts';
+import { collectInteractiveNodes } from '../utils/aria.ts';
 import { ErrorPageError } from '../utils/error-page.ts';
 import { createDebug, tag } from '../utils/logger.ts';
 
@@ -25,7 +25,8 @@ import { capabilityGroundingRule, dataProtectionRules } from './rules.ts';
 import { isInteractive } from './task-agent.ts';
 import { withdrawVisionTools } from './tools.ts';
 
-const CHECK_TOOLS = ['verify', 'see', 'research', 'context'];
+const CHECK_TOOLS = ['verify', 'see', 'research'];
+const EVIDENCE_TOOLS = ['verify', 'see'];
 const META_TOOLS = ['record', 'reset', 'stop', 'finish'];
 const PILOT_MESSAGE_LIMIT = 2;
 const PILOT_MESSAGE_MAX_LENGTH = 160;
@@ -326,6 +327,10 @@ export class Pilot implements Agent {
       overrides the others — weigh them together. Tester's record() notes are the LEAST reliable; always
       cross-check against actual actions and state. Visual screenshot analysis is strong for UI state
       (active tabs, visible counts, colors).
+      Judge every check by WHAT IT ESTABLISHES, never by the fact that it ran. A check that executed
+      successfully is failure evidence when its content negates the scenario goal — the goal's object
+      absent, the action not performed, the interaction impossible. "The check passed" and "the goal was
+      met" are different claims.
       If the final page clearly shows an equivalent success state in a different UI form, do not fail only
       because one narrow assertion targeted a specific badge, count, toast, or wording that the product
       represents differently.
@@ -574,8 +579,8 @@ export class Pilot implements Agent {
   }
 
   async settleExpectations(task: Test, finalState?: ActionResult): Promise<SettledExpectation[]> {
-    let image: string | null = null;
-    if (finalState?.screenshot && this.provider.hasVision()) image = `data:image/png;base64,${finalState.screenshot.toString('base64')}`;
+    let image: Buffer | null = null;
+    if (finalState?.screenshot && this.provider.hasVision()) image = finalState.screenshot;
 
     const decided = (text: string): 'passed' | 'failed' => {
       if (task.hasAchievedAny() && !task.getRemainingExpectations().includes(text)) return 'passed';
@@ -819,7 +824,7 @@ export class Pilot implements Agent {
     lines.push(`h3: ${state.h3 || ''}`);
     lines.push(`h4: ${state.h4 || ''}`);
 
-    const focusArea = detectFocusArea(state.ariaSnapshot);
+    const focusArea = state.overlay;
     if (focusArea.detected) {
       lines.push(`modal: ${focusArea.name || focusArea.type}`);
     } else {
@@ -995,20 +1000,20 @@ export class Pilot implements Agent {
 
   private hasSuccessfulCheckEvidence(currentState: ActionResult, testerConversation: Conversation): boolean {
     if (Object.values(currentState.verifications ?? {}).some(Boolean)) return true;
-    return testerConversation.getToolExecutions().some((t) => CHECK_TOOLS.includes(t.toolName) && t.wasSuccessful);
+    return testerConversation.getToolExecutions().some((t) => EVIDENCE_TOOLS.includes(t.toolName) && t.wasSuccessful);
   }
 
   private formatSuccessfulAssertions(currentState: ActionResult, testerConversation: Conversation): string {
     const lines: string[] = [];
     for (const [assertion, passed] of Object.entries(currentState.verifications ?? {})) {
-      if (passed) lines.push(`PASS state verification: ${assertion}`);
+      if (passed) lines.push(`state verification (passed): ${assertion}`);
     }
 
     for (const exec of testerConversation.getToolExecutions()) {
-      if (!CHECK_TOOLS.includes(exec.toolName) || !exec.wasSuccessful) continue;
+      if (!EVIDENCE_TOOLS.includes(exec.toolName) || !exec.wasSuccessful) continue;
       const description = exec.input?.assertion || exec.input?.request || truncateJson(exec.input);
       const result = exec.output?.message || exec.output?.analysis || exec.output?.result;
-      lines.push(`PASS ${exec.toolName}: ${description}${result ? ` -> ${result}` : ''}`);
+      lines.push(`CHECK ${exec.toolName} (executed successfully): ${description}${result ? ` -> ${result}` : ''}`);
     }
 
     return [...new Set(lines)].join('\n');
@@ -1137,7 +1142,7 @@ export class Pilot implements Agent {
 
       Tester tools: click, pressKey, form, see, verify, interact, context, research, xpathCheck,
       visualClick, back, getVisitedStates, reset, stop, finish, record.
-      Use tool names exactly as listed. Do not invent combined names, aliases, or names with channel markers such as "commentary".
+      Use tool names exactly as listed. Do not invent combined names or aliases.
 
       ${capabilityGroundingRule}