explorbot 0.0.5 → 0.1.1

package/src/ai/researcher/deep-analysis.ts

@@ -77,7 +77,7 @@ export function WithDeepAnalysis<T extends Constructor>(Base: T) {
     }
 
     private async _discoverExpandables(researchText: string): Promise<ExpandableElement[]> {
-      const allElements = new Map<number, ExpandableElement>();
+      const allElements = new Map<string, ExpandableElement>();
       for (const section of parseResearchSections(researchText)) {
         for (const el of section.elements) {
           if (el.eidx != null) allElements.set(el.eidx, { ...el, container: section.containerCss });
@@ -91,7 +91,7 @@ export function WithDeepAnalysis<T extends Constructor>(Base: T) {
         From this UI research, identify elements that could reveal hidden UI when clicked
         (dropdown menus, popups, expandable panels, accordion sections, overflow menus, tab switches).
 
-        Available eidx numbers: ${eidxList}
+        Available eidx refs: ${eidxList}
 
         ${researchText}
 
@@ -99,7 +99,7 @@ export function WithDeepAnalysis<T extends Constructor>(Base: T) {
         - Only pick elements that HIDE content until clicked (menus, dropdowns, accordions, tabs)
         - Skip regular links, data items, and navigation
         - For repeated elements (same expand button on every row), pick only the FIRST one
-        - Respond with comma-separated eidx numbers only, e.g.: 3, 7, 15
+        - Respond with comma-separated eidx refs only, e.g.: e3, e7, e15
       `;
 
       const model = this.provider.getModelForAgent('researcher');
@@ -112,7 +112,7 @@ export function WithDeepAnalysis<T extends Constructor>(Base: T) {
       const screenshot = this.actionResult?.screenshot;
       if (screenshot && this.provider.hasVision()) {
         const visionPrompt = dedent`
-          This screenshot has interactive elements labeled with eidx numbers (solid bordered boxes with numbers).
+          This screenshot has interactive elements labeled with eidx refs (solid bordered boxes with labels).
           Identify elements that could reveal hidden UI when clicked.
 
           Look for: overflow/ellipsis menus, chevron dropdowns, hamburger menus,
@@ -121,33 +121,30 @@ export function WithDeepAnalysis<T extends Constructor>(Base: T) {
           Rules:
           - For repeated icons (same icon on every list row), pick only the FIRST one
           - Skip regular text buttons, links, and navigation items
-          - Respond with comma-separated eidx numbers only, e.g.: 3, 7, 15
+          - Respond with comma-separated eidx refs only, e.g.: e3, e7, e15
         `;
         visionCall = this.provider.processImage(visionPrompt, screenshot.toString('base64'));
       }
 
       const [textRes, visionRes] = await Promise.all([textCall, visionCall]);
 
-      const eidxSet = new Set<number>();
+      const eidxSet = new Set<string>();
+      const parseRefs = (text: string | undefined) => {
+        if (!text) return [];
+        const matches = text.match(/e?\d+/g) || [];
+        const refs = matches.map((m) => (m.startsWith('e') ? m : `e${m}`));
+        return refs.filter((r) => allElements.has(r));
+      };
+
       for (const res of [textRes, visionRes]) {
-        if (!res?.text) continue;
-        const nums = res.text.match(/\d+/g)?.map(Number) || [];
-        for (const n of nums) {
-          if (allElements.has(n)) eidxSet.add(n);
+        for (const ref of parseRefs(res?.text)) {
+          eidxSet.add(ref);
         }
       }
 
-      const textNums =
-        textRes?.text
-          ?.match(/\d+/g)
-          ?.map(Number)
-          .filter((n) => allElements.has(n)) || [];
-      const visionNums =
-        visionRes?.text
-          ?.match(/\d+/g)
-          ?.map(Number)
-          .filter((n) => allElements.has(n)) || [];
-      debugLog(`Text model picked eidx: [${textNums.join(', ')}], Vision model picked eidx: [${visionNums.join(', ')}]`);
+      const textRefs = parseRefs(textRes?.text);
+      const visionRefs = parseRefs(visionRes?.text);
+      debugLog(`Text model picked eidx: [${textRefs.join(', ')}], Vision model picked eidx: [${visionRefs.join(', ')}]`);
 
       return [...eidxSet].map((eidx) => allElements.get(eidx)!);
     }

package/src/ai/researcher/locators.ts

@@ -146,7 +146,7 @@ export function WithLocators<T extends Constructor>(Base: T) {
         for (const fixedSection of fixedSections) {
           const originalSections = parseResearchSections(result.text);
           const original = originalSections.find((s) => s.name === fixedSection.name);
-          if (!original) continue;
+          if (!original || original.elements.length === 0) continue;
 
           if (fixedSection.containerCss && fixedSection.containerCss !== original.containerCss) {
             debugLog(`Fixed container for "${fixedSection.name}": '${original.containerCss}' → '${fixedSection.containerCss}'`);
@@ -177,8 +177,8 @@ export function WithLocators<T extends Constructor>(Base: T) {
       const sections = parseResearchSections(result.text);
       const brokenCss = new Set(result.locators.filter((l) => l.type === 'css' && l.valid === false).map((l) => `${l.section}::${l.element}`));
 
-      const needsXpath: number[] = [];
-      const needsXpathEls = new Map<number, { section: (typeof sections)[0]; el: (typeof sections)[0]['elements'][0] }>();
+      const needsXpath: string[] = [];
+      const needsXpathEls = new Map<string, { section: (typeof sections)[0]; el: (typeof sections)[0]['elements'][0] }>();
 
       for (const section of sections) {
         for (const el of section.elements) {

package/src/ai/researcher/parser.ts

@@ -13,7 +13,7 @@ export interface ResearchElement {
   coordinates: string | null;
   color: string | null;
   icon: string | null;
-  eidx: number | null;
+  eidx: string | null;
 }
 
 export interface ResearchSection {
@@ -62,8 +62,8 @@ export function mapRowToElement(row: Record<string, string>): ResearchElement |
   const name = stripQuotes(colMap.element || '');
   if (!name) return null;
 
-  const eidxRaw = (colMap.eidx || '').trim();
-  const eidxNum = eidxRaw ? Number.parseInt(eidxRaw, 10) : Number.NaN;
+  let eidxRaw = (colMap.eidx || '').trim();
+  if (eidxRaw && /^\d+$/.test(eidxRaw)) eidxRaw = `e${eidxRaw}`;
 
   const aria = parseAriaLocator(colMap.aria || '-');
 
@@ -76,7 +76,7 @@ export function mapRowToElement(row: Record<string, string>): ResearchElement |
     coordinates: (colMap.coordinates || '-').trim() === '-' ? null : colMap.coordinates.trim(),
     color: (colMap.color || '-').trim() === '-' || (colMap.color || '').trim() === '' ? null : colMap.color.trim(),
     icon: (colMap.icon || '-').trim() === '-' || (colMap.icon || '').trim() === '' ? null : colMap.icon.trim(),
-    eidx: Number.isNaN(eidxNum) ? null : eidxNum,
+    eidx: eidxRaw && eidxRaw !== '-' ? eidxRaw : null,
   };
 }
 

package/src/ai/researcher/research-result.ts

@@ -65,6 +65,7 @@ export class ResearchResult {
   }
 
   rebuildSectionInText(section: ResearchSection): void {
+    if (section.elements.length === 0) return;
     const newTable = rebuildSectionMarkdown(section);
     const escaped = section.name.replace(/"/g, '\\"');
     let sectionQuery = mdq(this.text).query(`section2(~"${escaped}")`);

package/src/ai/researcher.ts

@@ -131,8 +131,8 @@ export class Researcher extends ResearcherBase implements Agent {
       await this.ensureNavigated(state.url, screenshot && this.provider.hasVision());
       await this.hooksRunner.runBeforeHook('researcher', state.url);
 
-      const annotatedCount = await this.explorer.annotateElements();
-      debugLog(`Annotated ${annotatedCount} interactive elements with eidx`);
+      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() });
 
       if (isErrorPage(this.actionResult!)) {
@@ -154,7 +154,7 @@ export class Researcher extends ResearcherBase implements Agent {
 
       const combinedHtml = await this.actionResult!.combinedHtml();
 
-      if (!deep) {
+      if (!deep && !force) {
         const similar = await findSimilarResearch(combinedHtml);
         if (similar) {
           tag('info').log('Similar research found, reusing cached result');

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.'),
@@ -340,8 +340,13 @@ export function createCodeceptJSTools(explorer: Explorer, task: Task) {
           const previousState = ActionResult.fromState(stateManager.getCurrentState()!);
           const formLocator = codeLines[0] || 'form';
           const action = explorer.createAction();
+          const wasInIframe = await explorer.isInsideIframe();
           await action.attempt(codeBlock, explanation);
 
+          if (action.lastError && !wasInIframe && (await explorer.isInsideIframe())) {
+            await explorer.switchToMainFrame();
+          }
+
           const toolResult = await ActionResult.fromState(stateManager.getCurrentState()!).toToolResult(previousState, formLocator);
 
           if (action.lastError) {
@@ -380,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,7 +25,8 @@ 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);
 
     await explorer.annotateElements();
 
@@ -34,9 +41,9 @@ export class ContextCommand extends BaseCommand {
     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> {
@@ -78,7 +80,7 @@ export class ExploreCommand extends BaseCommand {
   }
 
   private printResults(savedPath?: string | null): void {
-    const allTests = this.completedPlans.flatMap((plan) => plan.tests.filter((t) => t.status !== 'pending').map((test) => ({ test, planTitle: plan.title })));
+    const allTests = this.completedPlans.flatMap((plan) => plan.tests.filter((t) => t.startTime != null).map((test) => ({ test, planTitle: plan.title })));
 
     if (allTests.length === 0) return;
 
@@ -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

@@ -2,6 +2,7 @@ import { existsSync, mkdirSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, extname, join, resolve } from 'node:path';
 import { log, tag } from '../utils/logger.js';
 import dedent from 'dedent';
+import chalk from 'chalk';
 import { getCliName } from '../utils/cli-name.ts';
 
 const DEFAULT_CONFIG_TEMPLATE = `import { createOpenRouter } from '@openrouter/ai-sdk-provider';
@@ -22,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'),
   },
 };
 
@@ -103,9 +104,11 @@ export function runInitCommand(options: InitCommandOptions): void {
     log('2. Set AI models config file');
     log('3. Set web application URL in the config file');
     log('4. Add initial knowledge (how to authorize to the application, etc.)');
-    tag('substep').log(`${getCliName()} learn * 'to aurhorize use these credentials: admin@example.com / secret123'`);
+    tag('substep').log(chalk.yellow(`${getCliName()} learn * 'to aurhorize use these credentials: admin@example.com / secret123'`));
+    tag('substep').log('You can use ${env.LOGIN} and ${env.PASSWORD} to reference environment variables.');
+
     log('5. Launch application on a relative URL');
-    tag('substep').log(`${getCliName()} start /dashboard`);
+    tag('substep').log(chalk.yellow(`${getCliName()} start /dashboard`));
 
     if (!existsSync('./output')) {
       mkdirSync('./output', { recursive: true });

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';
 
@@ -9,20 +12,14 @@ export class PlanCommand extends BaseCommand {
     { flags: '--fresh', description: 'Regenerate plan from scratch' },
     { flags: '--clear', description: 'Clear plan before regenerating' },
     { flags: '--style <name>', description: 'Planning style (normal, curious, psycho, performer)' },
+    { flags: '--focus <feature>', description: 'Focus area for test planning' },
   ];
 
   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 focus = args
-      .replace('--clear', '')
-      .replace('--fresh', '')
-      .replace(/--style\s+\S+/, '')
-      .trim();
-
-    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');
     }
@@ -31,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'];