explorbot 0.1.28 → 0.1.30

package/dist/boat/doc-collector/src/config.js

@@ -110,6 +110,9 @@ class DocbotConfigParser {
                 includePaths: [],
                 excludePaths: [],
                 deniedPathSegments: ['callback', 'callbacks', 'logout', 'signout', 'sign_out', 'destroy', 'delete', 'remove'],
+                deniedActionLabels: ['delete', 'remove', 'destroy', 'archive', 'discard', 'logout', 'sign out', 'signout', 'sign_out', 'erase', 'drop'],
+                maxPrimaryCandidates: 3,
+                maxInteractions: 5,
                 minCanActions: 1,
                 minInteractiveElements: 3,
             },

package/dist/boat/doc-collector/src/docbot.js

@@ -2,13 +2,14 @@ import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { ExplorBot } from "../../../src/explorbot.js";
 import { normalizeUrl } from "../../../src/state-manager.js";
-import { sanitizeFilename } from "../../../src/utils/strings.js";
 import { tag } from "../../../src/utils/logger.js";
+import { sanitizeFilename } from "../../../src/utils/strings.js";
 import { Documentarian } from "./ai/documentarian.js";
 import { DocbotConfigParser } from "./config.js";
 import { renderPageDocumentation, renderSpecIndex } from "./docs-renderer.js";
 import { getDocPageKey, shouldCrawlDocPath } from "./path-filter.js";
 import { extractResearchNavigationTargets } from "./research-navigation.js";
+import { captureDocumentationScreenshots } from "./screenshots.js";
 class DocBot {
     explorBot;
     configParser;
@@ -105,7 +106,7 @@ class DocBot {
                     documented.add(pageKey);
                     continue;
                 }
-                const filePath = this.savePageDocumentation(state, documentation);
+                const filePath = await this.savePageDocumentation(state, documentation, research);
                 pages.push({
                     url: state.url,
                     title: state.title || '',
@@ -347,11 +348,22 @@ class DocBot {
         const matches = [...research.matchAll(/\((\d+) elements?\)/g)];
         return matches.reduce((sum, match) => sum + Number.parseInt(match[1], 10), 0);
     }
-    savePageDocumentation(state, documentation) {
+    async savePageDocumentation(state, documentation, research) {
         const pagePath = this.getPageFilePath(state.url);
-        writeFileSync(pagePath, renderPageDocumentation(state, documentation), 'utf8');
+        const screenshots = await this.captureScreenshots(state, research, pagePath);
+        writeFileSync(pagePath, renderPageDocumentation(state, documentation, screenshots), 'utf8');
         return pagePath;
     }
+    async captureScreenshots(state, research, pagePath) {
+        if (!this.shouldUseScreenshots()) {
+            return [];
+        }
+        return captureDocumentationScreenshots(this.explorBot.getExplorer(), state, research, {
+            pageFilePath: pagePath,
+            screenshotsDir: this.getScreenshotsDir(),
+            config: this.config,
+        });
+    }
     saveIndex(startPath, pages, skipped, maxPages) {
         const indexPath = path.join(this.configParser.getOutputDir(), 'spec.md');
         writeFileSync(indexPath, renderSpecIndex(this.configParser.getOutputDir(), startPath, pages, skipped, maxPages), 'utf8');
@@ -360,6 +372,9 @@ class DocBot {
     getPagesDir() {
         return path.join(this.configParser.getOutputDir(), 'pages');
     }
+    getScreenshotsDir() {
+        return path.join(this.configParser.getOutputDir(), 'screenshots');
+    }
     getPageFilePath(pageUrl) {
         const normalized = normalizeUrl(pageUrl || '/');
         const baseName = sanitizeFilename(normalized || 'root');

package/dist/boat/doc-collector/src/docs-renderer.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-function renderPageDocumentation(state, documentation) {
+function renderPageDocumentation(state, documentation, screenshots = []) {
     const lines = [];
     lines.push(`# ${state.url}`);
     lines.push('');
@@ -11,6 +11,17 @@ function renderPageDocumentation(state, documentation) {
     lines.push('');
     lines.push(ensureSentence(documentation.summary));
     lines.push('');
+    if (screenshots.length > 0) {
+        lines.push('## Screenshots');
+        lines.push('');
+        for (const screenshot of screenshots) {
+            lines.push(`![${normalizeInlineText(screenshot.title)}](${screenshot.relativePath})`);
+            if (screenshot.selector) {
+                lines.push(`Section: \`${screenshot.selector}\``);
+            }
+            lines.push('');
+        }
+    }
     const interactions = documentation.interactions;
     if (interactions && interactions.length > 0) {
         lines.push('## State Transitions');

package/dist/boat/doc-collector/src/screenshots.js

@@ -0,0 +1,90 @@
+import { mkdirSync } from 'node:fs';
+import path from 'node:path';
+import { parseResearchSections } from "../../../src/ai/researcher/parser.js";
+import { safeFilename, sanitizeFilename } from "../../../src/utils/strings.js";
+const DEFAULT_MAX_SECTION_SCREENSHOTS = 8;
+export async function captureDocumentationScreenshots(explorer, state, research, options) {
+    const page = explorer.playwrightHelper?.page;
+    if (!page) {
+        return [];
+    }
+    mkdirSync(options.screenshotsDir, { recursive: true });
+    const screenshots = [];
+    const pageName = sanitizeFilename(state.url || 'page') || 'page';
+    const fullPage = await captureFullPageScreenshot(page, pageName, options);
+    if (fullPage) {
+        screenshots.push(fullPage);
+    }
+    const maxSections = getMaxSectionScreenshots(options.config);
+    for (const section of getScreenshotSections(research).slice(0, maxSections)) {
+        const screenshot = await captureSectionScreenshot(page, pageName, section, options);
+        if (!screenshot) {
+            continue;
+        }
+        screenshots.push(screenshot);
+    }
+    return screenshots;
+}
+export function getScreenshotSections(research) {
+    const sections = [];
+    const seen = new Set();
+    for (const section of parseResearchSections(research)) {
+        if (!section.containerCss) {
+            continue;
+        }
+        if (section.elements.length === 0) {
+            continue;
+        }
+        if (seen.has(section.containerCss)) {
+            continue;
+        }
+        seen.add(section.containerCss);
+        sections.push({
+            title: section.name,
+            selector: section.containerCss,
+        });
+    }
+    return sections;
+}
+async function captureFullPageScreenshot(page, pageName, options) {
+    const filePath = path.join(options.screenshotsDir, safeFilename(`${pageName}_page`, '.png'));
+    try {
+        await page.screenshot({ path: filePath, fullPage: true });
+    }
+    catch {
+        return null;
+    }
+    return {
+        title: 'Page screenshot',
+        path: filePath,
+        relativePath: toMarkdownPath(options.pageFilePath, filePath),
+        kind: 'page',
+    };
+}
+async function captureSectionScreenshot(page, pageName, section, options) {
+    const sectionName = sanitizeFilename(section.title) || 'section';
+    const filePath = path.join(options.screenshotsDir, safeFilename(`${pageName}_${sectionName}`, '.png'));
+    try {
+        await page.locator(section.selector).first().screenshot({ path: filePath });
+    }
+    catch {
+        return null;
+    }
+    return {
+        title: section.title,
+        path: filePath,
+        relativePath: toMarkdownPath(options.pageFilePath, filePath),
+        kind: 'section',
+        selector: section.selector,
+    };
+}
+function getMaxSectionScreenshots(config) {
+    const configured = config.docs?.maxSectionScreenshots;
+    if (configured && configured > 0) {
+        return configured;
+    }
+    return DEFAULT_MAX_SECTION_SCREENSHOTS;
+}
+function toMarkdownPath(pageFilePath, assetPath) {
+    return path.relative(path.dirname(pageFilePath), assetPath).replaceAll('\\', '/');
+}

package/dist/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/dist/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/dist/src/action.js

@@ -10,11 +10,13 @@ import { ActionResult } from './action-result.js';
 import { clearActivity, setActivity } from "./activity.js";
 import { ConfigParser, outputPath } from './config.js';
 import { Observability } from "./observability.js";
+import { isFatalBrowserError, isNavigationTransitionError } from "./utils/browser-errors.js";
 import { htmlCombinedSnapshot, minifyHtml } from './utils/html.js';
 import { createDebug, setStepSpanParent, tag } from './utils/logger.js';
+import { waitForPageReadiness } from "./utils/page-readiness.js";
 import { safeFilename } from "./utils/strings.js";
-import { isFatalBrowserError } from "./utils/browser-errors.js";
 const debugLog = createDebug('explorbot:action');
+const CAPTURE_NAVIGATION_TRANSITION_ATTEMPTS = 3;
 class Action {
     actor;
     stateManager;
@@ -63,17 +65,24 @@ 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) => {
-                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 = [];
+            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.grabCurrentUrl?.());
             let screenshotFile = undefined;
             const statesDir = outputPath('states');
@@ -399,6 +408,12 @@ class Action {
     getActionResult() {
         return this.actionResult;
     }
+    async waitForPageReadiness(page) {
+        await waitForPageReadiness(page, {
+            timeout: this.config.playwright.waitForTimeout,
+            spinnerSelectors: this.config.playwright.spinnerSelectors,
+        });
+    }
 }
 export default Action;
 function errorToString(error) {
@@ -407,18 +422,6 @@ function errorToString(error) {
     }
     return error.message || error.toString();
 }
-async function waitForUsablePageDom(page) {
-    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, frame, actor) {
     if (frame?.content)
         return frame.content();

package/dist/src/ai/fisherman.js

@@ -4,6 +4,7 @@ import { createDebug, tag } from "../utils/logger.js";
 const debugLog = createDebug('explorbot:fisherman');
 import { loop } from "../utils/loop.js";
 import { createFishermanTools } from "./fisherman-tools.js";
+import { dataProtectionRules } from "./rules.js";
 const MAX_ITERATIONS = 15;
 const MAX_TOOL_ROUNDTRIPS = 5;
 export class Fisherman {
@@ -65,7 +66,7 @@ export class Fisherman {
             spec: this.spec,
             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(async ({ stop, iteration }) => {
             debugLog(`iteration ${iteration}`);
@@ -149,7 +150,7 @@ export class Fisherman {
         }
         return lines.join('\n');
     }
-    buildSystemPrompt(endpointList, scopeUrl) {
+    buildSystemPrompt(endpointList, toolNames, scopeUrl) {
         const scopeBlock = scopeUrl ? `\n\nSCOPE: You are operating within ${scopeUrl}.\nAll created items must belong to this scope.` : '';
         return dedent `
       You are Fisherman — a data preparation agent. You create test data by making API requests.
@@ -158,6 +159,11 @@ export class Fisherman {
       ${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
@@ -169,6 +175,8 @@ export class Fisherman {
       - 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}
     `;
     }
     buildTaskPrompt(instructions) {
@@ -177,7 +185,10 @@ export class Fisherman {
 
       ${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/dist/src/ai/historian/codeceptjs.js

@@ -6,8 +6,9 @@ import { KnowledgeTracker } from "../../knowledge-tracker.js";
 import { tag } from "../../utils/logger.js";
 import { relativeToCwd } from "../../utils/next-steps.js";
 import { safeFilename } from "../../utils/strings.js";
-import { ASSERTION_TOOLS, CODECEPT_TOOLS } from "../tools.js";
-import { escapeString, getExecutionLabel, isNonReusableCode, stripComments } from "./utils.js";
+import { CODECEPT_TOOLS, isNonReusableCode, stripComments } from "../../utils/step-analyzer.js";
+import { ASSERTION_TOOLS } from "../tools.js";
+import { escapeString, getExecutionLabel } from "./utils.js";
 export function WithCodeceptJS(Base) {
     return class extends Base {
         toCode(conversation, scenario) {

package/dist/src/ai/historian/experience.js

@@ -3,10 +3,10 @@ import { z } from 'zod';
 import { ActionResult } from "../../action-result.js";
 import { Test } from "../../test-plan.js";
 import { tag } from "../../utils/logger.js";
+import { isCodeceptToolName, isNonReusableCode, mergeUniqueStepsByCode, stripComments, toReusableSessionStep } from "../../utils/step-analyzer.js";
 import { extractStatePath } from "../../utils/url-matcher.js";
-import { CODECEPT_TOOLS } from "../tools.js";
 import { debugLog } from "./mixin.js";
-import { getExecutionLabel, isNonReusableCode, stripComments } from "./utils.js";
+import { getExecutionLabel } from "./utils.js";
 export function WithExperience(Base) {
     return class extends Base {
         async saveSession(task, initialState, conversation) {
@@ -16,11 +16,17 @@ export function WithExperience(Base) {
             if (task instanceof Test) {
                 task.generatedCode = this.isPlaywrightFramework() ? await this.toPlaywrightCode(conversation, task.description) : this.toCode(conversation, task.description);
             }
-            const steps = await this.extractSteps(toolExecutions);
+            const conversationSteps = await this.extractSteps(toolExecutions);
+            const taskSteps = this.extractPassedCodeceptSteps(task);
+            const steps = mergeUniqueStepsByCode(conversationSteps, taskSteps);
             const skipExperience = result === 'failed' || (task instanceof Test && (task.hasFailed || task.isSkipped));
             if (!skipExperience) {
+                const hasExistingFlow = this.hasRelevantFlowExperience(initialState);
                 await this.detectRetryPatterns(toolExecutions, initialState);
-                const body = await this.curateFlow(steps, task, initialState);
+                let body = await this.curateFlow(steps, task, initialState);
+                if (!body.trim() && !hasExistingFlow) {
+                    body = this.renderFlowFromSuccessfulSteps(steps, task);
+                }
                 if (body.trim()) {
                     const relatedUrls = this.extractVisitedUrls(toolExecutions, initialState.url || '');
                     this.experienceTracker.writeFlow(initialState, body, relatedUrls);
@@ -46,7 +52,7 @@ export function WithExperience(Base) {
         async extractSteps(toolExecutions) {
             const stepsWithDiffs = [];
             for (const exec of toolExecutions) {
-                if (!CODECEPT_TOOLS.includes(exec.toolName))
+                if (!isCodeceptToolName(exec.toolName))
                     continue;
                 if (!exec.output?.code)
                     continue;
@@ -65,6 +71,18 @@ export function WithExperience(Base) {
             await this.analyzeDiscoveries(stepsWithDiffs);
             return stepsWithDiffs.map((s) => s.step);
         }
+        hasRelevantFlowExperience(state) {
+            return this.experienceTracker.getRelevantExperience(state).some((experience) => experience.content.includes('## FLOW:'));
+        }
+        extractPassedCodeceptSteps(task) {
+            const steps = [];
+            for (const step of Object.values(task.steps)) {
+                const sessionStep = toReusableSessionStep(step);
+                if (sessionStep)
+                    steps.push(sessionStep);
+            }
+            return steps;
+        }
         async curateFlow(steps, task, initialState) {
             if (steps.length === 0)
                 return '';
@@ -167,13 +185,37 @@ export function WithExperience(Base) {
                 return '';
             }
         }
+        renderFlowFromSuccessfulSteps(steps, task) {
+            if (steps.length === 0)
+                return '';
+            const title = task.description.charAt(0).toLowerCase() + task.description.slice(1);
+            const blocks = steps
+                .filter((step) => step.code)
+                .map((step) => {
+                const lines = [`* ${step.message}`];
+                lines.push('');
+                lines.push('```js');
+                lines.push(stripComments(step.code || ''));
+                lines.push('```');
+                if (step.discovery) {
+                    lines.push('');
+                    for (const discovery of step.discovery.split('\n').filter((line) => line.trim())) {
+                        lines.push(`> ${discovery.trim()}`);
+                    }
+                }
+                return lines.join('\n');
+            });
+            if (blocks.length === 0)
+                return '';
+            return `## FLOW: ${title}\n\n${blocks.join('\n\n')}\n\n---\n`;
+        }
         async detectRetryPatterns(toolExecutions, initialState) {
             if (!this.experienceTracker || !this.stateManager)
                 return;
             const failedByTool = new Map();
             const candidates = [];
             for (const exec of toolExecutions) {
-                if (!CODECEPT_TOOLS.includes(exec.toolName))
+                if (!isCodeceptToolName(exec.toolName))
                     continue;
                 if (!exec.output?.code)
                     continue;

package/dist/src/ai/historian/playwright.js

@@ -7,7 +7,8 @@ import { renderAssertion, renderCall } from "../../playwright-recorder.js";
 import { tag } from "../../utils/logger.js";
 import { relativeToCwd } from "../../utils/next-steps.js";
 import { safeFilename } from "../../utils/strings.js";
-import { ASSERTION_TOOLS, CODECEPT_TOOLS } from "../tools.js";
+import { CODECEPT_TOOLS } from "../../utils/step-analyzer.js";
+import { ASSERTION_TOOLS } from "../tools.js";
 import { escapeString, getExecutionLabel } from "./utils.js";
 const PLAYWRIGHT_EMITTED_TOOLS = [...CODECEPT_TOOLS, ...ASSERTION_TOOLS];
 export function WithPlaywright(Base) {

package/dist/src/ai/historian/utils.js

@@ -1,25 +1,7 @@
-import { isDynamicId } from "../../utils/xpath.js";
-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 { isNonReusableCode, stripComments } from "../../utils/step-analyzer.js";
 export function escapeString(str) {
     return str.replace(/'/g, "\\'").replace(/\n/g, ' ');
 }
-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 getExecutionLabel(exec, fallback) {
     return exec.input?.explanation || exec.input?.assertion || exec.input?.note || fallback || '';
 }

package/dist/src/ai/historian.js

@@ -6,7 +6,7 @@ import { WithCodeceptJS } from "./historian/codeceptjs.js";
 import { WithExperience } from "./historian/experience.js";
 import { WithPlaywright } from "./historian/playwright.js";
 import { WithScreencast } from "./historian/screencast.js";
-export { isNonReusableCode } from "./historian/utils.js";
+export { isNonReusableCode } from "../utils/step-analyzer.js";
 const HistorianBase = WithScreencast(WithPlaywright(WithCodeceptJS(WithExperience(Object))));
 export class Historian extends HistorianBase {
     constructor(provider, experienceTracker, reporter, stateManager, config, playwright) {

package/dist/src/ai/pilot.js

@@ -10,6 +10,7 @@ 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";
 const CHECK_TOOLS = ['verify', 'see', 'research', 'context'];
 const META_TOOLS = ['record', 'reset', 'stop', 'finish'];
@@ -71,7 +72,7 @@ export class Pilot {
         const notes = task.notesToString() || 'No notes recorded.';
         let visualAnalysis = '';
         let screenshotState = null;
-        if (this.provider.hasVision()) {
+        if (type === 'finish' && this.provider.hasVision()) {
             try {
                 screenshotState = await this.explorer.capturePageWithScreenshot();
                 if (screenshotState.screenshot) {
@@ -139,7 +140,7 @@ export class Pilot {
         try {
             const response = await this.provider.generateObject(messages, schema, this.provider.getAgenticModel('pilot'), {
                 agentName: 'pilot',
-                experimental_telemetry: { functionId: 'pilot.reviewVerdict' },
+                telemetry: { functionId: 'pilot.reviewVerdict' },
             });
             const result = response?.object;
             if (!result) {
@@ -229,7 +230,7 @@ export class Pilot {
         try {
             const response = await this.provider.generateObject(messages, schema, this.provider.getAgenticModel('pilot'), {
                 agentName: 'pilot',
-                experimental_telemetry: { functionId: 'pilot.reviewReset' },
+                telemetry: { functionId: 'pilot.reviewReset' },
             });
             const result = response?.object;
             if (!result) {
@@ -333,6 +334,8 @@ export class Pilot {
       You are Pilot — final decision maker for test pass/fail. Tester requested ${type}. Review the
       evidence and commit to a verdict; "continue" only when evidence is genuinely insufficient.
 
+      ${capabilityGroundingRule}
+
       ${this.buildSharedEvidenceRules(task)}
 
       DECISION:
@@ -341,6 +344,8 @@ export class Pilot {
         Pick assertions DOM can express; for non-DOM regions (iframes, canvas, Monaco/CodeMirror), target a
         stable landmark (container, ARIA role) instead of literal inner text. Your "pass" stands even if the
         DOM assertion can't be made.
+        Do not pass when Tester achieved only a related navigation/filter/tab/status outcome instead of the
+        requested action, workflow, or entity detail goal.
       - "fail": scenario was attempted but the goal was not achieved.
       - "skipped": scenario is irrelevant to the app, OR systematic infrastructure failures (LLM errors,
         crashes) prevented testing. NOT for "test failed to interact" — that's "fail" or "continue".
@@ -374,6 +379,10 @@ export class Pilot {
 
         FIRST: Decide if precondition() is needed.
 
+        ${capabilityGroundingRule}
+
+        ${dataProtectionRules}
+
         Call precondition() WHEN:
         - The scenario edits/deletes/modifies an item, and you want a DISPOSABLE item to act on safely
         - The scenario needs specific data clearly NOT on the current page (e.g., items with specific statuses for filtering)
@@ -498,7 +507,7 @@ export class Pilot {
             maxToolRoundtrips: opts.maxToolRoundtrips ?? 0,
             agentName: 'pilot',
             stopWhen: opts.task ? () => opts.task.hasFinished : undefined,
-            experimental_telemetry: { functionId },
+            telemetry: { functionId },
         });
         const text = result?.response?.text || '';
         const learned = (result?.toolExecutions || []).filter((e) => e.toolName === 'learnExperience' && e.output?.content).map((e) => e.output.content);
@@ -930,9 +939,13 @@ export class Pilot {
 
       Tester tools: click, pressKey, form, see, verify, context, research, xpathCheck, visualClick,
       back, getVisitedStates, reset, stop, finish, record.
+      Use tool names exactly as listed. Do not invent combined names, aliases, or names with channel markers such as "commentary".
+
+      ${capabilityGroundingRule}
 
       YOUR Pilot-only tool: precondition(description) — create FRESH disposable test data via API. Never
       request users. Use when:
+
       - Scenario edits/deletes/modifies an item → create a disposable target ("1 post").
       - Scenario needs auxiliary data (labels, categories, statuses for filtering).
       - Tester failed because required data is missing (empty dropdown, empty list).
@@ -942,6 +955,8 @@ export class Pilot {
       - Current page already shows the exact data needed.
       - Scenario tests navigation, search UI, or viewing.
 
+      ${dataProtectionRules}
+
       Describe WHAT to create, not what exists. RIGHT: precondition("1 test"). WRONG:
       precondition("1 test suite named Updated Suite with existing tests"). Keep descriptions short.