explorbot 0.1.8 → 0.1.10

package/src/command-handler.ts

@@ -155,7 +155,7 @@ export class CommandHandler implements InputManager {
         this.runningCommands.add(command.name);
         try {
           await command.execute(argsString);
-          command.suggestions.forEach((s) => tag('step').log(s));
+          command.printSuggestions();
         } catch (error: any) {
           if (error?.name === 'AbortError') throw error;
           tag('error').log(`/${command.name} failed: ${error instanceof Error ? error.message : String(error)}`);

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

@@ -3,12 +3,12 @@ import { join } from 'node:path';
 import { render } from 'ink';
 import React from 'react';
 import { tag } from '../utils/logger.js';
-import { BaseCommand } from './base-command.js';
+import { BaseCommand, type Suggestion } from './base-command.js';
 
 export class AddRuleCommand extends BaseCommand {
   name = 'add-rule';
   description = 'Create a rule file for an agent';
-  suggestions = ['/add-rule researcher check-tooltips'];
+  suggestions: Suggestion[] = [{ command: 'add-rule researcher check-tooltips', hint: 'example — add a rule for the researcher agent' }];
 
   async execute(args: string): Promise<void> {
     const parts = args.trim().split(/\s+/);

package/src/commands/base-command.ts

@@ -1,18 +1,27 @@
+import chalk from 'chalk';
 import { Command } from 'commander';
+import { isInteractive } from '../ai/task-agent.js';
 import type { ExplorBot } from '../explorbot.js';
+import { getCliName } from '../utils/cli-name.js';
+import { tag } from '../utils/logger.js';
 
 export interface CommandOption {
   flags: string;
   description: string;
 }
 
+export interface Suggestion {
+  command?: string;
+  hint: string;
+}
+
 export abstract class BaseCommand {
   abstract name: string;
   abstract description: string;
   aliases: string[] = [];
   options: CommandOption[] = [];
   tuiEnabled = true;
-  suggestions: string[] = [];
+  suggestions: Suggestion[] = [];
 
   protected explorBot: ExplorBot;
 
@@ -26,6 +35,22 @@ export abstract class BaseCommand {
     return this.name === commandName || this.aliases.includes(commandName);
   }
 
+  printSuggestions(): void {
+    if (this.suggestions.length === 0) return;
+    const prefix = isInteractive() ? '/' : `${getCliName()} `;
+    tag('info').log('');
+    tag('info').log(chalk.bold('Suggested:'));
+    for (const { command, hint } of this.suggestions) {
+      tag('info').log('');
+      if (!command) {
+        tag('info').log(chalk.dim(hint));
+        continue;
+      }
+      tag('info').log(chalk.dim(`${hint}:`));
+      tag('info').log(`  ${chalk.yellow(`${prefix}${command}`)}`);
+    }
+  }
+
   protected parseArgs(args: string): { opts: Record<string, string | boolean>; args: string[] } {
     const cmd = new Command();
     cmd.exitOverride();

package/src/commands/clean-command.ts

@@ -2,7 +2,7 @@ import { existsSync, readdirSync, rmSync, statSync, unlinkSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { ConfigParser, outputPath } from '../config.js';
 import { tag } from '../utils/logger.js';
-import { BaseCommand } from './base-command.js';
+import { BaseCommand, type Suggestion } from './base-command.js';
 
 export const CLEAN_TARGETS: Record<string, { description: string; getDir: () => string }> = {
   states: { description: 'page states', getDir: () => outputPath('states') },
@@ -41,7 +41,7 @@ function cleanDirectoryContents(dirPath: string): number {
 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: Suggestion[] = Object.entries(CLEAN_TARGETS).map(([name, target]) => ({ command: `clean ${name}`, hint: `clean ${target.description}` }));
 
   async execute(args: string): Promise<void> {
     const target = args.trim().toLowerCase();

package/src/commands/compact-command.ts

@@ -0,0 +1,156 @@
+import { basename } from 'node:path';
+import chalk from 'chalk';
+import type { ExperienceFile } from '../ai/experience-compactor.js';
+import type { ExperienceTracker } from '../experience-tracker.js';
+import { tag } from '../utils/logger.js';
+import { BaseCommand, type Suggestion } 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: Suggestion[] = [];
+
+  async execute(args: string): Promise<void> {
+    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' }];
+  }
+
+  private buildDryRunSuggestions(compactor: ReturnType<typeof this.explorBot.agentExperienceCompactor>, files: ExperienceFile[], target?: string): Suggestion[] {
+    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)` }];
+  }
+
+  private async runFullSweep(compactor: ReturnType<typeof this.explorBot.agentExperienceCompactor>, merge: boolean): Promise<{ merged: number; compacted: number }> {
+    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();
+  }
+
+  private resolveTarget(tracker: ExperienceTracker, target?: string): ExperienceFile[] | null {
+    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));
+  }
+
+  private printDryRun(compactor: ReturnType<typeof this.explorBot.agentExperienceCompactor>, files: ExperienceFile[], target: string | undefined, willMerge: boolean): void {
+    const lines: string[] = [];
+    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: string[] = [];
+      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/src/commands/context-command.ts

@@ -4,12 +4,18 @@ import { outputPath } from '../config.js';
 import { type ContextData, type ContextMode, formatContextSummary } from '../utils/context-formatter.js';
 import { tag } from '../utils/logger.js';
 import { extractValidContainers } from '../utils/research-parser.js';
-import { BaseCommand } from './base-command.js';
+import { BaseCommand, type Suggestion } 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: Suggestion[] = [
+    { 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/src/commands/drill-command.ts

@@ -1,9 +1,12 @@
-import { BaseCommand } from './base-command.js';
+import { BaseCommand, type Suggestion } 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: Suggestion[] = [
+    { command: 'research', hint: 'see UI map first' },
+    { command: 'navigate <page>', hint: 'go to another page' },
+  ];
 
   async execute(args: string): Promise<void> {
     const knowledgePath = this.parseKnowledgeArg(args);

package/src/commands/experience-command.ts

@@ -0,0 +1,125 @@
+import chalk from 'chalk';
+import type { ExperienceTocEntry, ExperienceTracker } from '../experience-tracker.js';
+import { tag } from '../utils/logger.js';
+import { BaseCommand, type Suggestion } 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: Suggestion[] = [];
+
+  async execute(args: string): Promise<void> {
+    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: Suggestion[] = [];
+    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;
+  }
+
+  private expand(tracker: ExperienceTracker, fileTag: string, sectionIndex: number, urlFilter?: string): void {
+    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()));
+  }
+
+  private formatToc(toc: ExperienceTocEntry[], urlFilter?: string, recency?: 'recent' | 'old'): string {
+    const totalSections = toc.reduce((sum, entry) => sum + entry.sections.length, 0);
+    const lines: string[] = [];
+
+    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');
+  }
+
+  private stripLeadingHeading(body: string): string {
+    const lines = body.split('\n');
+    if (lines[0]?.match(/^#{1,6}\s/)) {
+      return lines.slice(1).join('\n').trimStart();
+    }
+    return body;
+  }
+}

package/src/commands/explore-command.ts

@@ -1,17 +1,26 @@
-import figureSet from 'figures';
 import path from 'node:path';
+import figureSet from 'figures';
 import { getStyles } from '../ai/planner/styles.js';
-import { getCliName } from '../utils/cli-name.ts';
+import { Stats } from '../stats.js';
 import type { Plan } from '../test-plan.js';
-import { jsonToTable } from '../utils/markdown-parser.js';
+import { getCliName } from '../utils/cli-name.ts';
+import { ErrorPageError } from '../utils/error-page.ts';
 import { tag } from '../utils/logger.js';
-import { BaseCommand } from './base-command.js';
+import { jsonToTable } from '../utils/markdown-parser.js';
+import { BaseCommand, type Suggestion } 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: Suggestion[] = [
+    { command: 'navigate <page>', hint: 'go to another page' },
+    { command: 'research', hint: 'analyze current page' },
+    { command: 'plan <feature>', hint: 'plan testing' },
+  ];
 
   maxTests?: number;
   private testsRun = 0;
@@ -23,7 +32,9 @@ export class ExploreCommand extends BaseCommand {
       this.maxTests = Number.parseInt(opts.maxTests as string, 10);
     }
 
-    const feature = remaining.join(' ') || undefined;
+    const feature = (opts.focus as string) || remaining.join(' ') || undefined;
+    Stats.mode ??= 'explore';
+    Stats.focus ??= feature;
     const mainUrl = this.explorBot.getExplorer().getStateManager().getCurrentState()?.url;
 
     await this.runAllStyles(mainUrl, feature);
@@ -31,7 +42,7 @@ export class ExploreCommand extends BaseCommand {
     if (!mainPlan) return;
     this.completedPlans.push(mainPlan);
 
-    if (!this.isLimitReached()) {
+    if (!feature && !this.isLimitReached()) {
       const planner = this.explorBot.agentPlanner();
       while (true) {
         if (this.isLimitReached()) break;
@@ -71,12 +82,27 @@ export class ExploreCommand extends BaseCommand {
       }
       const opts: { fresh: boolean; style: string; extend?: Plan; completedPlans?: Plan[] } = { 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;
     }
   }
 
+  private async planWithRetry(feature: string | undefined, opts: { fresh: boolean; style: string; extend?: Plan; completedPlans?: Plan[] }, pageUrl?: string): Promise<void> {
+    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`);
+    }
+  }
+
   private printResults(savedPath?: string | null): void {
     const allTests = this.completedPlans.flatMap((plan) => plan.tests.filter((t) => t.startTime != null).map((test) => ({ test, planTitle: plan.title })));
 

package/src/commands/freesail-command.ts

@@ -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';
@@ -18,6 +19,7 @@ export class FreesailCommand extends BaseCommand {
   ];
 
   async execute(args: string): Promise<void> {
+    Stats.mode = 'freesail';
     const { opts } = this.parseArgs(args);
     let strategy: 'deep' | 'shallow' | undefined;
     if (opts.deep) strategy = 'deep';

package/src/commands/index.ts

@@ -1,21 +1,23 @@
 import type { ExplorBot } from '../explorbot.js';
+import { AddRuleCommand } from './add-rule-command.js';
 import type { BaseCommand } from './base-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';
@@ -53,6 +55,8 @@ const commandClasses: CommandClass[] = [
   PathCommand,
   LearnCommand,
   KnowsCommand,
+  ExperienceCommand,
+  CompactCommand,
   AddRuleCommand,
   ContextCommand,
   ContextAriaCommand,

package/src/commands/init-command.ts

@@ -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.ts';
+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/src/commands/learn-command.ts

@@ -1,12 +1,12 @@
 import { render } from 'ink';
 import React from 'react';
 import { tag } from '../utils/logger.js';
-import { BaseCommand } from './base-command.js';
+import { BaseCommand, type Suggestion } from './base-command.js';
 
 export class LearnCommand extends BaseCommand {
   name = 'learn';
   description = 'Store knowledge for current page';
-  suggestions = ['/knows - to view all knowledge'];
+  suggestions: Suggestion[] = [{ command: 'knows', hint: 'view all knowledge' }];
 
   async execute(args: string): Promise<void> {
     const note = args.trim();

package/src/commands/navigate-command.ts

@@ -1,10 +1,13 @@
 import { tag } from '../utils/logger.js';
-import { BaseCommand } from './base-command.js';
+import { BaseCommand, type Suggestion } 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: Suggestion[] = [
+    { command: 'research', hint: 'analyze current page' },
+    { command: 'plan <feature>', hint: 'plan testing' },
+  ];
 
   async execute(args: string): Promise<void> {
     const destination = args.trim();

package/src/commands/plan-clear-command.ts

@@ -1,10 +1,13 @@
 import { tag } from '../utils/logger.js';
-import { BaseCommand } from './base-command.js';
+import { BaseCommand, type Suggestion } 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: Suggestion[] = [
+    { command: 'test', hint: 'launch first test' },
+    { command: 'test *', hint: 'launch all tests' },
+  ];
 
   async execute(args: string): Promise<void> {
     this.explorBot.clearPlan();

package/src/commands/plan-command.ts

@@ -2,12 +2,16 @@ 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';
+import { BaseCommand, type Suggestion } 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: Suggestion[] = [
+    { 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' },
@@ -61,15 +65,18 @@ export class PlanCommand extends BaseCommand {
   }
 
   private updateSuggestions(): void {
-    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' });
   }
 }