explorbot 0.1.8 → 0.1.10

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

@@ -39,7 +39,7 @@ function cleanDirectoryContents(dirPath) {
 export class CleanCommand extends BaseCommand {
     name = 'clean';
     description = 'Clean files: clean [states|research|plans|experiences|output]';
-    suggestions = Object.keys(CLEAN_TARGETS).map((t) => `/clean ${t}`);
+    suggestions = Object.entries(CLEAN_TARGETS).map(([name, target]) => ({ command: `clean ${name}`, hint: `clean ${target.description}` }));
     async execute(args) {
         const target = args.trim().toLowerCase();
         if (!target) {

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

@@ -0,0 +1,138 @@
+import { basename } from 'node:path';
+import chalk from 'chalk';
+import { tag } from '../utils/logger.js';
+import { BaseCommand } from './base-command.js';
+const COMPACT_THRESHOLD = 5000;
+export class CompactCommand extends BaseCommand {
+    name = 'compact';
+    description = 'Compact stored experience files; optionally filtered by filename or URL substring';
+    options = [
+        { flags: '--dry-run', description: 'Preview without running AI or writing files' },
+        { flags: '--no-merge', description: 'Skip the cross-URL merge step when compacting all' },
+    ];
+    suggestions = [];
+    async execute(args) {
+        const { opts, args: remaining } = this.parseArgs(args);
+        const target = remaining[0];
+        const dryRun = !!opts.dryRun;
+        const merge = opts.merge !== false;
+        const tracker = this.explorBot.getExperienceTracker();
+        const files = this.resolveTarget(tracker, target);
+        if (files === null) {
+            tag('info').log('No experience files found.');
+            return;
+        }
+        if (files.length === 0) {
+            tag('info').log(`No experience files match target "${target}"`);
+            return;
+        }
+        const compactor = this.explorBot.agentExperienceCompactor();
+        if (dryRun) {
+            this.printDryRun(compactor, files, target, !target && merge);
+            this.suggestions = this.buildDryRunSuggestions(compactor, files, target);
+            return;
+        }
+        if (!target) {
+            const { merged, compacted } = await this.runFullSweep(compactor, merge);
+            tag('success').log(`Done. ${merged} merged, ${compacted} compacted.`);
+            this.suggestions = [{ command: 'experience', hint: 'list stored experiences' }];
+            return;
+        }
+        tag('info').log(`Compacting ${files.length} experience file${files.length === 1 ? '' : 's'}…`);
+        const compacted = await compactor.compactFiles(files);
+        if (compacted === 0) {
+            tag('info').log('No experience changes — nothing to strip and all content under size limit.');
+        }
+        else {
+            tag('success').log(`Compacted ${compacted}/${files.length} experience file${files.length === 1 ? '' : 's'}.`);
+        }
+        this.suggestions = [{ command: `experience ${target}`, hint: 'view updated file' }];
+    }
+    buildDryRunSuggestions(compactor, files, target) {
+        const wouldTouch = files.filter((f) => {
+            const stripped = compactor.stripNonUsefulEntries(f.content);
+            return stripped !== f.content || stripped.length >= COMPACT_THRESHOLD || compactor.isRecent(f);
+        });
+        if (wouldTouch.length === 0)
+            return [];
+        const argsPart = target ? ` ${target}` : '';
+        const count = wouldTouch.length;
+        return [{ command: `compact${argsPart}`, hint: `run compaction for real (${count} file${count === 1 ? '' : 's'} will be touched)` }];
+    }
+    async runFullSweep(compactor, merge) {
+        if (!merge) {
+            tag('info').log('Compacting all experience files (merge skipped)…');
+            const compacted = await compactor.compactFiles(this.explorBot.getExperienceTracker().getAllExperience());
+            return { merged: 0, compacted };
+        }
+        tag('info').log('Merging experience files with similar URLs, then compacting all…');
+        return compactor.compactAllExperiences();
+    }
+    resolveTarget(tracker, target) {
+        const all = tracker.getAllExperience();
+        if (all.length === 0)
+            return null;
+        if (!target)
+            return all;
+        if (target.endsWith('.md')) {
+            const bare = target.slice(0, -3);
+            const byFilename = all.find((f) => basename(f.filePath, '.md') === bare);
+            return byFilename ? [byFilename] : [];
+        }
+        const filter = target.toLowerCase();
+        return all.filter((f) => (f.data.url || '').toLowerCase().includes(filter));
+    }
+    printDryRun(compactor, files, target, willMerge) {
+        const lines = [];
+        const title = target ? `Dry run — target: "${target}"` : 'Dry run — full sweep';
+        lines.push(chalk.bold.underline.cyan(title));
+        if (willMerge) {
+            lines.push(chalk.dim('Merge step would run across all files before compaction.'));
+        }
+        let wouldStrip = 0;
+        let wouldAiReview = 0;
+        let wouldAiCompact = 0;
+        let totalChars = 0;
+        for (const file of files) {
+            const chars = file.content.length;
+            totalChars += chars;
+            const stripped = compactor.stripNonUsefulEntries(file.content);
+            const strippedChars = stripped.length;
+            const charsRemoved = chars - strippedChars;
+            const willStrip = stripped !== file.content;
+            const willReview = compactor.isRecent(file);
+            const willAi = strippedChars >= COMPACT_THRESHOLD;
+            if (willStrip)
+                wouldStrip++;
+            if (willReview)
+                wouldAiReview++;
+            if (willAi)
+                wouldAiCompact++;
+            const name = basename(file.filePath);
+            const url = file.data.url || chalk.dim('(no url)');
+            const markers = [];
+            if (willStrip) {
+                const label = charsRemoved > 0 ? `✂ strip -${charsRemoved} chars` : '✂ strip (rewrite)';
+                markers.push(chalk.yellow(label));
+            }
+            if (willReview)
+                markers.push(chalk.magenta('✓ ai-review'));
+            if (willAi)
+                markers.push(chalk.yellow('✎ ai-compact'));
+            if (markers.length === 0)
+                markers.push(chalk.dim('· skip'));
+            lines.push('');
+            lines.push(chalk.bold.green(name));
+            lines.push(`    ${chalk.cyan(url)}`);
+            lines.push(`    ${chalk.dim('size:')} ${chars} chars  ${markers.join('  ')}`);
+        }
+        lines.push('');
+        lines.push(chalk.bold('Summary'));
+        lines.push(`  ${chalk.dim('Files matched:')}      ${chalk.bold(String(files.length))}`);
+        lines.push(`  ${chalk.dim('Would strip:')}        ${chalk.bold(String(wouldStrip))} ${chalk.dim('(remove legacy / FAILED / Visual click, rename to FLOW/ACTION)')}`);
+        lines.push(`  ${chalk.dim('Would ai-review:')}    ${chalk.bold(String(wouldAiReview))} ${chalk.dim('(recent files ≤30d — quality/reusability check)')}`);
+        lines.push(`  ${chalk.dim('Would ai-compact:')}   ${chalk.bold(String(wouldAiCompact))} ${chalk.dim(`(over ${COMPACT_THRESHOLD} chars after strip)`)}`);
+        lines.push(`  ${chalk.dim('Total chars:')}        ${chalk.bold(String(totalChars))}`);
+        tag('info').log(lines.join('\n'));
+    }
+}

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

@@ -7,7 +7,13 @@ import { BaseCommand } from './base-command.js';
 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'];
+    suggestions = [
+        { command: 'context:aria', hint: 'show page ARIA snapshot' },
+        { command: 'context:html', hint: 'show page HTML' },
+        { command: 'context:knowledge', hint: 'show relevant knowledge' },
+        { command: 'context:experience', hint: 'show relevant experience' },
+        { command: 'context:data', hint: 'show captured page data' },
+    ];
     options = [
         { flags: '--visual', description: 'Include annotated screenshot' },
         { flags: '--screenshot', description: 'Include annotated screenshot' },

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

@@ -2,7 +2,10 @@ import { BaseCommand } from './base-command.js';
 export class DrillCommand extends BaseCommand {
     name = 'drill';
     description = 'Drill all components on current page to learn interactions';
-    suggestions = ['/research - to see UI map first', '/navigate <page> - to go to another page'];
+    suggestions = [
+        { command: 'research', hint: 'see UI map first' },
+        { command: 'navigate <page>', hint: 'go to another page' },
+    ];
     async execute(args) {
         const knowledgePath = this.parseKnowledgeArg(args);
         const maxComponents = this.parseMaxArg(args);

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

@@ -0,0 +1,104 @@
+import chalk from 'chalk';
+import { tag } from '../utils/logger.js';
+import { BaseCommand } from './base-command.js';
+export class ExperienceCommand extends BaseCommand {
+    name = 'experience';
+    description = 'List stored experiences; filter by filename or URL substring; expand a section by ref (e.g. LW1)';
+    options = [
+        { flags: '--recent', description: 'Only files modified within the last 30 days' },
+        { flags: '--old', description: 'Only files modified more than 30 days ago' },
+    ];
+    suggestions = [];
+    async execute(args) {
+        const { opts, args: remaining } = this.parseArgs(args);
+        if (opts.recent && opts.old) {
+            tag('info').log('Flags --recent and --old are mutually exclusive.');
+            return;
+        }
+        const recency = opts.recent ? 'recent' : opts.old ? 'old' : undefined;
+        const tracker = this.explorBot.getExperienceTracker();
+        const [first, second] = remaining;
+        const combinedRef = first?.match(/^([A-Z]+)[.\-]?(\d+)$/i);
+        if (combinedRef) {
+            this.expand(tracker, combinedRef[1].toUpperCase(), Number(combinedRef[2]));
+            return;
+        }
+        if (first && /^[A-Z]+$/i.test(first) && second && /^\d+$/.test(second)) {
+            this.expand(tracker, first.toUpperCase(), Number(second));
+            return;
+        }
+        const secondRef = second?.match(/^([A-Z]+)[.\-]?(\d+)$/i);
+        if (first && secondRef) {
+            this.expand(tracker, secondRef[1].toUpperCase(), Number(secondRef[2]), first);
+            return;
+        }
+        if (first && second && /^\d+$/.test(second)) {
+            const toc = tracker.listAllExperienceToc(first, { recency });
+            if (toc.length === 0) {
+                tag('info').log(`No experience found matching: ${first}`);
+                return;
+            }
+            this.expand(tracker, toc[0].fileTag, Number(second), first);
+            return;
+        }
+        const toc = tracker.listAllExperienceToc(first, { recency });
+        if (toc.length === 0) {
+            const scope = recency === 'recent' ? ' (recent only)' : recency === 'old' ? ' (old only)' : '';
+            tag('info').log(first ? `No experience found matching: ${first}${scope}` : `No experience files found${scope}. Experience is recorded automatically during test sessions.`);
+            return;
+        }
+        tag('info').log(this.formatToc(toc, first, recency));
+        const hints = [];
+        const exampleRef = `${toc[0].fileTag}1`;
+        hints.push({ command: `experience ${exampleRef}`, hint: 'read a section' });
+        const overloaded = toc.filter((entry) => entry.sections.length >= 10);
+        for (const entry of overloaded) {
+            hints.push({ command: `compact ${entry.fileHash}.md`, hint: `compact this file (${entry.sections.length} sections)` });
+        }
+        this.suggestions = hints;
+    }
+    expand(tracker, fileTag, sectionIndex, urlFilter) {
+        const section = tracker.getExperienceSectionByTag(fileTag, sectionIndex, urlFilter);
+        if (!section) {
+            tag('info').log(`No section ${fileTag}${sectionIndex} found${urlFilter ? ` for URL matching: ${urlFilter}` : ''}`);
+            return;
+        }
+        tag('info').log(`${chalk.dim('File:')} ${chalk.bold.green(`${section.fileHash}.md`)}`);
+        tag('info').log(`${chalk.dim('URL:')}  ${chalk.bold.cyan(section.url)}`);
+        tag('info').log(`${chalk.green(`${fileTag}${sectionIndex}`)} ${chalk.bold(section.title)}`);
+        tag('multiline').log(this.stripLeadingHeading(section.content.trim()));
+    }
+    formatToc(toc, urlFilter, recency) {
+        const totalSections = toc.reduce((sum, entry) => sum + entry.sections.length, 0);
+        const lines = [];
+        const scope = recency === 'recent' ? ' (recent, ≤30d)' : recency === 'old' ? ' (old, >30d)' : '';
+        const title = urlFilter ? `Experience matching "${urlFilter}"${scope}` : `Stored experience${scope}`;
+        lines.push(chalk.bold.underline.cyan(title));
+        for (const entry of toc) {
+            lines.push('');
+            lines.push(chalk.bold.green(`${entry.fileHash}.md`));
+            lines.push(`    ${chalk.cyan(entry.url)}`);
+            for (let i = 0; i < entry.sections.length; i++) {
+                const section = entry.sections[i];
+                const isLast = i === entry.sections.length - 1;
+                const branch = isLast ? '└─' : '├─';
+                const ref = chalk.yellow(`${entry.fileTag}${section.index}`);
+                lines.push(`    ${chalk.dim(branch)} ${ref} ${chalk.dim(':')} ${section.title}`);
+            }
+        }
+        const urls = new Set(toc.map((e) => e.url)).size;
+        lines.push('');
+        lines.push(chalk.bold('Summary'));
+        lines.push(`  ${chalk.dim('URLs:')}     ${chalk.bold(String(urls))}`);
+        lines.push(`  ${chalk.dim('Files:')}    ${chalk.bold(String(toc.length))}`);
+        lines.push(`  ${chalk.dim('Entries:')}  ${chalk.bold(String(totalSections))}`);
+        return lines.join('\n');
+    }
+    stripLeadingHeading(body) {
+        const lines = body.split('\n');
+        if (lines[0]?.match(/^#{1,6}\s/)) {
+            return lines.slice(1).join('\n').trimStart();
+        }
+        return body;
+    }
+}

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

@@ -1,15 +1,24 @@
-import figureSet from 'figures';
 import path from 'node:path';
+import figureSet from 'figures';
 import { getStyles } from '../ai/planner/styles.js';
+import { Stats } from '../stats.js';
 import { getCliName } from "../utils/cli-name.js";
-import { jsonToTable } from '../utils/markdown-parser.js';
+import { ErrorPageError } from "../utils/error-page.js";
 import { tag } from '../utils/logger.js';
+import { jsonToTable } from '../utils/markdown-parser.js';
 import { BaseCommand } from './base-command.js';
 export class ExploreCommand extends BaseCommand {
     name = 'explore';
     description = 'Start web exploration';
-    options = [{ flags: '--max-tests <number>', description: 'Maximum number of tests to run' }];
-    suggestions = ['/navigate <page> - to go to another page', '/research - to analyze', '/plan <feature> - to plan testing'];
+    options = [
+        { flags: '--max-tests <number>', description: 'Maximum number of tests to run' },
+        { flags: '--focus <feature>', description: 'Focus area for exploration' },
+    ];
+    suggestions = [
+        { command: 'navigate <page>', hint: 'go to another page' },
+        { command: 'research', hint: 'analyze current page' },
+        { command: 'plan <feature>', hint: 'plan testing' },
+    ];
     maxTests;
     testsRun = 0;
     completedPlans = [];
@@ -18,14 +27,16 @@ export class ExploreCommand extends BaseCommand {
         if (opts.maxTests) {
             this.maxTests = Number.parseInt(opts.maxTests, 10);
         }
-        const feature = remaining.join(' ') || undefined;
+        const feature = opts.focus || remaining.join(' ') || undefined;
+        Stats.mode ??= 'explore';
+        Stats.focus ??= feature;
         const mainUrl = this.explorBot.getExplorer().getStateManager().getCurrentState()?.url;
         await this.runAllStyles(mainUrl, feature);
         const mainPlan = this.explorBot.getCurrentPlan();
         if (!mainPlan)
             return;
         this.completedPlans.push(mainPlan);
-        if (!this.isLimitReached()) {
+        if (!feature && !this.isLimitReached()) {
             const planner = this.explorBot.agentPlanner();
             while (true) {
                 if (this.isLimitReached())
@@ -66,11 +77,26 @@ export class ExploreCommand extends BaseCommand {
             const opts = { fresh, style, completedPlans };
             if (fresh && parentPlan)
                 opts.extend = parentPlan;
-            await this.explorBot.plan(feature, opts);
+            await this.planWithRetry(feature, opts, pageUrl);
             await this.runPendingTests();
             fresh = false;
         }
     }
+    async planWithRetry(feature, opts, pageUrl) {
+        await this.explorBot.plan(feature, opts);
+        if (!this.explorBot.lastPlanError)
+            return;
+        if (this.explorBot.lastPlanError instanceof ErrorPageError) {
+            throw this.explorBot.lastPlanError;
+        }
+        tag('info').log(`Retrying planning style '${opts.style}'...`);
+        if (pageUrl)
+            await this.explorBot.visit(pageUrl);
+        await this.explorBot.plan(feature, opts);
+        if (this.explorBot.lastPlanError) {
+            tag('warning').log(`Planning style '${opts.style}' failed after retry, skipping`);
+        }
+    }
     printResults(savedPath) {
         const allTests = this.completedPlans.flatMap((plan) => plan.tests.filter((t) => t.startTime != null).map((test) => ({ test, planTitle: plan.title })));
         if (allTests.length === 0)

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

@@ -1,5 +1,6 @@
 import { Planner } from '../ai/planner.js';
 import { Researcher } from '../ai/researcher.js';
+import { Stats } from '../stats.js';
 import { tag } from '../utils/logger.js';
 import { loop } from '../utils/loop.js';
 import { BaseCommand } from './base-command.js';
@@ -16,6 +17,7 @@ export class FreesailCommand extends BaseCommand {
         { flags: '--max-tests <number>', description: 'Maximum number of tests to run' },
     ];
     async execute(args) {
+        Stats.mode = 'freesail';
         const { opts } = this.parseArgs(args);
         let strategy;
         if (opts.deep)

package/dist/src/commands/index.js

@@ -1,19 +1,21 @@
+import { AddRuleCommand } from './add-rule-command.js';
 import { CleanCommand } from './clean-command.js';
-import { DebugCommand } from './debug-command.js';
+import { CompactCommand } from './compact-command.js';
 import { ContextAriaCommand } from './context-aria-command.js';
 import { ContextCommand } from './context-command.js';
 import { ContextDataCommand } from './context-data-command.js';
 import { ContextExperienceCommand } from './context-experience-command.js';
 import { ContextHtmlCommand } from './context-html-command.js';
 import { ContextKnowledgeCommand } from './context-knowledge-command.js';
+import { DebugCommand } from './debug-command.js';
 import { DrillCommand } from './drill-command.js';
 import { ExitCommand } from './exit-command.js';
+import { ExperienceCommand } from './experience-command.js';
 import { ExploreCommand } from './explore-command.js';
 import { FreesailCommand } from './freesail-command.js';
 import { HelpCommand } from './help-command.js';
-import { AddRuleCommand } from './add-rule-command.js';
-import { LearnCommand } from './learn-command.js';
 import { KnowsCommand } from './knows-command.js';
+import { LearnCommand } from './learn-command.js';
 import { NavigateCommand } from './navigate-command.js';
 import { PathCommand } from './path-command.js';
 import { PlanClearCommand } from './plan-clear-command.js';
@@ -47,6 +49,8 @@ const commandClasses = [
     PathCommand,
     LearnCommand,
     KnowsCommand,
+    ExperienceCommand,
+    CompactCommand,
     AddRuleCommand,
     ContextCommand,
     ContextAriaCommand,

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

@@ -1,9 +1,9 @@
 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 dedent from 'dedent';
 import { getCliName } from "../utils/cli-name.js";
+import { log, tag } from '../utils/logger.js';
 const DEFAULT_CONFIG_TEMPLATE = `import { createOpenRouter } from '@openrouter/ai-sdk-provider';
 // import { '<your provider here>' } from '<your provider package here>';
 

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

@@ -5,7 +5,7 @@ import { BaseCommand } from './base-command.js';
 export class LearnCommand extends BaseCommand {
     name = 'learn';
     description = 'Store knowledge for current page';
-    suggestions = ['/knows - to view all knowledge'];
+    suggestions = [{ command: 'knows', hint: 'view all knowledge' }];
     async execute(args) {
         const note = args.trim();
         if (!note) {

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

@@ -3,7 +3,10 @@ import { BaseCommand } from './base-command.js';
 export class NavigateCommand extends BaseCommand {
     name = 'navigate';
     description = 'Navigate to URI or state using AI';
-    suggestions = ['/research - to analyze current page', '/plan <feature> - to plan testing'];
+    suggestions = [
+        { command: 'research', hint: 'analyze current page' },
+        { command: 'plan <feature>', hint: 'plan testing' },
+    ];
     async execute(args) {
         const destination = args.trim();
         if (!destination) {

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

@@ -3,7 +3,10 @@ import { BaseCommand } from './base-command.js';
 export class PlanClearCommand extends BaseCommand {
     name = 'plan:clear';
     description = 'Clear current plan and create a new one';
-    suggestions = ['/test - to launch first test', '/test * - to launch all tests'];
+    suggestions = [
+        { command: 'test', hint: 'launch first test' },
+        { command: 'test *', hint: 'launch all tests' },
+    ];
     async execute(args) {
         this.explorBot.clearPlan();
         tag('success').log('Plan cleared');

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

@@ -6,7 +6,11 @@ import { BaseCommand } from './base-command.js';
 export class PlanCommand extends BaseCommand {
     name = 'plan';
     description = 'Plan testing for a feature';
-    suggestions = ['/test - to launch first test', '/test * - to launch all tests', 'Edit the plan in file and call /plan:reload to update it'];
+    suggestions = [
+        { command: 'test', hint: 'launch first test' },
+        { command: 'test *', hint: 'launch all tests' },
+        { command: 'plan:reload', hint: 'after editing the plan file, reload it' },
+    ];
     options = [
         { flags: '--fresh', description: 'Regenerate plan from scratch' },
         { flags: '--clear', description: 'Clear plan before regenerating' },
@@ -50,13 +54,16 @@ export class PlanCommand extends BaseCommand {
         }
     }
     updateSuggestions() {
-        this.suggestions = ['/test - to launch first test', '/test * - to launch all tests'];
+        this.suggestions = [
+            { command: 'test', hint: 'launch first test' },
+            { command: 'test *', hint: '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({ command: `rerun ${path.relative(process.cwd(), f)}`, hint: 're-run automated tests' });
             }
         }
-        this.suggestions.push('Edit the plan in file and call /plan:reload to update it');
+        this.suggestions.push({ command: 'plan:reload', hint: 'after editing the plan file, reload it' });
     }
 }

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

@@ -2,6 +2,6 @@ import { BaseCommand } from './base-command.js';
 export class PlanEditCommand extends BaseCommand {
     name = 'plan:edit';
     description = 'Open test plan editor';
-    suggestions = ['/plan:edit - toggle tests on/off'];
+    suggestions = [{ command: 'plan:edit', hint: 'toggle tests on/off' }];
     async execute(_args) { }
 }

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

@@ -3,7 +3,10 @@ import { BaseCommand } from './base-command.js';
 export class PlanLoadCommand extends BaseCommand {
     name = 'plan:load';
     description = 'Load plan from file';
-    suggestions = ['/test - to launch first test', '/test * - to launch all tests'];
+    suggestions = [
+        { command: 'test', hint: 'launch first test' },
+        { command: 'test *', hint: 'launch all tests' },
+    ];
     async execute(args) {
         const filename = args.trim();
         if (!filename) {

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

@@ -3,7 +3,10 @@ import { BaseCommand } from './base-command.js';
 export class PlanReloadCommand extends BaseCommand {
     name = 'plan:reload';
     description = 'Clear current plan and regenerate';
-    suggestions = ['/test - to launch first test', '/test * - to launch all tests'];
+    suggestions = [
+        { command: 'test', hint: 'launch first test' },
+        { command: 'test *', hint: 'launch all tests' },
+    ];
     async execute(args) {
         const currentPlan = this.explorBot.getCurrentPlan();
         if (!currentPlan) {

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

@@ -4,7 +4,7 @@ import { BaseCommand } from './base-command.js';
 export class PlanSaveCommand extends BaseCommand {
     name = 'plan:save';
     description = 'Save current plan to file';
-    suggestions = ['/test - to launch first test'];
+    suggestions = [{ command: 'test', hint: 'launch first test' }];
     async execute(args) {
         const plan = this.explorBot.getCurrentPlan();
         if (!plan) {

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

@@ -5,7 +5,10 @@ import { BaseCommand } from './base-command.js';
 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'];
+    suggestions = [
+        { command: 'navigate <page>', hint: 'go to another page' },
+        { command: 'plan <feature>', hint: 'plan testing' },
+    ];
     options = [
         { flags: '--data', description: 'Include page data' },
         { flags: '--deep', description: 'Explore interactive elements by clicking them' },
@@ -37,7 +40,7 @@ export class ResearchCommand extends BaseCommand {
             tag('info').log(`Research file: ${join(outputDir, 'research', `${state.hash}.md`)}`);
         }
         if (!enableDeep) {
-            this.suggestions = ['/research <page> --deep - analyze page for all expandable elements and interactions'];
+            this.suggestions = [{ command: 'research <page> --deep', hint: 'analyze page for all expandable elements and interactions' }];
         }
     }
 }

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

@@ -3,7 +3,11 @@ import { ExploreCommand } from './explore-command.js';
 export class StartCommand extends BaseCommand {
     name = 'start';
     description = 'Start web exploration';
-    suggestions = ['/navigate <page> - to go to another page', '/research - to analyze', '/plan <feature> - to plan testing'];
+    suggestions = [
+        { command: 'navigate <page>', hint: 'go to another page' },
+        { command: 'research', hint: 'analyze current page' },
+        { command: 'plan <feature>', hint: 'plan testing' },
+    ];
     async execute(args) {
         await new ExploreCommand(this.explorBot).execute(args);
     }

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

@@ -1,12 +1,18 @@
+import { Stats } from '../stats.js';
 import { Test } from '../test-plan.js';
 import { tag } from '../utils/logger.js';
 import { BaseCommand } from './base-command.js';
 export class TestCommand extends BaseCommand {
     name = 'test';
     description = 'Launch tester agent to execute test scenarios';
-    suggestions = ['/test - to run next test', '/plan - to create new plan'];
+    suggestions = [
+        { command: 'test', hint: 'run next test' },
+        { command: 'plan', hint: 'create new plan' },
+    ];
     async execute(args) {
         const plan = this.explorBot.getCurrentPlan();
+        Stats.mode = 'test';
+        Stats.focus = plan?.title;
         const toExecute = [];
         const requirePlan = () => {
             if (!plan)