explorbot 0.1.28 → 0.1.30

package/dist/src/experience-tracker.js

@@ -2,11 +2,11 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSy
 import { basename, dirname, join } from 'node:path';
 import matter from 'gray-matter';
 import { marked } from 'marked';
-import { isNonReusableCode } from "./ai/historian/utils.js";
 import { ConfigParser } from './config.js';
 import { KnowledgeTracker } from './knowledge-tracker.js';
 import { createDebug, tag } from './utils/logger.js';
 import { mdq } from './utils/markdown-query.js';
+import { isNonReusableCode } from "./utils/step-analyzer.js";
 import { extractStatePath } from './utils/url-matcher.js';
 const debugLog = createDebug('explorbot:experience');
 const DEFAULT_MAX_EXPERIENCE_LINES = 100;

package/dist/src/explorbot.js

@@ -23,11 +23,12 @@ import { ConfigParser } from "./config.js";
 import { ExperienceTracker } from "./experience-tracker.js";
 import Explorer from "./explorer.js";
 import { KnowledgeTracker } from "./knowledge-tracker.js";
+import { Stats } from "./stats.js";
 import { Plan } from "./test-plan.js";
-import { parsePlansFromMarkdown } from "./utils/test-plan-markdown.js";
 import { setVerboseMode, tag } from "./utils/logger.js";
 import { relativeToCwd } from "./utils/next-steps.js";
 import { sanitizeFilename } from "./utils/strings.js";
+import { parsePlansFromMarkdown } from "./utils/test-plan-markdown.js";
 export class ExplorBot {
     configParser;
     explorer;
@@ -179,7 +180,13 @@ export class ExplorBot {
             this.agents.tester = this.createAgent(({ ai, explorer }) => {
                 const researcher = this.agentResearcher();
                 const navigator = this.agentNavigator();
-                const tools = createAgentTools({ explorer, researcher, navigator });
+                const stateManager = explorer.getStateManager();
+                const experienceTracker = stateManager.getExperienceTracker();
+                const getState = () => {
+                    const state = stateManager.getCurrentState();
+                    return state ? ActionResult.fromState(state) : null;
+                };
+                const tools = createAgentTools({ explorer, researcher, navigator, experienceTracker, getState });
                 return new Tester(explorer, ai, researcher, navigator, tools);
             });
             const qm = this.agentQuartermaster();
@@ -427,7 +434,11 @@ export class ExplorBot {
             tag('info').log(`Session report saved: ${relativeToCwd(filePath)}`);
             const reporter = this.explorer?.getReporter();
             if (reporter?.isEnabled()) {
-                await reporter.setRunDescription(markdown);
+                let description = markdown;
+                const modelsTable = Stats.modelsTable(this.provider.getConfiguredModels());
+                if (modelsTable)
+                    description = `${markdown}\n\n${modelsTable}`;
+                await reporter.setRunDescription(description);
             }
             this.lastReportedTestCount = tests.length;
         }

package/dist/src/explorer.js

@@ -2,10 +2,10 @@ import { existsSync, mkdirSync } from 'node:fs';
 import path from 'node:path';
 // @ts-ignore
 import * as codeceptjs from 'codeceptjs';
-import dedent from 'dedent';
 import stepsListener from 'codeceptjs/lib/listener/steps';
 import storeListener from 'codeceptjs/lib/listener/store';
 import { createTest } from 'codeceptjs/lib/mocha/test';
+import dedent from 'dedent';
 import { ActionResult } from "./action-result.js";
 import Action from './action.js';
 import { visuallyAnnotateContainers } from "./ai/researcher/coordinates.js";
@@ -17,10 +17,11 @@ import { PlaywrightRecorder } from "./playwright-recorder.js";
 import { Reporter } from "./reporter.js";
 import { StateManager } from './state-manager.js';
 import { TestResult } from "./test-plan.js";
+import { BrowserRecoveryError, isFatalBrowserError, isNavigationTransitionError } from "./utils/browser-errors.js";
 import { ELEMENT_EXTRACTION_CONFIG, getElementDataExtractorSource } from "./utils/html.js";
 import { createDebug, log, tag } from './utils/logger.js';
+import { waitForPageReadiness } from "./utils/page-readiness.js";
 import { WebElement } from "./utils/web-element.js";
-import { BrowserRecoveryError, isFatalBrowserError } from "./utils/browser-errors.js";
 const debugLog = createDebug('explorbot:explorer');
 const RECOVERABLE_NAVIGATION_ERRORS = /net::ERR_ABORTED|page\.screenshot.*Timeout|waiting for fonts to load/i;
 class Explorer {
@@ -250,16 +251,29 @@ class Explorer {
             return await operation();
         }
         catch (error) {
-            if (!this.isFatalBrowserError(error))
-                throw error;
+            let recoveryError = error;
+            if (isNavigationTransitionError(error)) {
+                tag('warning').log(`${label}: page is still navigating, waiting before retry...`);
+                await this.waitForPageReadiness();
+                try {
+                    return await operation();
+                }
+                catch (retryError) {
+                    if (!isNavigationTransitionError(retryError) && !this.isFatalBrowserError(retryError))
+                        throw retryError;
+                    recoveryError = retryError;
+                }
+            }
+            if (!this.isFatalBrowserError(recoveryError))
+                throw recoveryError;
             tag('warning').log(`${label}: browser page is unavailable, recovering...`);
             let recovered = await this.recoverFromBrowserError();
             if (!recovered)
                 recovered = await this.restartBrowser();
             if (!recovered)
-                throw new BrowserRecoveryError(label, error, false);
-            if (!(await this.waitForUsablePageDom()))
-                throw new BrowserRecoveryError(label, error, true);
+                throw new BrowserRecoveryError(label, recoveryError, false);
+            if (!(await this.waitForPageReadiness()))
+                throw new BrowserRecoveryError(label, recoveryError, true);
             try {
                 return await operation();
             }
@@ -308,7 +322,7 @@ class Explorer {
                 if (!RECOVERABLE_NAVIGATION_ERRORS.test(msg))
                     throw err;
                 tag('warning').log(`Navigation warning (continuing after load): ${msg.split('\n')[0]}`);
-                await this.playwrightHelper.page.waitForLoadState('domcontentloaded', { timeout: 10000 }).catch(() => { });
+                await this.waitForPageReadiness();
                 await action.capturePageState();
             }
         }
@@ -412,11 +426,11 @@ class Explorer {
             if (url) {
                 tag('warning').log(`Browser error detected, recovering by navigating to ${url}`);
                 await this.playwrightHelper.page.goto(url, { waitUntil: 'domcontentloaded', timeout: 10000 });
-                return this.waitForUsablePageDom();
+                return this.waitForPageReadiness();
             }
             tag('warning').log('Browser error detected, reloading page');
             await this.playwrightHelper.page.reload({ waitUntil: 'domcontentloaded', timeout: 10000 });
-            return this.waitForUsablePageDom();
+            return this.waitForPageReadiness();
         }
         catch (err) {
             tag('error').log(`Browser recovery failed: ${err instanceof Error ? err.message : err}`);
@@ -450,7 +464,7 @@ class Explorer {
             this.listenToStateChanged();
             if (url) {
                 await this.playwrightHelper.page.goto(url, { waitUntil: 'domcontentloaded', timeout: 10000 });
-                if (!(await this.waitForUsablePageDom()))
+                if (!(await this.waitForPageReadiness()))
                     return false;
             }
             tag('success').log('Browser restarted');
@@ -467,25 +481,14 @@ class Explorer {
             await this.playwrightHelper.switchTo();
         }
     }
-    async waitForUsablePageDom() {
+    async waitForPageReadiness() {
         const page = this.playwrightHelper?.page;
         if (!page)
             return false;
-        await page.waitForLoadState?.('domcontentloaded', { timeout: 5000 }).catch(() => { });
-        if (page.waitForFunction) {
-            const hasUsableDom = await page
-                .waitForFunction(() => {
-                const body = document.body;
-                if (!body)
-                    return false;
-                return body.children.length > 0 || body.textContent?.trim().length > 0;
-            }, undefined, { timeout: 5000 })
-                .then(() => true)
-                .catch(() => false);
-            if (!hasUsableDom)
-                return false;
-        }
-        await page.waitForLoadState?.('networkidle', { timeout: 3000 }).catch(() => { });
+        await waitForPageReadiness(page, {
+            timeout: this.config.playwright.waitForTimeout,
+            spinnerSelectors: this.config.playwright.spinnerSelectors,
+        });
         return true;
     }
     async isInsideIframe() {

package/dist/src/stats.js

@@ -39,6 +39,22 @@ export class Stats {
         }
         return String(num);
     }
+    static modelsTable(roleModels) {
+        const usedModels = Object.entries(Stats.models).filter(([, tokens]) => tokens.total > 0);
+        if (usedModels.length === 0)
+            return '';
+        const rolesByModel = {};
+        for (const [role, model] of Object.entries(roleModels)) {
+            if (!rolesByModel[model])
+                rolesByModel[model] = [];
+            rolesByModel[model].push(role);
+        }
+        const rows = usedModels.map(([model, tokens]) => {
+            const roles = rolesByModel[model]?.join(', ') || '-';
+            return `| ${roles} | ${model} | ${Stats.humanizeTokens(tokens.total)} |`;
+        });
+        return ['## Models', '', '| Role | Model | Tokens |', '| --- | --- | --- |', ...rows].join('\n');
+    }
     static hasActivity() {
         if (Stats.tests > 0 || Stats.plans > 0 || Stats.researches > 0)
             return true;

package/dist/src/utils/aria.js

@@ -334,6 +334,56 @@ const detectRenames = (prev, curr, prevTotals, currTotals) => {
     }
     return { added, removed };
 };
+// Interactive controls keep a stable role+name across a state flip; only an ARIA state
+// attribute changes. Report those flips on their own line so the model always sees
+// "now checked / now collapsed", in both directions, regardless of other page churn.
+const STATE_WORDS = {
+    checked: { on: 'checked', off: 'unchecked' },
+    selected: { on: 'selected', off: 'unselected' },
+    pressed: { on: 'pressed', off: 'unpressed' },
+    expanded: { on: 'expanded', off: 'collapsed' },
+};
+const STATE_ATTRS = Object.keys(STATE_WORDS);
+const stateWord = (attr, value) => {
+    if (attr === 'checked' && value === 'mixed')
+        return 'partially checked';
+    const words = STATE_WORDS[attr];
+    if (value === true || value === 'true')
+        return words.on;
+    return words.off;
+};
+// Pair entries by path; when role and name match but a state attr differs, it's a toggle.
+const detectToggles = (prev, curr) => {
+    const toggled = [];
+    const togglePaths = new Set();
+    const currByPath = new Map(curr.map((e) => [e.path, e]));
+    for (const before of prev) {
+        const after = currByPath.get(before.path);
+        if (!after)
+            continue;
+        if (before.entry.role !== after.entry.role)
+            continue;
+        if (before.entry.name !== after.entry.name)
+            continue;
+        const transitions = [];
+        for (const attr of STATE_ATTRS) {
+            const was = stateWord(attr, before.entry[attr]);
+            const now = stateWord(attr, after.entry[attr]);
+            if (was === now)
+                continue;
+            transitions.push(`${was} -> ${now}`);
+        }
+        if (transitions.length === 0)
+            continue;
+        togglePaths.add(before.path);
+        let label = String(after.entry.role);
+        const name = after.entry.name;
+        if (typeof name === 'string' && name.trim())
+            label += ` "${name.trim()}"`;
+        toggled.push(`${label}: ${transitions.join(', ')}`);
+    }
+    return { toggled, togglePaths };
+};
 const TOP_DIFF_ITEMS = 10;
 const formatDiffSection = (label, items) => {
     const summary = countBy(items);
@@ -357,10 +407,17 @@ const formatDiffSection = (label, items) => {
     }
     return lines;
 };
-const formatDiff = (added, removed) => {
-    if (added.length === 0 && removed.length === 0)
+const formatDiff = (added, removed, toggled) => {
+    if (added.length === 0 && removed.length === 0 && toggled.length === 0)
         return null;
-    return ['ariaDiff:', ...formatDiffSection('added', added), ...formatDiffSection('removed', removed)].join('\n');
+    const sections = ['ariaDiff:'];
+    if (toggled.length > 0) {
+        sections.push('  toggled:');
+        for (const line of toggled)
+            sections.push(`    - ${line}`);
+    }
+    sections.push(...formatDiffSection('added', added), ...formatDiffSection('removed', removed));
+    return sections.join('\n');
 };
 const CLOSE_OVERLAY_BUTTON_RE = /^close\s+(modal|dialog|popup|drawer|panel|sheet)\b/i;
 const findOverlayByCloseButton = (nodeList) => {
@@ -424,13 +481,16 @@ export const diffAriaSnapshots = (previous, current) => {
         tree = dropEmpty(tree);
         return flatten(tree);
     };
-    const prev = flat(previous);
-    const curr = flat(current);
+    const prevAll = flat(previous);
+    const currAll = flat(current);
+    const { toggled, togglePaths } = detectToggles(prevAll, currAll);
+    const prev = prevAll.filter((e) => !togglePaths.has(e.path));
+    const curr = currAll.filter((e) => !togglePaths.has(e.path));
     const prevTotals = countBy(prev.map((e) => e.summary));
     const currTotals = countBy(curr.map((e) => e.summary));
     const byCount = diffByCount(prevTotals, currTotals);
     const renames = detectRenames(prev, curr, prevTotals, currTotals);
-    return formatDiff([...byCount.added, ...renames.added], [...byCount.removed, ...renames.removed]);
+    return formatDiff([...byCount.added, ...renames.added], [...byCount.removed, ...renames.removed], toggled);
 };
 export const detectFocusArea = (snapshot) => {
     let tree = parseSnapshot(snapshot);

package/dist/src/utils/browser-errors.js

@@ -2,6 +2,7 @@
 // not typed exceptions. Keep those external message markers in one adapter so
 // recovery decisions are not duplicated across agents/actions.
 const FATAL_BROWSER_ERROR_MARKERS = ['Frame was detached', 'Target closed', 'Target page, context or browser has been closed', 'Execution context was destroyed', 'Protocol error', 'Session closed'];
+const NAVIGATION_TRANSITION_ERROR_MARKERS = ['most likely because of a navigation', 'navigating and changing the content'];
 export class BrowserRecoveryError extends Error {
     originalError;
     recovered;
@@ -18,6 +19,10 @@ export function isFatalBrowserError(error) {
     const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
     return FATAL_BROWSER_ERROR_MARKERS.some((marker) => message.includes(marker.toLowerCase()));
 }
+export function isNavigationTransitionError(error) {
+    const message = browserErrorMessage(error).toLowerCase();
+    return NAVIGATION_TRANSITION_ERROR_MARKERS.some((marker) => message.includes(marker.toLowerCase()));
+}
 export function browserErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/dist/src/utils/page-readiness.js

@@ -0,0 +1,48 @@
+export async function waitForPageReadiness(page, options = {}) {
+    if (!page)
+        return;
+    const timeout = options.timeout ?? 6000;
+    await page.waitForLoadState?.('domcontentloaded', { timeout })?.catch(() => { });
+    await Promise.race([waitForNetworkIdle(page, timeout), waitForVisibleSpinnersHidden(page, options.spinnerSelectors || [], timeout), sleep(timeout)]).catch(() => { });
+    await waitForPageBodyContent(page, timeout);
+}
+function waitForNetworkIdle(page, timeout) {
+    if (!page?.waitForLoadState)
+        return Promise.resolve();
+    return page.waitForLoadState('networkidle', { timeout }).catch(() => { });
+}
+async function waitForVisibleSpinnersHidden(page, selectors, timeout) {
+    if (!selectors.length)
+        return new Promise(() => { });
+    if (!page?.locator)
+        return new Promise(() => { });
+    const visibleSpinners = [];
+    for (const selector of selectors) {
+        const locator = page.locator(selector);
+        const isVisible = await locator
+            .first()
+            .isVisible({ timeout: 100 })
+            .catch(() => false);
+        if (!isVisible)
+            continue;
+        visibleSpinners.push(locator);
+    }
+    if (visibleSpinners.length === 0)
+        return new Promise(() => { });
+    return Promise.all(visibleSpinners.map((locator) => locator.waitFor({ state: 'hidden', timeout }).catch(() => { }))).then(() => { });
+}
+function waitForPageBodyContent(page, timeout) {
+    if (!page?.waitForFunction)
+        return Promise.resolve();
+    return page
+        .waitForFunction(() => {
+        const body = document.body;
+        if (!body)
+            return false;
+        return body.children.length > 0 || body.textContent?.trim().length > 0;
+    }, undefined, { timeout })
+        .catch(() => { });
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/src/utils/step-analyzer.js

@@ -0,0 +1,68 @@
+import { isDynamicId } from "./xpath.js";
+export const CODECEPT_TOOLS = ['click', 'hover', 'pressKey', 'form'];
+const CODECEPT_FORM_COMMANDS = ['I.fillField', 'I.type', 'I.selectOption', 'I.attachFile', 'I.checkOption', 'I.uncheckOption'];
+export function isCodeceptToolName(toolName) {
+    return CODECEPT_TOOLS.includes(toolName);
+}
+export function getCodeceptToolName(commandName) {
+    const toolName = CODECEPT_TOOLS.find((name) => commandName === `I.${name}`);
+    if (toolName)
+        return toolName;
+    if (CODECEPT_FORM_COMMANDS.includes(commandName))
+        return 'form';
+    return null;
+}
+export function getCodeceptToolNameFromCode(code) {
+    const parenIndex = code.trim().indexOf('(');
+    if (parenIndex < 1)
+        return null;
+    return getCodeceptToolName(code.trim().slice(0, parenIndex));
+}
+export function stripComments(code) {
+    return code
+        .split('\n')
+        .filter((line) => {
+        const trimmed = line.trim();
+        return trimmed && !trimmed.startsWith('//') && !trimmed.startsWith('/*') && !trimmed.startsWith('*');
+    })
+        .join('\n');
+}
+export function isNonReusableCode(code) {
+    if (/\bI\.clickXY\s*\(/.test(code))
+        return true;
+    for (const m of code.matchAll(/#([A-Za-z_][\w-]*)/g)) {
+        if (isDynamicId(m[1]))
+            return true;
+    }
+    return false;
+}
+export function toReusableSessionStep(step) {
+    if (step.status !== 'passed')
+        return null;
+    const code = stripComments(step.text);
+    if (!code || isNonReusableCode(code))
+        return null;
+    const toolName = getCodeceptToolNameFromCode(code);
+    if (!toolName)
+        return null;
+    return {
+        message: step.text,
+        status: 'passed',
+        tool: toolName,
+        code,
+    };
+}
+export function mergeUniqueStepsByCode(primary, secondary) {
+    const merged = [];
+    const seen = new Set();
+    for (const step of [...primary, ...secondary]) {
+        const identity = stripComments(step.code || '').trim();
+        if (!identity)
+            continue;
+        if (seen.has(identity))
+            continue;
+        seen.add(identity);
+        merged.push(step);
+    }
+    return merged;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "explorbot",
-  "version": "0.1.28",
+  "version": "0.1.30",
   "description": "CLI app built with React Ink, CodeceptJS, and Playwright",
   "license": "Elastic-2.0",
   "type": "module",
@@ -65,9 +65,10 @@
   },
   "author": "",
   "dependencies": {
-    "@ai-sdk/anthropic": "^3.0",
-    "@ai-sdk/groq": "^3.0",
-    "@ai-sdk/openai": "^3.0",
+    "@ai-sdk/anthropic": "^4.0",
+    "@ai-sdk/groq": "^4.0",
+    "@ai-sdk/openai": "^4.0",
+    "@ai-sdk/otel": "^1.0.2",
     "@axe-core/playwright": "^4.11.0",
     "@codeceptjs/reflection": "^0.5.2",
     "@faker-js/faker": "^10.4.0",
@@ -82,8 +83,8 @@
     "@opentelemetry/sdk-trace-base": "^2.2.0",
     "@opentelemetry/semantic-conventions": "^1.38.0",
     "@scalar/openapi-parser": "^0.25.6",
-    "@testomatio/reporter": "^2.8.4",
-    "ai": "^6.0.6",
+    "@testomatio/reporter": "^2.9.1",
+    "ai": "^7.0.2",
     "axe-core": "^4.11.1",
     "bash-tool": "^1.3.15",
     "cli-highlight": "^2.1.11",
@@ -110,6 +111,7 @@
     "parse5": "^8.0.0",
     "playwright": "^1.60",
     "react": "^19.1.1",
+    "sambanova-ai-provider": "^1.2.2",
     "strip-ansi": "^7.1.2",
     "turndown": "^7.2.1",
     "unique-names-generator": "^4.7.1",

package/rules/navigator/verification-actions.md

@@ -113,6 +113,8 @@ For input field values, ALWAYS use I.seeInField() — never check value via CSS
 Prefer text locators (label, name, placeholder) for form fields: I.seeInField('Search', 'value') over I.seeInField('input[name="search"]', 'value').
 Only use locators that exist in the provided HTML or ARIA snapshot.
 Verify exact conditions, not approximate matches.
+When the claim contains a concrete quoted value, generated assertion code MUST include that whole value. Do not shorten names, IDs, titles, emails, URLs, or other user-created values.
+For exact visible text, prefer a text assertion scoped to a specific container or an ARIA locator with the complete text. Partial text is not valid evidence for a claim about the full value.
 NEVER use `:has-text(...)` inside a seeElement/dontSeeElement locator. Checking text inside an element is the job of I.see(text, context) — the `:has-text()` form duplicates that capability with a fragile selector.
 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>

package/src/action.ts

@@ -18,14 +18,16 @@ import type { UserResolveFunction } from './explorbot.ts';
 import { Observability } from './observability.ts';
 import type { PlaywrightRecorder } from './playwright-recorder.ts';
 import type { StateManager } from './state-manager.js';
+import { isFatalBrowserError, isNavigationTransitionError } from './utils/browser-errors.ts';
 import { extractCodeBlocks } from './utils/code-extractor.js';
 import { htmlCombinedSnapshot, minifyHtml } from './utils/html.js';
 import { createDebug, setStepSpanParent, tag } from './utils/logger.js';
+import { waitForPageReadiness } from './utils/page-readiness.ts';
 import { safeFilename } from './utils/strings.ts';
 import { throttle } from './utils/throttle.ts';
-import { isFatalBrowserError } from './utils/browser-errors.ts';
 
 const debugLog = createDebug('explorbot:action');
+const CAPTURE_NAVIGATION_TRANSITION_ATTEMPTS = 3;
 
 class Action {
   private actor: CodeceptJS.I;
@@ -78,16 +80,21 @@ class Action {
       const timestamp = Date.now();
       const page = this.playwrightHelper.page;
       const frame = this.playwrightHelper.frame;
-      await page?.waitForLoadState('domcontentloaded', { timeout: 10000 })?.catch(() => {});
-      await waitForUsablePageDom(page);
+      await this.waitForPageReadiness(page);
       const grabAll = () => Promise.all([captureHtml(page, frame, this.actor), captureTitle(page, this.actor), this.captureBrowserLogs()]);
-      const [html, title, browserLogs] = await grabAll().catch(async (err: Error) => {
-        const msg = err instanceof Error ? err.message : String(err);
-        if (!/navigating and changing the content/i.test(msg)) throw err;
-        await page?.waitForLoadState('domcontentloaded', { timeout: 10000 })?.catch(() => {});
-        await waitForUsablePageDom(page);
-        return grabAll();
-      });
+      let html = '';
+      let title = '';
+      let browserLogs: any[] = [];
+      for (let attempt = 1; attempt <= CAPTURE_NAVIGATION_TRANSITION_ATTEMPTS; attempt++) {
+        try {
+          [html, title, browserLogs] = await grabAll();
+          break;
+        } catch (err) {
+          if (!isNavigationTransitionError(err)) throw err;
+          if (attempt === CAPTURE_NAVIGATION_TRANSITION_ATTEMPTS) throw err;
+          await this.waitForPageReadiness(page);
+        }
+      }
       const url = page?.url() || (await (this.actor as any).grabCurrentUrl?.());
 
       let screenshotFile: string | undefined = undefined;
@@ -442,6 +449,13 @@ class Action {
   getActionResult(): ActionResult | null {
     return this.actionResult;
   }
+
+  private async waitForPageReadiness(page: any): Promise<void> {
+    await waitForPageReadiness(page, {
+      timeout: this.config.playwright.waitForTimeout,
+      spinnerSelectors: this.config.playwright.spinnerSelectors,
+    });
+  }
 }
 
 export default Action;
@@ -453,22 +467,6 @@ function errorToString(error: any): string {
   return error.message || error.toString();
 }
 
-async function waitForUsablePageDom(page: any): Promise<void> {
-  if (!page?.waitForFunction) return;
-
-  await page
-    .waitForFunction(
-      () => {
-        const body = document.body;
-        if (!body) return false;
-        return body.children.length > 0 || body.textContent?.trim().length > 0;
-      },
-      undefined,
-      { timeout: 5000 }
-    )
-    .catch(() => {});
-}
-
 async function captureHtml(page: any, frame: any, actor: any): Promise<string> {
   if (frame?.content) return frame.content();
   if (page?.content) return page.content();

package/src/ai/fisherman.ts

@@ -9,6 +9,7 @@ import { loop } from '../utils/loop.ts';
 import type { Agent } from './agent.ts';
 import { type FishermanResult, createFishermanTools } from './fisherman-tools.ts';
 import type { Provider } from './provider.ts';
+import { dataProtectionRules } from './rules.ts';
 
 const MAX_ITERATIONS = 15;
 const MAX_TOOL_ROUNDTRIPS = 5;
@@ -85,7 +86,7 @@ export class Fisherman implements Agent {
       baseEndpoint: this.baseEndpoint,
     });
 
-    const conversation = this.provider.startConversation(this.buildSystemPrompt(endpointList, scopeUrl), 'fisherman');
+    const conversation = this.provider.startConversation(this.buildSystemPrompt(endpointList, Object.keys(tools), scopeUrl), 'fisherman');
     conversation.addUserText(this.buildTaskPrompt(instructions));
 
     await loop(
@@ -187,7 +188,7 @@ export class Fisherman implements Agent {
     return lines.join('\n');
   }
 
-  private buildSystemPrompt(endpointList: string, scopeUrl?: string): string {
+  private buildSystemPrompt(endpointList: string, toolNames: string[], scopeUrl?: string): string {
     const scopeBlock = scopeUrl ? `\n\nSCOPE: You are operating within ${scopeUrl}.\nAll created items must belong to this scope.` : '';
 
     return dedent`
@@ -197,6 +198,11 @@ export class Fisherman implements Agent {
       ${endpointList}
       ${scopeBlock}
 
+      AVAILABLE TOOLS:
+      ${toolNames.join(', ')}.
+      Use tool names exactly as listed. Do not invent aliases, combined names, or names with channel markers such as "commentary".
+      Match each tool input schema exactly. Do not invent parameter names or pass extra fields.
+
       WORKFLOW:
       1. Call getEndpointSpec to see the request body example for the endpoint
       2. Make requests — the response automatically extracts IDs, names, and status fields
@@ -208,6 +214,8 @@ export class Fisherman implements Agent {
       - Chain requests logically — create parent resources before children
       - If a request fails, try once more with adjusted data before reporting failure
       - Use realistic but unique data for each item (vary names, titles)
+
+      ${dataProtectionRules}
     `;
   }
 
@@ -217,7 +225,10 @@ export class Fisherman implements Agent {
 
       ${instructions}
 
-      Execute the necessary API requests to create this data. When done, call finish with the summary.
+      ${dataProtectionRules}
+
+      If data preparation is allowed by these rules, execute the necessary API requests to create this data.
+      When done, call finish with the summary. If data preparation is forbidden, call stop with the reason.
     `;
   }
 }

package/src/ai/historian/codeceptjs.ts

@@ -7,10 +7,11 @@ import type { Plan } from '../../test-plan.ts';
 import { tag } from '../../utils/logger.ts';
 import { relativeToCwd } from '../../utils/next-steps.ts';
 import { safeFilename } from '../../utils/strings.ts';
+import { CODECEPT_TOOLS, isNonReusableCode, stripComments } from '../../utils/step-analyzer.ts';
 import type { Conversation } from '../conversation.ts';
-import { ASSERTION_TOOLS, CODECEPT_TOOLS } from '../tools.ts';
+import { ASSERTION_TOOLS } from '../tools.ts';
 import type { Constructor } from './mixin.ts';
-import { escapeString, getExecutionLabel, isNonReusableCode, stripComments } from './utils.ts';
+import { escapeString, getExecutionLabel } from './utils.ts';
 
 export interface CodeceptJSMethods {
   toCode(conversation: Conversation, scenario: string): string;