explorbot 0.5.7 → 0.5.9

package/dist/src/ai/planner.js

@@ -18,6 +18,7 @@ import { WithSubPages, getPlannedByStateHash, getRegisteredPlan, registerPlan }
 import { POSSIBLE_SECTIONS } from "./researcher.js";
 import { findSimilarStateHash } from "./researcher/cache.js";
 import { hasFocusedSection } from "./researcher/focus.js";
+import { RulesLoader } from "../utils/rules-loader.js";
 import { capabilityGroundingRule, dataProtectionRules, fileUploadRule } from "./rules.js";
 const debugLog = createDebug('explorbot:planner');
 const TasksSchema = z.object({
@@ -33,6 +34,7 @@ const TasksSchema = z.object({
             .describe('List of expected outcomes that can be verified. Each outcome should be simple, specific, and easy to check (e.g., "Success message appears", "URL changes to /dashboard", "Form field shows error"). Keep outcomes atomic - do not combine multiple checks into one.'),
     }))
         .describe('List of testing scenarios'),
+    notPlannableReason: z.string().nullish().describe('When scenarios is empty, one sentence saying why this page has nothing to test; otherwise null.'),
 });
 const PlannerBase = WithSessionDedup(WithSubPages(Object));
 export class Planner extends PlannerBase {
@@ -178,6 +180,9 @@ export class Planner extends PlannerBase {
             if (!aiResult?.object?.scenarios) {
                 throw new Error('No tasks were created successfully');
             }
+            if (!this.currentPlan && aiResult.object.scenarios.length === 0 && aiResult.object.notPlannableReason) {
+                tag('warning').log(`Page is not plannable: ${aiResult.object.notPlannableReason}`);
+            }
             const defaultStartUrl = this.getDefaultStartUrl(state);
             const fromPlanning = aiResult.object.scenarios.map((s) => new Test(s.scenario, s.priority, s.expectedOutcomes, s.startUrl || defaultStartUrl, s.steps || []));
             return { tests: fromPlanning, planName: aiResult.object.planName };
@@ -303,11 +308,14 @@ export class Planner extends PlannerBase {
         conversation.autoTrimTag('tested_scenarios', 10000);
         conversation.autoTrimTag('docs_context', 8000);
         conversation.addUserText(this.getSystemMessage(feature));
+        let ignoredPagesRule = '';
+        if (!feature)
+            ignoredPagesRule = `\n${RulesLoader.loadRules('planner', ['ignored-pages'], state.url)}`;
         const planningPrompt = dedent `
       <task>
       Based on the page research, create ${this.MIN_TASKS}-${this.MAX_TASKS} exploratory testing scenarios.
       For each scenario provide specific steps and expected outcomes.
-      Exception: if the page reports the requested resource is missing, shows a failure state, or holds no content and no controls, return an empty scenarios list. Never invent tests for a page with nothing to exercise.
+      Exception: if the page reports the requested resource is missing, shows a failure state, or holds no content and no controls, return an empty scenarios list. Never invent tests for a page with nothing to exercise.${ignoredPagesRule}
       </task>
 
       <rules>

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

@@ -3,6 +3,7 @@ import type { ModelMessage } from 'ai';
 import { type AIConfig } from '../config.js';
 import { type RetryOptions } from '../utils/retry.js';
 import { Conversation } from './conversation.js';
+import type { Judge } from './judge.js';
 declare class AiError extends Error {
 }
 export declare class ContextLengthError extends Error {
@@ -10,6 +11,7 @@ export declare class ContextLengthError extends Error {
 export declare function flushTelemetry(): Promise<void>;
 export declare class Provider {
     config: AIConfig;
+    judge: Judge | null;
     telemetryEnabled: boolean;
     otelSdk: NodeSDK | null;
     defaultRetryOptions: RetryOptions;
@@ -20,6 +22,8 @@ export declare class Provider {
     validateConnection(): Promise<void>;
     stop(): Promise<void>;
     getModelForAgent(agentName?: string): any;
+    setJudge(judge: Judge | null): void;
+    oracle(statement: string, state: unknown, options?: any): Promise<boolean>;
     getAgenticModel(agentName?: string): any;
     getVisionModel(): any;
     getConfiguredModels(): Record<string, string>;

package/dist/src/ai/provider.js

@@ -2,11 +2,11 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 import { OpenTelemetry } from '@ai-sdk/otel';
 import { LangfuseSpanProcessor } from '@langfuse/otel';
 import { NodeSDK } from '@opentelemetry/sdk-node';
-import { APICallError, NoObjectGeneratedError, asSchema, extractJsonMiddleware, generateObject, generateText, isStepCount, parsePartialJson, registerTelemetry, tool, wrapLanguageModel } from 'ai';
+import { APICallError, NoObjectGeneratedError, NoOutputGeneratedError, Output, asSchema, extractJsonMiddleware, generateText, isStepCount, parsePartialJson, registerTelemetry, tool, wrapLanguageModel } from 'ai';
 import dedent from 'dedent';
 import { z } from 'zod';
 import { clearActivity, setActivity } from "../activity.js";
-import { configuredModels, modelName as getModelName } from '../config.js';
+import { PROVIDERS, configuredModels, modelName as getModelName, modelProvider } from '../config.js';
 import { executionController } from "../execution-controller.js";
 import { Observability } from "../observability.js";
 import { Stats } from "../stats.js";
@@ -75,6 +75,7 @@ function combinedAbortSignal(controller) {
 }
 export class Provider {
     config;
+    judge = null;
     telemetryEnabled = false;
     otelSdk = null;
     defaultRetryOptions = {
@@ -89,6 +90,7 @@ export class Provider {
                 error.message.includes('AI request timeout') ||
                 error.message.includes('schema') ||
                 error.message.includes('No object generated') ||
+                error.message.includes('No output generated') ||
                 error.message.includes('No response text') ||
                 error.message.includes('validate JSON')) &&
                 !error.message.includes('output truncated at maxTokens'));
@@ -112,6 +114,13 @@ export class Provider {
             });
         }
         catch (error) {
+            const envKey = PROVIDERS[modelProvider(this.config.model)]?.envKey;
+            const apiKey = envKey && process.env[envKey];
+            if (envKey && !apiKey)
+                throw new AiError(`AI connection failed: ${envKey} is not set. ${error.message}`);
+            if (apiKey && [401, 403].includes(error.statusCode)) {
+                throw new AiError(`AI connection failed: ${error.message}. ${envKey}=${apiKey.slice(0, 5)}**${apiKey.slice(-3)} was rejected, check the key`);
+            }
             throw new AiError(`AI connection failed: ${error.message}`);
         }
     }
@@ -125,6 +134,18 @@ export class Provider {
         const agentConfig = this.config.agents?.[agentName];
         return agentConfig?.model || this.config.model;
     }
+    setJudge(judge) {
+        this.judge = judge;
+    }
+    async oracle(statement, state, options = {}) {
+        const judged = await this.judge?.assert(statement, state);
+        if (typeof judged === 'boolean')
+            return judged;
+        const schema = z.object({ holds: z.boolean().describe('whether the statement is true') });
+        const content = `${statement}\n\n${JSON.stringify(state, null, 2)}`;
+        const response = await this.generateObject([{ role: 'user', content }], schema, this.getAgenticModel(options.agentName), options).catch(() => null);
+        return response?.object?.holds === true;
+    }
     getAgenticModel(agentName) {
         if (agentName) {
             const agentConfig = this.config.agents?.[agentName];
@@ -482,11 +503,12 @@ export class Provider {
         const modelName = getModelName(modelToUse);
         setActivity(`🤖 Asking ${modelName} for structured output`, 'ai');
         promptLog(`Using model: ${modelName}`);
-        const config = this.buildGenerateConfig({ schema }, { model: modelToUse }, options);
         try {
+            const { timeout, ...config } = this.buildGenerateConfig({ output: Output.object({ schema }) }, { model: modelToUse }, options);
             promptLog(messages[messages.length - 1].content);
             const response = await this.withModelRequestSlot(() => withRetry(async () => {
-                return (await this.raceWithIdleTimeout((signal) => generateObject({ messages, ...config, abortSignal: signal }), config.timeout || 30000));
+                const result = (await this.raceWithIdleTimeout((signal) => generateText({ messages, ...config, abortSignal: signal }), timeout || 30000));
+                return { object: result.output, usage: result.usage };
             }, this.getRetryOptions(options)));
             clearActivity();
             responseLog(response.object);
@@ -502,7 +524,7 @@ export class Provider {
             if (Provider.isContextLengthError(error)) {
                 return this.recoverFromContextLength(error, messages, options, (m, o) => this.generateObject(m, schema, model, o));
             }
-            if (NoObjectGeneratedError.isInstance(error))
+            if (NoObjectGeneratedError.isInstance(error) || NoOutputGeneratedError.isInstance(error))
                 return this.recoverWithPlainJson(messages, schema, modelToUse, options);
             throw new AiError(error.message || error.toString());
         }

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

@@ -1,7 +1,9 @@
+import type { Locator, Page } from 'playwright';
 import type { ActionResult } from '../action-result.js';
 import type Explorer from '../explorer.js';
 import type { StateManager, StateTransition, WebPageState } from '../state-manager.js';
 import type { Task } from '../test-plan.js';
+import { type UxMeasurements } from '../utils/ux-probe.js';
 import type { Conversation, ToolExecution } from './conversation.js';
 import type { Provider } from './provider.js';
 export declare class Quartermaster {
@@ -10,20 +12,46 @@ export declare class Quartermaster {
     outputDir: string;
     pageAnalyses: Map<string, PageAnalysis>;
     unsubscribe: (() => void) | null;
-    explorer: Explorer | null;
+    explorer: Explorer;
     pendingAnalyses: Promise<void>[];
-    constructor(provider: Provider, options?: {
+    constructor(provider: Provider, explorer: Explorer, options?: {
         model?: any;
     });
-    start(explorer: Explorer, stateManager: StateManager): void;
+    start(stateManager: StateManager): void;
     stop(): void;
     onPageChange(event: StateTransition): void;
     runAxeAnalysis(state: WebPageState): Promise<void>;
     analyzeSession(task: Task, initialState: ActionResult, conversation: Conversation): Promise<AnalysisReport | null>;
+    auditUx(result: ActionResult, context: UxAuditContext): Promise<string>;
     generateSemanticAnalysis(axeViolations: AxeViolation[], executions: ToolExecution[], initialState: ActionResult): Promise<SemanticIssue[]>;
     addNotesToTask(task: Task, report: AnalysisReport): void;
     saveReport(stateHash: string, report: AnalysisReport): void;
     formatReportMarkdown(report: AnalysisReport): string;
+    axeViolations(page: Page, include?: string): Promise<AxeViolation[]>;
+    markUxFocus(result: ActionResult, context: UxAuditContext): Promise<UxFocus>;
+    pickUxFocus(context: UxAuditContext, mark: (locator: Locator) => Promise<boolean>): Promise<UxFocus | null>;
+    collectUxEvidence(page: Page): Promise<UxEvidence>;
+    animationsIgnoringReducedMotion(page: Page): Promise<number>;
+    captureUxBreakpoint(page: Page): Promise<UxBreakpoint>;
+    writeUxReport(result: ActionResult, focus: UxFocus, evidence: UxEvidence, context: UxAuditContext): Promise<string>;
+}
+export interface UxAuditContext {
+    focus?: string;
+    commands: string[];
+}
+interface UxFocus {
+    area: string;
+    reason: string;
+}
+interface UxBreakpoint {
+    measurements: UxMeasurements;
+    aria: string;
+    screenshot?: string;
+}
+interface UxEvidence {
+    breakpoints: UxBreakpoint[];
+    axe: AxeViolation[];
+    notes: string[];
 }
 interface AxeViolation {
     id: string;

package/dist/src/ai/quartermaster.js

@@ -1,25 +1,41 @@
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import dedent from 'dedent';
 import { z } from 'zod';
 import { outputPath } from "../config.js";
+import { ariaRefSelector, ariaRefSnapshot, parseAriaRefs } from "../utils/aria-ref.js";
+import { compactAriaSnapshot } from "../utils/aria.js";
 import { createDebug, tag } from "../utils/logger.js";
+import { RulesLoader } from "../utils/rules-loader.js";
 import { isCodeceptToolName } from "../utils/step-analyzer.js";
+import { UX_FOCUS_ATTR, countRunningAnimations, measureUx, renderUxMeasurements, uxProbeArgs } from "../utils/ux-probe.js";
 const debugLog = createDebug('explorbot:quartermaster');
+const UX_RULES = ['ux/accessibility', 'ux/interaction', 'ux/responsive', 'ux/navigation', 'ux/copy', 'ux/forms', 'ux/readability', 'ux/motion', 'ux/charts'];
+const UX_BREAKPOINTS = [768, 375];
+const UX_FOCUS_SELECTOR = `[${UX_FOCUS_ATTR}]`;
+const UX_SETTLE_MS = 400;
+const UX_ARIA_CAP = 8000;
+const UX_SCREENSHOT_TIMEOUT = 5000;
+const UX_MAX_FINDINGS = 6;
+const AGENT_NAME = 'quartermaster';
+const FOCUS_CONTAINER_ROLES = ['main', 'region', 'form', 'dialog', 'alertdialog', 'navigation', 'complementary', 'article', 'table', 'grid', 'tabpanel', 'list', 'group', 'banner', 'contentinfo', 'search'];
 export class Quartermaster {
     provider;
     model;
     outputDir;
     pageAnalyses = new Map();
     unsubscribe = null;
-    explorer = null;
+    explorer;
     pendingAnalyses = [];
-    constructor(provider, options) {
+    constructor(provider, explorer, options) {
         this.provider = provider;
+        this.explorer = explorer;
         this.model = options?.model;
         this.outputDir = outputPath('a11y');
     }
-    start(explorer, stateManager) {
-        this.explorer = explorer;
+    start(stateManager) {
+        if (this.unsubscribe)
+            return;
         mkdirSync(this.outputDir, { recursive: true });
         this.unsubscribe = stateManager.onStateChange((event) => {
             this.onPageChange(event);
@@ -45,24 +61,13 @@ export class Quartermaster {
         this.pendingAnalyses.push(analysisPromise);
     }
     async runAxeAnalysis(state) {
-        const page = this.explorer?.page;
+        const page = this.explorer.page;
         if (!page || !state.hash) {
             debugLog('No page available for axe analysis');
             return;
         }
         try {
-            const { AxeBuilder } = await import('@axe-core/playwright');
-            const results = await new AxeBuilder({ page }).analyze();
-            const violations = results.violations.map((v) => ({
-                id: v.id,
-                impact: v.impact,
-                description: v.description,
-                helpUrl: v.helpUrl,
-                nodes: v.nodes.map((n) => ({
-                    html: n.html,
-                    target: n.target,
-                })),
-            }));
+            const violations = await this.axeViolations(page);
             this.pageAnalyses.set(state.hash, {
                 url: state.url,
                 stateHash: state.hash,
@@ -110,6 +115,22 @@ export class Quartermaster {
             return null;
         }
     }
+    async auditUx(result, context) {
+        const focus = await this.markUxFocus(result, context);
+        tag('step').log(`Auditing UX of ${focus.area}`);
+        try {
+            const evidence = await this.explorer.withPage((page) => this.collectUxEvidence(page));
+            return await this.writeUxReport(result, focus, evidence, context);
+        }
+        finally {
+            await this.explorer
+                .withPage((page) => page.evaluate((attr) => {
+                for (const el of Array.from(document.querySelectorAll(`[${attr}]`)))
+                    el.removeAttribute(attr);
+            }, UX_FOCUS_ATTR))
+                .catch(() => { });
+        }
+    }
     async generateSemanticAnalysis(axeViolations, executions, initialState) {
         const failedExecs = executions.filter((e) => !e.wasSuccessful);
         if (failedExecs.length === 0 && axeViolations.length === 0)
@@ -200,4 +221,228 @@ Focus on what would confuse a real user or caused the agent to make mistakes.`;
         }
         return content;
     }
+    async axeViolations(page, include) {
+        const { AxeBuilder } = await import('@axe-core/playwright');
+        let builder = new AxeBuilder({ page });
+        if (include)
+            builder = builder.include(include);
+        const results = await builder.analyze();
+        return results.violations.map((v) => ({
+            id: v.id,
+            impact: v.impact,
+            description: v.description,
+            helpUrl: v.helpUrl,
+            nodes: v.nodes.map((n) => ({
+                html: n.html,
+                target: n.target,
+            })),
+        }));
+    }
+    async markUxFocus(result, context) {
+        const mark = (locator) => locator
+            .first()
+            .evaluate((el, attr) => el.setAttribute(attr, ''), UX_FOCUS_ATTR)
+            .then(() => true)
+            .catch(() => false);
+        const region = result.overlay;
+        const locateRegion = (page) => {
+            if (region.root)
+                return page.locator(region.root);
+            if (region.xpath)
+                return page.locator(`xpath=${region.xpath}`);
+            const name = region.name || undefined;
+            return page.getByRole('dialog', { name }).or(page.getByRole('alertdialog', { name }));
+        };
+        const regionFocus = { area: region.name || `open ${region.type}`, reason: `it is the ${region.type} open on the page` };
+        if (!context.focus && region.isOpen && (await this.explorer.withPage((page) => mark(locateRegion(page)))))
+            return regionFocus;
+        if (context.focus || context.commands.length) {
+            const picked = await this.pickUxFocus(context, mark);
+            if (picked)
+                return picked;
+        }
+        if (region.isOpen && (await this.explorer.withPage((page) => mark(locateRegion(page)))))
+            return regionFocus;
+        let reason = 'nothing narrower is open or was touched by the session on this page';
+        if (context.focus)
+            reason = `"${context.focus}" matched no single container`;
+        return this.explorer.withPage(async (page) => {
+            if (await mark(page.locator('main, [role="main"]')))
+                return { area: 'main content', reason };
+            await mark(page.locator('body'));
+            return { area: 'whole page', reason: `${reason} and the page has no main landmark` };
+        });
+    }
+    async pickUxFocus(context, mark) {
+        const snapshot = await this.explorer.withPage(ariaRefSnapshot).catch(() => '');
+        const candidates = parseAriaRefs(snapshot).filter((entry) => FOCUS_CONTAINER_ROLES.includes(entry.role));
+        if (!candidates.length)
+            return null;
+        const hints = [];
+        if (context.focus)
+            hints.push(`The developer asked to review: ${context.focus}`);
+        if (context.commands.length)
+            hints.push('Commands the session ran on this page, latest last:', ...context.commands.map((command) => `- ${command}`));
+        const schema = z.object({
+            ref: z.enum(['none', ...candidates.map((entry) => entry.ref)]).describe('ref of the chosen container, or none'),
+            area: z.string().describe('the area named as a user would call it, a few words'),
+        });
+        const prompt = dedent `
+      Pick the page area a developer is working on, so a UX review covers it and nothing else.
+      Choose the smallest container that holds everything the hints point at.
+      Answer none when no listed container fits the hints.
+
+      <hints>
+      ${hints.join('\n')}
+      </hints>
+
+      <containers>
+      ${candidates.map((entry) => `- [${entry.ref}] ${entry.role} "${entry.name}"`).join('\n')}
+      </containers>
+
+      <page_aria>
+      ${snapshot.slice(0, UX_ARIA_CAP)}
+      </page_aria>
+    `;
+        const response = await this.provider.generateObject([{ role: 'user', content: prompt }], schema, this.model, { agentName: AGENT_NAME }).catch(() => null);
+        const ref = response?.object?.ref;
+        if (!ref || ref === 'none')
+            return null;
+        if (!(await this.explorer.withPage((page) => mark(page.locator(ariaRefSelector(ref))))))
+            return null;
+        let reason = 'the session commands on this page act inside it';
+        if (context.focus)
+            reason = `it holds "${context.focus}"`;
+        return { area: response.object.area, reason };
+    }
+    async collectUxEvidence(page) {
+        const evidence = { breakpoints: [], axe: [], notes: [] };
+        evidence.axe = await this.axeViolations(page, UX_FOCUS_SELECTOR).catch((error) => {
+            evidence.notes.push(`axe could not run: ${error.message}`);
+            return [];
+        });
+        const ignoredMotion = await this.animationsIgnoringReducedMotion(page);
+        if (ignoredMotion)
+            evidence.notes.push(`${ignoredMotion} animations in the area keep running when reduced motion is requested`);
+        const width = await page.evaluate(() => window.innerWidth);
+        evidence.breakpoints.push(await this.captureUxBreakpoint(page));
+        const narrower = UX_BREAKPOINTS.filter((breakpoint) => breakpoint < width);
+        if (!narrower.length)
+            return evidence;
+        const viewport = page.viewportSize();
+        if (!viewport) {
+            evidence.notes.push('the browser window has no fixed viewport, so narrower widths were not measured');
+            return evidence;
+        }
+        try {
+            for (const breakpoint of narrower) {
+                await page.setViewportSize({ width: breakpoint, height: viewport.height });
+                await page.waitForTimeout(UX_SETTLE_MS);
+                if ((await page.evaluate(() => window.innerWidth)) !== breakpoint) {
+                    evidence.notes.push(`resizing to ${breakpoint}px had no effect, so that width was not measured`);
+                    continue;
+                }
+                evidence.breakpoints.push(await this.captureUxBreakpoint(page));
+            }
+        }
+        finally {
+            await page.setViewportSize(viewport);
+        }
+        return evidence;
+    }
+    async animationsIgnoringReducedMotion(page) {
+        if (!(await page.evaluate(countRunningAnimations, UX_FOCUS_SELECTOR)))
+            return 0;
+        try {
+            await page.emulateMedia({ reducedMotion: 'reduce' });
+            await page.waitForTimeout(UX_SETTLE_MS);
+            return await page.evaluate(countRunningAnimations, UX_FOCUS_SELECTOR);
+        }
+        finally {
+            await page.emulateMedia({ reducedMotion: null });
+        }
+    }
+    async captureUxBreakpoint(page) {
+        const focus = page.locator(UX_FOCUS_SELECTOR).first();
+        const measurements = await page.evaluate(measureUx, uxProbeArgs(UX_FOCUS_SELECTOR));
+        const aria = await focus.ariaSnapshot().catch(() => '');
+        const breakpoint = { measurements, aria: compactAriaSnapshot(aria, true).slice(0, UX_ARIA_CAP) };
+        if (!this.provider.hasVision())
+            return breakpoint;
+        const screenshot = await focus.screenshot({ timeout: UX_SCREENSHOT_TIMEOUT }).catch(() => null);
+        if (screenshot)
+            breakpoint.screenshot = screenshot.toString('base64');
+        return breakpoint;
+    }
+    async writeUxReport(result, focus, evidence, context) {
+        const url = result.url || '';
+        const rules = [RulesLoader.loadRules(AGENT_NAME, UX_RULES, url), this.provider.getSystemPromptForAgent(AGENT_NAME, url)].filter(Boolean).join('\n\n');
+        const system = dedent `
+      <role>
+      You review the UX of one area of a web page a developer is building right now.
+      The report goes back to that developer, so every finding must point at something they can find in that area.
+      </role>
+
+      <focus>
+      Area under review: ${focus.area}, chosen because ${focus.reason}.
+      Report only on elements inside it. Page-wide header, navigation and footer are out of scope unless they are the area under review.
+      </focus>
+
+      <scope>
+      You see one page of one app, not the app.
+      - Report that a text fails and why. Never propose replacement wording, terminology, tone or language: the app's vocabulary is unknown to you.
+      - Never recommend colors, fonts, spacing values, design tokens or visual style: the project owns its design system.
+      - Sizes, gaps, overflow and contrast come only from <measurements> and <axe>. Never estimate them from a screenshot.
+      - Report only what the evidence shows. A check the evidence cannot settle is skipped, not guessed.
+      </scope>
+
+      <rules>
+      Each rule set carries the priority its findings are reported under.
+
+      ${rules}
+      </rules>
+
+      <output>
+      Markdown, no preamble.
+
+      ## Focus
+      One line: the area reviewed and the widths covered.
+
+      Then one section per priority that has findings, in this order: ## Critical, ## High, ## Medium, ## Low. Omit empty sections.
+      Each finding is one bullet of one sentence, at most 30 words:
+      - **<element as the user sees it>** (<rule set>, <width or "all widths">): <evidence>, <what it costs the user>.
+
+      One bullet per cause: elements failing the same check share a bullet naming at most three of them.
+      Write at most ${UX_MAX_FINDINGS} bullets in total across all sections, most severe first; drop the rest.
+      No fix wording, no rule ids, no list of skipped checks, no summary, no tables.
+      When nothing fails, write the Focus section and the line: No UX issues found in this area.
+      </output>
+    `;
+        const sections = [`<page url="${url}" title="${result.title || ''}"></page>`];
+        if (context.commands.length)
+            sections.push(`<session_commands>\n${context.commands.join('\n')}\n</session_commands>`);
+        sections.push(`<axe>\n${evidence.axe.map((v) => `[${v.impact}] ${v.id}: ${v.description} — ${v.nodes[0]?.html.slice(0, 100) || ''}`).join('\n') || 'no violations'}\n</axe>`);
+        if (evidence.notes.length)
+            sections.push(`<notes>\n${evidence.notes.join('\n')}\n</notes>`);
+        for (const breakpoint of evidence.breakpoints) {
+            const aria = breakpoint.aria || 'the area is not rendered at this width';
+            sections.push(`<breakpoint width="${breakpoint.measurements.width}">\n<measurements>\n${renderUxMeasurements(breakpoint.measurements)}\n</measurements>\n<aria>\n${aria}\n</aria>\n</breakpoint>`);
+        }
+        const shots = evidence.breakpoints.filter((breakpoint) => breakpoint.screenshot);
+        if (!shots.length)
+            sections.push('No screenshots are attached: judge from ARIA and measurements only, and say in Focus that visual checks were not possible.');
+        const content = [{ type: 'text', text: sections.join('\n\n') }];
+        for (const shot of shots) {
+            content.push({ type: 'text', text: `Screenshot of the area at ${shot.measurements.width}px:` });
+            content.push({ type: 'file', mediaType: 'image/png', data: shot.screenshot });
+        }
+        let model = this.model || this.provider.getModelForAgent(AGENT_NAME);
+        if (shots.length)
+            model = this.provider.getVisionModel();
+        const response = await this.provider.chat([
+            { role: 'system', content: system },
+            { role: 'user', content },
+        ], model, { agentName: AGENT_NAME });
+        return response.text;
+    }
 }

package/dist/src/ai/tester.js

@@ -322,8 +322,9 @@ export class Tester extends TaskAgent {
                     return;
                 }
                 if (actionPerformed && !wasSuccessful) {
+                    const noted = new Set(Object.values(task.notes).map((note) => note.message));
                     result?.toolExecutions
-                        ?.filter((execution) => !execution.wasSuccessful && execution.input?.explanation)
+                        ?.filter((execution) => !execution.wasSuccessful && execution.input?.explanation && !noted.has(execution.input.explanation))
                         .forEach((execution) => {
                         task.addNote(`Failed to ${execution.input.explanation} (${execution.toolName})`, TestResult.FAILED);
                     });
@@ -333,8 +334,10 @@ export class Tester extends TaskAgent {
                     return;
                 }
                 if (assertionPerformed) {
-                    const message = result?.toolExecutions?.find((execution) => execution.toolName === 'verify')?.output?.message || '';
-                    task.addNote(message, wasSuccessful ? TestResult.PASSED : TestResult.FAILED);
+                    const passedVerifications = result?.toolExecutions?.filter((execution) => this.ASSERTION_TOOLS.includes(execution.toolName) && execution.wasSuccessful) || [];
+                    for (const execution of passedVerifications)
+                        task.addNote(execution.output?.message || '', TestResult.PASSED);
+                    const message = passedVerifications.at(-1)?.output?.message || '';
                     if (wasSuccessful) {
                         conversation.addUserText(dedent `
                 Assertion "${message}" successfully passed!

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

@@ -576,6 +576,13 @@ export class ExploreCommand extends BaseCommand {
                 commands,
             });
         }
+        sections.push({
+            label: 'Explore more',
+            commands: [
+                { label: 'Whole site', command: `${cli} explore /` },
+                { label: 'Docs', command: 'https://testomat.ai/docs/explorbot' },
+            ],
+        });
         printNextSteps(sections);
     }
     isLimitReached() {

package/dist/src/commands/init-command.d.ts

@@ -11,5 +11,6 @@ type InitCommandOptions = {
     global?: boolean;
     provider?: string;
     apiKey?: string;
+    url?: string;
 };
 export {};