explorbot 0.1.12 → 0.1.15

package/src/components/StatusPane.tsx

@@ -52,9 +52,12 @@ export const StatusPane: React.FC<{ onComplete?: () => void }> = ({ onComplete }
             <Text bold>Usage</Text>
           </Box>
           <Row label="Time" value={Stats.getElapsedTime()} />
-          {tokenRows.map(([model, tokens]) => (
-            <Row key={model} label={model} value={`${Stats.humanizeTokens(tokens.total)} tokens`} />
-          ))}
+          {tokenRows.map(([model, tokens]) => {
+            const cached = tokens.cached ?? 0;
+            const cachePct = tokens.input > 0 ? Math.round((cached / tokens.input) * 100) : 0;
+            const suffix = cached > 0 ? ` (${Stats.humanizeTokens(cached)} cached, ${cachePct}%)` : '';
+            return <Row key={model} label={model} value={`${Stats.humanizeTokens(tokens.total)} tokens${suffix}`} />;
+          })}
         </>
       )}
     </Box>

package/src/config.ts

@@ -123,6 +123,7 @@ interface AgentsConfig {
   researcher?: ResearcherAgentConfig;
   planner?: PlannerAgentConfig;
   pilot?: PilotAgentConfig;
+  driller?: AgentConfig;
   'experience-compactor'?: AgentConfig;
   captain?: AgentConfig;
   quartermaster?: AgentConfig;
@@ -131,6 +132,7 @@ interface AgentsConfig {
   chief?: AgentConfig;
   curler?: AgentConfig;
   rerunner?: RerunnerAgentConfig;
+  analyst?: AgentConfig;
 }
 
 interface AIConfig {
@@ -179,6 +181,8 @@ interface ActionConfig {
 interface ReporterConfig {
   enabled?: boolean;
   html?: boolean;
+  markdown?: boolean;
+  runGroup?: string | null;
 }
 
 type ApiHookFn = (ctx: { headers: Record<string, string>; baseEndpoint: string }) => Promise<Record<string, string> | undefined> | Record<string, string> | undefined;

package/src/experience-tracker.ts

@@ -3,6 +3,7 @@ import { basename, dirname, join } from 'node:path';
 import matter from 'gray-matter';
 import { type Tokens, marked } from 'marked';
 import type { ActionResult } from './action-result.js';
+import { isNonReusableCode } from './ai/historian/utils.ts';
 import { ConfigParser } from './config.js';
 import { KnowledgeTracker } from './knowledge-tracker.js';
 import type { WebPageState } from './state-manager.js';
@@ -166,6 +167,10 @@ export class ExperienceTracker {
   writeAction(state: ActionResult, action: ActionInput): void {
     if (this.disabled || this.isWritingDisabled(state)) return;
     if (!action.code?.trim()) return;
+    if (isNonReusableCode(action.code)) {
+      debugLog('Skipping action with non-reusable code: %s', action.code);
+      return;
+    }
 
     this.ensureExperienceFile(state);
     const stateHash = state.getStateHash();
@@ -189,6 +194,10 @@ export class ExperienceTracker {
   writeFlow(state: ActionResult, body: string, relatedUrls?: string[]): void {
     if (this.disabled || this.isWritingDisabled(state)) return;
     if (!body?.trim()) return;
+    if (isNonReusableCode(body)) {
+      debugLog('Skipping flow body with non-reusable code');
+      return;
+    }
 
     this.ensureExperienceFile(state);
     const stateHash = state.getStateHash();

package/src/explorbot.ts

@@ -1,8 +1,8 @@
 import { existsSync, mkdirSync } from 'node:fs';
 import path from 'node:path';
 import { ActionResult } from './action-result.ts';
-import { Bosun } from './ai/bosun.ts';
 import { Captain } from './ai/captain.ts';
+import { Driller } from './ai/driller.ts';
 import { ExperienceCompactor } from './ai/experience-compactor.ts';
 import { Fisherman } from './ai/fisherman.ts';
 import { Historian } from './ai/historian.ts';
@@ -13,6 +13,7 @@ import { AIProvider } from './ai/provider.ts';
 import { Quartermaster } from './ai/quartermaster.ts';
 import { Rerunner } from './ai/rerunner.ts';
 import { Researcher } from './ai/researcher.ts';
+import { SessionAnalyst } from './ai/session-analyst.ts';
 import { Tester } from './ai/tester.ts';
 import { createAgentTools } from './ai/tools.ts';
 import { ApiClient } from './api/api-client.ts';
@@ -25,8 +26,9 @@ import Explorer from './explorer.ts';
 import { KnowledgeTracker } from './knowledge-tracker.ts';
 import { WebPageState } from './state-manager.ts';
 import type { Suite } from './suite.ts';
-import { Plan } from './test-plan.ts';
+import { Plan, type Test } from './test-plan.ts';
 import { setVerboseMode, tag } from './utils/logger.ts';
+import { relativeToCwd } from './utils/next-steps.ts';
 import { sanitizeFilename } from './utils/strings.ts';
 
 export interface ExplorBotOptions {
@@ -55,6 +57,8 @@ export class ExplorBot {
   lastPlanError: Error | null = null;
   lastSavedPlanPath: string | null = null;
   private agents: Record<string, any> = {};
+  private sessionPlans: Plan[] = [];
+  private lastReportedTestCount = 0;
 
   constructor(options: ExplorBotOptions = {}) {
     this.options = options;
@@ -284,15 +288,17 @@ export class ExplorBot {
     return this.agents.rerunner;
   }
 
-  agentBosun(): Bosun {
-    return (this.agents.bosun ||= this.createAgent(({ ai, explorer }) => {
-      const researcher = this.agentResearcher();
+  agentDriller(): Driller {
+    return (this.agents.driller ||= this.createAgent(({ ai, explorer }) => {
       const navigator = this.agentNavigator();
-      const tools = createAgentTools({ explorer, researcher, navigator });
-      return new Bosun(explorer, ai, researcher, navigator, tools);
+      return new Driller(explorer, ai, navigator);
     }));
   }
 
+  agentSessionAnalyst(): SessionAnalyst {
+    return (this.agents.sessionAnalyst ||= this.createAgent(({ ai }) => new SessionAnalyst(ai)));
+  }
+
   agentFisherman(): Fisherman | null {
     const fishermanConfig = this.config.ai?.agents?.fisherman;
     const hasApiConfig = !!this.config.api;
@@ -365,7 +371,7 @@ export class ExplorBot {
     }
     this.lastPlanError = null;
     try {
-      this.currentPlan = await planner.plan(feature, opts.style, opts.extend, opts.completedPlans);
+      this.setCurrentPlan(await planner.plan(feature, opts.style, opts.extend, opts.completedPlans));
     } catch (err) {
       this.lastPlanError = err instanceof Error ? err : new Error(String(err));
       tag('warning').log(`Planning failed: ${this.lastPlanError.message}`);
@@ -436,11 +442,50 @@ export class ExplorBot {
       throw new Error(`Plan file not found: ${planPath}`);
     }
 
-    this.currentPlan = Plan.fromMarkdown(planPath);
-    return this.currentPlan;
+    this.setCurrentPlan(Plan.fromMarkdown(planPath));
+    return this.currentPlan!;
   }
 
   setCurrentPlan(plan?: Plan): void {
     this.currentPlan = plan;
+    if (plan && !this.sessionPlans.includes(plan)) {
+      this.sessionPlans.push(plan);
+    }
+  }
+
+  getSessionTests(): Test[] {
+    return this.sessionPlans.flatMap((p) => p.tests.filter((t) => t.startTime != null));
+  }
+
+  async printSessionAnalysis(): Promise<void> {
+    const analystConfig = this.config.ai?.agents?.analyst;
+    if (analystConfig?.enabled === false) return;
+
+    const tests = this.getSessionTests();
+    if (tests.length === 0) return;
+    if (tests.length === this.lastReportedTestCount) return;
+
+    try {
+      const markdown = await this.agentSessionAnalyst().analyze(tests);
+      if (!markdown) {
+        this.lastReportedTestCount = tests.length;
+        return;
+      }
+
+      tag('multiline').log(markdown);
+
+      const filePath = this.agentSessionAnalyst().writeReport(markdown);
+      tag('info').log(`Session report saved: ${relativeToCwd(filePath)}`);
+
+      const reporter = this.explorer?.getReporter();
+      if (reporter?.isEnabled()) {
+        await reporter.setRunDescription(markdown);
+      }
+
+      this.lastReportedTestCount = tests.length;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      tag('warning').log(`Session analysis failed: ${message}`);
+    }
   }
 }

package/src/explorer.ts

@@ -19,8 +19,9 @@ import { PlaywrightRecorder } from './playwright-recorder.ts';
 import { Reporter } from './reporter.ts';
 import { StateManager } from './state-manager.js';
 import { Test } from './test-plan.ts';
+import { ELEMENT_EXTRACTION_CONFIG, getElementDataExtractorSource } from './utils/html.ts';
 import { createDebug, log, tag } from './utils/logger.js';
-import { WebElement, extractElementData } from './utils/web-element.ts';
+import { WebElement } from './utils/web-element.ts';
 
 declare global {
   namespace NodeJS {
@@ -337,11 +338,11 @@ class Explorer {
   async getEidxInContainer(containerCss: string | null): Promise<string[]> {
     const page = this.playwrightHelper.page;
     try {
-      const selector = containerCss ? `${containerCss} [data-explorbot-eidx]` : '[data-explorbot-eidx]';
+      const selector = containerCss ? `${containerCss} [${ELEMENT_EXTRACTION_CONFIG.attrs.eidx}]` : `[${ELEMENT_EXTRACTION_CONFIG.attrs.eidx}]`;
       const elements = await page.locator(selector).all();
       const result: string[] = [];
       for (const el of elements) {
-        const attr = await el.getAttribute('data-explorbot-eidx');
+        const attr = await el.getAttribute(ELEMENT_EXTRACTION_CONFIG.attrs.eidx);
         if (attr) result.push(attr);
       }
       return result;
@@ -359,7 +360,7 @@ class Explorer {
       const page = this.playwrightHelper.page;
       const base = container ? page.locator(container) : page;
       const el = locator.startsWith('//') ? base.locator(`xpath=${locator}`) : base.locator(locator);
-      return await el.first().getAttribute('data-explorbot-eidx');
+      return await el.first().getAttribute(ELEMENT_EXTRACTION_CONFIG.attrs.eidx);
     } catch (error) {
       if (this.isFatalBrowserError(error)) {
         tag('warning').log(`getEidxByLocator: ${error instanceof Error ? error.message : error}`);
@@ -548,10 +549,7 @@ class Explorer {
       if (!this.stateManager.getCurrentState()) return;
 
       const lastScreenshot = ActionResult.fromState(this.stateManager.getCurrentState()!).screenshotFile;
-      if (!lastScreenshot) return;
-
-      const screenshotPath = outputPath('states', lastScreenshot);
-      test.addArtifact(screenshotPath);
+      test.setActiveNoteScreenshot(lastScreenshot);
     };
 
     const dialogHandler = (dialog: any) => {
@@ -751,20 +749,20 @@ export async function annotatePageElements(page: any): Promise<{ ariaSnapshot: s
   for (const [role, entries] of byRole) {
     try {
       const rawList = await page.getByRole(role).evaluateAll(
-        (domElements: Element[], [data, extractFnStr]: [Array<{ name: string; ref: string }>, string]) => {
+        (domElements: Element[], [data, extractFnStr, config]: [Array<{ name: string; ref: string }>, string, typeof ELEMENT_EXTRACTION_CONFIG]) => {
           const extract = new Function(`return ${extractFnStr}`)() as (el: Element) => any;
           const results: any[] = [];
           let ariaIdx = 0;
           for (const el of domElements) {
             if (ariaIdx >= data.length) break;
-            el.setAttribute('data-explorbot-eidx', data[ariaIdx].ref);
-            const elData = extract(el);
+            el.setAttribute(config.attrs.eidx, data[ariaIdx].ref);
+            const elData = extract(el, config);
             if (elData) results.push(elData);
             ariaIdx++;
           }
           return results;
         },
-        [entries, extractElementData.toString()]
+        [entries, getElementDataExtractorSource(), ELEMENT_EXTRACTION_CONFIG]
       );
       for (const raw of rawList) {
         elements.push(WebElement.fromRawData(raw, role));

package/src/reporter.ts

@@ -33,8 +33,21 @@ export class Reporter {
       this.configureHtmlPipe();
     }
 
-    const pipe = process.env.TESTOMATIO && config?.html ? 'both' : process.env.TESTOMATIO ? 'testomatio' : 'html';
-    debugLog('Reporter initialized', { enabled: this.reporterEnabled, pipe });
+    if (this.reporterEnabled && config?.markdown) {
+      this.configureMarkdownPipe();
+    }
+
+    if (this.reporterEnabled) {
+      this.configureRunGroup(config?.runGroup);
+    }
+
+    debugLog('Reporter initialized', {
+      enabled: this.reporterEnabled,
+      testomatio: Boolean(process.env.TESTOMATIO),
+      html: Boolean(process.env.TESTOMATIO_HTML_REPORT_SAVE),
+      markdown: Boolean(process.env.TESTOMATIO_MARKDOWN_REPORT_SAVE),
+      runGroup: process.env.TESTOMATIO_RUNGROUP_TITLE || null,
+    });
   }
 
   private buildTitle(): string {
@@ -56,7 +69,31 @@ export class Reporter {
   private configureHtmlPipe(): void {
     process.env.TESTOMATIO_HTML_REPORT_SAVE = '1';
     process.env.TESTOMATIO_HTML_REPORT_FOLDER = outputPath('reports');
-    debugLog('HTML report pipe configured', { folder: process.env.TESTOMATIO_HTML_REPORT_FOLDER });
+    process.env.TESTOMATIO_HTML_FILENAME = `${Stats.sessionLabel()}.html`;
+    debugLog('HTML report pipe configured', {
+      folder: process.env.TESTOMATIO_HTML_REPORT_FOLDER,
+      filename: process.env.TESTOMATIO_HTML_FILENAME,
+    });
+  }
+
+  private configureMarkdownPipe(): void {
+    process.env.TESTOMATIO_MARKDOWN_REPORT_SAVE = '1';
+    process.env.TESTOMATIO_MARKDOWN_REPORT_FOLDER = outputPath('reports');
+    process.env.TESTOMATIO_MARKDOWN_FILENAME = `${Stats.sessionLabel()}-tests.md`;
+    debugLog('Markdown report pipe configured', {
+      folder: process.env.TESTOMATIO_MARKDOWN_REPORT_FOLDER,
+      filename: process.env.TESTOMATIO_MARKDOWN_FILENAME,
+    });
+  }
+
+  private configureRunGroup(runGroup: string | null | undefined): void {
+    if (process.env.TESTOMATIO_RUNGROUP_TITLE) return;
+    if (runGroup === null) return;
+    if (runGroup) {
+      process.env.TESTOMATIO_RUNGROUP_TITLE = runGroup;
+      return;
+    }
+    process.env.TESTOMATIO_RUNGROUP_TITLE = `Explorbot ${new Date().toISOString().slice(0, 10)}`;
   }
 
   async startRun(): Promise<void> {
@@ -73,7 +110,7 @@ export class Reporter {
       const timeoutMs = Number(process.env.TESTOMATIO_TIMEOUT_MS || '15000');
       const timeoutPromise = new Promise<'timeout'>((resolve) => setTimeout(() => resolve('timeout'), timeoutMs));
 
-      const result = await Promise.race([this.client.createRun().then(() => 'success' as const), timeoutPromise]);
+      const result = await Promise.race([this.client.createRun({ configuration: { exploratory: true } }).then(() => 'success' as const), timeoutPromise]);
 
       if (result === 'timeout') {
         debugLog('Reporter run creation timed out');
@@ -108,6 +145,7 @@ export class Reporter {
         message: note.message,
         status: note.status,
         screenshot: note.screenshot,
+        log: note.log,
       }))
       .sort((a, b) => a.startTime - b.startTime);
 
@@ -143,9 +181,18 @@ export class Reporter {
       if (noteEntry.screenshot) {
         step.artifacts = [outputPath('states', noteEntry.screenshot)];
       }
+      if (noteEntry.log) {
+        step.log = noteEntry.log;
+      }
       steps.push(step);
     }
 
+    const verificationStep = this.buildVerificationStep(test, lastScreenshotFile);
+    if (verificationStep) {
+      steps.push(verificationStep);
+      return steps;
+    }
+
     if (lastScreenshotFile && steps.length > 0) {
       const lastStep = steps[steps.length - 1];
       const screenshotPath = outputPath('states', lastScreenshotFile);
@@ -159,6 +206,39 @@ export class Reporter {
     return steps;
   }
 
+  private buildVerificationStep(test: Test, lastScreenshotFile?: string): Step | undefined {
+    const v = test.verification;
+    if (!v) return undefined;
+
+    const subSteps: Step[] = [];
+    if (v.message) subSteps.push({ category: 'framework', title: v.message, duration: 0 });
+    if (v.url) {
+      subSteps.push({
+        category: 'framework',
+        title: v.pageLabel ? `Navigated to ${v.pageLabel}` : 'Final page',
+        log: v.url,
+        duration: 0,
+      });
+    }
+    for (const detail of v.details) {
+      subSteps.push({ category: 'framework', title: detail, duration: 0 });
+    }
+
+    const screenshotFile = v.screenshot || lastScreenshotFile;
+
+    const step: Step = {
+      category: 'user',
+      title: 'Verification',
+      duration: 0,
+      status: v.status || 'none',
+      steps: subSteps.length > 0 ? subSteps : undefined,
+    };
+    if (screenshotFile) {
+      step.artifacts = [outputPath('states', screenshotFile)];
+    }
+    return step;
+  }
+
   async reportTest(test: Test, meta?: ReporterMeta): Promise<void> {
     await this.startRun();
 
@@ -229,6 +309,30 @@ export class Reporter {
     return this.isRunStarted;
   }
 
+  async setRunDescription(text: string): Promise<void> {
+    if (!this.isRunStarted) return;
+    if (!process.env.TESTOMATIO) return;
+    const runId = this.client.runId;
+    if (!runId) return;
+
+    const baseUrl = process.env.TESTOMATIO_URL || 'https://app.testomat.io';
+    const url = `${baseUrl}/api/reporter/${runId}`;
+    try {
+      const response = await fetch(url, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ api_key: process.env.TESTOMATIO, description: text }),
+      });
+      if (!response.ok) {
+        debugLog('Run description update failed:', response.status, response.statusText);
+        return;
+      }
+      debugLog('Run description updated');
+    } catch (error) {
+      debugLog('Failed to update run description:', error);
+    }
+  }
+
   private extractLastNoteMessage(test: Test): string {
     const notes = Object.values(test.notes);
     if (notes.length === 0) return '';

package/src/state-manager.ts

@@ -142,8 +142,8 @@ export class StateManager {
 
   /**
    * Extract state path from full URL
-   * Removes domain, port, protocol, and query params
-   * Keeps path and hash: /path/to/page#section
+   * Removes domain, port, protocol
+   * Keeps path, query, and hash: /path/to/page?tab=users#section
    */
   /**
    * Update current state from ActionResult and record transition if state changed
@@ -549,7 +549,8 @@ export class StateManager {
 export function normalizeUrl(url: string): string {
   try {
     const parsed = new URL(url, 'http://localhost');
-    return parsed.pathname.replace(/^\/+|\/+$/g, '');
+    const path = parsed.pathname.replace(/^\/+|\/+$/g, '');
+    return `${path}${parsed.search}${parsed.hash}`;
   } catch {
     return url.replace(/^\/+|\/+$/g, '');
   }

package/src/stats.ts

@@ -1,13 +1,17 @@
+import { uniqExplorationName } from './utils/unique-names.ts';
+
 interface TokenUsage {
   input: number;
   output: number;
   total: number;
+  cached?: number;
 }
 
 export type ExplorbotMode = 'explore' | 'test' | 'freesail' | 'tui';
 
 export class Stats {
   static startTime = Date.now();
+  static sessionName = uniqExplorationName();
   static researches = 0;
   static tests = 0;
   static plans = 0;
@@ -17,11 +21,12 @@ export class Stats {
 
   static recordTokens(_agent: string, model: string, usage: TokenUsage): void {
     if (!Stats.models[model]) {
-      Stats.models[model] = { input: 0, output: 0, total: 0 };
+      Stats.models[model] = { input: 0, output: 0, total: 0, cached: 0 };
     }
     Stats.models[model].input += usage.input;
     Stats.models[model].output += usage.output;
     Stats.models[model].total += usage.total;
+    Stats.models[model].cached = (Stats.models[model].cached ?? 0) + (usage.cached ?? 0);
   }
 
   static getElapsedTime(): string {
@@ -54,4 +59,8 @@ export class Stats {
     const totalTokens = Object.values(Stats.models).reduce((sum, m) => sum + m.total, 0);
     return totalTokens > 0;
   }
+
+  static sessionLabel(): string {
+    return `${Stats.mode || 'session'}-${Stats.sessionName}`;
+  }
 }

package/src/test-plan.ts

@@ -26,6 +26,7 @@ export interface Note {
   startTime: number;
   endTime: number;
   screenshot?: string;
+  log?: string;
 }
 
 export class ActiveNote {
@@ -34,6 +35,7 @@ export class ActiveNote {
   message: string;
   status?: TestResultType;
   screenshot?: string;
+  log?: string;
 
   constructor(task: Task, message: string, status?: TestResultType) {
     this.task = task;
@@ -73,6 +75,7 @@ export class Task {
   steps: Record<string, StepData>;
   states: WebPageState[];
   startUrl: string;
+  verification?: Verification;
   protected timestampCounter = 0;
   private activeNote?: ActiveNote;
 
@@ -102,6 +105,7 @@ export class Task {
       startTime: activeNote.getStartTime(),
       endTime,
       screenshot: activeNote.screenshot,
+      log: activeNote.log,
     };
     this.activeNote = undefined;
   }
@@ -118,13 +122,28 @@ export class Task {
       .join('\n');
   }
 
-  addNote(message: string, status: TestResultType = null, screenshot?: string): void {
-    const isDuplicate = Object.values(this.notes).some((note) => note.message === message && note.status === status);
+  addNote(message: string, status: TestResultType = null, screenshot?: string, log?: string): void {
+    const isDuplicate = Object.values(this.notes).some((note) => note.message === message && note.status === status && note.log === log);
     if (isDuplicate) return;
 
     const now = performance.now();
     const timestamp = `${now}_${this.timestampCounter++}`;
-    this.notes[timestamp] = { message, status, startTime: now, endTime: now, screenshot };
+    this.notes[timestamp] = { message, status, startTime: now, endTime: now, screenshot, log };
+  }
+
+  addUrlNote(state: UrlNoteState, prevState?: { title?: string; h1?: string; h2?: string }): void {
+    const fullUrl = state.fullUrl || state.url;
+    if (!fullUrl) return;
+
+    let label: string | undefined;
+    if (state.title && state.title !== prevState?.title) label = state.title;
+    else if (state.h1 && state.h1 !== prevState?.h1) label = state.h1;
+    else if (state.h2 && state.h2 !== prevState?.h2) label = state.h2;
+    else label = state.title || state.h1 || state.h2;
+
+    if (!label) return;
+
+    this.addNote(`Navigated to ${label}`, TestResult.PASSED, state.screenshotFile, fullUrl);
   }
 
   addState(state: WebPageState): void {
@@ -136,6 +155,28 @@ export class Task {
     this.steps[timestamp] = { text, duration, status, error, log, artifacts, noteStartTime: this.activeNote?.getStartTime() };
   }
 
+  setActiveNoteScreenshot(screenshotFile?: string): void {
+    if (!this.activeNote || !screenshotFile) return;
+    this.activeNote.screenshot = screenshotFile;
+  }
+
+  setVerification(message: string, status: TestResultType, state?: UrlNoteState): void {
+    this.verification ||= { message: '', status: null, details: [] };
+    this.verification.message = message;
+    this.verification.status = status;
+    if (!state) return;
+    if (state.screenshotFile) this.verification.screenshot = state.screenshotFile;
+    const fullUrl = state.fullUrl || state.url;
+    if (fullUrl) this.verification.url = fullUrl;
+    this.verification.pageLabel = state.title || state.h1 || state.h2 || undefined;
+  }
+
+  addVerificationDetail(detail: string): void {
+    if (!detail) return;
+    this.verification ||= { message: '', status: null, details: [] };
+    this.verification.details.push(detail);
+  }
+
   getLog(): Array<{ type: 'step' | 'note' | 'artifact'; content: string; timestamp: number }> {
     const merged: Record<string, { type: 'step' | 'note' | 'artifact'; content: string }> = {};
 
@@ -442,3 +483,21 @@ export class Plan {
     return planToAiContext(this, options);
   }
 }
+
+interface Verification {
+  message: string;
+  status: TestResultType;
+  screenshot?: string;
+  url?: string;
+  pageLabel?: string;
+  details: string[];
+}
+
+interface UrlNoteState {
+  url?: string;
+  fullUrl?: string;
+  title?: string;
+  h1?: string;
+  h2?: string;
+  screenshotFile?: string;
+}