explorbot 0.2.3 → 0.2.4

package/dist/boat/prima/src/pw-parser.js

@@ -14,5 +14,17 @@ export function isFunctionExpression(expr) {
     return { valid: true };
 }
 export function toCodeceptWrapper(expr) {
-    return `I.usePlaywrightTo('pw', async (playwright) => (${expr.trim()})(playwright))`;
+    return `return I.usePlaywrightTo('pw', async (playwright) => (${expr.trim()})(playwright))`;
+}
+export function takePwValue(held) {
+    if (held === undefined || held === null)
+        return undefined;
+    if (typeof held === 'string')
+        return held;
+    try {
+        return JSON.stringify(held, null, 2);
+    }
+    catch {
+        return String(held);
+    }
 }

package/dist/boat/prima/src/pw-registry.js

@@ -19,9 +19,8 @@ export function readDescriptors(dir = registryDir()) {
     }
     return descriptors;
 }
-export function selectDescriptor(descriptors, opts) {
-    const workspaceDir = path.resolve(opts.workspaceDir);
-    const candidates = descriptors.filter((descriptor) => path.resolve(descriptor.workspaceDir) === workspaceDir);
+export function selectDescriptor(descriptors, opts = {}) {
+    const candidates = descriptors;
     if (!candidates.length)
         return { candidates };
     if (opts.title) {
@@ -53,13 +52,13 @@ function parseDescriptor(file) {
     catch {
         return null;
     }
-    if (!data?.endpoint || !data?.title || !data?.workspaceDir)
+    if (!data?.endpoint || !data?.title)
         return null;
     return {
         file,
         title: data.title,
         endpoint: data.endpoint,
-        workspaceDir: data.workspaceDir,
+        workspaceDir: data.workspaceDir || '',
         browserName: data.browser?.browserName || DEFAULT_BROWSER,
         playwrightLib: data.playwrightLib || '',
     };

package/dist/boat/prima/src/session-log.js

@@ -0,0 +1,108 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { outputPath } from "../../../src/config.js";
+import { safeFilename } from "../../../src/utils/strings.js";
+import { renderEnvelope } from "./envelope.js";
+const EXPECTATION_STATUS = { passed: 'passed', failed: 'failed', unverified: 'skipped' };
+export function sessionsDir() {
+    return outputPath('prima', 'sessions');
+}
+export function sessionFile(key) {
+    return path.join(sessionsDir(), `${safeFilename(key)}.jsonl`);
+}
+export function latestSessionFile() {
+    const dir = sessionsDir();
+    if (!existsSync(dir))
+        return null;
+    const files = readdirSync(dir)
+        .filter((name) => name.endsWith('.jsonl'))
+        .map((name) => path.join(dir, name))
+        .sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs);
+    return files[0] || null;
+}
+export function recordCommand(file, session, envelope, durationMs) {
+    mkdirSync(path.dirname(file), { recursive: true });
+    if (recordedEndpoint(file) !== session.endpoint)
+        writeFileSync(file, jsonLine({ action: 'createRun', endpoint: session.endpoint, params: { title: session.title } }), 'utf-8');
+    appendFileSync(file, jsonLine({ action: 'addTest', testId: commandTest(envelope, durationMs) }), 'utf-8');
+}
+export function readSession(file) {
+    const entries = readEntries(file);
+    const run = entries.find((entry) => entry.action === 'createRun');
+    const tests = entries.filter((entry) => entry.action === 'addTest').map((entry) => entry.testId);
+    return { title: run?.params?.title || 'prima session', tests };
+}
+function commandTest(envelope, durationMs) {
+    let status = 'failed';
+    if (envelope.ok)
+        status = 'passed';
+    const test = {
+        rid: envelope.status,
+        title: envelope.command,
+        suite_title: 'Prima session',
+        status,
+        file: '<prima>',
+        description: [`page: ${envelope.page.url}`, envelope.stepFiles && `artifacts: ${envelope.stepFiles}`].filter(Boolean).join('\n'),
+        code: (envelope.used || []).join('\n'),
+        steps: commandSteps(envelope),
+        logs: renderEnvelope(envelope),
+        time: Math.round(durationMs),
+    };
+    if (envelope.failure)
+        test.error = { message: envelope.failure.error };
+    return test;
+}
+function commandSteps(envelope) {
+    const steps = [];
+    for (const step of envelope.steps || []) {
+        const entry = { category: 'user', title: step.label, status: 'passed', duration: 0, log: step.proof };
+        if (!step.ok) {
+            entry.status = 'failed';
+            entry.error = step.proof;
+        }
+        steps.push(entry);
+    }
+    for (const expectation of envelope.expectations || []) {
+        const entry = { category: 'user', title: `expected: ${expectation.text}`, status: EXPECTATION_STATUS[expectation.status], duration: 0 };
+        if (expectation.status === 'failed')
+            entry.error = 'the run did not reach this outcome';
+        steps.push(entry);
+    }
+    for (const assertion of envelope.assertions || []) {
+        const entry = { category: 'user', title: assertion.code, status: 'passed', duration: 0, log: assertion.proof.join('\n') };
+        if (!assertion.passed) {
+            entry.status = 'failed';
+            entry.error = 'the assertion did not hold on the page';
+        }
+        steps.push(entry);
+    }
+    return steps;
+}
+function recordedEndpoint(file) {
+    const [first] = readEntries(file);
+    return first?.endpoint || null;
+}
+function readEntries(file) {
+    if (!existsSync(file))
+        return [];
+    const entries = [];
+    for (const line of readFileSync(file, 'utf-8').split('\n')) {
+        if (!line.trim())
+            continue;
+        const entry = parseLine(line);
+        if (entry)
+            entries.push(entry);
+    }
+    return entries;
+}
+function parseLine(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+}
+function jsonLine(entry) {
+    return `${JSON.stringify(entry)}\n`;
+}

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "explorbot",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "CLI app built with React Ink, CodeceptJS, and Playwright",
   "license": "Elastic-2.0",
   "type": "module",
@@ -19,6 +19,7 @@
   },
   "files": [
     "dist/",
+    "docs/",
     "src/**/*.ts",
     "src/**/*.tsx",
     "bin/**/*.ts",
@@ -119,7 +120,7 @@
     "ora-classic": "^5.4.2",
     "parse5": "^8.0.0",
     "pixelmatch": "^7.2.0",
-    "playwright": "^1.60",
+    "playwright": "^1.62",
     "pngjs": "^7.0.0",
     "react": "^19.1.1",
     "sambanova-ai-provider": "^1.2.2",

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

@@ -105,9 +105,29 @@ Checks that page source does NOT contain expected text.
   I.dontSeeInSource('error-class');
 </example>
 
+### Asserting the state of a control
+
+State means disabled, checked, readonly, required, selected, expanded. A presence assertion says
+nothing about it, so assert it with an attribute selector:
+
+<example>
+  I.seeElement('button[aria-label="Submit"][disabled]');
+  I.dontSeeElement('button[aria-label="Submit"][disabled]');
+  I.seeElement('input[name="accept"][checked]');
+  I.seeElement('button[aria-label="Details"][aria-expanded="true"]');
+</example>
+
+Use I.seeElement for the state you expect and I.dontSeeElement for the state you expect to be
+absent — that pair expresses both directions.
+
+I.seeAttributesOnElements(<locator>, { disabled: true }) also exists, but only takes a state that
+must be PRESENT and does not resolve reliably against a role/text locator. Prefer the selector form above.
+
 <verification_rules>
 Be strict in assertions to avoid false positives.
 Prefer I.seeElement() with ARIA locators - most reliable.
+For a claim about a control's state, assert it with an attribute selector — presence of the element is not evidence of its state.
+If no assertion above can express the claim, say so instead of proposing an assertion that checks something weaker.
 I.see() and I.dontSee() MUST include context parameter.
 For input field values, ALWAYS use I.seeInField() — never check value via CSS attribute selectors or I.seeInSource.
 Prefer text locators (label, name, placeholder) for form fields: I.seeInField('Search', 'value') over I.seeInField('input[name="search"]', 'value').

package/dist/src/action-result.d.ts

@@ -24,6 +24,7 @@ interface ActionResultData extends WebPageState {
     }>;
     ariaSnapshot?: string | null;
     ariaSnapshotFile?: string;
+    focusedElement?: FocusedElement | null;
     iframeURL?: string;
     links?: Link[];
 }
@@ -69,6 +70,7 @@ export declare class ActionResult implements ActionResultData {
     snapshotCache: TTLCache<string>;
     readonly logFile: string | undefined;
     readonly ariaSnapshotFile: string | undefined;
+    readonly focusedElement: FocusedElement | null;
     _ariaSnapshot: string | null | undefined;
     _lastExtractedHtml: string | undefined;
     notes: string[];
@@ -128,4 +130,9 @@ export declare class Diff {
     get htmlDiff(): HtmlDiffResult | null;
     calculate(): Promise<void>;
 }
+export interface FocusedElement {
+    role: string;
+    name: string;
+    value?: string;
+}
 export {};

package/dist/src/action-result.js

@@ -30,6 +30,7 @@ export class ActionResult {
     snapshotCache = new TTLCache();
     logFile = undefined;
     ariaSnapshotFile = undefined;
+    focusedElement = null;
     _ariaSnapshot = undefined;
     _lastExtractedHtml = undefined;
     notes = [];
@@ -61,6 +62,9 @@ export class ActionResult {
         if (data.ariaSnapshotFile !== undefined) {
             this.ariaSnapshotFile = data.ariaSnapshotFile;
         }
+        if (data.focusedElement !== undefined) {
+            this.focusedElement = data.focusedElement;
+        }
         // Store HTML in a private property if provided
         if (data.html !== undefined) {
             this._html = data.html;

package/dist/src/action.d.ts

@@ -15,6 +15,7 @@ declare class Action {
         name: string;
         args: any[];
     }>;
+    lastValue: unknown;
     recorder?: PlaywrightRecorder;
     recovery: RecoveryRunner;
     mainDocumentStatus: number | undefined;
@@ -45,6 +46,7 @@ declare class Action {
     exitIframe(): Promise<void>;
     getActor(): CodeceptJS.I;
     getActionResult(): ActionResult | null;
+    restorePageTimeout(): void;
     waitForPageReadiness(page: any): Promise<void>;
 }
 export default Action;

package/dist/src/action.js

@@ -15,6 +15,8 @@ import { safeFilename } from "./utils/strings.js";
 import { codeceptJSSandbox, hasPlaywrightCommands, playwrightSandbox, sanitizeCodeBlock } from "./utils/web-sandbox.js";
 const debugLog = createDebug('explorbot:action');
 const CAPTURE_NAVIGATION_TRANSITION_ATTEMPTS = 3;
+const DEFAULT_ACTION_TIMEOUT = 3000;
+const DEFAULT_PAGE_TIMEOUT = 3000;
 class Action {
     actor;
     stateManager;
@@ -26,6 +28,7 @@ class Action {
     playwrightHelper;
     playwrightGroupId = null;
     assertionSteps = [];
+    lastValue;
     recorder;
     recovery;
     mainDocumentStatus = undefined;
@@ -120,9 +123,11 @@ class Action {
             const iframeSnapshots = await this.captureIframeSnapshots(html);
             let ariaSnapshot = null;
             let ariaSnapshotFile = undefined;
+            let focusedElement = null;
             try {
                 const page = this.playwrightHelper.page;
                 ariaSnapshot = await page.locator('body').ariaSnapshot();
+                focusedElement = await page.evaluate(readFocusedElement);
             }
             catch (err) {
                 debugLog('ARIA snapshot failed:', err instanceof Error ? `${err.message}\n${err.stack}` : err);
@@ -145,6 +150,7 @@ class Action {
                 iframeSnapshots,
                 ariaSnapshot,
                 ariaSnapshotFile,
+                focusedElement,
                 iframeURL: frame ? frame.url?.() || 'iframe' : undefined,
             });
             this.stateManager.updateState(result, codeBlock);
@@ -272,16 +278,19 @@ class Action {
             if (!sanitizedCode) {
                 throw new Error('No valid I.* or page.* commands found in code block');
             }
+            this.playwrightHelper?.page?.setDefaultTimeout(this.config.action?.timeout ?? DEFAULT_ACTION_TIMEOUT);
             if (isPlaywright) {
                 const page = this.playwrightHelper.page;
                 await playwrightSandbox(page, sanitizedCode);
                 await sleep(this.config.action?.delay || 500);
             }
             else {
-                codeceptJSSandbox(this.actor, sanitizedCode);
+                const returned = codeceptJSSandbox(this.actor, sanitizedCode);
                 await recorder.add(() => sleep(this.config.action?.delay || 500));
                 await recorder.promise();
+                this.lastValue = await returned;
             }
+            this.restorePageTimeout();
             if (executedSteps.length > 0) {
                 codeString = executedSteps.join('\n');
             }
@@ -300,6 +309,7 @@ class Action {
             throw err;
         }
         finally {
+            this.restorePageTimeout();
             detachMainDocumentResponse();
             if (groupId)
                 await this.recorder.endAction();
@@ -346,6 +356,9 @@ class Action {
     getActionResult() {
         return this.actionResult;
     }
+    restorePageTimeout() {
+        this.playwrightHelper?.page?.setDefaultTimeout(this.config.playwright.timeout ?? DEFAULT_PAGE_TIMEOUT);
+    }
     async waitForPageReadiness(page) {
         await waitForPageReadiness(page, {
             timeout: this.config.playwright.waitForTimeout,
@@ -408,3 +421,25 @@ const detachStepLogger = (listener) => {
     codeceptjs.event.dispatcher.off(codeceptjs.event.step.passed, listener);
     codeceptjs.event.dispatcher.off(codeceptjs.event.step.failed, listener);
 };
+const readFocusedElement = () => {
+    const el = document.activeElement;
+    if (!el || el === document.body)
+        return null;
+    const tag = el.tagName.toLowerCase();
+    const textish = new Set(['text', 'search', 'email', 'password', 'url', 'tel', 'number']);
+    let role = el.getAttribute('role') || tag;
+    if (tag === 'textarea' || el.isContentEditable)
+        role = 'textbox';
+    if (tag === 'input' && textish.has(el.type))
+        role = 'textbox';
+    if (tag === 'select')
+        role = 'combobox';
+    if (tag === 'a')
+        role = 'link';
+    const label = el.getAttribute('aria-label') || el.getAttribute('placeholder') || el.labels?.[0]?.textContent || el.textContent || '';
+    const focused = { role, name: label.trim().slice(0, 80) };
+    const value = el.value ?? el.textContent;
+    if (typeof value === 'string' && value)
+        focused.value = value.slice(0, 200);
+    return focused;
+};

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

@@ -16,7 +16,7 @@ export function WithWebMode(Base) {
                 navigator: ctx.explorBot.agentNavigator(),
             });
             const { see, context, visualClick, learnExperience } = agentTools;
-            return {
+            const tools = {
                 navigate: tool({
                     description: 'Navigate to a URL or page description using AI-powered navigation.',
                     inputSchema: z.object({
@@ -114,11 +114,14 @@ export function WithWebMode(Base) {
                     },
                 }),
                 ...codeceptTools,
-                see,
                 context,
-                visualClick,
                 learnExperience,
             };
+            if (see)
+                tools.see = see;
+            if (visualClick)
+                tools.visualClick = visualClick;
+            return tools;
         }
         webModePrompt() {
             return dedent `

package/dist/src/ai/captain.js

@@ -15,6 +15,7 @@ import { WithWebMode } from "./captain/web-mode.js";
 import { toolExecutionLabel } from './conversation.js';
 import { Researcher } from "./researcher.js";
 import { TaskAgent } from "./task-agent.js";
+import { withdrawVisionTools } from "./tools.js";
 const MAX_STEPS = 15;
 const CaptainBase = WithTestMode(WithWebMode(WithIdleMode(TaskAgent)));
 export class Captain extends CaptainBase {
@@ -389,6 +390,7 @@ export class Captain extends CaptainBase {
                 stop();
                 return;
             }
+            withdrawVisionTools(tools);
             const currentState = stateManager.getCurrentState();
             if (!currentState && this.getMode() !== 'idle') {
                 stop();

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

@@ -50,6 +50,8 @@ declare class Navigator implements Agent {
     } | null>;
     verifyState(message: string, actionResult: ActionResult): Promise<{
         verified: boolean;
+        inexpressible: boolean;
+        results: AssertionResult[];
         successfulCodes: string[];
         assertionSteps: Array<{
             name: string;
@@ -59,4 +61,9 @@ declare class Navigator implements Agent {
     }>;
     checkAlreadyVerified(aiResponse: string, actionResult: ActionResult): boolean;
 }
+export type AssertionResult = {
+    code: string;
+    passed: boolean;
+    proof: string[];
+};
 export { Navigator };

package/dist/src/ai/navigator.js

@@ -3,6 +3,7 @@ import dedent from 'dedent';
 import { z } from 'zod';
 import { ActionResult } from '../action-result.js';
 import { normalizeUrl } from '../state-manager.js';
+import { renderAssertion } from "../playwright-recorder.js";
 import { extractCodeBlocks } from '../utils/code-extractor.js';
 import { HooksRunner } from "../utils/hooks-runner.js";
 import { createDebug, pluralize, tag } from '../utils/logger.js';
@@ -628,6 +629,7 @@ class Navigator {
         const tools = this.buildExperienceTools();
         let codeBlocks = [];
         const successfulCodes = [];
+        const results = [];
         const assertionSteps = [];
         const action = this.explorer.action();
         let failures = 0;
@@ -660,6 +662,8 @@ class Navigator {
                 }
                 await action.exitIframe();
                 const verified = await action.attempt(codeBlock, message);
+                const proof = action.assertionSteps.map(renderAssertion).filter(Boolean);
+                results.push({ code: codeBlock, passed: verified, proof });
                 if (verified) {
                     tag('success').log('Verification passed');
                     successfulCodes.push(codeBlock);
@@ -668,11 +672,6 @@ class Navigator {
                 else {
                     failures++;
                 }
-                const target = Math.min(codeBlocks.length, this.verifyAttempts);
-                const majorityNeeded = Math.floor(target / 2) + 1;
-                if (successfulCodes.length >= majorityNeeded || failures > target - majorityNeeded) {
-                    stop();
-                }
             }, {
                 maxAttempts: this.verifyAttempts,
                 observability: {
@@ -691,9 +690,14 @@ class Navigator {
         let verified = successfulCodes.length >= majorityNeeded;
         if (alreadyVerified)
             verified = true;
+        const inexpressible = !alreadyVerified && totalAttempted === 0;
+        if (inexpressible) {
+            tag('warning').log('No assertion could express this claim');
+            return { verified: false, inexpressible, results, successfulCodes, assertionSteps, totalAttempted };
+        }
         actionResult.addVerification(message, verified);
         this.stateManager.updateState(actionResult);
-        return { verified, successfulCodes, assertionSteps, totalAttempted };
+        return { verified, inexpressible, results, successfulCodes, assertionSteps, totalAttempted };
     }
     checkAlreadyVerified(aiResponse, actionResult) {
         const verifiedMatch = aiResponse.match(/ALREADY_VERIFIED:\s*(.+)/i);

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

@@ -40,6 +40,10 @@ export declare class Pilot implements Agent {
     planTest(task: Test, currentState: ActionResult): Promise<string>;
     reviewNewPage(task: Test, currentState: ActionResult, testerConversation: Conversation): Promise<string>;
     analyzeProgress(task: Test, currentState: ActionResult, testerConversation: Conversation): Promise<string>;
+    settleExpectations(task: Test): Promise<Array<{
+        text: string;
+        status: 'passed' | 'failed' | 'unverified';
+    }>>;
     formatExpectations(task: Test): string;
     sendToPilot(userText: string, functionId: string, opts: {
         tools?: boolean;

package/dist/src/ai/pilot.js

@@ -4,13 +4,14 @@ import { z } from 'zod';
 import { ActionResult } from "../action-result.js";
 import { ConfigParser } from "../config.js";
 import { TestResult } from "../test-plan.js";
-import { collectInteractiveNodes, detectFocusArea, extractFocusedElement } from "../utils/aria.js";
+import { collectInteractiveNodes, detectFocusArea } from "../utils/aria.js";
 import { ErrorPageError } from "../utils/error-page.js";
 import { createDebug, tag } from "../utils/logger.js";
 const debugLog = createDebug('explorbot:pilot');
 import { truncateJson } from "../utils/strings.js";
 import { capabilityGroundingRule, dataProtectionRules } from "./rules.js";
 import { isInteractive } from "./task-agent.js";
+import { withdrawVisionTools } from "./tools.js";
 const CHECK_TOOLS = ['verify', 'see', 'research', 'context'];
 const META_TOOLS = ['record', 'reset', 'stop', 'finish'];
 export class Pilot {
@@ -484,6 +485,50 @@ export class Pilot {
         }
         return text;
     }
+    async settleExpectations(task) {
+        const undecided = task.expected.filter((text) => !task.getCheckedExpectations().includes(text));
+        const decided = (text) => {
+            if (task.hasAchievedAny() && !task.getRemainingExpectations().includes(text))
+                return 'passed';
+            return 'failed';
+        };
+        if (!undecided.length)
+            return task.expected.map((text) => ({ text, status: decided(text) }));
+        const schema = z.object({
+            outcomes: z.array(z.object({
+                expectation: z.string().describe('The expected outcome, repeated exactly as it was given'),
+                status: z.enum(['passed', 'failed', 'unverified']).describe('passed = the log shows it happened, failed = the log shows it did not, unverified = the run never established either way'),
+            })),
+        });
+        const userContent = dedent `
+      A test run has finished. Decide, for each expected outcome, what the run established about it.
+
+      <expected_outcomes>
+      ${undecided.map((text) => `- ${text}`).join('\n')}
+      </expected_outcomes>
+
+      <run_log>
+      ${task.notesToString() || 'No steps recorded.'}
+      </run_log>
+
+      The log is written in the tester's own words, so an outcome can be satisfied by a step that describes it
+      differently. Judge by what the steps show happened, not by whether the wording matches.
+      Choose "unverified" only when the log neither shows the outcome happening nor shows it failing —
+      that is a statement about the run, not about the application.
+    `;
+        const response = await this.provider
+            .generateObject([{ role: 'user', content: userContent }], schema, this.provider.getAgenticModel('pilot'), {
+            agentName: 'pilot',
+            telemetry: { functionId: 'pilot.settleExpectations' },
+        })
+            .catch(() => null);
+        const judged = new Map((response?.object?.outcomes || []).map((outcome) => [outcome.expectation, outcome.status]));
+        return task.expected.map((text) => {
+            if (!undecided.includes(text))
+                return { text, status: decided(text) };
+            return { text, status: judged.get(text) || 'unverified' };
+        });
+    }
     formatExpectations(task) {
         const checked = task.getCheckedExpectations();
         const remaining = task.getRemainingExpectations();
@@ -547,6 +592,7 @@ export class Pilot {
             planning.learnExperience = learnExperience;
         if (askUser)
             planning.askUser = askUser;
+        withdrawVisionTools(planning);
         return planning;
     }
     buildPreconditionTool(task) {
@@ -624,7 +670,7 @@ export class Pilot {
         const lines = [];
         lines.push(`url: ${state.url}`);
         lines.push(`title: ${state.title || 'unknown'}`);
-        const focused = extractFocusedElement(state.ariaSnapshot);
+        const focused = state.focusedElement;
         if (focused) {
             const valuePart = focused.value ? ` (value: "${focused.value}")` : '';
             lines.push(`focused: ${focused.role} "${focused.name}"${valuePart}`);

package/dist/src/ai/provider.js

@@ -290,6 +290,7 @@ export class Provider {
         try {
             const response = await withRetry(async () => {
                 const result = await generateText({ messages, ...config });
+                this.recordUsage(options.agentName || 'unknown', modelName, result.usage);
                 if (!result.text) {
                     debugLog(result);
                     if (result.finishReason === 'length') {
@@ -304,7 +305,6 @@ export class Provider {
             }, this.getRetryOptions(options));
             clearActivity();
             responseLog(response.text);
-            this.recordUsage(options.agentName || 'unknown', modelName, response.usage);
             return response;
         }
         catch (error) {
@@ -340,6 +340,7 @@ export class Provider {
         try {
             const response = await withRetry(async () => {
                 const result = (await this.raceWithIdleTimeout((signal) => generateText({ messages, ...config, abortSignal: signal }), config.timeout || 30000));
+                this.recordUsage(options.agentName || 'unknown', modelName, result.usage);
                 const hasToolCall = (result.toolCalls?.length || 0) > 0;
                 if (!result.text && !hasToolCall && result.finishReason === 'length') {
                     throw new ContextLengthError('AI response empty: output truncated at maxTokens. Increase maxOutputTokens in config or use a model with higher output capacity.');
@@ -355,7 +356,6 @@ export class Provider {
                 });
             }
             responseLog(response.text);
-            this.recordUsage(options.agentName || 'unknown', modelName, response.usage);
             return response;
         }
         catch (error) {

package/dist/src/ai/rerunner.js

@@ -21,7 +21,7 @@ import { RulesLoader } from "../utils/rules-loader.js";
 import { toolExecutionLabel } from "./conversation.js";
 import { actionRule, locatorRule, sectionContextRule } from "./rules.js";
 import { TaskAgent } from "./task-agent.js";
-import { createCodeceptJSTools } from "./tools.js";
+import { createCodeceptJSTools, withdrawVisionTools } from "./tools.js";
 const debugLog = createDebug('explorbot:rerunner');
 export class Rerunner extends TaskAgent {
     ACTION_TOOLS = ['click', 'pressKey', 'form'];
@@ -322,6 +322,7 @@ export class Rerunner extends TaskAgent {
                     },
                 }),
             };
+            withdrawVisionTools(tools);
             const conversation = this.provider.startConversation(this.getHealSystemPrompt(), 'rerunner');
             conversation.addUserText(this.getHealUserPrompt(failedCode, error));
             await loop(async ({ stop }) => {

package/dist/src/ai/researcher.js

@@ -76,7 +76,7 @@ export class Researcher extends ResearcherBase {
             const cached = getCachedResearch(stateHash);
             if (cached) {
                 debugLog('Previous research result found');
-                return `!! UI MAP IS CACHED AND MAY NOT REPRESENT CURRENT STATE; REFRESH RESEARCH IF YOU NOTICE ISSUES !!\n\n${cached}`;
+                return cached;
             }
         }
         Stats.researches++;