explorbot 0.1.0 → 0.1.2

package/src/ai/researcher.ts

@@ -131,9 +131,9 @@ export class Researcher extends ResearcherBase implements Agent {
       await this.ensureNavigated(state.url, screenshot && this.provider.hasVision());
       await this.hooksRunner.runBeforeHook('researcher', state.url);
 
-      const { ariaSnapshot, elements: annotatedElements } = await this.explorer.annotateElements();
+      const annotatedElements = await this.explorer.annotateElements();
       debugLog(`Annotated ${annotatedElements.length} interactive elements with eidx`);
-      this.actionResult = await this.explorer.createAction().capturePageState({ includeScreenshot: screenshot && this.provider.hasVision(), ariaSnapshot });
+      this.actionResult = await this.explorer.createAction().capturePageState({ includeScreenshot: screenshot && this.provider.hasVision() });
 
       if (isErrorPage(this.actionResult!)) {
         const recovered = await this.waitForPageLoad(screenshot);
@@ -385,10 +385,9 @@ export class Researcher extends ResearcherBase implements Agent {
     try {
       await withRetry(
         async () => {
-          const { ariaSnapshot } = await this.explorer.annotateElements();
+          await this.explorer.annotateElements();
           this.actionResult = await this.explorer.createAction().capturePageState({
             includeScreenshot: screenshot && this.provider.hasVision(),
-            ariaSnapshot,
           });
           if (isErrorPage(this.actionResult!)) throw new Error('Error page detected');
         },

package/src/ai/rules.ts

@@ -266,7 +266,7 @@ export const actionRule = dedent`
     I.fillField('Username', 'John', '.login-form'); // fills Username inside .login-form
     I.fillField('Username', 'John'); // fills the field located by name or placeholder or label "Username" with the text "John"
     I.fillField('//user/input', 'John'); // fills the field located by XPath "//user/input" with the text "John"
-  </example>
+  </example>  
 
   ### I.type
 
@@ -303,7 +303,7 @@ export const actionRule = dedent`
   </example>
 
   IMPORTANT: Requires an active/focused element for most keys.
-  Commonly used after I.type() to submit forms or navigate dropdowns.
+  Commonly used after I.type() or I.fillField() to submit forms or navigate dropdowns.
 
   ### I.switchTo
 

package/src/ai/tools.ts

@@ -310,7 +310,7 @@ export function createCodeceptJSTools(explorer: Explorer, task: Task) {
         I.selectOption({"role":"combobox","text":"Category"}, 'Technology')
 
         Do not submit form - use verify() first to check fields were filled correctly, then click() to submit.
-        Do not use: wait functions, amOnPage, reloadPage, saveScreenshot
+        Do not use: wait functions, amOnPage, reloadPage, saveScreenshot        
       `,
       inputSchema: z.object({
         codeBlock: z.string().describe('Valid CodeceptJS code starting with I. Can contain multiple commands separated by newlines.'),
@@ -385,7 +385,7 @@ export function createCodeceptJSTools(explorer: Explorer, task: Task) {
             message: `Form completed successfully with ${lines.length} commands.`,
             commandsExecuted: lines.length,
             code: codeBlock,
-            suggestion: 'Verify the form was filled in correctly using see() tool. Submit if needed by using click() tool.',
+            suggestion: 'Verify the form was filled in correctly using see() tool. If needed to submit: try click() tool or form() with I.pressKey("Enter").',
           });
         } catch (error) {
           activeNote.commit(TestResult.FAILED);

package/src/commands/add-rule-command.ts

@@ -6,8 +6,7 @@ import { tag } from '../utils/logger.js';
 import { BaseCommand } from './base-command.js';
 
 export class AddRuleCommand extends BaseCommand {
-  name = 'rules:add';
-  aliases = ['add-rule'];
+  name = 'add-rule';
   description = 'Create a rule file for an agent';
   suggestions = ['/add-rule researcher check-tooltips'];
 

package/src/commands/base-command.ts

@@ -1,3 +1,4 @@
+import { Command } from 'commander';
 import type { ExplorBot } from '../explorbot.js';
 
 export interface CommandOption {
@@ -24,4 +25,16 @@ export abstract class BaseCommand {
   matches(commandName: string): boolean {
     return this.name === commandName || this.aliases.includes(commandName);
   }
+
+  protected parseArgs(args: string): { opts: Record<string, string | boolean>; args: string[] } {
+    const cmd = new Command();
+    cmd.exitOverride();
+    for (const opt of this.options) {
+      cmd.option(opt.flags, opt.description);
+    }
+    cmd.argument('[args...]');
+    const argv = (args.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || []).map((s) => s.replace(/^["']|["']$/g, ''));
+    cmd.parse(argv, { from: 'user' });
+    return { opts: cmd.opts(), args: cmd.args };
+  }
 }

package/src/commands/context-command.ts

@@ -10,6 +10,12 @@ export class ContextCommand extends BaseCommand {
   name = 'context';
   description = 'Show page context summary (URL, headings, experience, knowledge, ARIA, HTML, research)';
   suggestions = ['context:aria', 'context:html', 'context:knowledge', 'context:experience', 'context:data'];
+  options = [
+    { flags: '--visual', description: 'Include annotated screenshot' },
+    { flags: '--screenshot', description: 'Include annotated screenshot' },
+    { flags: '--full', description: 'Show full context with HTML' },
+    { flags: '--attached', description: 'Show attached context mode' },
+  ];
 
   async execute(args: string): Promise<void> {
     const explorer = this.explorBot.getExplorer();
@@ -19,9 +25,10 @@ export class ContextCommand extends BaseCommand {
       throw new Error('No active page to show context for');
     }
 
-    const isVisual = args.includes('--visual') || args.includes('--screenshot');
+    const { opts } = this.parseArgs(args);
+    const isVisual = !!(opts.visual || opts.screenshot);
 
-    const { ariaSnapshot } = await explorer.annotateElements();
+    await explorer.annotateElements();
 
     if (isVisual) {
       const cachedResearch = Researcher.getCachedResearch(state);
@@ -29,14 +36,14 @@ export class ContextCommand extends BaseCommand {
       await explorer.visuallyAnnotateElements({ containers });
     }
 
-    const actionResult = await explorer.createAction().capturePageState({ includeScreenshot: isVisual, ariaSnapshot });
+    const actionResult = await explorer.createAction().capturePageState({ includeScreenshot: isVisual });
     const experienceTracker = explorer.getStateManager().getExperienceTracker();
     const knowledgeTracker = this.explorBot.getKnowledgeTracker();
 
     let mode: ContextMode = 'compact';
-    if (args.includes('--full')) {
+    if (opts.full) {
       mode = 'full';
-    } else if (args.includes('--attached')) {
+    } else if (opts.attached) {
       mode = 'attached';
     }
 

package/src/commands/drill-command.ts

@@ -3,7 +3,6 @@ import { BaseCommand } from './base-command.js';
 export class DrillCommand extends BaseCommand {
   name = 'drill';
   description = 'Drill all components on current page to learn interactions';
-  aliases = ['bosun'];
   suggestions = ['/research - to see UI map first', '/navigate <page> - to go to another page'];
 
   async execute(args: string): Promise<void> {

package/src/commands/explore-command.ts

@@ -1,6 +1,8 @@
+import { existsSync, readdirSync } from 'node:fs';
 import figureSet from 'figures';
 import path from 'node:path';
 import { getStyles } from '../ai/planner/styles.js';
+import { ConfigParser } from '../config.ts';
 import { getCliName } from '../utils/cli-name.ts';
 import type { Plan } from '../test-plan.js';
 import { jsonToTable } from '../utils/markdown-parser.js';
@@ -18,13 +20,12 @@ export class ExploreCommand extends BaseCommand {
   private completedPlans: Plan[] = [];
 
   async execute(args: string): Promise<void> {
-    const maxTestsMatch = args.match(/--max-tests\s+(\d+)/);
-    if (maxTestsMatch) {
-      this.maxTests = Number.parseInt(maxTestsMatch[1], 10);
-      args = args.replace(/--max-tests\s+\d+/, '').trim();
+    const { opts, args: remaining } = this.parseArgs(args);
+    if (opts.maxTests) {
+      this.maxTests = Number.parseInt(opts.maxTests as string, 10);
     }
 
-    const feature = args.trim() || undefined;
+    const feature = remaining.join(' ') || undefined;
     const mainUrl = this.explorBot.getExplorer().getStateManager().getCurrentState()?.url;
 
     await this.runAllStyles(mainUrl, feature);
@@ -61,6 +62,7 @@ export class ExploreCommand extends BaseCommand {
     if (mainUrl) await this.explorBot.visit(mainUrl);
     const savedPath = this.explorBot.savePlans(this.completedPlans);
     this.printResults(savedPath);
+    this.printRerunSuggestions();
   }
 
   private async runAllStyles(pageUrl?: string, feature?: string, parentPlan?: Plan, completedPlans?: Plan[]): Promise<void> {
@@ -113,6 +115,20 @@ export class ExploreCommand extends BaseCommand {
     }
   }
 
+  private printRerunSuggestions(): void {
+    const testsDir = ConfigParser.getInstance().getTestsDir();
+    if (!existsSync(testsDir)) return;
+
+    const testFiles = readdirSync(testsDir).filter((f) => f.endsWith('.js'));
+    if (testFiles.length === 0) return;
+
+    for (const file of testFiles) {
+      tag('info').log(`Generated: ${file}`);
+    }
+    tag('info').log(`List tests: ${getCliName()} runs`);
+    tag('info').log(`Re-run with healing: ${getCliName()} rerun <filename> [index]`);
+  }
+
   private isLimitReached(): boolean {
     return this.maxTests != null && this.testsRun >= this.maxTests;
   }

package/src/commands/freesail-command.ts

@@ -18,7 +18,12 @@ export class FreesailCommand extends BaseCommand {
   ];
 
   async execute(args: string): Promise<void> {
-    const { strategy, scope, maxTests } = parseArgs(args);
+    const { opts } = this.parseArgs(args);
+    let strategy: 'deep' | 'shallow' | undefined;
+    if (opts.deep) strategy = 'deep';
+    if (opts.shallow) strategy = 'shallow';
+    const scope = opts.scope as string | undefined;
+    const maxTests = opts.maxTests ? Number.parseInt(opts.maxTests as string, 10) : undefined;
 
     await this.explorBot.visitInitialState();
 
@@ -71,25 +76,3 @@ export class FreesailCommand extends BaseCommand {
     );
   }
 }
-
-function parseArgs(args: string): { strategy: 'deep' | 'shallow' | undefined; scope: string | undefined; maxTests: number | undefined } {
-  const parts = args.trim().split(/\s+/);
-  let strategy: 'deep' | 'shallow' | undefined;
-  let scope: string | undefined;
-  let maxTests: number | undefined;
-
-  for (let i = 0; i < parts.length; i++) {
-    if (parts[i] === '--deep') strategy = 'deep';
-    if (parts[i] === '--shallow') strategy = 'shallow';
-    if (parts[i] === '--scope' && parts[i + 1]) {
-      scope = parts[i + 1];
-      i++;
-    }
-    if (parts[i] === '--max-tests' && parts[i + 1]) {
-      maxTests = Number.parseInt(parts[i + 1], 10);
-      i++;
-    }
-  }
-
-  return { strategy, scope, maxTests };
-}

package/src/commands/index.ts

@@ -24,7 +24,9 @@ import { PlanEditCommand } from './plan-edit-command.js';
 import { PlanLoadCommand } from './plan-load-command.js';
 import { PlanReloadCommand } from './plan-reload-command.js';
 import { PlanSaveCommand } from './plan-save-command.js';
+import { RerunCommand } from './rerun-command.js';
 import { ResearchCommand } from './research-command.js';
+import { RunsCommand } from './runs-command.js';
 import { StartCommand } from './start-command.js';
 import { StatusCommand } from './status-command.tsx';
 import { TestCommand } from './test-command.js';
@@ -59,6 +61,8 @@ const commandClasses: CommandClass[] = [
   ContextExperienceCommand,
   ContextDataCommand,
   TestCommand,
+  RunsCommand,
+  RerunCommand,
   StatusCommand,
   DebugCommand,
   ExitCommand,

package/src/commands/init-command.ts

@@ -23,11 +23,11 @@ const config = {
 
   ai: {
     // fast model with tool calling capabilities
-    model: openrouter('<your base model here>'),
+    model: openrouter('openai/gpt-oss-20b:nitro'),
     // vision model for screenshot analysis
-    visionModel: openrouter('<your vision model here>'),
+    visionModel: openrouter('meta-llama/llama-4-scout-17b-16e-instruct'),
     // agentic model for decision making
-    agenticModel: openrouter('<your agentic model here>'),
+    agenticModel: openrouter('minimax/minimax-m2.5:nitro'),
   },
 };
 

package/src/commands/path-command.ts

@@ -14,7 +14,8 @@ export class PathCommand extends BaseCommand {
   options = [{ flags: '--links', description: 'Show outgoing links from each page' }];
 
   async execute(args: string): Promise<void> {
-    const showLinks = args.includes('--links');
+    const { opts } = this.parseArgs(args);
+    const showLinks = !!opts.links;
     const stateManager = this.explorBot.getExplorer().getStateManager();
     const history = stateManager.getStateHistory();
 

package/src/commands/plan-command.ts

@@ -1,3 +1,6 @@
+import path from 'node:path';
+import chalk from 'chalk';
+import figureSet from 'figures';
 import { tag } from '../utils/logger.js';
 import { BaseCommand } from './base-command.js';
 
@@ -13,21 +16,10 @@ export class PlanCommand extends BaseCommand {
   ];
 
   async execute(args: string): Promise<void> {
-    const clear = args.includes('--clear');
-    const fresh = args.includes('--fresh') || clear;
-    const styleMatch = args.match(/--style\s+(\S+)/);
-    const style = styleMatch?.[1];
-    const focusMatch = args.match(/--focus\s+("[^"]+"|'[^']+'|\S+)/);
-    const focusFromFlag = focusMatch?.[1]?.replace(/^["']|["']$/g, '');
-    const focusFromText = args
-      .replace('--clear', '')
-      .replace('--fresh', '')
-      .replace(/--style\s+\S+/, '')
-      .replace(/--focus\s+("[^"]+"|'[^']+'|\S+)/, '')
-      .trim();
-    const focus = focusFromFlag || focusFromText;
-
-    if (clear) {
+    const { opts, args: remaining } = this.parseArgs(args);
+    const focus = (opts.focus as string) || remaining.join(' ') || undefined;
+
+    if (opts.clear) {
       this.explorBot.clearPlan();
       tag('success').log('Plan cleared');
     }
@@ -36,11 +28,48 @@ export class PlanCommand extends BaseCommand {
       tag('info').log(`Planning focus: ${focus}`);
     }
 
-    await this.explorBot.plan(focus || undefined, { fresh, style });
+    await this.explorBot.plan(focus, { fresh: !!(opts.fresh || opts.clear), style: opts.style as string });
 
     const plan = this.explorBot.getCurrentPlan();
     if (!plan?.tests.length) {
       throw new Error('No test scenarios in the current plan.');
     }
+
+    this.printPlanSummary();
+    this.updateSuggestions();
+  }
+
+  private printPlanSummary(): void {
+    const suite = this.explorBot.getSuite();
+    const plan = this.explorBot.getCurrentPlan();
+
+    if (suite && suite.automatedTestCount > 0) {
+      const names = suite.getAutomatedTestNames();
+      console.log(`\n${chalk.bold.cyan(`Already implemented (${names.length} tests)`)}`);
+      for (let i = 0; i < names.length; i++) {
+        console.log(`  ${chalk.dim(`${i + 1}.`)} ${chalk.green(figureSet.pointer)} ${names[i]}`);
+      }
+    }
+
+    if (plan?.tests.length) {
+      console.log(`\n${chalk.bold.cyan(`New test scenarios (${plan.tests.length})`)}`);
+      for (let i = 0; i < plan.tests.length; i++) {
+        const t = plan.tests[i];
+        console.log(`  ${chalk.dim(`${i + 1}.`)} ${chalk.green(figureSet.pointer)} ${t.scenario} ${chalk.dim(`[${t.priority}]`)}`);
+      }
+    }
+  }
+
+  private updateSuggestions(): void {
+    this.suggestions = ['/test - to launch first test', '/test * - to launch all tests'];
+
+    const suite = this.explorBot.getSuite();
+    if (suite && suite.automatedTestCount > 0) {
+      for (const f of suite.getAutomatedTestFiles()) {
+        this.suggestions.push(`/rerun ${path.relative(process.cwd(), f)} - re-run automated tests`);
+      }
+    }
+
+    this.suggestions.push('Edit the plan in file and call /plan:reload to update it');
   }
 }

package/src/commands/rerun-command.ts

@@ -0,0 +1,46 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { ConfigParser } from '../config.ts';
+import { tag } from '../utils/logger.ts';
+import { BaseCommand } from './base-command.js';
+
+export class RerunCommand extends BaseCommand {
+  name = 'rerun';
+  description = 'Re-run generated tests with AI auto-healing';
+  tuiEnabled = true;
+
+  async execute(args: string): Promise<void> {
+    const { args: remaining } = this.parseArgs(args);
+    const filename = remaining[0];
+    const indexArg = remaining[1];
+
+    if (!filename) {
+      tag('error').log('Usage: /rerun <filename> [index]');
+      return;
+    }
+
+    let filePath = resolve(filename);
+    if (!existsSync(filePath)) {
+      filePath = resolve(ConfigParser.getInstance().getTestsDir(), filename);
+    }
+
+    const testIndices = indexArg ? parseTestIndices(indexArg) : undefined;
+    await this.explorBot.agentRerunner().rerun(filePath, { testIndices });
+  }
+}
+
+function parseTestIndices(input: string): number[] {
+  if (input === '*' || input === 'all') return [];
+
+  const indices = new Set<number>();
+  for (const part of input.split(',')) {
+    const trimmed = part.trim();
+    const range = trimmed.match(/^(\d+)-(\d+)$/);
+    if (range) {
+      for (let i = Number.parseInt(range[1]); i <= Number.parseInt(range[2]); i++) indices.add(i - 1);
+    } else {
+      indices.add(Number.parseInt(trimmed) - 1);
+    }
+  }
+  return [...indices].sort((a, b) => a - b);
+}

package/src/commands/research-command.ts

@@ -7,12 +7,18 @@ export class ResearchCommand extends BaseCommand {
   name = 'research';
   description = 'Research current page or navigate to URI and research. Use --deep to explore interactive elements by clicking them. Use --data to include page data.';
   suggestions = ['/navigate <page> - to go to another page', '/plan <feature> - to plan testing'];
+  options = [
+    { flags: '--data', description: 'Include page data' },
+    { flags: '--deep', description: 'Explore interactive elements by clicking them' },
+    { flags: '--no-fix', description: 'Skip fixing research issues' },
+  ];
 
   async execute(args: string): Promise<void> {
-    const includeData = args.includes('--data');
-    const enableDeep = args.includes('--deep');
-    const noFix = args.includes('--no-fix');
-    const target = args.replace('--data', '').replace('--deep', '').replace('--no-fix', '').trim();
+    const { opts, args: remaining } = this.parseArgs(args);
+    const includeData = !!opts.data;
+    const enableDeep = !!opts.deep;
+    const noFix = !!opts.noFix;
+    const target = remaining.join(' ');
 
     if (target) {
       await this.explorBot.agentNavigator().visit(target);

package/src/commands/runs-command.ts

@@ -0,0 +1,27 @@
+import * as codeceptjs from 'codeceptjs';
+import { ConfigParser } from '../config.ts';
+import { dryRunTestFile, loadTestSuites, printTestList } from '../utils/test-files.ts';
+import { BaseCommand } from './base-command.js';
+
+export class RunsCommand extends BaseCommand {
+  name = 'runs';
+  description = 'List generated test files and their scenarios';
+  tuiEnabled = true;
+
+  async execute(args: string): Promise<void> {
+    if (!this.explorBot.isExploring) {
+      codeceptjs.container.create({ helpers: {} }, {});
+    }
+
+    const { args: remaining } = this.parseArgs(args);
+    const filePath = remaining[0];
+
+    if (filePath) {
+      await dryRunTestFile(filePath);
+      return;
+    }
+
+    const suites = loadTestSuites(ConfigParser.getInstance().getTestsDir());
+    printTestList(suites);
+  }
+}

package/src/commands/start-command.ts

@@ -3,7 +3,6 @@ import { ExploreCommand } from './explore-command.js';
 
 export class StartCommand extends BaseCommand {
   name = 'start';
-  aliases = ['sail'];
   description = 'Start web exploration';
   suggestions = ['/navigate <page> - to go to another page', '/research - to analyze', '/plan <feature> - to plan testing'];
 

package/src/commands/test-command.ts

@@ -25,10 +25,10 @@ export class TestCommand extends BaseCommand {
     } else if (args === '*' || args === 'all') {
       toExecute.push(...requirePlan().getPendingTests());
     } else if (args.match(/^[\d,\-\s]+$/)) {
-      const pending = requirePlan().getPendingTests();
-      const indices = parseTestIndices(args, pending.length);
+      const visible = requirePlan().tests.filter((t) => t.enabled);
+      const indices = parseTestIndices(args, visible.length);
       for (const idx of indices) {
-        toExecute.push(pending[idx]);
+        toExecute.push(visible[idx]);
       }
     } else {
       const matching = plan?.getPendingTests().filter((test) => test.scenario.toLowerCase().includes(args.toLowerCase())) || [];

package/src/components/App.tsx

@@ -242,6 +242,14 @@ export function App({ explorBot, initialShowInput = false, exitOnEmptyInput = fa
         setShowPlanEditor(true);
         return;
       }
+      if (key.upArrow) {
+        setTaskScrollOffset((prev) => Math.max(0, prev - 1));
+        return;
+      }
+      if (key.downArrow) {
+        setTaskScrollOffset((prev) => prev + 1);
+        return;
+      }
     }
 
     if (!showInput && !showPlanEditor) {

package/src/config.ts

@@ -85,6 +85,22 @@ interface NavigatorAgentConfig extends AgentConfig {
   maxAttempts?: number;
 }
 
+type HealFn = (ctx: { I: any }) => Promise<void> | void;
+
+interface HealRecipe {
+  priority?: number;
+  steps?: string[];
+  fn: (context: { step: any; error: Error; prevSteps?: any[] }) => HealFn | Promise<HealFn | null> | null;
+}
+
+interface RerunnerAgentConfig extends AgentConfig {
+  healLimit?: number;
+  ariaSnapshotLimit?: number;
+  retryFailedStep?: Record<string, any>;
+  screenshotOnFail?: Record<string, any>;
+  recipes?: Record<string, HealRecipe>;
+}
+
 interface PlannerAgentConfig extends AgentConfig {
   styles?: string[];
   stylesDir?: string;
@@ -103,6 +119,7 @@ interface AgentsConfig {
   fisherman?: AgentConfig;
   chief?: AgentConfig;
   curler?: AgentConfig;
+  rerunner?: RerunnerAgentConfig;
 }
 
 interface AIConfig {
@@ -214,6 +231,8 @@ export type {
   ResearcherAgentConfig,
   NavigatorAgentConfig,
   PlannerAgentConfig,
+  RerunnerAgentConfig,
+  HealRecipe,
   Hook,
   HookConfig,
   HooksConfig,
@@ -328,6 +347,10 @@ export class ConfigParser {
     return outputPath('plans');
   }
 
+  public getTestsDir(): string {
+    return outputPath('tests');
+  }
+
   // For testing purposes only
   public static resetForTesting(): void {
     if (ConfigParser.instance) {

package/src/explorbot.ts

@@ -14,11 +14,13 @@ import { Planner } from './ai/planner.ts';
 import { AIProvider } from './ai/provider.ts';
 import { Quartermaster } from './ai/quartermaster.ts';
 import { Researcher } from './ai/researcher.ts';
+import { Rerunner } from './ai/rerunner.ts';
 import { Tester } from './ai/tester.ts';
 import { createAgentTools } from './ai/tools.ts';
 import type { ExplorbotConfig } from './config.js';
 import { ConfigParser } from './config.ts';
 import Explorer from './explorer.ts';
+import type { Suite } from './suite.ts';
 import { KnowledgeTracker } from './knowledge-tracker.ts';
 import { WebPageState } from './state-manager.ts';
 import { Plan } from './test-plan.ts';
@@ -245,6 +247,21 @@ export class ExplorBot {
     }));
   }
 
+  agentRerunner(): Rerunner {
+    if (!this.agents.rerunner) {
+      this.agents.rerunner = this.createAgent(({ ai, explorer }) => {
+        const researcher = this.agentResearcher();
+        const navigator = this.agentNavigator();
+        const tools = createAgentTools({ explorer, researcher, navigator });
+        return new Rerunner(explorer, ai, tools);
+      });
+      const qm = this.agentQuartermaster();
+      if (qm) this.agents.rerunner.setQuartermaster(qm);
+      this.agents.rerunner.setHistorian(this.agentHistorian());
+    }
+    return this.agents.rerunner;
+  }
+
   agentBosun(): Bosun {
     return (this.agents.bosun ||= this.createAgent(({ ai, explorer }) => {
       const researcher = this.agentResearcher();
@@ -291,6 +308,10 @@ export class ExplorBot {
     return this.currentPlan;
   }
 
+  getSuite(): Suite | null {
+    return this.agentPlanner().getSuite();
+  }
+
   getPlanFeature(): string | undefined {
     return this.planFeature;
   }

package/src/explorer.ts

@@ -309,8 +309,9 @@ class Explorer {
     return action;
   }
 
-  async annotateElements(): Promise<{ ariaSnapshot: string; elements: WebElement[] }> {
-    return annotatePageElements(this.playwrightHelper.page);
+  async annotateElements(): Promise<WebElement[]> {
+    const { elements } = await annotatePageElements(this.playwrightHelper.page);
+    return elements;
   }
 
   async visuallyAnnotateElements(opts?: { containers?: Array<{ css: string; label: string }> }): Promise<number> {