explorbot 0.1.10 → 0.1.12

package/src/browser-server.ts

@@ -2,7 +2,9 @@ import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from '
 import path from 'node:path';
 import { chromium, firefox, webkit } from 'playwright-core';
 import { ConfigParser } from './config.js';
-import { log, tag } from './utils/logger.js';
+import { getCliName } from './utils/cli-name.ts';
+import { log } from './utils/logger.js';
+import { type NextStepSection, printNextSteps } from './utils/next-steps.ts';
 
 const ENDPOINT_FILENAME = '.browser-endpoint';
 
@@ -57,8 +59,20 @@ async function launchServer(opts: { browser?: string; show?: boolean }): Promise
   writeEndpoint(wsEndpoint);
 
   log(`Browser server started: ${browserName} (${opts.show ? 'headed' : 'headless'})`);
-  tag('info').log(`WebSocket endpoint: ${wsEndpoint}`);
-  tag('info').log(`Endpoint saved to: ${getEndpointFilePath()}`);
+
+  const cli = getCliName();
+  const sections: NextStepSection[] = [
+    {
+      label: 'Browser server',
+      path: getEndpointFilePath(),
+      commands: [
+        { label: 'Endpoint', command: wsEndpoint },
+        { label: 'Status', command: `${cli} browser status` },
+        { label: 'Stop', command: `${cli} browser stop` },
+      ],
+    },
+  ];
+  printNextSteps(sections);
 
   return server;
 }

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

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 import { render } from 'ink';
 import React from 'react';
 import { tag } from '../utils/logger.js';
+import { type NextStepSection, printNextSteps, relativeToCwd } from '../utils/next-steps.ts';
 import { BaseCommand, type Suggestion } from './base-command.js';
 
 export class AddRuleCommand extends BaseCommand {
@@ -43,19 +44,22 @@ export class AddRuleCommand extends BaseCommand {
 
     const filePath = join(rulesDir, `${ruleName}.md`);
     if (existsSync(filePath)) {
-      tag('warning').log(`Rule file already exists: ${filePath}`);
+      tag('warning').log(`Rule file already exists: ${relativeToCwd(filePath)}`);
       return null;
     }
 
     const content = opts?.content || `Instructions for ${agentName} agent.`;
     writeFileSync(filePath, `${content.trim()}\n`);
-    tag('success').log(`Rule created: ${filePath}`);
 
-    if (opts?.urlPattern) {
-      tag('info').log(`Add to config: ai.agents.${agentName}.rules: [{ '${opts.urlPattern}': '${ruleName}' }]`);
-    } else {
-      tag('info').log(`Add to config: ai.agents.${agentName}.rules: ['${ruleName}']`);
-    }
+    const configLine = opts?.urlPattern ? `ai.agents.${agentName}.rules: [{ '${opts.urlPattern}': '${ruleName}' }]` : `ai.agents.${agentName}.rules: ['${ruleName}']`;
+    const sections: NextStepSection[] = [
+      {
+        label: 'Rule',
+        path: filePath,
+        commands: [{ label: 'Add to config', command: configLine }],
+      },
+    ];
+    printNextSteps(sections);
 
     return filePath;
   }

package/src/commands/clean-command.ts

@@ -8,6 +8,7 @@ export const CLEAN_TARGETS: Record<string, { description: string; getDir: () =>
   states: { description: 'page states', getDir: () => outputPath('states') },
   research: { description: 'research cache', getDir: () => outputPath('research') },
   plans: { description: 'test plans', getDir: () => outputPath('plans') },
+  tests: { description: 'generated tests', getDir: () => outputPath('tests') },
   experiences: { description: 'experience files', getDir: () => getExperienceDir() },
   output: { description: 'all output files', getDir: () => outputPath() },
 };
@@ -40,7 +41,7 @@ function cleanDirectoryContents(dirPath: string): number {
 
 export class CleanCommand extends BaseCommand {
   name = 'clean';
-  description = 'Clean files: clean [states|research|plans|experiences|output]';
+  description = 'Clean files: clean [states|research|plans|tests|experiences|output]';
   suggestions: Suggestion[] = Object.entries(CLEAN_TARGETS).map(([name, target]) => ({ command: `clean ${name}`, hint: `clean ${target.description}` }));
 
   async execute(args: string): Promise<void> {

package/src/commands/explore-command.ts

@@ -1,12 +1,14 @@
-import path from 'node:path';
 import figureSet from 'figures';
 import { getStyles } from '../ai/planner/styles.js';
+import { outputPath } from '../config.js';
 import { Stats } from '../stats.js';
 import type { Plan } from '../test-plan.js';
 import { getCliName } from '../utils/cli-name.ts';
 import { ErrorPageError } from '../utils/error-page.ts';
 import { tag } from '../utils/logger.js';
 import { jsonToTable } from '../utils/markdown-parser.js';
+import { type NextStepSection, printNextSteps, relativeToCwd } from '../utils/next-steps.ts';
+import { safeFilename } from '../utils/strings.ts';
 import { BaseCommand, type Suggestion } from './base-command.js';
 
 export class ExploreCommand extends BaseCommand {
@@ -70,8 +72,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> {
@@ -103,7 +105,7 @@ export class ExploreCommand extends BaseCommand {
     }
   }
 
-  private printResults(savedPath?: string | null): void {
+  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;
@@ -132,22 +134,52 @@ 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;
+    const screencasts = savedFiles.filter((f) => f.endsWith('.webm'));
+    const testFiles = savedFiles.filter((f) => !f.endsWith('.webm'));
+
+    if (testFiles.length > 0) {
+      const commands = testFiles.map((f) => ({ label: '', command: `${cli} rerun ${relativeToCwd(f)}` }));
+      commands.push({ label: 'List tests', command: `${cli} runs` });
+      sections.push({
+        label: `Generated tests (${testFiles.length})`,
+        commands,
+      });
+    }
 
-    for (const filePath of savedFiles) {
-      tag('info').log(`Generated: ${path.basename(filePath)}`);
+    if (screencasts.length > 0) {
+      const commands = screencasts.map((f) => ({ label: '', command: relativeToCwd(f) }));
+      const screencastDir = relativeToCwd(outputPath('screencasts'));
+      const planSlugs = [...new Set(this.completedPlans.map((p) => safeFilename(p.title)).filter(Boolean))];
+      for (const slug of planSlugs) {
+        commands.push({ label: 'Browse plan', command: `ls ${screencastDir}/${slug}-*` });
+      }
+      sections.push({
+        label: `Screencasts (${screencasts.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/init-command.ts

@@ -4,6 +4,7 @@ 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/plan-command.ts

@@ -1,7 +1,9 @@
 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 { type NextStepSection, printNextSteps, relativeToCwd } from '../utils/next-steps.ts';
 import { BaseCommand, type Suggestion } from './base-command.js';
 
 export class PlanCommand extends BaseCommand {
@@ -41,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 {

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

@@ -1,5 +1,5 @@
-import path from 'node:path';
-import { tag } from '../utils/logger.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 {
@@ -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/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,16 @@ interface PlannerAgentConfig extends AgentConfig {
   stylesDir?: string;
 }
 
+interface ScreencastConfig {
+  size?: { width: number; height: number };
+  quality?: number;
+}
+
+interface HistorianAgentConfig extends AgentConfig {
+  framework?: 'codeceptjs' | 'playwright';
+  screencast?: boolean | ScreencastConfig;
+}
+
 interface AgentsConfig {
   tester?: TesterAgentConfig;
   navigator?: NavigatorAgentConfig;
@@ -116,7 +126,7 @@ interface AgentsConfig {
   'experience-compactor'?: AgentConfig;
   captain?: AgentConfig;
   quartermaster?: AgentConfig;
-  historian?: AgentConfig;
+  historian?: HistorianAgentConfig;
   fisherman?: AgentConfig;
   chief?: AgentConfig;
   curler?: AgentConfig;
@@ -229,6 +239,7 @@ export type {
   ActionConfig,
   AgentConfig,
   AgentsConfig,
+  HistorianAgentConfig,
   ResearcherAgentConfig,
   NavigatorAgentConfig,
   PlannerAgentConfig,

package/src/execution-controller.ts

@@ -10,6 +10,7 @@ export class ExecutionController extends EventEmitter {
   private inputCallback: InputCallback | null = null;
   private interruptResolvers: Array<() => void> = [];
   private abortController: AbortController | null = null;
+  private awaitingInput = false;
 
   private constructor() {
     super();
@@ -48,6 +49,10 @@ export class ExecutionController extends EventEmitter {
     this.emit('idle');
   }
 
+  isAwaitingInput(): boolean {
+    return this.awaitingInput;
+  }
+
   isInterrupted(): boolean {
     return this.interrupted;
   }
@@ -77,11 +82,16 @@ export class ExecutionController extends EventEmitter {
   }
 
   async requestInput(prompt: string): Promise<string | null> {
-    if (this.inputCallback) {
-      return await this.inputCallback(prompt);
+    if (!this.inputCallback) {
+      return await this.readlineInput(prompt);
     }
 
-    return await this.readlineInput(prompt);
+    this.awaitingInput = true;
+    try {
+      return await this.inputCallback(prompt);
+    } finally {
+      this.awaitingInput = false;
+    }
   }
 
   private async readlineInput(prompt: string): Promise<string | null> {
@@ -103,6 +113,7 @@ export class ExecutionController extends EventEmitter {
     this.interrupted = false;
     this.interruptResolvers = [];
     this.abortController = null;
+    this.awaitingInput = false;
   }
 }
 

package/src/experience-tracker.ts

@@ -18,15 +18,17 @@ export const RECENT_WINDOW_DAYS = 30;
 /**
  * Stores and reads per-page experience files (`./experience/<stateHash>.md`).
  *
- * Format rules (enforced by writeFlow/writeAction — the only supported writers):
+ * Two writers, two contracts:
  *
- *   ## FLOW: <imperative title>        multi-step, `*` bullets + optional ```js``` + `>` discovery, ends with `---`
- *   ## ACTION: <imperative title>      single-step, optional `Solution:` line + one ```js``` code block
+ *   writeFlow(state, body, relatedUrls?)  — caller hands in a fully-formatted
+ *                                            `## FLOW: <imperative title>` block (multi-step,
+ *                                            `*` bullets + optional ```js``` + `>` discovery,
+ *                                            ends with `---`). Tracker dedups + prepends.
+ *   writeAction(state, ActionInput)        — `## ACTION: <imperative title>`, single-step,
+ *                                            optional `Solution:` line + one ```js``` code block.
+ *                                            Title normalized via normalizeTitle().
  *
  * - Always h2. Never h3 for FLOW/ACTION.
- * - Title is an imperative verb phrase, lowercase-first, no trailing punctuation.
- *   Writers normalize automatically (strip own `FLOW:` / `ACTION:` prefix if the caller included it,
- *   lowercase first char, trim trailing `.!?,;:`).
  * - On read (getSuccessfulExperience), headings are rendered as
  *   `## HOW to <title> (multi-step|single-step)` so prompts get natural phrasing.
  */
@@ -184,27 +186,27 @@ export class ExperienceTracker {
     tag('substep').log(` Added ACTION to: ${stateHash}.md`);
   }
 
-  writeFlow(state: ActionResult, flow: FlowInput): void {
+  writeFlow(state: ActionResult, body: string, relatedUrls?: string[]): void {
     if (this.disabled || this.isWritingDisabled(state)) return;
-    if (!flow.steps?.length) return;
+    if (!body?.trim()) return;
 
     this.ensureExperienceFile(state);
     const stateHash = state.getStateHash();
     const { content, data } = this.readExperienceFile(stateHash);
 
-    if (flow.relatedUrls?.length) {
+    if (content.includes(body)) {
+      debugLog('Skipping duplicate flow body');
+      return;
+    }
+
+    if (relatedUrls?.length) {
       const currentPath = extractStatePath(state.url || '');
       const existingRelated = Array.isArray(data.related) ? data.related : [];
-      const allRelated = [...new Set([...existingRelated, ...flow.relatedUrls])];
+      const allRelated = [...new Set([...existingRelated, ...relatedUrls])];
       data.related = allRelated.filter((url) => url !== currentPath);
     }
 
-    const title = normalizeTitle(flow.scenario);
-    if (!title) return;
-
-    const sessionContent = this.trimSessionContent(generateFlowContent(title, flow.steps));
-    if (!sessionContent) return;
-    const updatedContent = `${sessionContent}\n${content}`;
+    const updatedContent = `${body}\n${content}`;
     this.writeExperienceFile(stateHash, updatedContent, data);
 
     tag('substep').log(`Added FLOW to: ${stateHash}.md`);
@@ -277,35 +279,6 @@ export class ExperienceTracker {
     // The actual files will be cleaned up by test cleanup
   }
 
-  private trimSessionContent(content: string): string | null {
-    const q = mdq(content);
-    if (q.query('heading').count() === 0) return null;
-    if (q.query('code').count() === 0) return null;
-
-    let result = content;
-    const codeBlocks = q.query('code').each();
-    if (codeBlocks.length > 2) {
-      for (const block of codeBlocks.slice(2)) {
-        result = result.replace(block.text(), '');
-      }
-    }
-
-    const blockquotes = mdq(result).query('blockquote').each();
-    if (blockquotes.length > 5) {
-      for (const bq of blockquotes.slice(5)) {
-        result = result.replace(bq.text(), '');
-      }
-    }
-
-    const lines = result.split('\n');
-    if (lines.length > 40) {
-      result = lines.slice(0, 40).join('\n');
-    }
-
-    if (!result.trim()) return null;
-    return result;
-  }
-
   getSuccessfulExperience(state: ActionResult, options?: { includeDescendants?: boolean; stripCode?: boolean }): string[] {
     const records = this.getRelevantExperience(state, {
       includeDescendantExperience: options?.includeDescendants,
@@ -513,7 +486,9 @@ export function renderExperienceToc(toc: ExperienceTocEntry[]): string {
 
   const lines: string[] = [];
   lines.push('<experience>');
-  lines.push('Past experience for this page — reusable recipes recorded from prior successful runs.');
+  lines.push('Past experience for this page — recipes recorded from prior successful runs.');
+  lines.push('Locators and step ordering worked then; the page may have changed since.');
+  lines.push('Treat as a starting hypothesis, not ground truth. If a step fails, fall back to ARIA/UI-map.');
   lines.push('FLOW: = multi-step recipe (bullets + code + discovery). ACTION: = single-step snippet (one code block).');
   lines.push('Call learn_experience({ fileTag, sectionIndex }) to read a section when it looks relevant to the current step.');
   lines.push('');
@@ -559,26 +534,6 @@ function generateActionContent(title: string, code: string, explanation?: string
   return lines.join('\n');
 }
 
-function generateFlowContent(title: string, steps: SessionStep[]): string {
-  let content = `## FLOW: ${title}\n\n`;
-  for (const step of steps) {
-    content += `* ${step.message}\n\n`;
-    if (step.code) {
-      content += '```js\n';
-      content += `${step.code}\n`;
-      content += '```\n\n';
-    }
-    if (step.discovery) {
-      const discoveries = step.discovery.split('\n').filter((d) => d.trim());
-      for (const discovery of discoveries) {
-        content += `> ${discovery.trim()}\n\n`;
-      }
-    }
-  }
-  content += '---\n';
-  return content;
-}
-
 function renderAsHowTo(content: string): string {
   const tokens = marked.lexer(content);
   let result = '';
@@ -606,12 +561,6 @@ export interface ExperienceFile {
   mtime: Date;
 }
 
-export interface FlowInput {
-  scenario: string;
-  steps: SessionStep[];
-  relatedUrls?: string[];
-}
-
 export interface ActionInput {
   title: string;
   code: string;