explorbot 0.3.1 → 0.3.4

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/docs/basics/providers.md

@@ -154,14 +154,12 @@ Set the recommended model in the exported config:
 ```javascript
 export default {
   ai: {
+    model: anthropic('claude-haiku-4-5-20251001'),
+    visionModel: anthropic('claude-haiku-4-5-20251001'),
     agenticModel: anthropic('claude-haiku-4-5-20251001'),
   },
 };
 ```
-
-> [!NOTE]
-> This provider currently doesn't serve `model` and `visionModel`, which is required for Explorbot to run at optimal cost and speed.
-> It is recommended to pair it with another AI provider.
 <!-- END provider:anthropic -->
 
 ### Azure OpenAI

package/models.json

@@ -18,6 +18,8 @@
     "agenticModel": "gpt-5.6-luna"
   },
   "anthropic": {
+    "model": "claude-haiku-4-5-20251001",
+    "visionModel": "claude-haiku-4-5-20251001",
     "agenticModel": "claude-haiku-4-5-20251001"
   },
   "mistral": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "explorbot",
-  "version": "0.3.1",
+  "version": "0.3.4",
   "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;
     }
@@ -545,17 +550,9 @@ export class ActionResult implements ActionResultData {
     }
 
     if (diff.htmlParts.length > 0) {
-      const htmlConfig = this.normalizeHtmlConfig();
-      const processedParts: HtmlDiffPart[] = [];
-      for (const part of diff.htmlParts) {
-        const filteredHtml = htmlCombinedSnapshot(part.subtree, htmlConfig?.combined);
-        const minified = await minifyHtml(filteredHtml);
-        if (minified) {
-          processedParts.push({ ...part, subtree: minified });
-        }
-      }
-      if (processedParts.length > 0) {
-        pageDiff.htmlParts = collapseHtmlParts(processedParts);
+      const collapsed = collapseHtmlParts(await diff.cleanedHtmlParts());
+      if (collapsed.length > 0) {
+        pageDiff.htmlParts = collapsed;
       }
     }
 
@@ -596,10 +593,12 @@ function collapseHtmlParts(parts: HtmlDiffPart[]): HtmlDiffPart[] {
   const fullPageReRender = total > HTML_PARTS_TOTAL_BUDGET || parts.length > HTML_PARTS_COUNT_LIMIT;
 
   if (fullPageReRender) {
-    return parts.map((part) => ({
-      ...part,
-      subtree: `<html><head></head><body>...collapsed (${part.subtree.length} chars, ${part.added.length} added, ${part.removed.length} removed)...</body></html>`,
-    }));
+    return parts
+      .filter((part) => part.added.length > 0 || part.removed.length > 0)
+      .map((part) => ({
+        ...part,
+        subtree: `<html><head></head><body>...collapsed (${part.subtree.length} chars, ${part.added.length} added, ${part.removed.length} removed)...</body></html>`,
+      }));
   }
 
   return parts.map((part) => {
@@ -655,6 +654,17 @@ export class Diff {
     return this._htmlDiffResult.parts;
   }
 
+  async cleanedHtmlParts(): Promise<HtmlDiffPart[]> {
+    const htmlConfig = ConfigParser.getInstance().getConfig().html;
+    const cleaned: HtmlDiffPart[] = [];
+    for (const part of this.htmlParts) {
+      const minified = await minifyHtml(htmlCombinedSnapshot(part.subtree, htmlConfig?.combined));
+      if (!minified) continue;
+      cleaned.push({ ...part, subtree: minified });
+    }
+    return cleaned;
+  }
+
   get ariaChanged(): string | null {
     return this._ariaDiffResult;
   }

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';
@@ -36,6 +37,7 @@ class Action {
   public playwrightHelper: any;
   public playwrightGroupId: string | null = null;
   public assertionSteps: Array<{ name: string; args: any[] }> = [];
+  public executedSteps: ExecutedStep[] = [];
   public lastValue: unknown;
   private recorder?: PlaywrightRecorder;
   private recovery: RecoveryRunner;
@@ -144,11 +146,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 +181,7 @@ class Action {
         ariaSnapshot,
         ariaSnapshotFile,
         focusedElement,
+        overlayHtml: overlayHtml || undefined,
         iframeURL: frame ? frame.url?.() || 'iframe' : undefined,
       });
       this.stateManager.updateState(result, codeBlock);
@@ -190,6 +195,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;
 
@@ -315,9 +330,9 @@ class Action {
 
     let codeString = code.replace(/^\(I\) => /, '').trim();
 
-    const executedSteps: string[] = [];
+    const executedSteps: ExecutedStep[] = [];
     const assertionSteps: Array<{ name: string; args: any[] }> = [];
-    const stepListener = attachStepLogger(executedSteps, assertionSteps);
+    const detachSteps = attachStepLogger(executedSteps, assertionSteps);
     const groupId = this.recorder ? await this.recorder.beginAction(codeString) : null;
     this.playwrightGroupId = groupId;
     const detachResponses = this.captureResponses();
@@ -346,12 +361,13 @@ class Action {
         await recorder.add(() => sleep(this.config.action?.delay || 500));
         await recorder.promise();
         this.lastValue = await returned;
+        if (!recorder.isRunning()) throw new Error('CodeceptJS recorder is stopped, commands were skipped and never reached the browser');
       }
 
       this.restorePageTimeout();
 
       if (executedSteps.length > 0) {
-        codeString = executedSteps.join('\n');
+        codeString = executedSteps.map((step) => step.command).join('\n');
       }
 
       const pageState = await this.captureOnce({ codeBlock: codeString });
@@ -368,10 +384,11 @@ class Action {
       this.assertionSteps = [];
       throw err;
     } finally {
+      this.executedSteps = executedSteps;
       this.restorePageTimeout();
       detachResponses();
       if (groupId) await this.recorder!.endAction();
-      detachStepLogger(stepListener);
+      detachSteps();
       if (stepSpan) {
         stepSpan.end();
       }
@@ -473,11 +490,13 @@ const ASSERTION_STEP_NAMES = new Set(['see', 'dontSee', 'seeElement', 'dontSeeEl
 
 type StepListener = (step: any, error?: any) => void;
 
-const attachStepLogger = (target: string[], assertionsTarget?: Array<{ name: string; args: any[] }>): StepListener => {
+export const attachStepLogger = (target: ExecutedStep[], assertionsTarget?: Array<{ name: string; args: any[] }>): (() => void) => {
   const listener: StepListener = (step, error) => {
     if (!step?.toCode) return;
     if (step.name?.startsWith('grab')) return;
-    target.push(step.toCode());
+    const executed: ExecutedStep = { command: step.toCode(), success: !error };
+    if (error) executed.error = errorToString(error);
+    target.push(executed);
     if (assertionsTarget && ASSERTION_STEP_NAMES.has(step.name)) {
       assertionsTarget.push({ name: step.name, args: step.args || [] });
     }
@@ -489,12 +508,10 @@ const attachStepLogger = (target: string[], assertionsTarget?: Array<{ name: str
   };
   codeceptjs.event.dispatcher.on(codeceptjs.event.step.passed, listener);
   codeceptjs.event.dispatcher.on(codeceptjs.event.step.failed, listener);
-  return listener;
-};
-
-const detachStepLogger = (listener: StepListener) => {
-  codeceptjs.event.dispatcher.off(codeceptjs.event.step.passed, listener);
-  codeceptjs.event.dispatcher.off(codeceptjs.event.step.failed, listener);
+  return () => {
+    codeceptjs.event.dispatcher.off(codeceptjs.event.step.passed, listener);
+    codeceptjs.event.dispatcher.off(codeceptjs.event.step.failed, listener);
+  };
 };
 
 const readFocusedElement = () => {
@@ -516,3 +533,9 @@ const readFocusedElement = () => {
   if (typeof value === 'string' && value) focused.value = value.slice(0, 200);
   return focused;
 };
+
+export interface ExecutedStep {
+  command: string;
+  success: boolean;
+  error?: string;
+}

package/src/ai/conversation.ts

@@ -5,12 +5,13 @@ export interface ToolExecution {
   input: any;
   output: any;
   wasSuccessful: boolean;
+  reasoning?: string;
 }
 
-export function toToolExecution(toolName: string, input: any, rawOutput: any): ToolExecution {
+export function toToolExecution(toolName: string, input: any, rawOutput: any, reasoning?: string): ToolExecution {
   let output = rawOutput;
   if (rawOutput?.type === 'json' && rawOutput?.value) output = rawOutput.value;
-  return { toolName, input, output, wasSuccessful: output?.success !== false };
+  return { toolName, input, output, wasSuccessful: output?.success !== false, reasoning };
 }
 
 export function toolExecutionLabel(input: Record<string, any> | undefined): string {
@@ -213,13 +214,17 @@ export class Conversation {
   }
 
   getToolExecutions(): ToolExecution[] {
-    const toolCalls = new Map<string, any>();
+    const toolCalls = new Map<string, { input: any; reasoning?: string }>();
     for (const message of this.messages) {
       if (message.role !== 'assistant') continue;
       if (!Array.isArray(message.content)) continue;
+      const reasoning = message.content
+        .filter((part: any) => part.type === 'reasoning' && part.text?.trim())
+        .map((part: any) => part.text.trim())
+        .join('\n');
       for (const part of message.content) {
         if (part.type !== 'tool-call') continue;
-        toolCalls.set(part.toolCallId, part.input);
+        toolCalls.set(part.toolCallId, { input: part.input, reasoning });
       }
     }
 
@@ -230,7 +235,8 @@ export class Conversation {
       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));
+        const call = toolCalls.get(part.toolCallId);
+        executions.push(toToolExecution(part.toolName, call?.input || {}, part.output, call?.reasoning));
       }
     }
 

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/navigator.ts

@@ -3,12 +3,13 @@ import dedent from 'dedent';
 import { z } from 'zod';
 import { ActionResult } from '../action-result.js';
 import type Action from '../action.ts';
+import type { ExecutedStep } from '../action.ts';
 import type { ExplorbotConfig } from '../config.ts';
 import type { ExperienceTracker } from '../experience-tracker.js';
 import Explorer from '../explorer.ts';
 import type { KnowledgeTracker } from '../knowledge-tracker.js';
-import { type StateManager, normalizeUrl } from '../state-manager.js';
 import { renderAssertion } from '../playwright-recorder.ts';
+import { type StateManager, normalizeUrl } from '../state-manager.js';
 import { isFatalBrowserError } from '../utils/browser-errors.ts';
 import { getCliName } from '../utils/cli-name.ts';
 import { extractCodeBlocks } from '../utils/code-extractor.js';
@@ -37,6 +38,7 @@ class Navigator implements Agent {
 
   private MAX_ATTEMPTS = Number.parseInt(process.env.MAX_ATTEMPTS || '5');
   lastFailureReason: string | null = null;
+  executedSteps: ExecutedStep[] = [];
 
   private systemPrompt = dedent`
   <role>
@@ -217,12 +219,18 @@ class Navigator implements Agent {
     if (!this.provider) throw new Error('AI-assisted recovery is unavailable: no AI model is configured.');
 
     this.lastFailureReason = null;
+    this.executedSteps = [];
     tag('info').log('AI Navigator resolving state at', actionResult.url);
     debugLog('Resolution message:', message);
 
     const action = opts?.action ?? this.explorer.action();
     const expectedUrl = opts?.expectedUrl;
 
+    if (expectedUrl && this.targetUrlReached(action, expectedUrl, actionResult)) {
+      tag('success').log(`Already at ${expectedUrl} — navigation resolved`);
+      return true;
+    }
+
     const knowledge = this.knowledgeTracker.renderRelevantContext(actionResult);
 
     const conversation = this.provider.startConversation(this.systemPrompt, 'navigator');
@@ -313,14 +321,19 @@ class Navigator implements Agent {
           resolved = check.urlMatches && freshHash !== actionResult.getStateHash();
 
           if (!resolved && attempt.ok) {
-            lastFailure = `URL did not change (still ${check.freshState.url})`;
+            if (check.urlMatches) {
+              lastFailure = `Reached ${check.freshState.url} but the page state did not change`;
+              tag('warning').log(`Page state did not change at ${check.freshState.url}`);
+            } else {
+              lastFailure = `Reached ${check.freshState.url}, expected ${expectedUrl}`;
+              tag('warning').log(`URL verification failed: expected ${expectedUrl}, got ${check.freshState.url}`);
+            }
             batchFailures.push({
               code: codeBlock,
               error: lastFailure,
               ariaChanges: await this.ariaDiff(check.freshState, prevActionResult),
               urlAfter: check.freshState.url,
             });
-            tag('warning').log(`URL verification failed: expected ${expectedUrl}, got ${check.freshState.url}`);
           }
           if (freshHash !== prevHash && (attempt.ok || check.urlMatches)) {
             progressBlocks.push(codeBlock);
@@ -456,6 +469,7 @@ class Navigator implements Agent {
 
     debugLog(`Attempting resolution: ${codeBlock}`);
     const ok = await action.attempt(codeBlock, message);
+    this.executedSteps.push(...action.executedSteps);
 
     const page = action.playwrightHelper?.page;
     if (page) {
@@ -484,11 +498,15 @@ class Navigator implements Agent {
     }
 
     const freshState = await this.explorer.capture();
-    const urlMatches = this.isSameExpectedOrigin(expectedUrl, action.stateManager) && matchesNavigationUrl(expectedUrl, this.comparableUrl(freshState, expectedUrl));
+    const urlMatches = this.targetUrlReached(action, expectedUrl, freshState);
 
     return { freshState, urlMatches };
   }
 
+  private targetUrlReached(action: Action, expectedUrl: string, state: ActionResult): boolean {
+    return this.isSameExpectedOrigin(expectedUrl, action.stateManager) && matchesNavigationUrl(expectedUrl, this.comparableUrl(state, expectedUrl));
+  }
+
   private async ariaDiff(freshState: ActionResult, previous: ActionResult): Promise<string | null> {
     if (freshState.getStateHash() === previous.getStateHash()) return null;
     try {

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';
 
@@ -28,6 +28,7 @@ import { withdrawVisionTools } from './tools.ts';
 const CHECK_TOOLS = ['verify', 'see', 'research'];
 const EVIDENCE_TOOLS = ['verify', 'see'];
 const META_TOOLS = ['record', 'reset', 'stop', 'finish'];
+const PILOT_REASONING_LIMIT = 500;
 const PILOT_MESSAGE_LIMIT = 2;
 const PILOT_MESSAGE_MAX_LENGTH = 160;
 
@@ -824,7 +825,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 {
@@ -1044,6 +1045,12 @@ export class Pilot implements Agent {
         if (resultMessage) line += `\n   result: ${resultMessage}`;
         if (errorDetail && errorDetail !== resultMessage) line += `\n   error: ${errorDetail}`;
 
+        if (!t.wasSuccessful && t.reasoning) {
+          let rationale = t.reasoning;
+          if (rationale.length > PILOT_REASONING_LIMIT) rationale = `...${rationale.slice(-PILOT_REASONING_LIMIT)}`;
+          line += `\n   tester reasoned: ${rationale.replace(/\n+/g, ' ')}`;
+        }
+
         const attempts = t.output?.attempts;
         if (attempts && attempts.length > 1 && t.wasSuccessful) {
           const failedBefore = attempts.filter((a: any) => !a.success);

package/src/ai/provider.ts

@@ -37,6 +37,15 @@ function createHarmonyChannelFallbackTool() {
 }
 
 let telemetryRegistered = false;
+let beforeExitFlushHooked = false;
+let activeOtelSdk: NodeSDK | null = null;
+
+export async function flushTelemetry(): Promise<void> {
+  const sdk = activeOtelSdk;
+  activeOtelSdk = null;
+  if (!sdk) return;
+  await sdk.shutdown().catch((error) => debugLog(`Telemetry flush failed: ${error instanceof Error ? error.message : error}`));
+}
 
 const CONTEXT_LENGTH_PATTERNS = ['reduce the length', 'context length', 'maximum context', 'token limit', 'too many tokens', 'max_tokens', 'context_length_exceeded', 'output truncated at maxtokens'];
 
@@ -117,6 +126,10 @@ export class Provider {
     }
   }
 
+  async stop(): Promise<void> {
+    await flushTelemetry();
+  }
+
   getModelForAgent(agentName?: string): any {
     if (!agentName) {
       return this.config.model;
@@ -270,7 +283,12 @@ export class Provider {
       spanProcessors: [processor],
       instrumentations: [],
     });
+    activeOtelSdk = this.otelSdk;
     void this.otelSdk.start();
+    if (!beforeExitFlushHooked) {
+      process.on('beforeExit', () => void flushTelemetry());
+      beforeExitFlushHooked = true;
+    }
     if (!telemetryRegistered) {
       registerTelemetry(new OpenTelemetry());
       telemetryRegistered = true;
@@ -324,7 +342,7 @@ export class Provider {
   async invokeConversation(conversation: Conversation, tools?: any, options: any = {}): Promise<{ conversation: Conversation; response: any; toolExecutions?: any[] } | null> {
     const response = tools ? await this.generateWithTools(conversation.messages, conversation.model, tools, options) : await this.chat(conversation.messages, conversation.model, options);
 
-    const responseMessages = response.response?.messages || [];
+    const responseMessages = response.responseMessages || [];
     if (responseMessages.length > 0) {
       conversation.messages.push(...responseMessages);
       tag('debug').log('Added', responseMessages.length, 'messages from response');

package/src/ai/researcher/deep-analysis.ts

@@ -5,10 +5,11 @@ import { executionController } from '../../execution-controller.ts';
 import type Explorer from '../../explorer.ts';
 import type { StateManager } from '../../state-manager.js';
 import { WebPageState } from '../../state-manager.js';
-import { detectFocusArea, diffAriaSnapshots } from '../../utils/aria.ts';
+import { diffAriaSnapshots } from '../../utils/aria.ts';
 import { extractCodeBlocks } from '../../utils/code-extractor.ts';
 import { tag } from '../../utils/logger.js';
 import { mdq } from '../../utils/markdown-query.ts';
+import { truncate } from '../../utils/strings.ts';
 import type { Provider } from '../provider.js';
 import { getCachedResearch, getPreviousResearch, saveResearch } from './cache.ts';
 import { type Constructor, debugLog } from './mixin.ts';
@@ -16,6 +17,7 @@ import { type ResearchElement, parseResearchSections } from './parser.ts';
 import type { ResearchResult } from './research-result.ts';
 
 const DEFAULT_MAX_EXPANDABLE_CLICKS = 10;
+const MAX_HTML_DIFF_CHARS = 20_000;
 
 export function WithDeepAnalysis<T extends Constructor>(Base: T) {
   return class extends Base {
@@ -86,7 +88,7 @@ export function WithDeepAnalysis<T extends Constructor>(Base: T) {
     }
 
     async researchOverlay(current: ActionResult, previous: ActionResult, pageStateHash: string): Promise<string | null> {
-      const focusArea = detectFocusArea(current.ariaSnapshot);
+      const focusArea = current.overlay;
       if (!focusArea.detected || !focusArea.name) return null;
       if (focusArea.type !== 'dialog' && focusArea.type !== 'modal') return null;
 
@@ -486,6 +488,9 @@ export function WithDeepAnalysis<T extends Constructor>(Base: T) {
         `;
       }
 
+      const cleanedParts = await diff.cleanedHtmlParts();
+      const htmlChanges = truncate(cleanedParts.map((p) => `[Container: ${p.container}]\n${p.subtree}`).join('\n\n'), MAX_HTML_DIFF_CHARS);
+
       const prompt = dedent`
         ${intro}
         Analyze the changes and produce a UI map section.
@@ -494,7 +499,7 @@ export function WithDeepAnalysis<T extends Constructor>(Base: T) {
         ${diff.ariaChanged || 'none'}
 
         HTML changes:
-        ${diff.htmlParts.map((p) => `[Container: ${p.container}]\n${p.subtree}`).join('\n\n') || 'none'}
+        ${htmlChanges || 'none'}
         ${alreadyHint}
 
         Respond with a SINGLE section in this format: