explorbot 0.2.4 → 0.2.5

package/src/ai/pilot.ts

@@ -7,6 +7,7 @@ import { ConfigParser } from '../config.ts';
 import type Explorer from '../explorer.ts';
 import type { PlaywrightRecorder } from '../playwright-recorder.ts';
 import type { StateManager } from '../state-manager.ts';
+import { Stats } from '../stats.ts';
 import { type Test, TestResult } from '../test-plan.ts';
 import { collectInteractiveNodes, detectFocusArea } from '../utils/aria.ts';
 import { ErrorPageError } from '../utils/error-page.ts';
@@ -562,24 +563,46 @@ export class Pilot implements Agent {
     return text;
   }
 
-  async settleExpectations(task: Test): Promise<Array<{ text: string; status: 'passed' | 'failed' | 'unverified' }>> {
-    const undecided = task.expected.filter((text) => !task.getCheckedExpectations().includes(text));
+  async settleExpectations(task: Test, finalState?: ActionResult): Promise<SettledExpectation[]> {
+    let image: string | null = null;
+    if (finalState?.screenshot && this.provider.hasVision()) image = `data:image/png;base64,${finalState.screenshot.toString('base64')}`;
+
     const decided = (text: string): 'passed' | 'failed' => {
       if (task.hasAchievedAny() && !task.getRemainingExpectations().includes(text)) return 'passed';
       return 'failed';
     };
 
+    let undecided = task.expected.filter((text) => !task.getCheckedExpectations().includes(text));
+    if (image) undecided = task.expected;
     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'),
+          status: z.enum(['passed', 'failed', 'unverified', 'contradiction']).describe('passed = the evidence shows it happened, failed = the evidence shows it did not, unverified = the run never established either way, contradiction = the picture and the run disagree'),
+          evidence: z.string().nullable().describe('What settled it. For a contradiction, what each side shows. Null when there is nothing to add'),
         })
       ),
     });
 
+    let pageEvidence = '';
+    if (image) {
+      pageEvidence = dedent`
+        A screenshot of the whole page as the run left it is attached. It is the proof: an outcome is satisfied
+        when the page shows it to somebody looking at it. The log only says what the run did.
+
+        Not finding something in the picture is not by itself a disagreement. Report "contradiction" only when
+        the picture shows something incompatible with what the run claims — a list visibly empty, an error where
+        a result was expected, the old value still displayed, a control visibly disabled. When you simply cannot
+        make it out, say "unverified" and name what you could not find.
+
+        The picture covers the full page, but not the inside of a region that scrolls on its own, and not the
+        state of the page before the run ended. An outcome established earlier stays established even when the
+        page has moved past it, and that is not a contradiction.
+      `;
+    }
+
     const userContent = dedent`
       A test run has finished. Decide, for each expected outcome, what the run established about it.
 
@@ -591,23 +614,43 @@ export class Pilot implements Agent {
       ${task.notesToString() || 'No steps recorded.'}
       </run_log>
 
+      ${pageEvidence}
+
       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 —
+      Choose "unverified" only when the evidence 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' as const, content: userContent }], schema, this.provider.getAgenticModel('pilot'), {
-        agentName: 'pilot',
-        telemetry: { functionId: 'pilot.settleExpectations' },
-      })
-      .catch(() => null);
+    const settle = (content: any, model: any) =>
+      this.provider
+        .generateObject([{ role: 'user' as const, content }], schema, model, {
+          agentName: 'pilot',
+          telemetry: { functionId: 'pilot.settleExpectations' },
+        })
+        .catch(() => null);
+
+    let response = null;
+    if (image) {
+      const seen = [
+        { type: 'text', text: userContent },
+        { type: 'file', mediaType: 'image/png', data: image },
+      ];
+      response = await settle(seen, this.provider.getVisionModel());
+      if (!response) {
+        Stats.visionDisabled = true;
+        tag('warning').log('⚠️ Vision model could not judge the outcomes. Settling them from the run log instead.');
+      }
+    }
+
+    if (!response) response = await settle(userContent, this.provider.getAgenticModel('pilot'));
 
-    const judged = new Map((response?.object?.outcomes || []).map((outcome: any) => [outcome.expectation, outcome.status]));
+    const judged = new Map((response?.object?.outcomes || []).map((outcome: any) => [outcome.expectation, outcome]));
     return task.expected.map((text) => {
       if (!undecided.includes(text)) return { text, status: decided(text) };
-      return { text, status: (judged.get(text) as 'passed' | 'failed' | 'unverified') || 'unverified' };
+      const outcome = judged.get(text) as { status: SettledStatus; evidence?: string } | undefined;
+      if (!outcome) return { text, status: 'unverified' as SettledStatus };
+      return { text, status: outcome.status || 'unverified', evidence: outcome.evidence };
     });
   }
 
@@ -1116,3 +1159,11 @@ export class Pilot implements Agent {
     `;
   }
 }
+
+export type SettledStatus = 'passed' | 'failed' | 'unverified' | 'contradiction';
+
+export interface SettledExpectation {
+  text: string;
+  status: SettledStatus;
+  evidence?: string;
+}

package/src/ai/provider.ts

@@ -4,7 +4,7 @@ import { NodeSDK } from '@opentelemetry/sdk-node';
 import { generateObject, generateText, isStepCount, registerTelemetry } from 'ai';
 import type { ModelMessage } from 'ai';
 import { clearActivity, setActivity } from '../activity.ts';
-import type { AIConfig } from '../config.js';
+import { type AIConfig, configuredModels, modelName as getModelName } from '../config.js';
 import { executionController } from '../execution-controller.ts';
 import { Observability } from '../observability.ts';
 import { Stats } from '../stats.ts';
@@ -88,10 +88,6 @@ export class Provider {
     this.initLangfuse();
   }
 
-  private getModelName(model: any): string {
-    return model?.modelId || model?.model || 'unknown';
-  }
-
   async validateConnection(): Promise<void> {
     try {
       await generateText({
@@ -120,13 +116,13 @@ export class Provider {
     return this.config.agenticModel || this.config.model;
   }
 
+  getVisionModel(): any {
+    return this.config.visionModel;
+  }
+
   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);
-    }
+    const models: Record<string, string> = {};
+    for (const [role, model] of Object.entries(configuredModels(this.config))) models[role] = model.name;
     return models;
   }
 
@@ -223,11 +219,7 @@ export class Provider {
   }
 
   private initLangfuse() {
-    const langfuseConfig = this.config.langfuse;
-    const publicKey = langfuseConfig?.publicKey || process.env.LANGFUSE_PUBLIC_KEY;
-    const secretKey = langfuseConfig?.secretKey || process.env.LANGFUSE_SECRET_KEY;
-    const baseUrl = langfuseConfig?.baseUrl || process.env.LANGFUSE_BASE_URL || process.env.LANGFUSE_HOST;
-    const enabled = langfuseConfig?.enabled ?? Boolean(publicKey && secretKey);
+    const { enabled, publicKey, secretKey, baseUrl } = this.config.langfuse || {};
 
     if (!enabled || !publicKey || !secretKey) {
       return;
@@ -316,7 +308,7 @@ export class Provider {
   }
 
   async chat(messages: ModelMessage[], model: any, options: any = {}): Promise<any> {
-    const modelName = this.getModelName(model);
+    const modelName = getModelName(model);
     setActivity(`🤖 Asking ${modelName}`, 'ai');
     promptLog(`Using model: ${modelName}`);
 
@@ -360,7 +352,7 @@ export class Provider {
   }
 
   async generateWithTools(messages: ModelMessage[], model: any, tools: any, options: any = {}): Promise<any> {
-    const modelName = this.getModelName(model);
+    const modelName = getModelName(model);
     setActivity(`🤖 Asking ${modelName} with dynamic tools`, 'ai');
     promptLog(`Using model: ${modelName}`);
 
@@ -418,7 +410,7 @@ export class Provider {
 
   async generateObject(messages: ModelMessage[], schema: any, model?: any, options: any = {}): Promise<any> {
     const modelToUse = model || this.config.model;
-    const modelName = this.getModelName(modelToUse);
+    const modelName = getModelName(modelToUse);
     setActivity(`🤖 Asking ${modelName} for structured output`, 'ai');
     promptLog(`Using model: ${modelName}`);
 
@@ -620,7 +612,7 @@ export class Provider {
       clearActivity();
       responseLog(response.text);
 
-      this.recordUsage('vision', this.getModelName(this.config.visionModel), response.usage);
+      this.recordUsage('vision', getModelName(this.config.visionModel), response.usage);
 
       return response;
     } catch (error: any) {

package/src/ai/researcher/cache.ts

@@ -4,6 +4,7 @@ import { Worker } from 'node:worker_threads';
 import { outputPath } from '../../config.ts';
 import { TTLCache } from '../../utils/cache.ts';
 import { computeHtmlFingerprint } from '../../utils/html-diff.ts';
+import { tag } from '../../utils/logger.ts';
 import { debugLog } from './mixin.ts';
 
 const CACHE_TTL_MS = 6 * 60 * 60 * 1000; // 6 hours
@@ -15,6 +16,14 @@ const memoryCache = new TTLCache<string>(CACHE_TTL_MS);
 
 let fingerprintWorker: Worker | null = null;
 
+export function researchPath(hash: string): string {
+  return outputPath('research', `${hash}.md`);
+}
+
+export function reportResearch(hash: string, text: string): void {
+  tag('data').log('research', { path: researchPath(hash), hash, content: text });
+}
+
 function getStatesDir(): string {
   return outputPath('states');
 }
@@ -35,7 +44,7 @@ export function getCachedResearch(hash: string): string {
   if (!hash) return '';
   const cached = memoryCache.get(hash);
   if (cached !== undefined) return cached;
-  const researchFile = outputPath('research', `${hash}.md`);
+  const researchFile = researchPath(hash);
   if (!existsSync(researchFile)) return '';
   const stats = statSync(researchFile);
   if (Date.now() - stats.mtimeMs > CACHE_TTL_MS) return '';
@@ -46,7 +55,7 @@ export function getCachedResearch(hash: string): string {
 
 export function getPreviousResearch(hash: string): string {
   if (!hash) return '';
-  const researchFile = outputPath('research', `${hash}.md`);
+  const researchFile = researchPath(hash);
   if (!existsSync(researchFile)) return '';
   return readFileSync(researchFile, 'utf8');
 }
@@ -57,6 +66,7 @@ export function saveResearch(hash: string, text: string, combinedHtml?: string):
   if (!existsSync(researchDir)) mkdirSync(researchDir, { recursive: true });
   writeFileSync(researchFile, text);
   memoryCache.set(hash, text);
+  reportResearch(hash, text);
   debugLog(`Research saved to ${researchFile}`);
 
   if (combinedHtml) {

package/src/ai/researcher.ts

@@ -19,7 +19,7 @@ import { annotatePageElements } from '../utils/web-annotate.ts';
 import type { Agent, AgentDeps } from './agent.js';
 import type { Navigator } from './navigator.ts';
 import { ContextLengthError, type Provider } from './provider.js';
-import { findSimilarResearch, getCachedResearch, saveResearch } from './researcher/cache.ts';
+import { findSimilarResearch, getCachedResearch, reportResearch, saveResearch } from './researcher/cache.ts';
 import { type CoordinateMethods, WithCoordinates } from './researcher/coordinates.ts';
 import { type DeepAnalysisMethods, WithDeepAnalysis } from './researcher/deep-analysis.ts';
 import { detectFocusedSection, hasFocusedSection, markSectionAsFocused, pickDefaultFocusedSection } from './researcher/focus.ts';
@@ -102,6 +102,7 @@ export class Researcher extends ResearcherBase implements Agent {
       const cached = getCachedResearch(stateHash);
       if (cached) {
         debugLog('Previous research result found');
+        reportResearch(stateHash, cached);
         return cached;
       }
     }

package/src/ai/session-analyst.ts

@@ -4,6 +4,7 @@ import dedent from 'dedent';
 import { outputPath } from '../config.ts';
 import { Stats } from '../stats.ts';
 import type { Test } from '../test-plan.ts';
+import { tag } from '../utils/logger.ts';
 import type { Agent } from './agent.ts';
 import type { Provider } from './provider.ts';
 
@@ -117,6 +118,7 @@ export class SessionAnalyst implements Agent {
     const dir = path.dirname(filePath);
     if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
     writeFileSync(filePath, markdown);
+    tag('data').log('report', { path: filePath, content: markdown });
     return filePath;
   }
 

package/src/ai/tester.ts

@@ -96,7 +96,7 @@ export class Tester extends TaskAgent implements Agent {
     return this.currentConversation;
   }
 
-  async test(task: Test): Promise<{ success: boolean }> {
+  async test(task: Test, opts: TestOptions = {}): Promise<{ success: boolean }> {
     Stats.tests++;
     const state = this.stateManager.getCurrentState();
     if (!state) throw new Error('No state found');
@@ -151,11 +151,11 @@ export class Tester extends TaskAgent implements Agent {
           expected: task.expected,
         },
       },
-      async () => this.runTestSession(task, initialState, conversation, { offFailedRequest })
+      async () => this.runTestSession(task, initialState, conversation, { offFailedRequest }, opts)
     );
   }
 
-  private async runTestSession(task: Test, initialState: ActionResult, conversation: Conversation, handlers: TestSessionHandlers): Promise<{ success: boolean }> {
+  private async runTestSession(task: Test, initialState: ActionResult, conversation: Conversation, handlers: TestSessionHandlers, opts: TestOptions): Promise<{ success: boolean }> {
     const { offFailedRequest } = handlers;
 
     if (this.pilot) {
@@ -187,15 +187,19 @@ export class Tester extends TaskAgent implements Agent {
       return { success: task.isSuccessful };
     }
 
-    debugLog(`Navigating to ${task.startUrl}`);
-    try {
-      await this.explorer.visit(task.startUrl!);
-    } catch (error) {
-      const result = await this.handleLoopError(task, error);
-      if (result === 'stop') {
-        offFailedRequest?.();
-        await this.cleanupStartedTest(task);
-        return { success: task.isSuccessful };
+    if (opts.startOnCurrentPage) debugLog(`Starting on the page already open at ${task.startUrl}`);
+
+    if (!opts.startOnCurrentPage) {
+      debugLog(`Navigating to ${task.startUrl}`);
+      try {
+        await this.explorer.visit(task.startUrl!);
+      } catch (error) {
+        const result = await this.handleLoopError(task, error);
+        if (result === 'stop') {
+          offFailedRequest?.();
+          await this.cleanupStartedTest(task);
+          return { success: task.isSuccessful };
+        }
       }
     }
 
@@ -1160,3 +1164,7 @@ export class Tester extends TaskAgent implements Agent {
 interface TestSessionHandlers {
   offFailedRequest?: () => void;
 }
+
+export interface TestOptions {
+  startOnCurrentPage?: boolean;
+}

package/src/ai/tools.ts

@@ -810,7 +810,10 @@ export function createAgentTools({ explorer, stateManager, ai, researcher, navig
             });
           }
 
-          return failedToolResult('interact', `Failed to execute: ${instruction}`, {
+          let reason = '';
+          if (navigator.lastFailureReason) reason = `: ${navigator.lastFailureReason}`;
+
+          return failedToolResult('interact', `Failed to execute: ${instruction}${reason}`, {
             ...toolResult,
             suggestion: 'The action could not be completed. Try a different instruction or use more specific element descriptions.',
           });

package/src/commands/config-command.ts

@@ -0,0 +1,146 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+import { type AIConfig, ConfigParser, EXPLORBOT_ENV_VARS, type ReporterConfig, configuredModels } from '../config.js';
+import { listSites } from '../global-config.js';
+import { Reporter } from '../reporter.js';
+import { getCliName } from '../utils/cli-name.js';
+import { tag } from '../utils/logger.js';
+import { BaseCommand } from './base-command.js';
+
+export class ConfigCommand extends BaseCommand {
+  name = 'config';
+  description = 'Show models, config file and paths used by this run';
+
+  async execute(): Promise<void> {
+    const parser = ConfigParser.getInstance();
+    tag('info').log(ConfigCommand.render(this.explorBot.getConfig(), { configPath: parser.getConfigPath(), root: parser.getProjectRoot() }));
+  }
+
+  static async summary(options: { config?: string; path?: string; url?: string; json?: boolean } = {}): Promise<string> {
+    const parser = ConfigParser.getInstance();
+    const [site] = listSites();
+    const load = (baseUrl?: string) => parser.loadConfig({ config: options.config, path: options.path, baseUrl });
+
+    const config = await load(options.url).catch((error) => {
+      if (!site) throw error;
+      return load(site.url);
+    });
+
+    return ConfigCommand.render(config, { configPath: parser.getConfigPath(), root: parser.getProjectRoot(), json: options.json });
+  }
+
+  static data(config: SummarizedConfig, options: ConfigSummaryOptions = {}): ConfigData {
+    let configPath = '';
+    if (options.configPath && existsSync(options.configPath)) configPath = options.configPath;
+
+    const dirs: Record<string, string> = {};
+    if (options.root) {
+      for (const [name, dir] of Object.entries({ output: 'output', ...config.dirs })) {
+        dirs[name] = path.join(options.root, dir);
+      }
+    }
+
+    const env: Record<string, string> = {};
+    for (const variable of EXPLORBOT_ENV_VARS) {
+      const value = process.env[variable.name];
+      if (value) env[variable.name] = value;
+    }
+
+    const models: Record<string, string> = {};
+    const providers: Record<string, string> = {};
+    for (const [role, model] of Object.entries(configuredModels(config.ai))) {
+      models[role] = model.name;
+      if (model.provider) providers[role] = model.provider;
+    }
+
+    return {
+      config: configPath,
+      url: config.playwright?.url || config.web?.url || config.api?.baseEndpoint || '',
+      browser: config.playwright?.browser || '',
+      headless: !config.playwright?.show,
+      dirs,
+      models,
+      providers,
+      integrations: {
+        langfuse: !!config.ai?.langfuse?.enabled,
+        testomatio: Reporter.resolveEnabled(config.reporter),
+      },
+      env,
+    };
+  }
+
+  static render(config: SummarizedConfig, options: ConfigSummaryOptions = {}): string {
+    const data = ConfigCommand.data(config, options);
+    if (options.json) return JSON.stringify(data, null, 2);
+
+    const lines: string[] = [];
+    const section = (title: string, entries: [string, string][]) => {
+      if (!entries.length) return;
+      const width = Math.max(...entries.map(([label]) => label.length));
+      lines.push(chalk.bold(title));
+      for (const [label, value] of entries) lines.push(`  ${chalk.dim(label.padEnd(width))}  ${value}`);
+      lines.push('');
+    };
+
+    const general: [string, string][] = [['config', data.config || 'EXPLORBOT_* environment variables']];
+    if (data.url) general.push(['url', data.url]);
+    if (data.browser) {
+      let window = 'visible';
+      if (data.headless) window = 'headless';
+      general.push(['browser', `${data.browser}, ${window}`]);
+    }
+    for (const [name, dir] of Object.entries(data.dirs)) general.push([name, dir]);
+    section('Config', general);
+
+    const providerWidth = Math.max(0, ...Object.values(data.providers).map((provider) => provider.length));
+    const models: [string, string][] = Object.entries(data.models).map(([role, model]) => {
+      if (!providerWidth) return [role, model];
+      return [role, `${chalk.dim((data.providers[role] || '').padEnd(providerWidth))}  ${model}`];
+    });
+    if (!models.length) models.push(['model', chalk.red(`not configured — run ${getCliName()} init`)]);
+    section('Models', models);
+
+    const integrations: [string, string][] = [];
+    if (data.integrations.langfuse) integrations.push(['langfuse', 'traces sent']);
+    if (data.integrations.testomatio) integrations.push(['testomatio', 'runs reported']);
+    section('Integrations', integrations);
+
+    const env: [string, string][] = Object.entries(data.env).map(([name, value]) => {
+      let shown = value;
+      if (shown.length > 60) shown = `${shown.slice(0, 57)}...`;
+      return [name, shown];
+    });
+    section('Environment', env);
+
+    lines.push(chalk.dim(`Every EXPLORBOT_* variable: ${getCliName()} --help`));
+    return lines.join('\n');
+  }
+}
+
+interface ConfigSummaryOptions {
+  configPath?: string | null;
+  root?: string;
+  json?: boolean;
+}
+
+export interface ConfigData {
+  config: string;
+  url: string;
+  browser: string;
+  headless: boolean;
+  dirs: Record<string, string>;
+  models: Record<string, string>;
+  providers: Record<string, string>;
+  integrations: { langfuse: boolean; testomatio: boolean };
+  env: Record<string, string>;
+}
+
+interface SummarizedConfig {
+  ai?: AIConfig;
+  playwright?: { url?: string; browser?: string; show?: boolean };
+  web?: { url?: string };
+  api?: { baseEndpoint?: string };
+  dirs?: Record<string, string>;
+  reporter?: ReporterConfig;
+}

package/src/commands/index.ts

@@ -3,6 +3,7 @@ import { AddRuleCommand } from './add-rule-command.js';
 import type { BaseCommand } from './base-command.js';
 import { CleanCommand } from './clean-command.js';
 import { CompactCommand } from './compact-command.js';
+import { ConfigCommand } from './config-command.js';
 import { ContextAriaCommand } from './context-aria-command.js';
 import { ContextCommand } from './context-command.js';
 import { ContextDataCommand } from './context-data-command.js';
@@ -70,6 +71,7 @@ const commandClasses: CommandClass[] = [
   RunsCommand,
   RerunCommand,
   StatusCommand,
+  ConfigCommand,
   DebugCommand,
   ExitCommand,
 ];

package/src/config.ts

@@ -514,6 +514,7 @@ export class ConfigParser {
         model: { modelId: 'test-model', provider: 'test' },
         config: {},
         vision: false,
+        langfuse: { enabled: false },
       },
       dirs: {
         knowledge: join(testBaseDir, 'knowledge'),
@@ -650,6 +651,18 @@ export class ConfigParser {
       config.playwright.url = options.baseUrl;
     }
 
+    if (config.ai) {
+      const langfuse = config.ai.langfuse;
+      const publicKey = langfuse?.publicKey || process.env.LANGFUSE_PUBLIC_KEY;
+      const secretKey = langfuse?.secretKey || process.env.LANGFUSE_SECRET_KEY;
+      config.ai.langfuse = {
+        enabled: langfuse?.enabled ?? Boolean(publicKey && secretKey),
+        publicKey,
+        secretKey,
+        baseUrl: langfuse?.baseUrl || process.env.LANGFUSE_BASE_URL || process.env.LANGFUSE_HOST,
+      };
+    }
+
     return config;
   }
 
@@ -762,6 +775,32 @@ export function missingConfigMessage(configFile = 'explorbot.config.js'): string
   `;
 }
 
+export function modelName(model: unknown): string {
+  if (typeof model === 'string') return model;
+  return (model as any)?.modelId || (model as any)?.model || 'unknown';
+}
+
+export function modelProvider(model: unknown): string {
+  const provider = (model as any)?.provider;
+  if (typeof provider === 'string') return provider.split('.')[0];
+  if (typeof model === 'string') return model.split('/')[0];
+  return '';
+}
+
+export function configuredModels(ai?: AIConfig): Record<string, ConfiguredModel> {
+  if (!ai?.model) return {};
+
+  const describe = (model: unknown): ConfiguredModel => ({ name: modelName(model), provider: modelProvider(model) });
+
+  const models: Record<string, ConfiguredModel> = { model: describe(ai.model) };
+  if (ai.agenticModel) models.agenticModel = describe(ai.agenticModel);
+  if (ai.visionModel) models.visionModel = describe(ai.visionModel);
+  for (const [agent, agentConfig] of Object.entries(ai.agents || {})) {
+    if (agentConfig?.model) models[agent] = describe(agentConfig.model);
+  }
+  return models;
+}
+
 export async function resolveConfigModels(ai?: AIConfig): Promise<void> {
   if (!ai) return;
 
@@ -838,6 +877,11 @@ export async function createModel(provider: string, modelId: string): Promise<an
 
 type ModelRole = 'model' | 'visionModel' | 'agenticModel';
 
+interface ConfiguredModel {
+  name: string;
+  provider: string;
+}
+
 interface ProviderInfo {
   envKey: string;
   load: () => Promise<(modelId: string) => any>;
@@ -849,4 +893,4 @@ interface EnvVar {
   required?: boolean;
 }
 
-export type { ModelRole, EnvVar, ProviderInfo };
+export type { ModelRole, EnvVar, ProviderInfo, ConfiguredModel };

package/src/explorbot.ts

@@ -487,9 +487,11 @@ export class ExplorBot {
 
   setCurrentPlan(plan?: Plan): void {
     this.currentPlan = plan;
-    if (plan && !this.sessionPlans.includes(plan)) {
+    if (!plan) return;
+    if (!this.sessionPlans.includes(plan)) {
       this.sessionPlans.push(plan);
     }
+    plan.notifyChange();
   }
 
   getSessionTests(): Test[] {

package/src/remote.ts

@@ -16,8 +16,9 @@ const FLUSH_TIMEOUT_MS = 3000;
  * process and a CI bot are the same case.
  *
  * It **is** a LogDestination — that is the whole integration on the logger's
- * side — and it answers asks by installing itself as the execution
- * controller's input callback. Nothing else in explorbot knows it exists.
+ * side, messages and `data` alike — and it answers asks by installing itself
+ * as the execution controller's input callback. Nothing else in explorbot
+ * knows it exists.
  */
 export class Remote implements LogDestination {
   private url: string | null = null;
@@ -110,6 +111,11 @@ export class Remote implements LogDestination {
    */
   write(entry: TaggedLogEntry): void {
     if (entry.type === 'html') return;
+    if (entry.type === 'data') {
+      const [kind, payload] = entry.originalArgs || [];
+      this.send(String(kind), payload);
+      return;
+    }
     let content = stripAnsi(entry.content ?? '');
     if (content.length > CONTENT_CAP) content = `${content.slice(0, CONTENT_CAP)}… (${content.length} chars)`;
     this.send('log', {

package/src/state-manager.ts

@@ -1,8 +1,8 @@
-import { type FocusedElement, ActionResult } from './action-result.js';
+import { ActionResult, type FocusedElement } from './action-result.js';
 import type { ExperienceTracker } from './experience-tracker.js';
 import type { Knowledge, KnowledgeTracker } from './knowledge-tracker.js';
 import { detectFocusArea } from './utils/aria.js';
-import { createDebug } from './utils/logger.js';
+import { createDebug, tag } from './utils/logger.js';
 import { slugify } from './utils/strings.js';
 import { extractStatePath } from './utils/url-matcher.js';
 
@@ -117,6 +117,9 @@ export class StateManager {
    * Emit state change event to all listeners
    */
   private emitStateChange(event: StateTransition): void {
+    const state = event.toState;
+    tag('data').log('state', { url: state.fullUrl || state.url, path: state.url, title: state.title, h1: state.h1 });
+
     this.stateChangeListeners.forEach((listener) => {
       try {
         listener(event);