explorbot 0.1.9 → 0.1.11

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

@@ -1,12 +1,18 @@
 import path from 'node:path';
 import chalk from 'chalk';
 import figureSet from 'figures';
+import { getCliName } from "../utils/cli-name.js";
 import { tag } from '../utils/logger.js';
+import { printNextSteps, relativeToCwd } from "../utils/next-steps.js";
 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' },
@@ -30,6 +36,36 @@ export class PlanCommand extends BaseCommand {
         }
         this.printPlanSummary();
         this.updateSuggestions();
+        this.printNextSteps();
+    }
+    printNextSteps() {
+        const savedPath = this.explorBot.lastSavedPlanPath;
+        if (!savedPath)
+            return;
+        const cli = getCliName();
+        const relPlan = relativeToCwd(savedPath);
+        const sections = [
+            {
+                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);
     }
     printPlanSummary() {
         const suite = this.explorBot.getSuite();
@@ -50,13 +86,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

@@ -1,10 +1,10 @@
-import path from 'node:path';
-import { tag } from '../utils/logger.js';
+import { getCliName } from "../utils/cli-name.js";
+import { printNextSteps, relativeToCwd } from "../utils/next-steps.js";
 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) {
@@ -12,10 +12,22 @@ export class PlanSaveCommand extends BaseCommand {
         }
         const filename = args.trim() || undefined;
         const savedPath = this.explorBot.savePlan(filename);
-        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`);
-        }
+        if (!savedPath)
+            return;
+        const cli = getCliName();
+        const relPlan = relativeToCwd(savedPath);
+        const sections = [
+            {
+                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/dist/src/commands/rerun-command.js

@@ -19,6 +19,10 @@ export class RerunCommand extends BaseCommand {
         if (!existsSync(filePath)) {
             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/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)

package/dist/src/components/App.js

@@ -72,16 +72,27 @@ export function App({ explorBot, initialShowInput = false, exitOnEmptyInput = fa
             setInterruptPrompt(prompt);
             setShowInput(true);
             return new Promise((resolve) => {
-                interruptResolveRef.current = resolve;
+                interruptResolveRef.current = (value) => {
+                    interruptResolveRef.current = null;
+                    setInterruptPrompt(null);
+                    resolve(value);
+                };
             });
         });
         const handleIdle = () => {
             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();
         };
     }, []);
@@ -244,9 +255,10 @@ export function App({ explorBot, initialShowInput = false, exitOnEmptyInput = fa
             return;
         }
         if (isCommand) {
-            setInterruptPrompt(null);
+            if (interruptResolveRef.current) {
+                interruptResolveRef.current(null);
+            }
             setShowInput(false);
-            interruptResolveRef.current = null;
             executionController.startExecution();
             try {
                 await commandHandler.executeCommand(trimmed);
@@ -264,8 +276,6 @@ export function App({ explorBot, initialShowInput = false, exitOnEmptyInput = fa
         }
         if (interruptResolveRef.current) {
             interruptResolveRef.current(input);
-            interruptResolveRef.current = null;
-            setInterruptPrompt(null);
             setShowInput(false);
             return;
         }

package/dist/src/execution-controller.js

@@ -7,6 +7,7 @@ export class ExecutionController extends EventEmitter {
     inputCallback = null;
     interruptResolvers = [];
     abortController = null;
+    awaitingInput = false;
     constructor() {
         super();
     }
@@ -39,6 +40,9 @@ export class ExecutionController extends EventEmitter {
         this.interruptResolvers = [];
         this.emit('idle');
     }
+    isAwaitingInput() {
+        return this.awaitingInput;
+    }
     isInterrupted() {
         return this.interrupted;
     }
@@ -64,10 +68,16 @@ export class ExecutionController extends EventEmitter {
         return userInput;
     }
     async requestInput(prompt) {
-        if (this.inputCallback) {
+        if (!this.inputCallback) {
+            return await this.readlineInput(prompt);
+        }
+        this.awaitingInput = true;
+        try {
             return await this.inputCallback(prompt);
         }
-        return await this.readlineInput(prompt);
+        finally {
+            this.awaitingInput = false;
+        }
     }
     async readlineInput(prompt) {
         const rl = readline.createInterface({
@@ -86,6 +96,7 @@ export class ExecutionController extends EventEmitter {
         this.interrupted = false;
         this.interruptResolvers = [];
         this.abortController = null;
+        this.awaitingInput = false;
     }
 }
 export const executionController = ExecutionController.getInstance();

package/dist/src/experience-tracker.js

@@ -9,6 +9,24 @@ import { mdq } from './utils/markdown-query.js';
 import { extractStatePath } from './utils/url-matcher.js';
 const debugLog = createDebug('explorbot:experience');
 const DEFAULT_MAX_EXPERIENCE_LINES = 100;
+export const RECENT_WINDOW_DAYS = 30;
+/**
+ * Stores and reads per-page experience files (`./experience/<stateHash>.md`).
+ *
+ * Two writers, two contracts:
+ *
+ *   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.
+ * - On read (getSuccessfulExperience), headings are rendered as
+ *   `## HOW to <title> (multi-step|single-step)` so prompts get natural phrasing.
+ */
 export class ExperienceTracker {
     experienceDir;
     disabled;
@@ -122,28 +140,48 @@ export class ExperienceTracker {
     isWritingDisabled(state) {
         return this.knowledgeTracker.getRelevantKnowledge(state).some((k) => k.noExperienceWriting === true || k.noExperienceWriting === 'true');
     }
-    async saveSuccessfulResolution(state, originalMessage, code, explanation) {
+    writeAction(state, action) {
         if (this.disabled || this.isWritingDisabled(state))
             return;
+        if (!action.code?.trim())
+            return;
+        this.ensureExperienceFile(state);
+        const stateHash = state.getStateHash();
+        const { content, data } = this.readExperienceFile(stateHash);
+        if (content.includes(action.code)) {
+            debugLog('Skipping duplicate action', action.code);
+            return;
+        }
+        const title = normalizeTitle(action.title.split('\n')[0]);
+        if (!title)
+            return;
+        const filteredCode = action.code.replace(/I\.amOnPage\s*\([^)]*\)/gs, '');
+        const newEntry = generateActionContent(title, filteredCode, action.explanation);
+        const updatedContent = `${newEntry}\n\n${content}`;
+        this.writeExperienceFile(stateHash, updatedContent, data);
+        tag('substep').log(` Added ACTION to: ${stateHash}.md`);
+    }
+    writeFlow(state, body, relatedUrls) {
+        if (this.disabled || this.isWritingDisabled(state))
+            return;
+        if (!body?.trim())
+            return;
         this.ensureExperienceFile(state);
         const stateHash = state.getStateHash();
         const { content, data } = this.readExperienceFile(stateHash);
-        if (content.includes(code)) {
-            debugLog('Skipping duplicate successful resolution', code);
+        if (content.includes(body)) {
+            debugLog('Skipping duplicate flow body');
             return;
         }
-        const filteredCode = code.replace(/I\.amOnPage\s*\([^)]*\)/gs, '');
-        const newEntryContent = `### SUCCEEDED: ${originalMessage.split('\n')[0]}
-
-${explanation ? `Solution: ${explanation}` : ''}
-
-\`\`\`javascript
-${filteredCode}
-\`\`\`
-`;
-        const updatedContent = `${newEntryContent}\n\n${content}`;
+        if (relatedUrls?.length) {
+            const currentPath = extractStatePath(state.url || '');
+            const existingRelated = Array.isArray(data.related) ? data.related : [];
+            const allRelated = [...new Set([...existingRelated, ...relatedUrls])];
+            data.related = allRelated.filter((url) => url !== currentPath);
+        }
+        const updatedContent = `${body}\n${content}`;
         this.writeExperienceFile(stateHash, updatedContent, data);
-        tag('substep').log(` Added successful resolution to: ${stateHash}.md`);
+        tag('substep').log(`Added FLOW to: ${stateHash}.md`);
     }
     getAllExperience() {
         const allFiles = [];
@@ -159,10 +197,12 @@ ${filteredCode}
                     try {
                         const content = readFileSync(file, 'utf8');
                         const parsed = matter(content);
+                        const mtime = statSync(file).mtime;
                         allFiles.push({
                             filePath: file,
                             data: parsed.data,
                             content: parsed.content,
+                            mtime,
                         });
                     }
                     catch (error) {
@@ -205,71 +245,6 @@ ${filteredCode}
         // Clear any in-memory state if needed
         // The actual files will be cleaned up by test cleanup
     }
-    saveSessionExperience(state, entry) {
-        if (this.disabled || this.isWritingDisabled(state))
-            return;
-        this.ensureExperienceFile(state);
-        const stateHash = state.getStateHash();
-        const { content, data } = this.readExperienceFile(stateHash);
-        if (entry.relatedUrls?.length) {
-            const currentPath = extractStatePath(state.url || '');
-            const existingRelated = Array.isArray(data.related) ? data.related : [];
-            const allRelated = [...new Set([...existingRelated, ...entry.relatedUrls])];
-            data.related = allRelated.filter((url) => url !== currentPath);
-        }
-        const sessionContent = this.trimSessionContent(this.generateSessionContent(entry));
-        if (!sessionContent)
-            return;
-        const updatedContent = `${sessionContent}\n${content}`;
-        this.writeExperienceFile(stateHash, updatedContent, data);
-        tag('substep').log(`Added session experience to: ${stateHash}.md`);
-    }
-    generateSessionContent(entry) {
-        let content = `## Successful Flow: ${entry.scenario}\n\n`;
-        for (const step of entry.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;
-    }
-    trimSessionContent(content) {
-        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, options) {
         const records = this.getRelevantExperience(state, {
             includeDescendantExperience: options?.includeDescendants,
@@ -278,11 +253,12 @@ ${filteredCode}
         for (const record of records) {
             if (!record.content)
                 continue;
-            const successFlows = mdq(record.content).query('section(~"Successful Flow")').text();
-            const succeeded = mdq(record.content).query('section(~"SUCCEEDED")').text();
-            let combined = [successFlows, succeeded].filter(Boolean).join('\n\n');
+            const flows = mdq(record.content).query('section(~"FLOW:")').text();
+            const actions = mdq(record.content).query('section(~"ACTION:")').text();
+            let combined = [flows, actions].filter(Boolean).join('\n\n');
             if (!combined.trim())
                 continue;
+            combined = renderAsHowTo(combined);
             if (options?.stripCode) {
                 combined = mdq(combined).query('code').replace('');
             }
@@ -339,6 +315,69 @@ ${filteredCode}
         }
         return null;
     }
+    listAllExperienceToc(filter, options) {
+        const records = this.getAllExperience();
+        if (records.length === 0)
+            return [];
+        const trimmed = filter?.trim();
+        let matching = records;
+        if (trimmed) {
+            if (trimmed.endsWith('.md')) {
+                const bare = trimmed.slice(0, -3);
+                const byFilename = records.find((record) => basename(record.filePath, '.md') === bare);
+                matching = byFilename ? [byFilename] : [];
+            }
+            else {
+                const lower = trimmed.toLowerCase();
+                matching = records.filter((record) => {
+                    const url = (record.data?.url || '').toLowerCase();
+                    if (!url)
+                        return false;
+                    return url.includes(lower);
+                });
+            }
+        }
+        if (options?.recency) {
+            const cutoff = Date.now() - RECENT_WINDOW_DAYS * 24 * 60 * 60 * 1000;
+            matching = matching.filter((record) => {
+                const isRecent = record.mtime.getTime() >= cutoff;
+                return options.recency === 'recent' ? isRecent : !isRecent;
+            });
+        }
+        const sorted = matching.sort((a, b) => {
+            const aUrl = a.data?.url || '';
+            const bUrl = b.data?.url || '';
+            return aUrl.localeCompare(bUrl);
+        });
+        const toc = [];
+        for (let i = 0; i < sorted.length; i++) {
+            const record = sorted[i];
+            const sections = listTocHeadings(record.content);
+            if (sections.length === 0)
+                continue;
+            toc.push({
+                fileTag: indexToLetters(toc.length),
+                fileHash: basename(record.filePath, '.md'),
+                url: record.data?.url || '',
+                sections,
+            });
+        }
+        return toc;
+    }
+    getExperienceSectionByTag(fileTag, sectionIndex, filter) {
+        const toc = this.listAllExperienceToc(filter);
+        const entry = toc.find((e) => e.fileTag === fileTag);
+        if (!entry)
+            return null;
+        const filePath = this.findExperienceFileByHash(entry.fileHash);
+        if (!filePath)
+            return null;
+        const { content } = this.readExperienceFile(entry.fileHash);
+        const extracted = extractHeadingSection(content, sectionIndex);
+        if (!extracted)
+            return null;
+        return { title: extracted.title, url: entry.url, content: extracted.body, fileHash: entry.fileHash };
+    }
 }
 function listTocHeadings(content) {
     const tokens = marked.lexer(content);
@@ -403,7 +442,11 @@ export function renderExperienceToc(toc) {
         return '';
     const lines = [];
     lines.push('<experience>');
-    lines.push('Past experience for this page. Call learn_experience({ fileTag, sectionIndex }) to read a section.');
+    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('');
     for (const entry of toc) {
         lines.push(`File ${entry.fileTag} ${entry.url}:`);
@@ -416,3 +459,51 @@ export function renderExperienceToc(toc) {
     lines.push('</experience>');
     return lines.join('\n');
 }
+function normalizeTitle(raw) {
+    let t = (raw || '').trim();
+    for (const p of ['FLOW:', 'ACTION:']) {
+        if (t.toLowerCase().startsWith(p.toLowerCase())) {
+            t = t.slice(p.length).trim();
+            break;
+        }
+    }
+    while (t.length > 0 && '.!?,;:'.includes(t[t.length - 1])) {
+        t = t.slice(0, -1);
+    }
+    if (t.length > 0)
+        t = t[0].toLowerCase() + t.slice(1);
+    return t;
+}
+function generateActionContent(title, code, explanation) {
+    const lines = [];
+    lines.push(`## ACTION: ${title}`);
+    lines.push('');
+    if (explanation) {
+        lines.push(`Solution: ${explanation}`);
+        lines.push('');
+    }
+    lines.push('```javascript');
+    lines.push(code);
+    lines.push('```');
+    lines.push('');
+    return lines.join('\n');
+}
+function renderAsHowTo(content) {
+    const tokens = marked.lexer(content);
+    let result = '';
+    for (const token of tokens) {
+        if (token.type === 'heading' && token.depth === 2) {
+            const text = token.text.trim();
+            if (text.startsWith('FLOW:')) {
+                result += `## HOW to ${text.slice(5).trim()} (multi-step)\n\n`;
+                continue;
+            }
+            if (text.startsWith('ACTION:')) {
+                result += `## HOW to ${text.slice(7).trim()} (single-step)\n\n`;
+                continue;
+            }
+        }
+        result += token.raw || '';
+    }
+    return result;
+}