explorbot 0.1.0 → 0.1.2

package/dist/src/ai/researcher/fingerprint-worker.js

@@ -1,5 +1,6 @@
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
+import { parentPort } from 'node:worker_threads';
 import { computeHtmlFingerprint } from "../../utils/html-diff.js";
 function diceSimilarity(a, b) {
     let intersection = 0;
@@ -12,15 +13,15 @@ function diceSimilarity(a, b) {
         return 100;
     return Math.round(((2 * intersection) / total) * 100);
 }
-self.onmessage = (event) => {
-    const { html, statesDir, maxAgeMs, threshold } = event.data;
+parentPort.on('message', (data) => {
+    const { html, statesDir, maxAgeMs, threshold } = data;
     if (!existsSync(statesDir)) {
-        self.postMessage({ matchHash: null, similarity: 0 });
+        parentPort.postMessage({ matchHash: null, similarity: 0 });
         return;
     }
     const currentFingerprint = new Set(computeHtmlFingerprint(html));
     if (currentFingerprint.size === 0) {
-        self.postMessage({ matchHash: null, similarity: 0 });
+        parentPort.postMessage({ matchHash: null, similarity: 0 });
         return;
     }
     const now = Date.now();
@@ -41,5 +42,5 @@ self.onmessage = (event) => {
         }
     }
     const matched = bestSimilarity >= threshold;
-    self.postMessage({ matchHash: matched ? bestHash : null, similarity: bestSimilarity });
-};
+    parentPort.postMessage({ matchHash: matched ? bestHash : null, similarity: bestSimilarity });
+});

package/dist/src/ai/researcher.js

@@ -98,9 +98,9 @@ export class Researcher extends ResearcherBase {
             setActivity(`${this.emoji} Researching...`, 'action');
             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);
                 if (!recovered) {
@@ -325,10 +325,9 @@ export class Researcher extends ResearcherBase {
             return false;
         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/dist/src/ai/rules.js

@@ -257,7 +257,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
 
@@ -294,7 +294,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/dist/src/ai/tools.js

@@ -274,7 +274,7 @@ export function createCodeceptJSTools(explorer, 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.'),
@@ -335,7 +335,7 @@ export function createCodeceptJSTools(explorer, 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) {

package/dist/src/commands/add-rule-command.js

@@ -5,8 +5,7 @@ import React from 'react';
 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'];
     async execute(args) {

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

@@ -1,3 +1,4 @@
+import { Command } from 'commander';
 export class BaseCommand {
     aliases = [];
     options = [];
@@ -10,4 +11,15 @@ export class BaseCommand {
     matches(commandName) {
         return this.name === commandName || this.aliases.includes(commandName);
     }
+    parseArgs(args) {
+        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/dist/src/commands/context-command.js

@@ -8,27 +8,34 @@ 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) {
         const explorer = this.explorBot.getExplorer();
         const state = explorer.getStateManager().getCurrentState();
         if (!state) {
             throw new Error('No active page to show context for');
         }
-        const isVisual = args.includes('--visual') || args.includes('--screenshot');
-        const { ariaSnapshot } = await explorer.annotateElements();
+        const { opts } = this.parseArgs(args);
+        const isVisual = !!(opts.visual || opts.screenshot);
+        await explorer.annotateElements();
         if (isVisual) {
             const cachedResearch = Researcher.getCachedResearch(state);
             const containers = cachedResearch ? extractValidContainers(cachedResearch) : [];
             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 = 'compact';
-        if (args.includes('--full')) {
+        if (opts.full) {
             mode = 'full';
         }
-        else if (args.includes('--attached')) {
+        else if (opts.attached) {
             mode = 'attached';
         }
         const contextData = {

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

@@ -2,7 +2,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) {
         const knowledgePath = this.parseKnowledgeArg(args);

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

@@ -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.js";
 import { getCliName } from "../utils/cli-name.js";
 import { jsonToTable } from '../utils/markdown-parser.js';
 import { tag } from '../utils/logger.js';
@@ -14,12 +16,11 @@ export class ExploreCommand extends BaseCommand {
     testsRun = 0;
     completedPlans = [];
     async execute(args) {
-        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, 10);
         }
-        const feature = args.trim() || undefined;
+        const feature = remaining.join(' ') || undefined;
         const mainUrl = this.explorBot.getExplorer().getStateManager().getCurrentState()?.url;
         await this.runAllStyles(mainUrl, feature);
         const mainPlan = this.explorBot.getCurrentPlan();
@@ -56,6 +57,7 @@ export class ExploreCommand extends BaseCommand {
             await this.explorBot.visit(mainUrl);
         const savedPath = this.explorBot.savePlans(this.completedPlans);
         this.printResults(savedPath);
+        this.printRerunSuggestions();
     }
     async runAllStyles(pageUrl, feature, parentPlan, completedPlans) {
         let fresh = true;
@@ -107,6 +109,19 @@ export class ExploreCommand extends BaseCommand {
             tag('info').log(`Re-run tests: ${getCliName()} test ${relativePath} <index>`);
         }
     }
+    printRerunSuggestions() {
+        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]`);
+    }
     isLimitReached() {
         return this.maxTests != null && this.testsRun >= this.maxTests;
     }

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

@@ -16,7 +16,14 @@ export class FreesailCommand extends BaseCommand {
         { flags: '--max-tests <number>', description: 'Maximum number of tests to run' },
     ];
     async execute(args) {
-        const { strategy, scope, maxTests } = parseArgs(args);
+        const { opts } = this.parseArgs(args);
+        let strategy;
+        if (opts.deep)
+            strategy = 'deep';
+        if (opts.shallow)
+            strategy = 'shallow';
+        const scope = opts.scope;
+        const maxTests = opts.maxTests ? Number.parseInt(opts.maxTests, 10) : undefined;
         await this.explorBot.visitInitialState();
         let testsRun = 0;
         await loop(async (ctx) => {
@@ -60,24 +67,3 @@ export class FreesailCommand extends BaseCommand {
         }, { maxAttempts: Number.POSITIVE_INFINITY });
     }
 }
-function parseArgs(args) {
-    const parts = args.trim().split(/\s+/);
-    let strategy;
-    let scope;
-    let maxTests;
-    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/dist/src/commands/index.js

@@ -22,7 +22,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.js";
 import { TestCommand } from './test-command.js';
@@ -53,6 +55,8 @@ const commandClasses = [
     ContextExperienceCommand,
     ContextDataCommand,
     TestCommand,
+    RunsCommand,
+    RerunCommand,
     StatusCommand,
     DebugCommand,
     ExitCommand,

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

@@ -22,11 +22,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/dist/src/commands/path-command.js

@@ -5,7 +5,8 @@ export class PathCommand extends BaseCommand {
     description = 'Display ASCII graph of navigation paths during the session';
     options = [{ flags: '--links', description: 'Show outgoing links from each page' }];
     async execute(args) {
-        const showLinks = args.includes('--links');
+        const { opts } = this.parseArgs(args);
+        const showLinks = !!opts.links;
         const stateManager = this.explorBot.getExplorer().getStateManager();
         const history = stateManager.getStateHistory();
         if (history.length === 0) {

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

@@ -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';
 export class PlanCommand extends BaseCommand {
@@ -11,30 +14,49 @@ export class PlanCommand extends BaseCommand {
         { flags: '--focus <feature>', description: 'Focus area for test planning' },
     ];
     async execute(args) {
-        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 || remaining.join(' ') || undefined;
+        if (opts.clear) {
             this.explorBot.clearPlan();
             tag('success').log('Plan cleared');
         }
         if (focus) {
             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 });
         const plan = this.explorBot.getCurrentPlan();
         if (!plan?.tests.length) {
             throw new Error('No test scenarios in the current plan.');
         }
+        this.printPlanSummary();
+        this.updateSuggestions();
+    }
+    printPlanSummary() {
+        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}]`)}`);
+            }
+        }
+    }
+    updateSuggestions() {
+        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/dist/src/commands/rerun-command.js

@@ -0,0 +1,42 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { ConfigParser } from "../config.js";
+import { tag } from "../utils/logger.js";
+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) {
+        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) {
+    if (input === '*' || input === 'all')
+        return [];
+    const indices = new Set();
+    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/dist/src/commands/research-command.js

@@ -6,11 +6,17 @@ 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) {
-        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/dist/src/commands/runs-command.js

@@ -0,0 +1,22 @@
+import * as codeceptjs from 'codeceptjs';
+import { ConfigParser } from "../config.js";
+import { dryRunTestFile, loadTestSuites, printTestList } from "../utils/test-files.js";
+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) {
+        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/dist/src/commands/start-command.js

@@ -2,7 +2,6 @@ import { BaseCommand } from './base-command.js';
 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'];
     async execute(args) {

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

@@ -24,10 +24,10 @@ export class TestCommand extends BaseCommand {
             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 {

package/dist/src/components/App.js

@@ -206,6 +206,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) {
             if (key.upArrow) {

package/dist/src/config.js

@@ -100,6 +100,9 @@ export class ConfigParser {
     getPlansDir() {
         return outputPath('plans');
     }
+    getTestsDir() {
+        return outputPath('tests');
+    }
     // For testing purposes only
     static resetForTesting() {
         if (ConfigParser.instance) {

package/dist/src/explorbot.js

@@ -14,6 +14,7 @@ import { Planner } from "./ai/planner.js";
 import { AIProvider } from "./ai/provider.js";
 import { Quartermaster } from "./ai/quartermaster.js";
 import { Researcher } from "./ai/researcher.js";
+import { Rerunner } from "./ai/rerunner.js";
 import { Tester } from "./ai/tester.js";
 import { createAgentTools } from "./ai/tools.js";
 import { ConfigParser } from "./config.js";
@@ -202,6 +203,21 @@ export class ExplorBot {
             return new Historian(ai, experienceTracker, reporter, explorer.getStateManager());
         }));
     }
+    agentRerunner() {
+        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() {
         return (this.agents.bosun ||= this.createAgent(({ ai, explorer }) => {
             const researcher = this.agentResearcher();
@@ -243,6 +259,9 @@ export class ExplorBot {
     getCurrentPlan() {
         return this.currentPlan;
     }
+    getSuite() {
+        return this.agentPlanner().getSuite();
+    }
     getPlanFeature() {
         return this.planFeature;
     }

package/dist/src/explorer.js

@@ -244,7 +244,8 @@ class Explorer {
         return action;
     }
     async annotateElements() {
-        return annotatePageElements(this.playwrightHelper.page);
+        const { elements } = await annotatePageElements(this.playwrightHelper.page);
+        return elements;
     }
     async visuallyAnnotateElements(opts) {
         return visuallyAnnotateContainers(this.playwrightHelper.page, opts?.containers || []);