explorbot 0.1.8 → 0.1.10

package/dist/src/experience-tracker.js

@@ -9,6 +9,22 @@ 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`).
+ *
+ * Format rules (enforced by writeFlow/writeAction — the only supported writers):
+ *
+ *   ## FLOW: <imperative title>        multi-step, `*` bullets + optional ```js``` + `>` discovery, ends with `---`
+ *   ## ACTION: <imperative title>      single-step, optional `Solution:` line + one ```js``` code block
+ *
+ * - 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.
+ */
 export class ExperienceTracker {
     experienceDir;
     disabled;
@@ -122,28 +138,50 @@ 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(code)) {
-            debugLog('Skipping duplicate successful resolution', code);
+        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, flow) {
+        if (this.disabled || this.isWritingDisabled(state))
+            return;
+        if (!flow.steps?.length)
             return;
+        this.ensureExperienceFile(state);
+        const stateHash = state.getStateHash();
+        const { content, data } = this.readExperienceFile(stateHash);
+        if (flow.relatedUrls?.length) {
+            const currentPath = extractStatePath(state.url || '');
+            const existingRelated = Array.isArray(data.related) ? data.related : [];
+            const allRelated = [...new Set([...existingRelated, ...flow.relatedUrls])];
+            data.related = allRelated.filter((url) => url !== currentPath);
         }
-        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}`;
+        const title = normalizeTitle(flow.scenario);
+        if (!title)
+            return;
+        const sessionContent = this.trimSessionContent(generateFlowContent(title, flow.steps));
+        if (!sessionContent)
+            return;
+        const updatedContent = `${sessionContent}\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,44 +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)
@@ -278,11 +280,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 +342,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 +469,9 @@ 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 — reusable recipes recorded from prior successful runs.');
+    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 +484,70 @@ 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 generateFlowContent(title, steps) {
+    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) {
+    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;
+}

package/dist/src/explorbot.js

@@ -1,9 +1,6 @@
 import { existsSync, mkdirSync } from 'node:fs';
 import path from 'node:path';
 import { ActionResult } from "./action-result.js";
-import { ApiClient } from "./api/api-client.js";
-import { RequestStore } from "./api/request-store.js";
-import { loadSpec } from "./api/spec-reader.js";
 import { Bosun } from "./ai/bosun.js";
 import { Captain } from "./ai/captain.js";
 import { ExperienceCompactor } from "./ai/experience-compactor.js";
@@ -14,11 +11,15 @@ import { Pilot } from "./ai/pilot.js";
 import { Planner } from "./ai/planner.js";
 import { AIProvider } from "./ai/provider.js";
 import { Quartermaster } from "./ai/quartermaster.js";
-import { Researcher } from "./ai/researcher.js";
 import { Rerunner } from "./ai/rerunner.js";
+import { Researcher } from "./ai/researcher.js";
 import { Tester } from "./ai/tester.js";
 import { createAgentTools } from "./ai/tools.js";
+import { ApiClient } from "./api/api-client.js";
+import { RequestStore } from "./api/request-store.js";
+import { loadSpec } from "./api/spec-reader.js";
 import { ConfigParser } from "./config.js";
+import { ExperienceTracker } from "./experience-tracker.js";
 import Explorer from "./explorer.js";
 import { KnowledgeTracker } from "./knowledge-tracker.js";
 import { Plan } from "./test-plan.js";
@@ -34,6 +35,7 @@ export class ExplorBot {
     needsInput = false;
     currentPlan;
     planFeature;
+    lastPlanError = null;
     agents = {};
     constructor(options = {}) {
         this.options = options;
@@ -54,13 +56,11 @@ export class ExplorBot {
             return;
         }
         try {
-            this.config = await this.configParser.loadConfig(this.options);
-            this.provider = new AIProvider(this.config.ai);
-            await this.provider.validateConnection();
+            await this.startProviderOnly();
             this.explorer = new Explorer(this.config, this.provider, this.options);
             await this.explorer.start();
             if (!this.options.incognito) {
-                await this.agentExperienceCompactor().compactAllExperiences();
+                await this.agentExperienceCompactor().autocompact();
             }
             if (this.userResolveFn)
                 this.explorer.setUserResolve(this.userResolveFn);
@@ -71,9 +71,16 @@ export class ExplorBot {
             process.exit(1);
         }
     }
+    async startProviderOnly() {
+        if (this.provider)
+            return;
+        this.config = await this.configParser.loadConfig(this.options);
+        this.provider = new AIProvider(this.config.ai);
+        await this.provider.validateConnection();
+    }
     async stop() {
         this.agents.quartermaster?.stop();
-        await this.explorer.stop();
+        await this.explorer?.stop();
     }
     async visitInitialState() {
         const url = this.options.from || '/';
@@ -97,6 +104,12 @@ export class ExplorBot {
         }
         return new KnowledgeTracker();
     }
+    getExperienceTracker() {
+        if (this.explorer) {
+            return this.explorer.getStateManager().getExperienceTracker();
+        }
+        return new ExperienceTracker();
+    }
     getConfig() {
         return this.config;
     }
@@ -186,10 +199,7 @@ export class ExplorBot {
         return this.agents.captain;
     }
     agentExperienceCompactor() {
-        return (this.agents.experienceCompactor ||= this.createAgent(({ ai, explorer }) => {
-            const experienceTracker = explorer.getStateManager().getExperienceTracker();
-            return new ExperienceCompactor(ai, experienceTracker);
-        }));
+        return (this.agents.experienceCompactor ||= new ExperienceCompactor(this.provider, this.getExperienceTracker()));
     }
     agentQuartermaster() {
         const config = this.config.ai?.agents?.quartermaster;
@@ -293,11 +303,13 @@ export class ExplorBot {
         if (this.currentPlan) {
             planner.setPlan(this.currentPlan);
         }
+        this.lastPlanError = null;
         try {
             this.currentPlan = await planner.plan(feature, opts.style, opts.extend, opts.completedPlans);
         }
         catch (err) {
-            tag('warning').log(`Planning failed: ${err instanceof Error ? err.message : err}`);
+            this.lastPlanError = err instanceof Error ? err : new Error(String(err));
+            tag('warning').log(`Planning failed: ${this.lastPlanError.message}`);
             if (!this.currentPlan)
                 return undefined;
             return this.currentPlan;

package/dist/src/explorer.js

@@ -8,12 +8,12 @@ import { createTest } from 'codeceptjs/lib/mocha/test';
 import { ActionResult } from "./action-result.js";
 import Action from './action.js';
 import { visuallyAnnotateContainers } from "./ai/researcher/coordinates.js";
+import { RequestStore } from "./api/request-store.js";
+import { XhrCapture } from "./api/xhr-capture.js";
 import { ConfigParser, outputPath } from './config.js';
 import { KnowledgeTracker } from './knowledge-tracker.js';
 import { Reporter } from "./reporter.js";
 import { StateManager } from './state-manager.js';
-import { RequestStore } from "./api/request-store.js";
-import { XhrCapture } from "./api/xhr-capture.js";
 import { createDebug, log, tag } from './utils/logger.js';
 import { WebElement, extractElementData } from "./utils/web-element.js";
 const debugLog = createDebug('explorbot:explorer');
@@ -42,7 +42,7 @@ class Explorer {
         this.initializeContainer();
         this.stateManager = new StateManager({ incognito: this.options?.incognito });
         this.knowledgeTracker = new KnowledgeTracker();
-        this.reporter = new Reporter(config.reporter);
+        this.reporter = new Reporter(config.reporter, this.stateManager);
     }
     initializeContainer() {
         try {

package/dist/src/reporter.js

@@ -1,20 +1,34 @@
 import { Client } from '@testomatio/reporter';
 import { outputPath } from './config.js';
+import { Stats } from './stats.js';
 import { createDebug } from './utils/logger.js';
 const debugLog = createDebug('explorbot:reporter');
 export class Reporter {
     client;
     isRunStarted = false;
     reporterEnabled;
-    constructor(config) {
+    stateManager;
+    constructor(config, stateManager) {
         this.reporterEnabled = Reporter.resolveEnabled(config);
+        this.stateManager = stateManager;
         if (this.reporterEnabled && (!process.env.TESTOMATIO || config?.html)) {
             this.configureHtmlPipe();
         }
-        this.client = new Client({ apiKey: process.env.TESTOMATIO || '' });
         const pipe = process.env.TESTOMATIO && config?.html ? 'both' : process.env.TESTOMATIO ? 'testomatio' : 'html';
         debugLog('Reporter initialized', { enabled: this.reporterEnabled, pipe });
     }
+    buildTitle() {
+        if (process.env.TESTOMATIO_TITLE)
+            return process.env.TESTOMATIO_TITLE;
+        const url = this.stateManager?.getCurrentState()?.url;
+        const parts = ['Explorbot session'];
+        if (url)
+            parts.push(url);
+        if (Stats.focus)
+            parts.push(`focus: "${Stats.focus}"`);
+        parts.push(`at ${new Date().toISOString().slice(0, 16)}`);
+        return parts.join(' ');
+    }
     static resolveEnabled(config) {
         if (config?.enabled === true)
             return true;
@@ -35,6 +49,7 @@ export class Reporter {
             return;
         }
         try {
+            this.client = new Client({ apiKey: process.env.TESTOMATIO || '', title: this.buildTitle() });
             const timeoutMs = Number(process.env.TESTOMATIO_TIMEOUT_MS || '15000');
             const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve('timeout'), timeoutMs));
             const result = await Promise.race([this.client.createRun().then(() => 'success'), timeoutPromise]);

package/dist/src/stats.js

@@ -3,6 +3,8 @@ export class Stats {
     static researches = 0;
     static tests = 0;
     static plans = 0;
+    static mode;
+    static focus;
     static models = {};
     static recordTokens(_agent, model, usage) {
         if (!Stats.models[model]) {

package/dist/src/suite.js

@@ -3,8 +3,8 @@ import path from 'node:path';
 import { Reflection } from '@codeceptjs/reflection';
 import { ConfigParser } from "./config.js";
 import { normalizeUrl } from "./state-manager.js";
-import { parsePlanFromMarkdown } from "./utils/test-plan-markdown.js";
 import { createDebug } from "./utils/logger.js";
+import { parsePlanFromMarkdown } from "./utils/test-plan-markdown.js";
 const debugLog = createDebug('explorbot:suite');
 export class Suite {
     url;

package/dist/src/utils/error-page.js

@@ -16,3 +16,13 @@ export function isErrorPage(actionResult) {
         return true;
     return false;
 }
+export class ErrorPageError extends Error {
+    url;
+    title;
+    constructor(url, title) {
+        super(`Error page detected at ${url}${title ? ` (${title})` : ''}`);
+        this.url = url;
+        this.title = title;
+        this.name = 'ErrorPageError';
+    }
+}

package/dist/src/utils/logger.js

@@ -4,9 +4,9 @@ import { context, trace } from '@opentelemetry/api';
 import chalk from 'chalk';
 import debug from 'debug';
 import dedent from 'dedent';
+import stripAnsi from 'strip-ansi';
 import { ConfigParser } from '../config.js';
 import { Observability } from "../observability.js";
-import stripAnsi from 'strip-ansi';
 import { parseMarkdownToTerminal } from "./markdown-terminal.js";
 class DebugFilter {
     patterns = [];

package/dist/src/utils/rules-loader.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import { basename, dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { tag } from "./logger.js";

package/dist/src/utils/test-files.js

@@ -3,9 +3,9 @@ import path from 'node:path';
 import chalk from 'chalk';
 import { highlight } from 'cli-highlight';
 import * as codeceptjs from 'codeceptjs';
-import store from 'codeceptjs/lib/store';
 import stepsListener from 'codeceptjs/lib/listener/steps';
 import storeListener from 'codeceptjs/lib/listener/store';
+import store from 'codeceptjs/lib/store';
 import figureSet from 'figures';
 import { ConfigParser } from "../config.js";
 export function loadTestSuites(testsDir) {

package/dist/src/utils/url-matcher.js

@@ -1,4 +1,54 @@
 import micromatch from 'micromatch';
+import { ConfigParser } from '../config.js';
+export function isDynamicSegment(segment) {
+    try {
+        const configRegex = ConfigParser.getInstance().getConfig().dynamicPageRegex;
+        if (configRegex)
+            return new RegExp(configRegex, 'i').test(segment);
+    }
+    catch {
+        /* config not loaded yet */
+    }
+    // numeric: /users/123
+    if (/^\d+$/.test(segment))
+        return true;
+    // UUID: /items/550e8400-e29b-41d4-a716-446655440000
+    if (/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i.test(segment))
+        return true;
+    // ULID: /items/01ARZ3NDEKTSV4RRFFQ69G5FAV
+    if (/^[0-9A-HJKMNP-TV-Z]{26}$/.test(segment))
+        return true;
+    // hex ID (4+ chars): /suite/70dae98a
+    if (/^[a-f0-9]{4,}$/i.test(segment))
+        return true;
+    // hex-prefixed slug (8+ hex before dash): /suite/95ef0c94-mobile
+    if (/^[a-f0-9]{8,}-/i.test(segment))
+        return true;
+    // short mixed alphanumeric (digits + letters, ≤8 chars, no dash): /item/x7f2
+    if (segment.length <= 8 && !segment.includes('-') && /\d/.test(segment) && /[a-z]/i.test(segment))
+        return true;
+    return false;
+}
+export function hasDynamicUrlSegment(url) {
+    return url.split('/').some((seg) => seg.length > 0 && isDynamicSegment(seg));
+}
+export function generalizeSegment(segment) {
+    if (/^\d+$/.test(segment))
+        return '\\d+';
+    if (/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i.test(segment))
+        return '[a-f0-9-]+';
+    if (/^[0-9A-HJKMNP-TV-Z]{26}$/.test(segment))
+        return '[0-9A-HJKMNP-TV-Z]+';
+    if (/^[a-f0-9]+$/i.test(segment))
+        return '[a-f0-9]+';
+    return '[^/]+';
+}
+export function generalizeUrl(url) {
+    return url
+        .split('/')
+        .map((seg) => (seg.length > 0 && isDynamicSegment(seg) ? generalizeSegment(seg) : seg))
+        .join('/');
+}
 export function matchesUrl(pattern, path) {
     if (pattern === '*')
         return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "explorbot",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "CLI app built with React Ink, CodeceptJS, and Playwright",
   "license": "Elastic-2.0",
   "type": "module",

package/src/ai/bosun.ts

@@ -473,7 +473,11 @@ export class Bosun extends TaskAgent implements Agent {
     const successfulInteractions = results.filter((r) => r.result === 'success' && r.code);
 
     for (const interaction of successfulInteractions) {
-      await experienceTracker.saveSuccessfulResolution(actionResult, `Drill ${interaction.action}: ${interaction.component}`, interaction.code!, interaction.description);
+      experienceTracker.writeAction(actionResult, {
+        title: `Drill ${interaction.action}: ${interaction.component}`,
+        code: interaction.code!,
+        explanation: interaction.description,
+      });
     }
 
     if (successfulInteractions.length > 0) {