explorbot 0.1.9 → 0.1.11

package/src/commands/explore-command.ts

@@ -1,11 +1,13 @@
 import figureSet from 'figures';
-import path from 'node:path';
 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 { type NextStepSection, printNextSteps, relativeToCwd } from '../utils/next-steps.ts';
+import { BaseCommand, type Suggestion } from './base-command.js';
 
 export class ExploreCommand extends BaseCommand {
   name = 'explore';
@@ -14,7 +16,11 @@ export class ExploreCommand extends BaseCommand {
     { flags: '--max-tests <number>', description: 'Maximum number of tests to run' },
     { flags: '--focus <feature>', description: 'Focus area for exploration' },
   ];
-  suggestions = ['/navigate <page> - to go to another page', '/research - to analyze', '/plan <feature> - to plan testing'];
+  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;
@@ -27,6 +33,8 @@ export class ExploreCommand extends BaseCommand {
     }
 
     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);
@@ -34,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;
@@ -62,8 +70,8 @@ export class ExploreCommand extends BaseCommand {
     this.explorBot.setCurrentPlan(mainPlan);
     if (mainUrl) await this.explorBot.visit(mainUrl);
     const savedPath = this.explorBot.savePlans(this.completedPlans);
-    this.printResults(savedPath);
-    this.printRerunSuggestions();
+    this.printResults();
+    this.printNextSteps(savedPath);
   }
 
   private async runAllStyles(pageUrl?: string, feature?: string, parentPlan?: Plan, completedPlans?: Plan[]): Promise<void> {
@@ -74,13 +82,28 @@ 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 printResults(savedPath?: string | null): void {
+  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(): void {
     const allTests = this.completedPlans.flatMap((plan) => plan.tests.filter((t) => t.startTime != null).map((test) => ({ test, planTitle: plan.title })));
 
     if (allTests.length === 0) return;
@@ -109,22 +132,36 @@ export class ExploreCommand extends BaseCommand {
     if (hasSubPages) columns.push('Plan');
     tag('multiline').log(jsonToTable(rows, columns));
     tag('info').log(`${figureSet.tick} ${allTests.length} tests completed`);
+  }
 
-    if (savedPath) {
-      const relativePath = path.relative(process.cwd(), savedPath);
-      tag('info').log(`Re-run tests: ${getCliName()} test ${relativePath} <index>`);
+  private printNextSteps(savedPlanPath?: string | null): void {
+    const cli = getCliName();
+    const sections: NextStepSection[] = [];
+
+    if (savedPlanPath) {
+      const relPlan = relativeToCwd(savedPlanPath);
+      sections.push({
+        label: 'Plan',
+        path: savedPlanPath,
+        commands: [
+          { label: 'Re-run', command: `${cli} test ${relPlan} 1` },
+          { label: 'Run all', command: `${cli} test ${relPlan} *` },
+          { label: 'Run range', command: `${cli} test ${relPlan} 1-3` },
+        ],
+      });
     }
-  }
 
-  private printRerunSuggestions(): void {
     const savedFiles = this.explorBot.agentHistorian().getSavedFiles();
-    if (savedFiles.length === 0) return;
-
-    for (const filePath of savedFiles) {
-      tag('info').log(`Generated: ${path.basename(filePath)}`);
+    if (savedFiles.length > 0) {
+      const commands = savedFiles.map((f) => ({ label: '', command: `${cli} rerun ${relativeToCwd(f)}` }));
+      commands.push({ label: 'List tests', command: `${cli} runs` });
+      sections.push({
+        label: `Generated tests (${savedFiles.length})`,
+        commands,
+      });
     }
-    tag('info').log(`List tests: ${getCliName()} runs`);
-    tag('info').log(`Re-run with healing: ${getCliName()} rerun <filename> [index]`);
+
+    printNextSteps(sections);
   }
 
   private isLimitReached(): boolean {

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,10 @@
 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';
+import { relativeToCwd } from '../utils/next-steps.ts';
 
 const DEFAULT_CONFIG_TEMPLATE = `import { createOpenRouter } from '@openrouter/ai-sdk-provider';
 // import { '<your provider here>' } from '<your provider package here>';
@@ -61,10 +62,10 @@ export function runInitCommand(options: InitCommandOptions): void {
     const dir = resolve(customPath);
     if (!existsSync(dir)) {
       mkdirSync(dir, { recursive: true });
-      log(`Created directory: ${dir}`);
+      log(`Created directory: ${relativeToCwd(dir)}`);
     }
     process.chdir(dir);
-    log(`Working in directory: ${dir}`);
+    log(`Working in directory: ${relativeToCwd(dir)}`);
   }
 
   try {
@@ -78,24 +79,24 @@ export function runInitCommand(options: InitCommandOptions): void {
     const dir = dirname(outPath);
     if (!existsSync(dir)) {
       mkdirSync(dir, { recursive: true });
-      log(`Created directory: ${dir}`);
+      log(`Created directory: ${relativeToCwd(dir)}`);
     }
 
     if (existsSync(outPath) && !force) {
-      log(`Config file already exists: ${outPath}`);
+      log(`Config file already exists: ${relativeToCwd(outPath)}`);
       log('Use --force to overwrite existing file');
       process.exit(1);
     }
 
     writeFileSync(outPath, DEFAULT_CONFIG_TEMPLATE, 'utf8');
-    log(`Created config file: ${outPath}`);
+    log(`Created config file: ${relativeToCwd(outPath)}`);
 
     const envPath = resolve(process.cwd(), '.env');
     if (!existsSync(envPath)) {
       writeFileSync(envPath, `${DEFAULT_ENV_TEMPLATE}\n`, 'utf8');
-      log(`Created env file: ${envPath}`);
+      log(`Created env file: ${relativeToCwd(envPath)}`);
     } else {
-      log(`Env file already exists: ${envPath}`);
+      log(`Env file already exists: ${relativeToCwd(envPath)}`);
     }
 
     log('');
@@ -112,7 +113,7 @@ export function runInitCommand(options: InitCommandOptions): void {
 
     if (!existsSync('./output')) {
       mkdirSync('./output', { recursive: true });
-      log('Created directory: ./output');
+      log('Created directory: output');
     }
   } catch (error) {
     log('Failed to create config file:', error);

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

@@ -1,13 +1,19 @@
 import path from 'node:path';
 import chalk from 'chalk';
 import figureSet from 'figures';
+import { getCliName } from '../utils/cli-name.ts';
 import { tag } from '../utils/logger.js';
-import { BaseCommand } from './base-command.js';
+import { type NextStepSection, printNextSteps, relativeToCwd } from '../utils/next-steps.ts';
+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' },
@@ -37,6 +43,39 @@ export class PlanCommand extends BaseCommand {
 
     this.printPlanSummary();
     this.updateSuggestions();
+    this.printNextSteps();
+  }
+
+  private printNextSteps(): void {
+    const savedPath = this.explorBot.lastSavedPlanPath;
+    if (!savedPath) return;
+
+    const cli = getCliName();
+    const relPlan = relativeToCwd(savedPath);
+    const sections: NextStepSection[] = [
+      {
+        label: 'Plan',
+        path: savedPath,
+        commands: [
+          { label: 'Re-run', command: `${cli} test ${relPlan} 1` },
+          { label: 'Run all', command: `${cli} test ${relPlan} *` },
+          { label: 'Run range', command: `${cli} test ${relPlan} 1-3` },
+          { label: 'Reload', command: `/plan:load ${relPlan}` },
+        ],
+      },
+    ];
+
+    const suite = this.explorBot.getSuite();
+    const files = suite && suite.automatedTestCount > 0 ? suite.getAutomatedTestFiles() : [];
+    if (files.length > 0) {
+      const commands = files.map((f) => ({ label: '', command: `${cli} rerun ${relativeToCwd(f)}` }));
+      sections.push({
+        label: `Automated tests (${files.length})`,
+        commands,
+      });
+    }
+
+    printNextSteps(sections);
   }
 
   private printPlanSummary(): void {
@@ -61,15 +100,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' });
   }
 }

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

@@ -1,9 +1,9 @@
-import { BaseCommand } from './base-command.js';
+import { BaseCommand, type Suggestion } 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: Suggestion[] = [{ command: 'plan:edit', hint: 'toggle tests on/off' }];
 
   async execute(_args: string): Promise<void> {}
 }

package/src/commands/plan-load-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 PlanLoadCommand extends BaseCommand {
   name = 'plan:load';
   description = 'Load plan from file';
-  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> {
     const filename = args.trim();

package/src/commands/plan-reload-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 PlanReloadCommand extends BaseCommand {
   name = 'plan:reload';
   description = 'Clear current plan and regenerate';
-  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> {
     const currentPlan = this.explorBot.getCurrentPlan();

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

@@ -1,11 +1,11 @@
-import path from 'node:path';
-import { tag } from '../utils/logger.js';
-import { BaseCommand } from './base-command.js';
+import { getCliName } from '../utils/cli-name.ts';
+import { type NextStepSection, printNextSteps, relativeToCwd } from '../utils/next-steps.ts';
+import { BaseCommand, type Suggestion } 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: Suggestion[] = [{ command: 'test', hint: 'launch first test' }];
 
   async execute(args: string): Promise<void> {
     const plan = this.explorBot.getCurrentPlan();
@@ -15,11 +15,22 @@ export class PlanSaveCommand extends BaseCommand {
 
     const filename = args.trim() || undefined;
     const savedPath = this.explorBot.savePlan(filename);
+    if (!savedPath) return;
 
-    if (savedPath) {
-      const relativePath = path.relative(process.cwd(), savedPath);
-      tag('success').log(`Plan saved to: ${relativePath}`);
-      tag('info').log(`Run /plan:load ${relativePath} to reload it`);
-    }
+    const cli = getCliName();
+    const relPlan = relativeToCwd(savedPath);
+    const sections: NextStepSection[] = [
+      {
+        label: 'Plan',
+        path: savedPath,
+        commands: [
+          { label: 'Re-run', command: `${cli} test ${relPlan} 1` },
+          { label: 'Run all', command: `${cli} test ${relPlan} *` },
+          { label: 'Run range', command: `${cli} test ${relPlan} 1-3` },
+          { label: 'Reload', command: `/plan:load ${relPlan}` },
+        ],
+      },
+    ];
+    printNextSteps(sections);
   }
 }

package/src/commands/rerun-command.ts

@@ -24,6 +24,11 @@ export class RerunCommand extends BaseCommand {
       filePath = resolve(ConfigParser.getInstance().getTestsDir(), filename);
     }
 
+    if (filePath.endsWith('.spec.ts') || filePath.endsWith('.spec.js')) {
+      tag('error').log(`Rerun does not support Playwright tests. Run them with: npx playwright test ${filePath}`);
+      return;
+    }
+
     const testIndices = indexArg ? parseTestIndices(indexArg) : undefined;
     await this.explorBot.agentRerunner().rerun(filePath, { testIndices });
   }

package/src/commands/research-command.ts

@@ -1,12 +1,15 @@
 import { join } from 'node:path';
 import { ConfigParser } from '../config.ts';
 import { tag } from '../utils/logger.ts';
-import { BaseCommand } from './base-command.js';
+import { BaseCommand, type Suggestion } 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: Suggestion[] = [
+    { 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' },
@@ -45,7 +48,7 @@ export class ResearchCommand extends BaseCommand {
     }
 
     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/src/commands/start-command.ts

@@ -1,10 +1,14 @@
-import { BaseCommand } from './base-command.js';
+import { BaseCommand, type Suggestion } from './base-command.js';
 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: Suggestion[] = [
+    { command: 'navigate <page>', hint: 'go to another page' },
+    { command: 'research', hint: 'analyze current page' },
+    { command: 'plan <feature>', hint: 'plan testing' },
+  ];
 
   async execute(args: string): Promise<void> {
     await new ExploreCommand(this.explorBot).execute(args);

package/src/commands/test-command.ts

@@ -1,14 +1,20 @@
+import { Stats } from '../stats.js';
 import { Test } from '../test-plan.js';
 import { tag } from '../utils/logger.js';
-import { BaseCommand } from './base-command.js';
+import { BaseCommand, type Suggestion } 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: Suggestion[] = [
+    { command: 'test', hint: 'run next test' },
+    { command: 'plan', hint: 'create new plan' },
+  ];
 
   async execute(args: string): Promise<void> {
     const plan = this.explorBot.getCurrentPlan();
+    Stats.mode = 'test';
+    Stats.focus = plan?.title;
     const toExecute: Test[] = [];
 
     const requirePlan = () => {

package/src/components/App.tsx

@@ -99,7 +99,11 @@ export function App({ explorBot, initialShowInput = false, exitOnEmptyInput = fa
       setShowInput(true);
 
       return new Promise<string | null>((resolve) => {
-        interruptResolveRef.current = resolve;
+        interruptResolveRef.current = (value) => {
+          interruptResolveRef.current = null;
+          setInterruptPrompt(null);
+          resolve(value);
+        };
       });
     });
 
@@ -107,11 +111,19 @@ export function App({ explorBot, initialShowInput = false, exitOnEmptyInput = fa
       setShowInput(true);
     };
 
+    const handleInterrupt = () => {
+      if (interruptResolveRef.current) {
+        interruptResolveRef.current(null);
+      }
+    };
+
     executionController.on('idle', handleIdle);
+    executionController.on('interrupt', handleInterrupt);
     setInputCallbackReady(true);
 
     return () => {
       executionController.off('idle', handleIdle);
+      executionController.off('interrupt', handleInterrupt);
       executionController.reset();
     };
   }, []);
@@ -284,9 +296,10 @@ export function App({ explorBot, initialShowInput = false, exitOnEmptyInput = fa
       }
 
       if (isCommand) {
-        setInterruptPrompt(null);
+        if (interruptResolveRef.current) {
+          interruptResolveRef.current(null);
+        }
         setShowInput(false);
-        interruptResolveRef.current = null;
         executionController.startExecution();
         try {
           await commandHandler.executeCommand(trimmed);
@@ -303,8 +316,6 @@ export function App({ explorBot, initialShowInput = false, exitOnEmptyInput = fa
 
       if (interruptResolveRef.current) {
         interruptResolveRef.current(input);
-        interruptResolveRef.current = null;
-        setInterruptPrompt(null);
         setShowInput(false);
         return;
       }

package/src/config.ts

@@ -107,6 +107,10 @@ interface PlannerAgentConfig extends AgentConfig {
   stylesDir?: string;
 }
 
+interface HistorianAgentConfig extends AgentConfig {
+  framework?: 'codeceptjs' | 'playwright';
+}
+
 interface AgentsConfig {
   tester?: TesterAgentConfig;
   navigator?: NavigatorAgentConfig;
@@ -116,7 +120,7 @@ interface AgentsConfig {
   'experience-compactor'?: AgentConfig;
   captain?: AgentConfig;
   quartermaster?: AgentConfig;
-  historian?: AgentConfig;
+  historian?: HistorianAgentConfig;
   fisherman?: AgentConfig;
   chief?: AgentConfig;
   curler?: AgentConfig;
@@ -229,6 +233,7 @@ export type {
   ActionConfig,
   AgentConfig,
   AgentsConfig,
+  HistorianAgentConfig,
   ResearcherAgentConfig,
   NavigatorAgentConfig,
   PlannerAgentConfig,