explorbot 0.3.2 → 0.3.4

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

@@ -1,15 +1,17 @@
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, extname, join, resolve } from 'node:path';
 import chalk from 'chalk';
-import dedent from 'dedent';
 import { ConfigParser, PROVIDERS } from "../config.js";
 import { findGlobalConfig, globalConfigPath, globalDir, globalEnvPath } from "../global-config.js";
 import { getCliName } from "../utils/cli-name.js";
 import { log, tag } from '../utils/logger.js';
 import { relativeToCwd } from "../utils/next-steps.js";
-function defaultConfigTemplate() {
+function defaultConfigTemplate(provider, esm) {
+    let moduleExport = 'module.exports = config;';
+    if (esm)
+        moduleExport = 'export default config;';
     return `// 'provider/model-id' uses a bundled provider.
-// It is also possible to import provider as a module from Vercel AI SDK.  
+// It is also possible to import provider as a module from Vercel AI SDK.
 // https://github.com/testomatio/explorbot/blob/main/docs/basics/providers.md
 
 const config = {
@@ -19,7 +21,7 @@ const config = {
   },
 
   ai: {
-${modelLines('openrouter')}
+${modelLines(provider)}
   },
 
   reporter: {
@@ -32,16 +34,17 @@ ${modelLines('openrouter')}
   },
 };
 
-export default config;
+${moduleExport}
 `;
 }
-const DEFAULT_ENV_TEMPLATE = dedent `
-# AI provider API keys
-OPENROUTER_API_KEY=
-
-# OPENAI_API_KEY=
-# ANTHROPIC_API_KEY=
-# GROQ_API_KEY=
+function envTemplate(provider) {
+    const keyLines = Object.entries(PROVIDERS).map(([name, { envKey }]) => {
+        if (name === provider)
+            return `${envKey}=`;
+        return `# ${envKey}=`;
+    });
+    return `# AI provider API keys
+${keyLines.join('\n')}
 
 # Langfuse Tracing
 LANGFUSE_SECRET_KEY=
@@ -49,10 +52,11 @@ LANGFUSE_PUBLIC_KEY=
 LANGFUSE_BASE_URL=
 
 # Testomat.io API key to publish run results
-TESTOMATIO=
-`;
+TESTOMATIO=`;
+}
 export async function runInit(options) {
-    if (options.global || options.provider) {
+    const localRequested = !!(options.configPath || options.path);
+    if (options.global || (options.provider && !localRequested)) {
         await runGlobalInit(options);
         return;
     }
@@ -61,8 +65,12 @@ export async function runInit(options) {
         return;
     }
     const choice = await renderInitWizard('choose');
-    if (choice === 'local')
-        runInitCommand(options);
+    if (choice !== 'local')
+        return;
+    const provider = await renderLocalProviderWizard();
+    if (!provider)
+        return;
+    runInitCommand({ ...options, provider });
 }
 export function writeGlobalConfig(provider, apiKey) {
     if (!PROVIDERS[provider]) {
@@ -87,7 +95,7 @@ export function writeGlobalConfig(provider, apiKey) {
     tag('substep').log(chalk.yellow(`${getCliName()} sites`));
 }
 export function runInitCommand(options) {
-    const configPath = options.configPath ?? './explorbot.config.js';
+    const provider = options.provider || 'openrouter';
     const force = options.force ?? false;
     const customPath = options.path;
     const originalCwd = process.cwd();
@@ -100,13 +108,15 @@ export function runInitCommand(options) {
         process.chdir(dir);
         log(`Working in directory: ${relativeToCwd(dir)}`);
     }
+    const configName = 'explorbot.config.js';
+    const configPath = options.configPath ?? `./${configName}`;
     try {
         let outPath = resolve(configPath);
         if (existsSync(outPath) && statSync(outPath).isDirectory()) {
-            outPath = join(outPath, 'explorbot.config.js');
+            outPath = join(outPath, configName);
         }
         else if (!extname(outPath)) {
-            outPath = join(outPath, 'explorbot.config.js');
+            outPath = join(outPath, configName);
         }
         const dir = dirname(outPath);
         if (!existsSync(dir)) {
@@ -118,23 +128,28 @@ export function runInitCommand(options) {
             log('Use --force to overwrite existing file');
             process.exit(1);
         }
-        writeFileSync(outPath, defaultConfigTemplate(), 'utf8');
+        const esm = extname(outPath) !== '.js' || isModuleProject(dirname(outPath));
+        writeFileSync(outPath, defaultConfigTemplate(provider, esm), 'utf8');
         log(`Created config file: ${relativeToCwd(outPath)}`);
         const envPath = resolve(process.cwd(), '.env');
         if (!existsSync(envPath)) {
-            writeFileSync(envPath, `${DEFAULT_ENV_TEMPLATE}\n`, 'utf8');
+            writeFileSync(envPath, `${envTemplate(provider)}\n`, 'utf8');
             log(`Created env file: ${relativeToCwd(envPath)}`);
         }
         else {
             log(`Env file already exists: ${relativeToCwd(envPath)}`);
         }
+        const missing = missingRoles(provider);
+        if (missing.length) {
+            tag('warning').log(`No recommended ${missing.join(' and ')} for ${provider} — set the model ids in ${relativeToCwd(outPath)}`);
+        }
         log('');
         log('Next steps:');
         log('1. Configure AI provider in .env');
         log('2. Set AI models config file');
         log('3. Set web application URL in the config file');
         log('4. Add initial knowledge (how to authorize to the application, etc.)');
-        tag('substep').log(chalk.yellow(`${getCliName()} learn * 'to aurhorize use these credentials: admin@example.com / secret123'`));
+        tag('substep').log(chalk.yellow(`${getCliName()} learn * 'to authorize use these credentials: admin@example.com / secret123'`));
         tag('substep').log('You can use ${env.LOGIN} and ${env.PASSWORD} to reference environment variables.');
         log('5. Launch application on a relative URL');
         tag('substep').log(chalk.yellow(`${getCliName()} start /dashboard`));
@@ -187,6 +202,23 @@ async function renderInitWizard(mode) {
         }), { exitOnCtrlC: false, patchConsole: false });
     });
 }
+async function renderLocalProviderWizard() {
+    const [{ render }, React, InitWizard] = await Promise.all([import('ink'), import('react'), import('../components/InitWizard.js').then((m) => m.default)]);
+    return new Promise((resolve) => {
+        const finish = (provider) => {
+            unmount();
+            resolve(provider);
+        };
+        const { unmount } = render(React.createElement(InitWizard, {
+            mode: 'local',
+            globalConfigExists: !!findGlobalConfig(),
+            onLocal: () => finish(null),
+            onComplete: () => finish(null),
+            onCancel: () => finish(null),
+            onLocalProvider: (provider) => finish(provider),
+        }), { exitOnCtrlC: false, patchConsole: false });
+    });
+}
 function modelLines(provider) {
     const recommended = ConfigParser.recommendedModels()[provider] || {};
     const roles = [
@@ -216,9 +248,27 @@ ${modelLines(provider)}
   },
 };
 
-export default config;
+module.exports = config;
 `;
 }
+function isModuleProject(configDir) {
+    let currentDir = resolve(configDir);
+    while (true) {
+        const packagePath = join(currentDir, 'package.json');
+        if (existsSync(packagePath)) {
+            try {
+                return JSON.parse(readFileSync(packagePath, 'utf8')).type === 'module';
+            }
+            catch {
+                return false;
+            }
+        }
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir)
+            return false;
+        currentDir = parentDir;
+    }
+}
 function missingRoles(provider) {
     const recommended = ConfigParser.recommendedModels()[provider] || {};
     return ['model', 'visionModel', 'agenticModel'].filter((role) => !recommended[role]);

package/dist/src/components/InitWizard.d.ts

@@ -1,10 +1,11 @@
 import React from 'react';
 interface InitWizardProps {
-    mode: 'choose' | 'global';
+    mode: 'choose' | 'global' | 'local';
     globalConfigExists: boolean;
     onLocal: () => void;
     onComplete: () => void;
     onCancel: () => void;
+    onLocalProvider?: (provider: string) => void;
 }
 declare const InitWizard: React.FC<InitWizardProps>;
 export default InitWizard;

package/dist/src/components/InitWizard.js

@@ -7,7 +7,7 @@ import { ConfigParser, PROVIDERS, createModel } from '../config.js';
 import { globalDir } from '../global-config.js';
 import InputReadline from './InputReadline.js';
 const PROVIDER_NAMES = Object.keys(PROVIDERS);
-const InitWizard = ({ mode, globalConfigExists, onLocal, onComplete, onCancel }) => {
+const InitWizard = ({ mode, globalConfigExists, onLocal, onComplete, onCancel, onLocalProvider }) => {
     const [step, setStep] = useState(mode === 'choose' ? 'target' : 'provider');
     const [targetIndex, setTargetIndex] = useState(0);
     const [providerIndex, setProviderIndex] = useState(0);
@@ -67,8 +67,12 @@ const InitWizard = ({ mode, globalConfigExists, onLocal, onComplete, onCancel })
                 setProviderIndex((index) => Math.max(0, index - 1));
             if (key.downArrow)
                 setProviderIndex((index) => Math.min(PROVIDER_NAMES.length - 1, index + 1));
-            if (key.return)
-                setStep('key');
+            if (key.return) {
+                if (mode === 'local')
+                    onLocalProvider?.(provider);
+                else
+                    setStep('key');
+            }
             return;
         }
         if (status)
@@ -121,7 +125,7 @@ const InitWizard = ({ mode, globalConfigExists, onLocal, onComplete, onCancel })
         React.createElement(Box, { marginTop: 1 },
             React.createElement(Text, { dimColor: true },
                 "Config goes to ",
-                globalDir(),
+                mode === 'local' ? 'the current directory' : globalDir(),
                 " | ",
                 step === 'key' ? 'Enter: continue' : '↑↓: select | Enter: confirm',
                 " | Ctrl+C: exit"))));

package/dist/src/explorer.js

@@ -203,6 +203,7 @@ class Explorer {
         const projectRoot = configParser.getProjectRoot();
         global.output_dir = configParser.getStatesDir();
         global.codecept_dir = projectRoot;
+        global.codeceptjs = codeceptjs;
         configParser.validateConfig(this.config);
         codeceptjs.container.create(this.convertToCodeceptConfig(this.config), {});
     }

package/dist/src/knowledge-tracker.d.ts

@@ -17,7 +17,9 @@ export declare class KnowledgeTracker {
     renderRelevantKnowledge(state: ActionResult): string;
     renderRelevantContext(state: ActionResult): string;
     renderApplicationSpec(state: ActionResult): string;
-    addKnowledge(urlPattern: string, description: string): {
+    addKnowledge(urlPattern: string, description: string, opts?: {
+        replace?: boolean;
+    }): {
         filename: string;
         filePath: string;
         isNewFile: boolean;

package/dist/src/knowledge-tracker.js

@@ -73,7 +73,7 @@ export class KnowledgeTracker {
     renderApplicationSpec(state) {
         return this.applicationSpec?.renderFor(state) || '';
     }
-    addKnowledge(urlPattern, description) {
+    addKnowledge(urlPattern, description, opts) {
         const configParser = ConfigParser.getInstance();
         const configPath = configParser.getConfigPath();
         if (!configPath) {
@@ -102,11 +102,11 @@ export class KnowledgeTracker {
             const existingDescription = parsed.content.trim();
             // Append new knowledge with separator
             let newContent;
-            if (existingDescription) {
-                newContent = `${existingDescription}\n\n---\n\n${description}`;
+            if (opts?.replace || !existingDescription) {
+                newContent = description;
             }
             else {
-                newContent = description;
+                newContent = `${existingDescription}\n\n---\n\n${description}`;
             }
             const fileContent = matter.stringify(newContent, frontmatter);
             writeFileSync(filePath, fileContent, 'utf8');

package/dist/src/utils/aria.js

@@ -569,7 +569,7 @@ export function parseAriaLocator(ariaStr) {
     const trimmed = ariaStr.trim();
     if (trimmed === '-' || trimmed === '' || trimmed === '"-"')
         return null;
-    const match = trimmed.match(/\{\s*["']?role["']?\s*:\s*['"]([^'"]+)['"]\s*,\s*["']?text["']?\s*:\s*['"]([^'"]*)['"]\s*\}/);
+    const match = trimmed.match(/\{\s*["']?role["']?\s*:\s*['"]([^'"]+)['"]\s*,\s*["']?(?:text|name)["']?\s*:\s*['"]([^'"]*)['"]\s*\}/);
     if (!match)
         return null;
     return { role: match[1], text: match[2] };

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.2",
+  "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

@@ -550,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;
       }
     }
 
@@ -601,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) => {
@@ -660,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

@@ -37,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;
@@ -329,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();
@@ -360,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 });
@@ -382,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();
       }
@@ -487,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 || [] });
     }
@@ -503,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 = () => {
@@ -530,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/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

@@ -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;
 
@@ -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);