explorbot 0.2.4 → 0.2.5

package/dist/src/ai/provider.js

@@ -3,6 +3,7 @@ import { LangfuseSpanProcessor } from '@langfuse/otel';
 import { NodeSDK } from '@opentelemetry/sdk-node';
 import { generateObject, generateText, isStepCount, registerTelemetry } from 'ai';
 import { clearActivity, setActivity } from "../activity.js";
+import { configuredModels, modelName as getModelName } from '../config.js';
 import { executionController } from "../execution-controller.js";
 import { Observability } from "../observability.js";
 import { Stats } from "../stats.js";
@@ -79,9 +80,6 @@ export class Provider {
         this.config = config;
         this.initLangfuse();
     }
-    getModelName(model) {
-        return model?.modelId || model?.model || 'unknown';
-    }
     async validateConnection() {
         try {
             await generateText({
@@ -108,16 +106,13 @@ export class Provider {
         }
         return this.config.agenticModel || this.config.model;
     }
+    getVisionModel() {
+        return this.config.visionModel;
+    }
     getConfiguredModels() {
-        const models = { 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 = {};
+        for (const [role, model] of Object.entries(configuredModels(this.config)))
+            models[role] = model.name;
         return models;
     }
     getSystemPromptForAgent(agentName, currentUrl) {
@@ -207,11 +202,7 @@ export class Provider {
         return retry(reduced.messages, { ...options, _contextRetryLevel: reduced.nextLevel });
     }
     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;
         }
@@ -282,7 +273,7 @@ export class Provider {
         return { conversation, response, toolExecutions };
     }
     async chat(messages, model, options = {}) {
-        const modelName = this.getModelName(model);
+        const modelName = getModelName(model);
         setActivity(`🤖 Asking ${modelName}`, 'ai');
         promptLog(`Using model: ${modelName}`);
         const config = this.buildGenerateConfig({ maxOutputTokens: 16384 }, { model, abortSignal: executionController.getAbortSignal() }, options);
@@ -324,7 +315,7 @@ export class Provider {
         }
     }
     async generateWithTools(messages, model, tools, options = {}) {
-        const modelName = this.getModelName(model);
+        const modelName = getModelName(model);
         setActivity(`🤖 Asking ${modelName} with dynamic tools`, 'ai');
         promptLog(`Using model: ${modelName}`);
         const toolNames = Object.keys(tools || {});
@@ -379,7 +370,7 @@ export class Provider {
     }
     async generateObject(messages, schema, model, options = {}) {
         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}`);
         const config = this.buildGenerateConfig({ schema }, { model: modelToUse }, options);
@@ -557,7 +548,7 @@ export class Provider {
             }, this.getRetryOptions());
             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) {

package/dist/src/ai/researcher/cache.d.ts

@@ -1,3 +1,5 @@
+export declare function researchPath(hash: string): string;
+export declare function reportResearch(hash: string, text: string): void;
 export declare function clearResearchCache(): void;
 export declare function getCachedResearch(hash: string): string;
 export declare function getPreviousResearch(hash: string): string;

package/dist/src/ai/researcher/cache.js

@@ -4,6 +4,7 @@ import { Worker } from 'node:worker_threads';
 import { outputPath } from "../../config.js";
 import { TTLCache } from "../../utils/cache.js";
 import { computeHtmlFingerprint } from "../../utils/html-diff.js";
+import { tag } from "../../utils/logger.js";
 import { debugLog } from "./mixin.js";
 const CACHE_TTL_MS = 6 * 60 * 60 * 1000; // 6 hours
 const FINGERPRINT_MAX_AGE_MS = 60 * 60 * 1000; // 1 hour
@@ -11,6 +12,12 @@ const FINGERPRINT_WORKER_TIMEOUT_MS = 10_000;
 const SIMILARITY_THRESHOLD = 90;
 const memoryCache = new TTLCache(CACHE_TTL_MS);
 let fingerprintWorker = null;
+export function researchPath(hash) {
+    return outputPath('research', `${hash}.md`);
+}
+export function reportResearch(hash, text) {
+    tag('data').log('research', { path: researchPath(hash), hash, content: text });
+}
 function getStatesDir() {
     return outputPath('states');
 }
@@ -30,7 +37,7 @@ export function getCachedResearch(hash) {
     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);
@@ -43,7 +50,7 @@ export function getCachedResearch(hash) {
 export function getPreviousResearch(hash) {
     if (!hash)
         return '';
-    const researchFile = outputPath('research', `${hash}.md`);
+    const researchFile = researchPath(hash);
     if (!existsSync(researchFile))
         return '';
     return readFileSync(researchFile, 'utf8');
@@ -55,6 +62,7 @@ export function saveResearch(hash, text, combinedHtml) {
         mkdirSync(researchDir, { recursive: true });
     writeFileSync(researchFile, text);
     memoryCache.set(hash, text);
+    reportResearch(hash, text);
     debugLog(`Research saved to ${researchFile}`);
     if (combinedHtml) {
         const statesDir = getStatesDir();

package/dist/src/ai/researcher.js

@@ -13,7 +13,7 @@ import { mdq } from "../utils/markdown-query.js";
 import { RulesLoader } from "../utils/rules-loader.js";
 import { annotatePageElements } from "../utils/web-annotate.js";
 import { ContextLengthError } from './provider.js';
-import { findSimilarResearch, getCachedResearch, saveResearch } from "./researcher/cache.js";
+import { findSimilarResearch, getCachedResearch, reportResearch, saveResearch } from "./researcher/cache.js";
 import { WithCoordinates } from "./researcher/coordinates.js";
 import { WithDeepAnalysis } from "./researcher/deep-analysis.js";
 import { detectFocusedSection, hasFocusedSection, markSectionAsFocused, pickDefaultFocusedSection } from "./researcher/focus.js";
@@ -76,6 +76,7 @@ export class Researcher extends ResearcherBase {
             const cached = getCachedResearch(stateHash);
             if (cached) {
                 debugLog('Previous research result found');
+                reportResearch(stateHash, cached);
                 return cached;
             }
         }

package/dist/src/ai/session-analyst.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import dedent from 'dedent';
 import { outputPath } from "../config.js";
 import { Stats } from "../stats.js";
+import { tag } from "../utils/logger.js";
 export class SessionAnalyst {
     emoji = '🧐';
     provider;
@@ -103,6 +104,7 @@ export class SessionAnalyst {
         if (!existsSync(dir))
             mkdirSync(dir, { recursive: true });
         writeFileSync(filePath, markdown);
+        tag('data').log('report', { path: filePath, content: markdown });
         return filePath;
     }
     serializeTest(test, ref) {

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

@@ -39,10 +39,10 @@ export declare class Tester extends TaskAgent implements Agent {
     getCurrentState(): ActionResult;
     get progressCheckInterval(): number;
     getConversation(): Conversation | null;
-    test(task: Test): Promise<{
+    test(task: Test, opts?: TestOptions): Promise<{
         success: boolean;
     }>;
-    runTestSession(task: Test, initialState: ActionResult, conversation: Conversation, handlers: TestSessionHandlers): Promise<{
+    runTestSession(task: Test, initialState: ActionResult, conversation: Conversation, handlers: TestSessionHandlers, opts: TestOptions): Promise<{
         success: boolean;
     }>;
     shouldAnalyzeProgress(iteration: number, currentState: ActionResult): boolean;
@@ -93,4 +93,7 @@ export declare class Tester extends TaskAgent implements Agent {
 interface TestSessionHandlers {
     offFailedRequest?: () => void;
 }
+export interface TestOptions {
+    startOnCurrentPage?: boolean;
+}
 export {};

package/dist/src/ai/tester.js

@@ -74,7 +74,7 @@ export class Tester extends TaskAgent {
     getConversation() {
         return this.currentConversation;
     }
-    async test(task) {
+    async test(task, opts = {}) {
         Stats.tests++;
         const state = this.stateManager.getCurrentState();
         if (!state)
@@ -120,9 +120,9 @@ export class Tester extends TaskAgent {
                 startUrl: task.startUrl,
                 expected: task.expected,
             },
-        }, async () => this.runTestSession(task, initialState, conversation, { offFailedRequest }));
+        }, async () => this.runTestSession(task, initialState, conversation, { offFailedRequest }, opts));
     }
-    async runTestSession(task, initialState, conversation, handlers) {
+    async runTestSession(task, initialState, conversation, handlers, opts) {
         const { offFailedRequest } = handlers;
         if (this.pilot) {
             try {
@@ -151,16 +151,20 @@ export class Tester extends TaskAgent {
             await this.cleanupStartedTest(task);
             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 };
+                }
             }
         }
         const startState = this.stateManager.getCurrentState();

package/dist/src/ai/tools.js

@@ -698,7 +698,10 @@ export function createAgentTools({ explorer, stateManager, ai, researcher, navig
                             message: `Successfully executed: ${instruction}`,
                         });
                     }
-                    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/dist/src/commands/config-command.d.ts

@@ -0,0 +1,51 @@
+import { type AIConfig, type ReporterConfig } from '../config.js';
+import { BaseCommand } from './base-command.js';
+export declare class ConfigCommand extends BaseCommand {
+    name: string;
+    description: string;
+    execute(): Promise<void>;
+    static summary(options?: {
+        config?: string;
+        path?: string;
+        url?: string;
+        json?: boolean;
+    }): Promise<string>;
+    static data(config: SummarizedConfig, options?: ConfigSummaryOptions): ConfigData;
+    static render(config: SummarizedConfig, options?: ConfigSummaryOptions): string;
+}
+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;
+}
+export {};

package/dist/src/commands/config-command.js

@@ -0,0 +1,117 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+import { ConfigParser, EXPLORBOT_ENV_VARS, 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() {
+        const parser = ConfigParser.getInstance();
+        tag('info').log(ConfigCommand.render(this.explorBot.getConfig(), { configPath: parser.getConfigPath(), root: parser.getProjectRoot() }));
+    }
+    static async summary(options = {}) {
+        const parser = ConfigParser.getInstance();
+        const [site] = listSites();
+        const load = (baseUrl) => 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, options = {}) {
+        let configPath = '';
+        if (options.configPath && existsSync(options.configPath))
+            configPath = options.configPath;
+        const dirs = {};
+        if (options.root) {
+            for (const [name, dir] of Object.entries({ output: 'output', ...config.dirs })) {
+                dirs[name] = path.join(options.root, dir);
+            }
+        }
+        const env = {};
+        for (const variable of EXPLORBOT_ENV_VARS) {
+            const value = process.env[variable.name];
+            if (value)
+                env[variable.name] = value;
+        }
+        const models = {};
+        const providers = {};
+        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, options = {}) {
+        const data = ConfigCommand.data(config, options);
+        if (options.json)
+            return JSON.stringify(data, null, 2);
+        const lines = [];
+        const section = (title, entries) => {
+            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 = [['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 = 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 = [];
+        if (data.integrations.langfuse)
+            integrations.push(['langfuse', 'traces sent']);
+        if (data.integrations.testomatio)
+            integrations.push(['testomatio', 'runs reported']);
+        section('Integrations', integrations);
+        const env = 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');
+    }
+}

package/dist/src/commands/index.js

@@ -1,6 +1,7 @@
 import { AddRuleCommand } from './add-rule-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';
@@ -64,6 +65,7 @@ const commandClasses = [
     RunsCommand,
     RerunCommand,
     StatusCommand,
+    ConfigCommand,
     DebugCommand,
     ExitCommand,
 ];

package/dist/src/config.d.ts

@@ -272,12 +272,19 @@ export declare class ConfigMissingError extends Error {
 }
 export declare function envConfigRequested(): boolean;
 export declare function missingConfigMessage(configFile?: string): string;
+export declare function modelName(model: unknown): string;
+export declare function modelProvider(model: unknown): string;
+export declare function configuredModels(ai?: AIConfig): Record<string, ConfiguredModel>;
 export declare function resolveConfigModels(ai?: AIConfig): Promise<void>;
 export declare function resolveOutputRoot(baseUrl?: string): string;
 export declare function resolveStateRoot(baseUrl: string, ephemeral?: boolean): string;
 export declare function materializeKnowledge(outputRoot: string): void;
 export declare function createModel(provider: string, modelId: string): Promise<any>;
 type ModelRole = 'model' | 'visionModel' | 'agenticModel';
+interface ConfiguredModel {
+    name: string;
+    provider: string;
+}
 interface ProviderInfo {
     envKey: string;
     load: () => Promise<(modelId: string) => any>;
@@ -287,4 +294,4 @@ interface EnvVar {
     description: string;
     required?: boolean;
 }
-export type { ModelRole, EnvVar, ProviderInfo };
+export type { ModelRole, EnvVar, ProviderInfo, ConfiguredModel };

package/dist/src/config.js

@@ -231,6 +231,7 @@ export class ConfigParser {
                 model: { modelId: 'test-model', provider: 'test' },
                 config: {},
                 vision: false,
+                langfuse: { enabled: false },
             },
             dirs: {
                 knowledge: join(testBaseDir, 'knowledge'),
@@ -358,6 +359,17 @@ export class ConfigParser {
             config.playwright = config.playwright || { browser: 'chromium', url: '' };
             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;
     }
     validateConfig(config) {
@@ -454,6 +466,34 @@ export function missingConfigMessage(configFile = 'explorbot.config.js') {
     Providers: ${Object.keys(PROVIDERS).join(', ')}
   `;
 }
+export function modelName(model) {
+    if (typeof model === 'string')
+        return model;
+    return model?.modelId || model?.model || 'unknown';
+}
+export function modelProvider(model) {
+    const provider = model?.provider;
+    if (typeof provider === 'string')
+        return provider.split('.')[0];
+    if (typeof model === 'string')
+        return model.split('/')[0];
+    return '';
+}
+export function configuredModels(ai) {
+    if (!ai?.model)
+        return {};
+    const describe = (model) => ({ name: modelName(model), provider: modelProvider(model) });
+    const models = { 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) {
     if (!ai)
         return;

package/dist/src/explorbot.js

@@ -418,9 +418,12 @@ export class ExplorBot {
     }
     setCurrentPlan(plan) {
         this.currentPlan = plan;
-        if (plan && !this.sessionPlans.includes(plan)) {
+        if (!plan)
+            return;
+        if (!this.sessionPlans.includes(plan)) {
             this.sessionPlans.push(plan);
         }
+        plan.notifyChange();
     }
     getSessionTests() {
         return this.sessionPlans.flatMap((p) => p.tests.filter((t) => t.startTime != null));

package/dist/src/remote.d.ts

@@ -6,8 +6,9 @@ import { type LogDestination, type TaggedLogEntry } from './utils/logger.js';
  * 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 declare class Remote implements LogDestination {
     url: string | null;

package/dist/src/remote.js

@@ -13,8 +13,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 {
     url = null;
@@ -105,6 +106,11 @@ export class Remote {
     write(entry) {
         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)`;

package/dist/src/state-manager.d.ts

@@ -1,4 +1,4 @@
-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';
 export interface Link {

package/dist/src/state-manager.js

@@ -1,6 +1,6 @@
 import { ActionResult } from './action-result.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';
 const debugLog = createDebug('explorbot:state');
@@ -40,6 +40,8 @@ export class StateManager {
      * Emit state change event to all listeners
      */
     emitStateChange(event) {
+        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);

package/dist/src/test-plan.d.ts

@@ -113,6 +113,7 @@ export declare class Test extends Task {
     finish(result?: TestResultType): void;
     getDurationMs(): number | null;
     getRemainingExpectations(): string[];
+    reportStatus(): void;
     getLog(): Array<{
         type: 'step' | 'note' | 'artifact';
         content: string;