explorbot 0.1.28 → 0.1.30

package/src/ai/historian/experience.ts

@@ -6,12 +6,12 @@ import type { Reporter, ReporterStep } from '../../reporter.ts';
 import type { StateManager } from '../../state-manager.ts';
 import { type Task, Test } from '../../test-plan.ts';
 import { tag } from '../../utils/logger.ts';
+import { isCodeceptToolName, isNonReusableCode, mergeUniqueStepsByCode, stripComments, toReusableSessionStep } from '../../utils/step-analyzer.ts';
 import { extractStatePath } from '../../utils/url-matcher.ts';
 import type { Conversation, ToolExecution } from '../conversation.ts';
 import type { Provider } from '../provider.ts';
-import { CODECEPT_TOOLS } from '../tools.ts';
 import { type Constructor, debugLog } from './mixin.ts';
-import { getExecutionLabel, isNonReusableCode, stripComments } from './utils.ts';
+import { getExecutionLabel } from './utils.ts';
 
 export interface ExperienceMethods {
   saveSession(task: Task, initialState: ActionResult, conversation: Conversation): Promise<void>;
@@ -38,12 +38,18 @@ export function WithExperience<T extends Constructor>(Base: T) {
         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);
@@ -76,7 +82,7 @@ export function WithExperience<T extends Constructor>(Base: T) {
       const stepsWithDiffs: Array<{ step: SessionStep; ariaDiff: string | null }> = [];
 
       for (const exec of toolExecutions) {
-        if (!CODECEPT_TOOLS.includes(exec.toolName as any)) continue;
+        if (!isCodeceptToolName(exec.toolName)) continue;
         if (!exec.output?.code) continue;
         if (!exec.wasSuccessful) continue;
         if (isNonReusableCode(exec.output.code)) continue;
@@ -96,6 +102,19 @@ export function WithExperience<T extends Constructor>(Base: T) {
       return stepsWithDiffs.map((s) => s.step);
     }
 
+    private hasRelevantFlowExperience(state: ActionResult): boolean {
+      return this.experienceTracker.getRelevantExperience(state).some((experience) => experience.content.includes('## FLOW:'));
+    }
+
+    private extractPassedCodeceptSteps(task: Task): SessionStep[] {
+      const steps: SessionStep[] = [];
+      for (const step of Object.values(task.steps)) {
+        const sessionStep = toReusableSessionStep(step);
+        if (sessionStep) steps.push(sessionStep);
+      }
+      return steps;
+    }
+
     private async curateFlow(steps: SessionStep[], task: Task, initialState: ActionResult): Promise<string> {
       if (steps.length === 0) return '';
 
@@ -207,6 +226,32 @@ export function WithExperience<T extends Constructor>(Base: T) {
       }
     }
 
+    private renderFlowFromSuccessfulSteps(steps: SessionStep[], task: Task): string {
+      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`;
+    }
+
     private async detectRetryPatterns(toolExecutions: ToolExecution[], initialState: ActionResult): Promise<void> {
       if (!this.experienceTracker || !this.stateManager) return;
 
@@ -214,7 +259,7 @@ export function WithExperience<T extends Constructor>(Base: T) {
       const candidates: Array<{ failed: ToolExecution[]; success: ToolExecution }> = [];
 
       for (const exec of toolExecutions) {
-        if (!CODECEPT_TOOLS.includes(exec.toolName as any)) continue;
+        if (!isCodeceptToolName(exec.toolName)) continue;
         if (!exec.output?.code) continue;
 
         if (!exec.wasSuccessful) {

package/src/ai/historian/playwright.ts

@@ -8,8 +8,9 @@ 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 } 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 } from './utils.ts';
 

package/src/ai/historian/utils.ts

@@ -1,30 +1,10 @@
-import { isDynamicId } from '../../utils/xpath.ts';
 import type { ToolExecution } from '../conversation.ts';
-
-export function isNonReusableCode(code: string): boolean {
-  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.ts';
 
 export function escapeString(str: string): string {
   return str.replace(/'/g, "\\'").replace(/\n/g, ' ');
 }
 
-export function stripComments(code: string): string {
-  return code
-    .split('\n')
-    .filter((line) => {
-      const trimmed = line.trim();
-      return trimmed && !trimmed.startsWith('//') && !trimmed.startsWith('/*') && !trimmed.startsWith('*');
-    })
-    .join('\n');
-}
-
 export function getExecutionLabel(exec: ToolExecution, fallback?: string): string {
   return exec.input?.explanation || exec.input?.assertion || exec.input?.note || fallback || '';
 }

package/src/ai/historian.ts

@@ -13,7 +13,7 @@ import { type PlaywrightMethods, WithPlaywright } from './historian/playwright.t
 import { type ScreencastMethods, WithScreencast } from './historian/screencast.ts';
 import type { Provider } from './provider.ts';
 
-export { isNonReusableCode } from './historian/utils.ts';
+export { isNonReusableCode } from '../utils/step-analyzer.ts';
 
 const HistorianBase = WithScreencast(WithPlaywright(WithCodeceptJS(WithExperience(Object as unknown as new (...args: any[]) => object))));
 

package/src/ai/pilot.ts

@@ -18,6 +18,7 @@ import type { Fisherman } from './fisherman.ts';
 import type { Navigator } from './navigator.ts';
 import type { Provider } from './provider.ts';
 import type { Researcher } from './researcher.ts';
+import { capabilityGroundingRule, dataProtectionRules } from './rules.ts';
 import { isInteractive } from './task-agent.ts';
 
 const CHECK_TOOLS = ['verify', 'see', 'research', 'context'];
@@ -91,7 +92,7 @@ export class Pilot implements Agent {
 
     let visualAnalysis = '';
     let screenshotState: ActionResult | null = null;
-    if (this.provider.hasVision()) {
+    if (type === 'finish' && this.provider.hasVision()) {
       try {
         screenshotState = await this.explorer.capturePageWithScreenshot();
         if (screenshotState.screenshot) {
@@ -164,7 +165,7 @@ export class Pilot implements Agent {
     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;
@@ -266,7 +267,7 @@ export class Pilot implements Agent {
     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;
@@ -378,6 +379,8 @@ export class Pilot implements Agent {
       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:
@@ -386,6 +389,8 @@ export class Pilot implements Agent {
         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".
@@ -424,6 +429,10 @@ export class Pilot implements Agent {
 
         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)
@@ -576,7 +585,7 @@ export class Pilot implements Agent {
       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: any) => e.toolName === 'learnExperience' && e.output?.content).map((e: any) => e.output.content);
@@ -1029,9 +1038,13 @@ export class Pilot implements Agent {
 
       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).
@@ -1041,6 +1054,8 @@ export class Pilot implements Agent {
       - 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.
 

package/src/ai/planner.ts

@@ -24,7 +24,7 @@ import type { Provider } from './provider.js';
 import { POSSIBLE_SECTIONS, Researcher } from './researcher.ts';
 import { findSimilarStateHash } from './researcher/cache.ts';
 import { hasFocusedSection } from './researcher/focus.ts';
-import { fileUploadRule, protectionRule } from './rules.ts';
+import { capabilityGroundingRule, dataProtectionRules, fileUploadRule } from './rules.ts';
 
 const debugLog = createDebug('explorbot:planner');
 
@@ -35,7 +35,7 @@ const TasksSchema = z.object({
       z.object({
         scenario: z.string().describe('A single sentence describing what to test'),
         priority: z.enum(['critical', 'important', 'high', 'normal', 'low']).describe('Priority of the task based on business importance'),
-        startUrl: z.string().nullable().describe('Start URL for the test if different from plan URL (only for tests on visited subpages)'),
+        startUrl: z.string().nullable().describe('Start URL for the test if different from plan URL. Use only stable feature/list/detail pages, not transient create/edit/modal URLs unless the scenario specifically starts inside that form.'),
         steps: z.array(z.string()).describe('List of steps to perform for this scenario. Each step should be a specific action (e.g., "Open the form", "Enter required data", "Submit the form"). Keep steps atomic and actionable.'),
         expectedOutcomes: z
           .array(z.string())
@@ -90,6 +90,9 @@ export class Planner extends PlannerBase implements Agent {
     const featureDirective = feature
       ? `\n    IMPORTANT: The user requested to focus specifically on: "${feature}"\n    ALL scenarios MUST be directly related to this feature. Do not propose generic page tests unrelated to it.\n    Use the user's exact wording to guide scenario names — do not substitute different entities (e.g., do not plan "suite" actions when user said "test").`
       : '';
+    const focusExistingDataDirective = feature
+      ? '\n    If this focus asks for search, filter, tabs, sorting, or list behavior involving existing items, only use item names/values visible in the provided page research. If no concrete visible item names/values are present, do NOT propose scenarios that require an existing known item; propose no-match search, empty-state, clear-search, tab/filter empty-list, or other read-only list behavior instead.'
+      : '';
     return dedent`
     <role>
     You are ISTQB certified senior manual QA planning exploratory testing session of a web application.
@@ -113,7 +116,7 @@ export class Planner extends PlannerBase implements Agent {
       Bad: "Open delete dropdown" + "Confirm deletion" — these are ONE test, not two.
       Bad: "Search for X" + "Verify search results" — searching and verifying is ONE test.
       Bad: "Leave field empty" + "Click submit" — that's one negative test, not two.
-      If two scenarios cannot run independently (one requires the other to run first), merge them into one.${featureDirective}
+      If two scenarios cannot run independently (one requires the other to run first), merge them into one.${featureDirective}${focusExistingDataDirective}
     </task>
 
     ${customPrompt || ''}
@@ -341,6 +344,11 @@ export class Planner extends PlannerBase implements Agent {
       If a scenario needs existing records, recipients, results, notifications, or other target data, propose it only when that data is visible or API preconditions can create it.
       If the page appears read-only, degraded, demo-limited, maintenance-like, or lacks write controls, prefer read-only scenarios such as opening panels, inspecting visible lists, filtering, searching, or verifying current state.
       Do not assume hidden data exists just because a control is present.
+      For scenarios that act on existing items or search/filter by existing values, use only item names or values visible in research, visited pages, or prior observed flows.
+      If the list is empty or no concrete item names are visible, do not invent "known" or "existing" items. Prefer empty-state, no-match search, clear-search, or read-only list behavior scenarios.
+      Search, filter, sorting, tab, and list scenarios must start from a stable page where those controls are visible; avoid transient create/edit/new URLs unless the scenario tests that form.
+      For option values and list items, use only visible or previously observed data; do not add create/update/delete setup unless the user explicitly requests that workflow.
+      Detail-view scenarios must target visible data entities from list rows, cards, tree nodes, or detail links; do not use filter tabs, counters, status tabs, breadcrumbs, or navigation controls as detail targets.
       DO NOT propose "verification-only" tests that merely open a UI element (modal, dropdown, panel) and check it exists.
       Every test must complete a meaningful action that changes application state or produces a business outcome.
       Opening a modal is NOT a test — performing an action INSIDE the modal IS a test.
@@ -351,7 +359,8 @@ export class Planner extends PlannerBase implements Agent {
       Tests that only switch views, toggle filters, or paginate are LESS valuable — propose them only after data-changing tests are covered.
       If multiple ways to create or modify data exist (different types, different forms), propose a separate test for each.
       </priority_order>
-      ${protectionRule}
+      ${capabilityGroundingRule}
+      ${dataProtectionRules}
       ${fileUploadRule}
       </rules>
 
@@ -514,7 +523,9 @@ export class Planner extends PlannerBase implements Agent {
           .join('\n')}
 
         You MAY propose tests starting from these pages if they are relevant to the plan "${this.currentPlan.title}".
-        Set startUrl for such tests. Ignore pages that belong to a different feature area.
+        Set startUrl for such tests only when the page is a stable feature/list/detail page.
+        Do not use create/edit/new/modal URLs as startUrl for scenarios that need the underlying page.
+        Ignore pages that belong to a different feature area.
         </context_from_previous_tests>
 
         Propose ONLY new scenarios that are NOT in the existing tests list.

package/src/ai/provider.ts

@@ -1,6 +1,7 @@
+import { OpenTelemetry } from '@ai-sdk/otel';
 import { LangfuseSpanProcessor } from '@langfuse/otel';
 import { NodeSDK } from '@opentelemetry/sdk-node';
-import { generateObject, generateText, stepCountIs } from 'ai';
+import { generateObject, generateText, isStepCount, registerTelemetry } from 'ai';
 import type { ModelMessage } from 'ai';
 import { clearActivity, setActivity } from '../activity.ts';
 import type { AIConfig } from '../config.js';
@@ -19,9 +20,11 @@ const responseLog = createDebug('explorbot:provider:in');
 class AiError extends Error {}
 export class ContextLengthError extends Error {}
 
+let telemetryRegistered = false;
+
 function extractCachedTokens(usage: any): number {
   if (!usage) return 0;
-  const direct = usage.cachedInputTokens ?? usage.inputTokenDetails?.cacheReadTokens;
+  const direct = usage.inputTokenDetails?.cacheReadTokens ?? usage.cachedInputTokens;
   if (typeof direct === 'number') return direct;
   const raw = usage.raw;
   const fromRaw = raw?.prompt_tokens_details?.cached_tokens ?? raw?.promptTokensDetails?.cachedTokens;
@@ -86,7 +89,7 @@ export class Provider {
       await generateText({
         model: this.config.model,
         prompt: 'hi',
-        maxTokens: 1,
+        maxOutputTokens: 1,
       });
     } catch (error: any) {
       throw new AiError(`AI connection failed: ${error.message}`);
@@ -110,6 +113,16 @@ export class Provider {
     return this.config.agenticModel || this.config.model;
   }
 
+  getConfiguredModels(): Record<string, string> {
+    const models: Record<string, string> = { model: this.getModelName(this.config.model) };
+    if (this.config.agenticModel) models.agenticModel = this.getModelName(this.config.agenticModel);
+    if (this.config.visionModel) models.visionModel = this.getModelName(this.config.visionModel);
+    for (const [agent, agentConfig] of Object.entries(this.config.agents || {})) {
+      if (agentConfig?.model) models[agent] = this.getModelName(agentConfig.model);
+    }
+    return models;
+  }
+
   getSystemPromptForAgent(agentName: string, currentUrl?: string): string | undefined {
     const agentConfig = this.config.agents?.[agentName as keyof typeof this.config.agents];
     const parts: string[] = [];
@@ -129,6 +142,12 @@ export class Provider {
     return agentConfig?.providerOptions;
   }
 
+  getReasoningForAgent(agentName?: string): string | undefined {
+    if (!agentName) return undefined;
+    const agentConfig = this.config.agents?.[agentName as keyof typeof this.config.agents];
+    return agentConfig?.reasoning;
+  }
+
   private getRetryOptions(options: any = {}): RetryOptions {
     return {
       ...this.defaultRetryOptions,
@@ -146,6 +165,12 @@ export class Provider {
     };
   }
 
+  private finalizeConfig(config: Record<string, any>, options: any, telemetry: any): void {
+    if (telemetry) config.telemetry = telemetry;
+    const reasoning = this.getReasoningForAgent(options.agentName);
+    if (reasoning) config.reasoning ??= reasoning;
+  }
+
   private initLangfuse() {
     const langfuseConfig = this.config.langfuse;
     const publicKey = langfuseConfig?.publicKey || process.env.LANGFUSE_PUBLIC_KEY;
@@ -167,6 +192,10 @@ export class Provider {
       instrumentations: [],
     });
     void this.otelSdk.start();
+    if (!telemetryRegistered) {
+      registerTelemetry(new OpenTelemetry());
+      telemetryRegistered = true;
+    }
     this.telemetryEnabled = true;
   }
 
@@ -177,20 +206,20 @@ export class Provider {
 
     const runTelemetry = Observability.getTelemetry();
 
-    if (!options.experimental_telemetry) {
-      return runTelemetry || { isEnabled: true };
+    if (!options.telemetry) {
+      return runTelemetry;
     }
 
     if (!runTelemetry) {
-      return options.experimental_telemetry;
+      return options.telemetry;
     }
 
     return {
       ...runTelemetry,
-      ...options.experimental_telemetry,
+      ...options.telemetry,
       metadata: {
         ...runTelemetry.metadata,
-        ...options.experimental_telemetry.metadata,
+        ...options.telemetry.metadata,
       },
     };
   }
@@ -242,15 +271,16 @@ export class Provider {
     const telemetry = this.getTelemetry(options);
     const config = this.mergeProviderOptions(
       {
-        maxTokens: 16384,
+        maxOutputTokens: 16384,
+        allowSystemInMessages: true,
         ...(this.config.config || {}),
         ...options,
-        ...(telemetry ? { experimental_telemetry: telemetry } : {}),
         model,
         abortSignal: executionController.getAbortSignal(),
       },
       options.agentName
     );
+    this.finalizeConfig(config, options, telemetry);
 
     promptLog(messages[messages.length - 1].content);
     try {
@@ -259,7 +289,7 @@ export class Provider {
         if (!result.text) {
           debugLog(result);
           if (result.finishReason === 'length') {
-            throw new ContextLengthError('AI response empty: output truncated at maxTokens. Increase maxTokens in config or use a model with higher output capacity.');
+            throw new ContextLengthError('AI response empty: output truncated at maxTokens. Increase maxOutputTokens in config or use a model with higher output capacity.');
           }
           throw new Error('No response text from AI');
         }
@@ -315,23 +345,24 @@ export class Provider {
     const telemetry = this.getTelemetry(options);
     const maxRoundtrips = options.maxToolRoundtrips ?? 5;
     const extraStop = options.stopWhen;
-    const stopConditions: any[] = [stepCountIs(maxRoundtrips)];
+    const stopConditions: any[] = [isStepCount(maxRoundtrips)];
     if (extraStop) stopConditions.push(extraStop);
     const { stopWhen: _ignoredStopWhen, ...optionsWithoutStop } = options;
     const config = this.mergeProviderOptions(
       {
         tools,
-        maxTokens: 16384,
+        maxOutputTokens: 16384,
         toolChoice: 'auto',
+        allowSystemInMessages: true,
         ...(this.config.config || {}),
         ...optionsWithoutStop,
         stopWhen: stopConditions,
-        ...(telemetry ? { experimental_telemetry: telemetry } : {}),
         model,
         abortSignal: executionController.getAbortSignal(),
       },
       options.agentName
     );
+    this.finalizeConfig(config, options, telemetry);
     try {
       const response = await withRetry(async () => {
         const timeout = config.timeout || 30000;
@@ -346,7 +377,7 @@ export class Provider {
           ])) as any;
           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 maxTokens in config or use a model with higher output capacity.');
+            throw new ContextLengthError('AI response empty: output truncated at maxTokens. Increase maxOutputTokens in config or use a model with higher output capacity.');
           }
           return result;
         } finally {
@@ -409,14 +440,15 @@ export class Provider {
     const config = this.mergeProviderOptions(
       {
         schema,
+        allowSystemInMessages: true,
         ...(this.config.config || {}),
         ...options,
-        ...(telemetry ? { experimental_telemetry: telemetry } : {}),
         model: modelToUse,
         abortSignal: executionController.getAbortSignal(),
       },
       options.agentName
     );
+    this.finalizeConfig(config, options, telemetry);
 
     try {
       promptLog(messages[messages.length - 1].content);
@@ -617,13 +649,13 @@ export class Provider {
     ];
 
     const telemetry = this.getTelemetry({});
-    const config = {
-      maxTokens: 16384,
+    const config: Record<string, any> = {
+      maxOutputTokens: 16384,
       ...(this.config.config || {}),
-      ...(telemetry ? { experimental_telemetry: telemetry } : {}),
       model: this.config.visionModel,
       abortSignal: executionController.getAbortSignal(),
     };
+    if (telemetry) config.telemetry = telemetry;
 
     try {
       promptLog(`Processing image with prompt: ${prompt}`);

package/src/ai/quartermaster.ts

@@ -6,9 +6,9 @@ import { ConfigParser } from '../config.ts';
 import type { StateManager, StateTransition, WebPageState } from '../state-manager.ts';
 import type { Task } from '../test-plan.ts';
 import { createDebug, tag } from '../utils/logger.ts';
+import { isCodeceptToolName } from '../utils/step-analyzer.ts';
 import type { Conversation, ToolExecution } from './conversation.ts';
 import type { Provider } from './provider.ts';
-import { CODECEPT_TOOLS } from './tools.ts';
 
 const debugLog = createDebug('explorbot:quartermaster');
 
@@ -140,7 +140,7 @@ export class Quartermaster {
       const pageAnalysis = this.pageAnalyses.get(stateHash);
 
       const toolExecutions = conversation.getToolExecutions();
-      const codeceptExecutions = toolExecutions.filter((e) => CODECEPT_TOOLS.includes(e.toolName as any));
+      const codeceptExecutions = toolExecutions.filter((e) => isCodeceptToolName(e.toolName));
 
       if (codeceptExecutions.length === 0 && !pageAnalysis?.axeViolations.length) {
         debugLog('No interactions or violations to analyze');

package/src/ai/researcher.ts

@@ -68,6 +68,13 @@ export class Researcher extends ResearcherBase implements Agent {
     this.stateManager = explorer.getStateManager();
     this.experienceTracker = this.stateManager.getExperienceTracker();
     this.hooksRunner = new HooksRunner(explorer, explorer.getConfig());
+
+    const ai = explorer.getConfig().ai;
+    if (ai) {
+      ai.agents ??= {};
+      ai.agents.researcher ??= {};
+      ai.agents.researcher.reasoning ??= 'low';
+    }
   }
 
   protected getNavigator(): Navigator {
@@ -177,7 +184,7 @@ export class Researcher extends ResearcherBase implements Agent {
       } catch (error) {
         if (!(error instanceof ContextLengthError) || retriesLeft <= 0) {
           if (error instanceof ContextLengthError) {
-            tag('warning').log('Output truncated. Try lowering reasoning effort or increasing maxTokens in ai.config.');
+            tag('warning').log('Output truncated. Try lowering reasoning effort or increasing maxOutputTokens in ai.config.');
           }
           throw error;
         }

package/src/ai/rules.ts

@@ -153,6 +153,52 @@ export const protectionRule = dedent`
   </important>
 `;
 
+export const dataProtectionRules = dedent`
+  <data_protection_rules>
+  ${protectionRule}
+
+  If the user request, scenario, focus, or test instructions explicitly prohibit creating,
+  editing, updating, deleting, removing, or otherwise mutating data, do not perform those
+  actions through the UI, API preconditions, cleanup, fallback steps, or Fisherman.
+
+  Do not use Fisherman or API data preparation to bypass a no-mutation, read-only, search,
+  filter, tab, or list-inspection constraint. Use visible existing data when it is available.
+  If no suitable data exists, report the missing precondition instead of creating data.
+
+  Destructive actions are allowed only against disposable data created by the current scenario
+  or prepared for that scenario by Fisherman/API preconditions. Existing application data must
+  remain unchanged.
+  </data_protection_rules>
+`;
+
+export const capabilityGroundingRule = dedent`
+  <capability_grounding>
+  When a scenario depends on a named action, menu item, status, option, workflow, or feature,
+  that capability must be visible or explicitly confirmed in the current research/page context
+  for the same target entity type.
+
+  Do not transfer capabilities between similar entities, rows, lists, detail pages, or menus.
+  Do not replace a requested action with a synonym or related action unless the UI explicitly
+  shows that action for the target entity.
+
+  When an action is described as applying to an item, row, card, record, node, or entity,
+  the target must be grounded as that kind of data entity in the current context. Do not use
+  navigation links, filter tabs, counters, breadcrumbs, headings, toolbar controls, or other
+  page controls as the subject of row/entity actions.
+
+  When a scenario asks to open, view, inspect, or navigate to an entity detail view, success
+  requires evidence of that entity detail context. An active filter, selected tab, visible count,
+  or filtered list is not enough to prove an entity detail view opened.
+
+  Do not rewrite a scenario goal to match a similar outcome that happened accidentally. If the
+  requested entity detail/action/workflow was not achieved, report that mismatch instead of
+  passing the test for a related filter, tab, navigation, or status view.
+
+  If the required capability is not available for the target entity after reasonable discovery,
+  record the missing capability and stop instead of repeatedly trying unrelated locators.
+  </capability_grounding>
+`;
+
 export const focusedElementRule = dedent`
   <focused_element_actions>
   When a text input element is focused (textbox, combobox, contenteditable):