explorbot 0.5.10 → 0.6.0

package/dist/boat/api-tester/src/ai/curler.js

@@ -25,7 +25,7 @@ export class Curler {
         debugLog('Starting test:', test.scenario);
         this.requestState.clear();
         test.start();
-        await this.reporter.reportTestStart(test);
+        await this.reporter.reportTestStart();
         const conversation = this.provider.startConversation(this.buildSystemPrompt(), 'curler', this.provider.getAgenticModel('curler'));
         const tools = createCurlerTools(this.apiClient, this.requestState, test, opts?.searchSpec);
         const knowledge = test.startUrl && this.knowledgeTracker?.renderEndpointKnowledge(test.startUrl);

package/dist/boat/api-tester/src/cli.js

@@ -18,7 +18,7 @@ export function createApiCommands(name = 'api') {
         .option('--style <style>', 'Planning style: basename of a file in rules/chief/styles/')
         .option('--fresh', 'Start planning from scratch')
         .action(async (endpoint, options) => {
-        await run(name, options, endpoint, async (bot) => {
+        await run(options, endpoint, async (bot) => {
             const command = new PlanCommand(bot);
             command.prefix = name;
             command.style = options.style;
@@ -47,7 +47,7 @@ export function createApiCommands(name = 'api') {
     });
     RecommendedModelsCommand.register(cmd);
     addCommonOptions(cmd.command('test <planfile> [index]').description('Execute tests from a plan file. Index: 1, 1-3, *')).action(async (planfile, index, options) => {
-        await run(name, options, undefined, async (bot) => {
+        await run(options, undefined, async (bot) => {
             const command = new TestCommand(bot);
             command.index = index;
             await command.execute(planfile);
@@ -57,7 +57,7 @@ export function createApiCommands(name = 'api') {
         });
     });
     addCommonOptions(cmd.command('explore <endpoint>').description('Full cycle: plan, execute tests, re-plan. Use * to cover many endpoints, or the base endpoint for all of them')).action(async (endpoint, options) => {
-        await run(name, options, endpoint, async (bot) => {
+        await run(options, endpoint, async (bot) => {
             const command = new ExploreCommand(bot);
             await command.execute(endpoint);
             if (command.result.failed)
@@ -96,7 +96,7 @@ export function createApiCommands(name = 'api') {
     });
     return cmd;
 }
-async function run(name, options, endpoint, body) {
+async function run(options, endpoint, body) {
     setPreserveConsoleLogs(true);
     try {
         if (endpoint && URL.canParse(endpoint))

package/dist/models.json

@@ -3,7 +3,7 @@
     "model": "openai/gpt-oss-20b:nitro",
     "visionModel": "openai/gpt-5.6-luna",
     "agenticModel": "anthropic/claude-haiku-5.5",
-    "decisionModel": "typesafe/jev-latest"
+    "decisionModel": "~typesafe/jev-latest"
   },
   "poolside": {
     "model": "poolside/laguna-xs-2.1"

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "explorbot",
-  "version": "0.5.10",
+  "version": "0.6.0",
   "description": "CLI app built with React Ink, CodeceptJS, and Playwright",
   "license": "Elastic-2.0",
   "type": "module",
@@ -131,6 +131,7 @@
     "sambanova-ai-provider": "^1.2.2",
     "strip-ansi": "^7.1.2",
     "turndown": "^7.2.1",
+    "wrap-ansi": "^9.0.2",
     "unique-names-generator": "^4.7.1",
     "yaml": "^2.8.3",
     "yargs": "^17.7.2",

package/dist/rules/navigator/output.md

@@ -65,14 +65,8 @@ Trying to fill the form on the page
 ```
 
 ```js
-  I.fillField('/html/body/div/div/div/form/input[@name="name"]', 'Value');
+  I.fillField('//html/body//form//input[@name="name"]', 'Value');
 ```
 </example_output>
 
-If you don't know the answer, answer as:
-
-<example_output>
-```js
-  throw new Error('No resolution');
-```
-</example_output>
+If no solution is possible, call stop() with the reason instead of proposing code.

package/dist/rules/navigator/verification-actions.md

@@ -26,6 +26,10 @@ Prefer ARIA locators for reliable element detection.
   I.seeElement('.success-message');
 </example>
 
+To assert text inside element via `has-text` CSS, prefer using I.see() instead:
+
+Prefer `I.see('Collection', '.users')` over `I.seeElement(".users div:has-text("Collection")")` 
+
 ### I.seeInField
 
 I.seeInField(<locator>, <value>, <context>)
@@ -141,8 +145,8 @@ NEVER use `:has-text(...)` inside a seeElement/dontSeeElement locator. Checking
 NEVER emit two assertions that check the same fact with different shapes. `I.see(text, locator)` and `I.seeElement("<locator>:has-text('text')")` verify the same thing — pick one (prefer I.see). One claim, one assertion.
 </verification_rules>
 
-[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 OR ARIA SNAPSHOT]
 [DO NOT USE WAIT FUNCTIONS]
 
-</actions>
+</actions>

package/dist/rules/planner/ignored-pages.md

@@ -3,4 +3,5 @@ Do not plan tests for these pages, return an empty scenarios list:
 - sign in
 - sign up
 - password recovery
+If the page shows a sign-in form instead of the content its URL is for, also set prerequisite.
 </ignored_pages>

package/dist/src/action-result.js

@@ -615,7 +615,7 @@ export class Diff {
     async calculate() {
         if (!this.previous)
             return;
-        this._htmlDiffResult = await htmlDiff(this.previous.html, this.current.html, ConfigParser.getInstance().getConfig().html);
+        this._htmlDiffResult = await htmlDiff(this.previous.html, this.current.html);
         if (!this._isSameUrl) {
             this._messages = liveRegionMessages(this.previous.html, this.current.html);
             return;

package/dist/src/action.d.ts

@@ -7,7 +7,6 @@ declare class Action {
     stateManager: StateManager;
     actionResult: ActionResult | null;
     config: ExplorbotConfig;
-    action: string | null;
     lastError: Error | null;
     playwrightHelper: any;
     playwrightGroupId: string | null;

package/dist/src/action.js

@@ -27,8 +27,6 @@ class Action {
     stateManager;
     actionResult = null;
     config;
-    // action info
-    action = null;
     lastError = null;
     playwrightHelper;
     playwrightGroupId = null;
@@ -366,7 +364,6 @@ class Action {
         }
     }
     async executeOnce(code, verbatim = false) {
-        let error = null;
         setActivity('🔎 Browsing...', 'action');
         let codeString = code.replace(/^\(I\) => /, '').trim();
         const executedSteps = [];
@@ -410,7 +407,6 @@ class Action {
         }
         catch (err) {
             debugLog('Action error', errorToString(err));
-            error = err;
             if (!isPlaywright) {
                 await recorder.reset();
                 await recorder.start();

package/dist/src/ai/captain/idle-mode.js

@@ -3,7 +3,9 @@ import { createBashTool } from 'bash-tool';
 import dedent from 'dedent';
 import { z } from 'zod';
 import { ConfigParser } from "../../config.js";
-import { Test } from "../../test-plan.js";
+import { Plan, Test } from "../../test-plan.js";
+import { getStyles } from "../planner/styles.js";
+import { PlanningBlockedError } from "../../utils/error-page.js";
 import { listRecentArtifacts, readCaptainFile } from "./file-tools.js";
 import { resolveProjectRoot } from "./mixin.js";
 let cachedBashTool = null;
@@ -32,44 +34,58 @@ export function WithIdleMode(Base) {
                 });
             }
             const tools = {
-                updatePlan: tool({
-                    description: 'Update the current plan by replacing or appending tests',
+                plan: tool({
+                    description: dedent `
+            Plan tests for the current page. Adds them to the current plan when it is for this page, otherwise starts a new plan.
+            Without tests, the Planner writes the tests. With tests, exactly those tests are added and the Planner does not run: use it for tests the user dictates.
+            Returns how many tests were added, or why planning failed.
+          `,
                     inputSchema: z.object({
-                        action: z.enum(['replace', 'append']).optional().describe('replace clears existing tests, append keeps them'),
-                        title: z.string().optional().describe('New plan title'),
+                        feature: z.string().optional().describe('Focus area for the Planner'),
+                        style: z
+                            .enum(Object.keys(getStyles()))
+                            .optional()
+                            .describe('Planning style for the Planner; omit to let it choose'),
                         tests: z
                             .array(z.object({
                             scenario: z.string(),
                             priority: z.enum(['critical', 'important', 'high', 'normal', 'low']).optional(),
                             expected: z.array(z.string()).optional(),
                         }))
-                            .optional(),
+                            .optional()
+                            .describe('Tests to add as written, without running the Planner'),
+                        replace: z.boolean().optional().describe('Remove the tests already in this page plan first'),
+                        title: z.string().optional().describe('New plan title'),
                     }),
-                    execute: async ({ action, title, tests }) => {
+                    execute: async ({ feature, style, tests, replace, title }) => {
+                        if (ctx.blocker instanceof PlanningBlockedError) {
+                            feature = ctx.blocker.feature;
+                            style = ctx.blocker.style;
+                        }
+                        const url = ctx.explorBot.stateManager().getCurrentState()?.url || '';
                         let plan = ctx.explorBot.getCurrentPlan();
-                        if (!plan) {
-                            plan = await ctx.explorBot.plan();
+                        if (plan?.url && plan.url !== url)
+                            plan = undefined;
+                        if (replace)
+                            plan?.tests.splice(0);
+                        const before = new Set(plan?.tests ?? []);
+                        if (!tests?.length) {
+                            plan = await ctx.explorBot.plan(feature, { style });
+                            const error = ctx.explorBot.lastPlanError;
+                            if (error)
+                                return { success: false, message: error.message };
                         }
                         if (!plan) {
-                            return { success: false, message: 'Plan unavailable' };
-                        }
-                        if (title) {
-                            plan.title = title;
+                            plan = new Plan(url);
+                            ctx.explorBot.setCurrentPlan(plan);
                         }
-                        if (tests?.length) {
-                            if (!action || action === 'replace') {
-                                plan.tests.length = 0;
-                            }
-                            const currentUrl = ctx.explorBot.stateManager().getCurrentState()?.url || '';
-                            for (const testInput of tests) {
-                                const priority = testInput.priority || 'normal';
-                                const expected = testInput.expected?.length ? testInput.expected : [];
-                                const test = new Test(testInput.scenario, priority, expected, currentUrl);
-                                plan.addTest(test);
-                            }
+                        for (const t of tests ?? []) {
+                            plan.addTest(new Test(t.scenario, t.priority || 'normal', t.expected ?? [], url));
                         }
+                        if (title)
+                            plan.title = title;
                         plan.updateStatus();
-                        return { success: true, tests: plan.tests.length };
+                        return { success: true, testsAdded: plan.tests.filter((t) => !before.has(t)).length, tests: plan.tests.length };
                     },
                 }),
                 project: tool({
@@ -132,7 +148,7 @@ export function WithIdleMode(Base) {
             const outputDir = config.dirs?.output || 'output';
             return dedent `
         <idle_capabilities>
-        - Plan management: updatePlan() — replace or append tests in the current plan
+        - Plan management: plan() — run the Planner on the current page, or add tests you write yourself
         - readFile() — read specific report, plan, log, generated test, knowledge, or experience file content
         - bash() — discover files and inspect file metadata
           - READ from: ${knowledgeDir}/, ${experienceDir}/, ${outputDir}/

package/dist/src/ai/captain/mixin.d.ts

@@ -1,10 +1,12 @@
 import type { ExplorBot } from '../../explorbot.js';
 import type { Task } from '../../test-plan.js';
+import type { BlockedError } from '../../utils/error-page.js';
 export type Constructor<T = object> = new (...args: any[]) => T;
 export declare const debugLog: (...args: any[]) => void;
 export type CaptainMode = 'idle' | 'web' | 'test' | 'heal';
 export interface ModeContext {
     explorBot: ExplorBot;
     task: Task;
+    blocker: BlockedError | null;
 }
 export declare function resolveProjectRoot(): string | null;

package/dist/src/ai/captain/web-mode.js

@@ -1,6 +1,7 @@
 import { tool } from 'ai';
 import dedent from 'dedent';
 import { z } from 'zod';
+import { pageEvidence } from "../judge.js";
 import { actionRule, locatorRule, sectionContextRule } from "../rules.js";
 import { createAgentTools, createCodeceptJSTools } from "../tools.js";
 import { debugLog } from "./mixin.js";
@@ -35,6 +36,15 @@ export function WithWebMode(Base) {
                         }
                     },
                 }),
+                oracle: tool({
+                    description: 'Ask a yes/no question about the current page. Much cheaper than see or context.',
+                    inputSchema: z.object({ question: z.string() }),
+                    execute: async ({ question }) => {
+                        const captured = await ctx.explorBot.getExplorer().capture({ screenshot: true });
+                        const holds = await ctx.explorBot.getProvider().oracle(question, pageEvidence(captured), { agentName: 'captain', screenshot: captured.screenshot, telemetry: { functionId: 'captain.oracle' } });
+                        return { success: holds !== null, question, answer: holds };
+                    },
+                }),
                 browser: tool({
                     description: dedent `
             Direct browser access via Playwright. Use for diagnostics and browser management.
@@ -146,6 +156,7 @@ export function WithWebMode(Base) {
         - click() accepts array of commands to try in order — include ARIA, CSS, XPath variants
         - If click() fails with all provided commands, use visualClick() tool as fallback
         - When an action fails or result is unexpected, investigate or inform the user instead of retrying silently
+        - For a quick yes/no question about the page, use oracle instead of see or context
       `;
         }
     };

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

@@ -2,6 +2,7 @@ import type { ExperienceTracker } from '../experience-tracker.js';
 import type { ExplorBot } from '../explorbot.js';
 import type { WebPageState } from '../state-manager.js';
 import { Task, Test } from '../test-plan.js';
+import { BlockedError } from '../utils/error-page.js';
 import { HooksRunner } from '../utils/hooks-runner.js';
 import type { Agent } from './agent.js';
 import { type CaptainMode, type ModeContext } from './captain/mixin.js';
@@ -9,6 +10,7 @@ import { type Conversation } from './conversation.js';
 import type { Navigator } from './navigator.js';
 import type { Provider } from './provider.js';
 import { TaskAgent } from './task-agent.js';
+import type { SupervisorAction } from './tester.js';
 declare const CaptainBase: {
     new (...args: any[]): {
         testModeTools(ctx: ModeContext): Record<string, any>;
@@ -39,6 +41,9 @@ export declare class Captain extends CaptainBase implements Agent {
         description: string;
         options: string;
     }[];
+    unresolvedBlockers: Set<string>;
+    handling: boolean;
+    blocker: BlockedError | null;
     constructor(explorBot: ExplorBot);
     setCommandExecutor(fn: (cmd: string) => Promise<void>, descriptions: {
         name: string;
@@ -148,12 +153,9 @@ export declare class Captain extends CaptainBase implements Agent {
     handle(input: string, options?: {
         reset?: boolean;
     }): Promise<string | null>;
+    resolveBlocker(error: unknown, resolved: () => boolean | Promise<boolean>): Promise<boolean>;
 }
 export default Captain;
-interface SupervisorAction {
-    action: 'inject' | 'stop' | 'pass' | 'skip';
-    message: string;
-}
 interface ExecutionRecoveryAction {
     action: 'continue' | 'stop';
     message: string;

package/dist/src/ai/captain.js

@@ -4,6 +4,7 @@ import { z } from 'zod';
 import { ActionResult } from '../action-result.js';
 import { Task } from "../test-plan.js";
 import { formatHeadings } from "../utils/context-formatter.js";
+import { BlockedError } from "../utils/error-page.js";
 import { HooksRunner } from "../utils/hooks-runner.js";
 import { startLogCapture, stopLogCapture, tag } from '../utils/logger.js';
 import { loop } from '../utils/loop.js';
@@ -26,6 +27,9 @@ export class Captain extends CaptainBase {
     hooksRunner = null;
     commandExecutor = null;
     commandDescriptions = [];
+    unresolvedBlockers = new Set();
+    handling = false;
+    blocker = null;
     constructor(explorBot) {
         super();
         this.explorBot = explorBot;
@@ -106,6 +110,7 @@ export class Captain extends CaptainBase {
     - After a successful action, if the pageDiff confirms the goal, call done() immediately — do not verify with see() or context() unless the user explicitly asked for verification
     - Prefer completing in fewer tool calls over thoroughness
     - NEVER run tests unless the user explicitly asks
+    - When an agent reports it is blocked, decide which agent can resolve it and delegate to that agent
     - If you are answering with information rather than completing a browser action, include the actual user-facing answer in done({ details }). Do not only say that it was shown or explained.
     ${mode === 'web' || mode === 'heal' ? this.webModeRules() : ''}
     ${mode === 'test' || mode === 'heal' ? this.testModeRules() : ''}
@@ -281,7 +286,7 @@ export class Captain extends CaptainBase {
     }
     async tools(task, onDone) {
         const mode = this.getMode();
-        const ctx = { explorBot: this.explorBot, task };
+        const ctx = { explorBot: this.explorBot, task, blocker: this.blocker };
         const core = this.coreTools(task, onDone);
         const idle = await this.idleModeTools(ctx);
         if (mode === 'heal')
@@ -393,6 +398,7 @@ export class Captain extends CaptainBase {
     Execute the request using available tools. After a successful action, check the pageDiff — if it confirms the goal, call done() immediately.
     `;
         conversation.addUserText(initialPrompt);
+        this.handling = true;
         await loop(async ({ stop, iteration, userInput }) => {
             debugLog(`Captain iteration ${iteration}`);
             if (isDone) {
@@ -452,6 +458,8 @@ export class Captain extends CaptainBase {
                 tag('error').log(`Captain error: ${error}`);
                 stop();
             },
+        }).finally(() => {
+            this.handling = false;
         });
         const finalUrl = stateManager.getCurrentState()?.url || startUrl;
         await this.getHooksRunner().runAfterHook('captain', finalUrl);
@@ -463,6 +471,22 @@ export class Captain extends CaptainBase {
         }
         return null;
     }
+    async resolveBlocker(error, resolved) {
+        if (!(error instanceof BlockedError) || this.handling)
+            return false;
+        const key = `${error.name} ${error.url} ${error.blocker}`;
+        if (this.unresolvedBlockers.has(key))
+            return false;
+        tag('info').log(`Captain takes over: ${error.message}`);
+        this.blocker = error;
+        await this.handle(error.request, { reset: true }).finally(() => {
+            this.blocker = null;
+        });
+        if (await resolved())
+            return true;
+        this.unresolvedBlockers.add(key);
+        return false;
+    }
 }
 export default Captain;
 function isExplicitSlashRequest(input, command) {

package/dist/src/ai/driller.js

@@ -119,7 +119,7 @@ export class Driller extends TaskAgent {
         setActivity(`${this.emoji} Capturing annotated page state...`, 'action');
         const action = this.explorer.action();
         try {
-            const annotated = await Promise.race([
+            await Promise.race([
                 this.explorer.withPage(annotatePageElements),
                 new Promise((_, reject) => {
                     setTimeout(() => reject(new Error('annotateElements timeout')), 15000);

package/dist/src/ai/experience-compactor.js

@@ -1,5 +1,5 @@
 import { unlinkSync } from 'node:fs';
-import { basename } from 'node:path';
+import { basename, relative } from 'node:path';
 import dedent from 'dedent';
 import { z } from 'zod';
 import { RECENT_WINDOW_DAYS } from '../experience-tracker.js';
@@ -258,7 +258,7 @@ export class ExperienceCompactor {
             mergedFrom: group.files.map((f) => f.data.url),
         };
         this.experienceTracker.writeExperienceFile(targetStateHash, combinedContent, newFrontmatter);
-        log(`Merged ${group.files.length} experience files into ${targetFile.filePath}`);
+        log(`Merged ${group.files.length} experience files into ${relative(process.cwd(), targetFile.filePath)}`);
         debugLog('New URL pattern:', group.pattern);
         for (const sourceFile of sourceFiles) {
             try {

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

@@ -1,3 +1,4 @@
+import type { ActionResult } from '../action-result.js';
 import type { AIConfig } from '../config.js';
 import { JudgeProvider } from './judge-provider.js';
 export declare const UNDECIDED = "undecided";
@@ -17,6 +18,7 @@ export declare class Judge {
         direct: boolean;
     };
     threshold: number;
+    failureReported: boolean;
     constructor(provider: JudgeProvider, enabled: {
         tool: boolean;
         direct: boolean;
@@ -30,3 +32,8 @@ export declare class Judge {
     request(question: string, options: string[] | boolean | null, state: unknown): Promise<Decision>;
     recordFailure(error: unknown): null;
 }
+export declare function pageEvidence(actionResult: ActionResult): {
+    url: string;
+    title: string;
+    page: string;
+};

package/dist/src/ai/judge.js

@@ -1,6 +1,6 @@
 import { clearActivity, setActivity } from "../activity.js";
 import { Observability } from "../observability.js";
-import { createDebug } from "../utils/logger.js";
+import { createDebug, tag } from "../utils/logger.js";
 import { JudgeProvider } from "./judge-provider.js";
 const debugLog = createDebug('explorbot:judge');
 const APPROVAL_THRESHOLD = 0.7;
@@ -27,6 +27,7 @@ export class Judge {
     provider;
     enabled;
     threshold;
+    failureReported = false;
     constructor(provider, enabled, threshold = APPROVAL_THRESHOLD) {
         this.provider = provider;
         this.enabled = enabled;
@@ -95,6 +96,9 @@ export class Judge {
     }
     recordFailure(error) {
         debugLog('judge declined: %s', error);
+        if (!this.failureReported)
+            tag('warning').log(`Decision model ${this.provider.model} failed (${error}); continuing without it`);
+        this.failureReported = true;
         const span = Observability.getSpan();
         span?.setAttribute('ai.telemetry.metadata.judgeError', String(error));
         span?.setAttribute('langfuse.observation.level', 'ERROR');
@@ -102,3 +106,6 @@ export class Judge {
         return null;
     }
 }
+export function pageEvidence(actionResult) {
+    return { url: actionResult.url, title: actionResult.title, page: actionResult.getCompactARIA().slice(0, JUDGE_PAGE_CAP) };
+}

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

@@ -36,6 +36,7 @@ declare class Navigator implements Agent {
     }, expectedUrl: string): string;
     isSameExpectedOrigin(expectedUrl: string, stateManager: any): boolean;
     isOnExpectedPage(expectedUrl: string, stateManager: any): boolean;
+    isOn(url: string): boolean;
     visit(url: string, opts?: {
         recover?: boolean;
     }): Promise<boolean>;

package/dist/src/ai/navigator.js

@@ -7,7 +7,7 @@ import { normalizeUrl } from '../state-manager.js';
 import { isFatalBrowserError } from "../utils/browser-errors.js";
 import { getCliName } from "../utils/cli-name.js";
 import { extractCodeBlocks } from '../utils/code-extractor.js';
-import { isLoginPage } from "../utils/error-page.js";
+import { NavigationBlockedError, isLoginPage } from "../utils/error-page.js";
 import { HooksRunner } from "../utils/hooks-runner.js";
 import { createDebug, pluralize, tag } from '../utils/logger.js';
 import { loop, pause } from '../utils/loop.js';
@@ -20,6 +20,7 @@ import { actionRule, credentialsRule, locatorRule, unexpectedPopupRule } from '.
 import { isInteractive } from './task-agent.js';
 import { createLearnExperienceTool } from "./tools.js";
 const debugLog = createDebug('explorbot:navigator');
+const MAX_TRIED_STEPS = 5;
 class Navigator {
     emoji = '🧭';
     provider;
@@ -120,6 +121,9 @@ class Navigator {
         const currentUrl = this.getComparableCurrentUrl(stateManager, expectedUrl);
         return matchesNavigationUrl(expectedUrl, currentUrl);
     }
+    isOn(url) {
+        return this.isOnExpectedPage(url, this.stateManager);
+    }
     async visit(url, opts = {}) {
         return this.visitOnce(url, opts.recover !== false);
     }
@@ -171,9 +175,9 @@ class Navigator {
         }
     }
     navigationError(url, fallback) {
-        if (this.lastFailureReason)
-            return new Error(`Navigation to ${url} failed: ${this.lastFailureReason}`);
-        return new Error(`Navigation to ${url} failed: ${fallback}`);
+        const currentUrl = this.stateManager.getCurrentState()?.url || '';
+        const tried = this.executedSteps.slice(-MAX_TRIED_STEPS).map((step) => step.command);
+        return new NavigationBlockedError(url, currentUrl, this.lastFailureReason || fallback, tried);
     }
     failureReason(stopReason, knowledge, url) {
         const reasons = [];
@@ -364,7 +368,7 @@ class Navigator {
         Propose different solutions to achieve the result.
         Solution should be valid CodeceptJS code.
         Use only data from the <page> context to plan the solution.
-        The page is given as an ARIA snapshot only: use ARIA and text locators from it.
+        The page is given as an ARIA snapshot only: use ARIA and text locators from it; propose CSS/XPath only once <page_html> is provided.
         Full HTML is provided if these solutions fail.
         Try various ways to achieve the result
       </task>
@@ -692,7 +696,7 @@ class Navigator {
         Do not generate assertions that would pass even if the specific claim is false.
       </task>
 
-      ${RulesLoader.loadRules('navigator', ['verification-actions'], actionResult.url || '')}
+      ${RulesLoader.loadRules('navigator', ['verification-actions', 'verification-output'], actionResult.url || '').replace('{{maxAttempts}}', String(this.verifyAttempts))}
 
       ${experience}
 
@@ -765,7 +769,7 @@ class Navigator {
         const totalAttempted = Math.min(codeBlocks.length, this.verifyAttempts);
         let verified = successfulCodes.length > 0 && !failures;
         if (successfulCodes.length && failures)
-            verified = await this.provider.oracle(message, { assertions: results.map(({ code, passed, error }) => ({ code, passed, error })) }, { agentName: 'navigator', telemetry: { functionId: 'navigator.verifyState' } });
+            verified = (await this.provider.oracle(message, { assertions: results.map(({ code, passed, error }) => ({ code, passed, error })) }, { agentName: 'navigator', telemetry: { functionId: 'navigator.verifyState' } })) === true;
         if (alreadyVerified)
             verified = true;
         const inexpressible = !alreadyVerified && totalAttempted === 0;

package/dist/src/ai/planner/subpages.js

@@ -68,7 +68,7 @@ export function WithSubPages(Base) {
         async pickNextSubPage(candidates) {
             if (candidates.length === 0)
                 return null;
-            const plannedEntries = [...planRegistry.entries()].map(([key, record]) => `- ${record.url} (${record.plan.tests.length} tests${record.feature ? `, feature: ${record.feature}` : ''})`).join('\n');
+            const plannedEntries = [...planRegistry.entries()].map(([, record]) => `- ${record.url} (${record.plan.tests.length} tests${record.feature ? `, feature: ${record.feature}` : ''})`).join('\n');
             const candidateList = candidates.map((c) => `- ${c.url} (visits: ${c.visitCount}${c.title ? `, title: "${c.title}"` : ''}${c.h1 ? `, h1: "${c.h1}"` : ''})`).join('\n');
             const conversation = this.provider.startConversation(dedent `
           You pick the next most business-relevant sub-page to test from a list of candidates.