explorbot 0.1.32-beta.1 → 0.2.0

package/dist/src/config.d.ts

@@ -230,6 +230,8 @@ export declare class ConfigParser {
     getConfig(): ExplorbotConfig;
     getConfigPath(): string | null;
     getOutputDir(): string;
+    getProjectRoot(): string;
+    resolveProjectDir(relativeDir: string): string;
     getStatesDir(): string;
     getPlansDir(): string;
     getTestsDir(): string;

package/dist/src/config.js

@@ -96,6 +96,18 @@ export class ConfigParser {
             throw new Error('Config path not found');
         return path.join(path.dirname(configPath), config.dirs?.output || 'output');
     }
+    getProjectRoot() {
+        const configPath = this.getConfigPath();
+        if (configPath)
+            return path.dirname(configPath);
+        return process.cwd();
+    }
+    resolveProjectDir(relativeDir) {
+        const configPath = this.getConfigPath();
+        if (!configPath)
+            return relativeDir;
+        return path.join(path.dirname(configPath), relativeDir);
+    }
     getStatesDir() {
         return outputPath('states');
     }

package/dist/src/experience-tracker.d.ts

@@ -22,7 +22,7 @@ export declare class ExperienceTracker {
     experienceDir: string;
     disabled: boolean;
     knowledgeTracker: KnowledgeTracker;
-    constructor(options?: {
+    constructor(knowledgeTracker: KnowledgeTracker, options?: {
         disabled?: boolean;
     });
     getExperienceDirectories(): string[];
@@ -31,8 +31,11 @@ export declare class ExperienceTracker {
         content: string;
         data: any;
     };
+    readExperienceFileAt(filePath: string): {
+        content: string;
+        data: any;
+    };
     writeExperienceFile(stateHash: string, content: string, frontmatter?: any): void;
-    hasRecentExperience(stateHash: string, prefix?: string): boolean;
     getExperienceFilePath(stateHash: string): string;
     ensureExperienceFile(state: ActionResult): string;
     updateSummary(state: ActionResult, summary: string): void;
@@ -43,10 +46,6 @@ export declare class ExperienceTracker {
     getRelevantExperience(state: ActionResult, options?: {
         includeDescendantExperience?: boolean;
     }): ExperienceFile[];
-    /**
-     * Clean up experience tracker (for testing)
-     */
-    cleanup(): void;
     getSuccessfulExperience(state: ActionResult, options?: {
         includeDescendants?: boolean;
         stripCode?: boolean;
@@ -54,6 +53,7 @@ export declare class ExperienceTracker {
     getExperienceTableOfContents(state: ActionResult, options?: {
         includeDescendantExperience?: boolean;
     }): ExperienceTocEntry[];
+    renderExperienceTocFor(state: ActionResult): string;
     getExperienceSection(fileTag: string, sectionIndex: number, state: ActionResult, options?: {
         includeDescendantExperience?: boolean;
     }): {
@@ -61,6 +61,11 @@ export declare class ExperienceTracker {
         url: string;
         content: string;
     } | null;
+    buildToc(records: ExperienceFile[]): ExperienceTocEntry[];
+    readSectionByHash(fileHash: string, sectionIndex: number): {
+        title: string;
+        body: string;
+    } | null;
     findExperienceFileByHash(fileHash: string): string | null;
     listAllExperienceToc(filter?: string, options?: {
         recency?: 'recent' | 'old';

package/dist/src/experience-tracker.js

@@ -1,10 +1,9 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
-import { basename, dirname, join } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
 import matter from 'gray-matter';
-import { marked } from 'marked';
 import { ConfigParser } from './config.js';
-import { KnowledgeTracker } from './knowledge-tracker.js';
-import { createDebug, tag } from './utils/logger.js';
+import { createDebug, pluralize, tag } from './utils/logger.js';
+import { loadMarkdownFiles } from './utils/markdown-files.js';
 import { mdq } from './utils/markdown-query.js';
 import { redactSecrets } from './utils/secrets.js';
 import { isNonReusableCode } from "./utils/step-analyzer.js";
@@ -33,20 +32,13 @@ export class ExperienceTracker {
     experienceDir;
     disabled;
     knowledgeTracker;
-    constructor(options = {}) {
+    constructor(knowledgeTracker, options = {}) {
         const configParser = ConfigParser.getInstance();
         const config = configParser.getConfig();
-        const configPath = configParser.getConfigPath();
         this.disabled = options.disabled ?? false;
-        this.knowledgeTracker = new KnowledgeTracker();
+        this.knowledgeTracker = knowledgeTracker;
         // Resolve experience directory relative to the config file location (project root)
-        if (configPath) {
-            const projectRoot = dirname(configPath);
-            this.experienceDir = join(projectRoot, config.dirs?.experience || 'experience');
-        }
-        else {
-            this.experienceDir = config.dirs?.experience || 'experience';
-        }
+        this.experienceDir = configParser.resolveProjectDir(config.dirs?.experience || 'experience');
         if (!this.disabled) {
             this.ensureDirectory(this.experienceDir);
         }
@@ -84,7 +76,9 @@ export class ExperienceTracker {
         }
     }
     readExperienceFile(stateHash) {
-        const filePath = this.getExperienceFilePath(stateHash);
+        return this.readExperienceFileAt(this.getExperienceFilePath(stateHash));
+    }
+    readExperienceFileAt(filePath) {
         const fileContent = readFileSync(filePath, 'utf8');
         const { content, data } = matter(fileContent);
         return { content, data };
@@ -97,20 +91,6 @@ export class ExperienceTracker {
         const fileContent = matter.stringify(redactSecrets(content), frontmatter || {});
         writeFileSync(filePath, fileContent, 'utf8');
     }
-    hasRecentExperience(stateHash, prefix = '') {
-        if (this.disabled) {
-            return false;
-        }
-        if (prefix) {
-            stateHash = `${prefix}_${stateHash}`;
-        }
-        const filePath = this.getExperienceFilePath(stateHash);
-        if (!existsSync(filePath)) {
-            return false;
-        }
-        const stats = statSync(filePath);
-        return stats.mtime.getTime() > Date.now() - 1000 * 60 * 60 * 24;
-    }
     getExperienceFilePath(stateHash) {
         return join(this.experienceDir, `${stateHash}.md`);
     }
@@ -154,7 +134,10 @@ export class ExperienceTracker {
         this.ensureExperienceFile(state);
         const stateHash = state.getStateHash();
         const { content, data } = this.readExperienceFile(stateHash);
-        if (content.includes(action.code)) {
+        if (mdq(content)
+            .query('code')
+            .meta()
+            .some((m) => m.text.trim() === action.code.trim())) {
             debugLog('Skipping duplicate action', action.code);
             return;
         }
@@ -179,7 +162,10 @@ export class ExperienceTracker {
         this.ensureExperienceFile(state);
         const stateHash = state.getStateHash();
         const { content, data } = this.readExperienceFile(stateHash);
-        if (content.includes(body)) {
+        if (mdq(content)
+            .query('section2')
+            .each()
+            .some((s) => s.text().trim() === body.trim())) {
             debugLog('Skipping duplicate flow body');
             return;
         }
@@ -200,25 +186,9 @@ export class ExperienceTracker {
                 continue;
             }
             try {
-                const files = readdirSync(experienceDir)
-                    .filter((file) => file.endsWith('.md'))
-                    .map((file) => join(experienceDir, file));
-                for (const file of files) {
-                    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) {
-                        debugLog(`Failed to read experience file ${file}:`, error);
-                    }
-                }
+                allFiles.push(...loadMarkdownFiles(experienceDir, {
+                    onError: (filePath, error) => debugLog(`Failed to read experience file ${filePath}:`, error),
+                }));
             }
             catch (error) {
                 debugLog(`Failed to read experience directory ${experienceDir}:`, error);
@@ -242,19 +212,18 @@ export class ExperienceTracker {
             });
         })
             .map((experience) => {
-            const lines = experience.content.split('\n');
-            if (lines.length <= maxLines)
+            if (experience.content.split('\n').length <= maxLines)
                 return experience;
-            return { ...experience, content: lines.slice(0, maxLines).join('\n') };
+            let content = experience.content;
+            while (content.split('\n').length > maxLines) {
+                const sections = mdq(content).query('section2').each();
+                if (sections.length <= 1)
+                    break;
+                content = sections[sections.length - 1].replace('');
+            }
+            return { ...experience, content };
         });
     }
-    /**
-     * Clean up experience tracker (for testing)
-     */
-    cleanup() {
-        // Clear any in-memory state if needed
-        // The actual files will be cleaned up by test cleanup
-    }
     getSuccessfulExperience(state, options) {
         const records = this.getRelevantExperience(state, {
             includeDescendantExperience: options?.includeDescendants,
@@ -286,36 +255,48 @@ export class ExperienceTracker {
             const bHash = basename(b.filePath, '.md');
             return aHash.localeCompare(bHash);
         });
+        return this.buildToc(sorted);
+    }
+    renderExperienceTocFor(state) {
+        const toc = this.getExperienceTableOfContents(state);
+        if (toc.length === 0)
+            return '';
+        const totalSections = toc.reduce((sum, entry) => sum + entry.sections.length, 0);
+        debugLog(`injecting experience TOC (${toc.length} files, ${totalSections} sections)`);
+        tag('operation').log(`Found ${toc.length} experience ${pluralize(toc.length, 'file')} (${totalSections} sections)`);
+        return renderExperienceToc(toc);
+    }
+    getExperienceSection(fileTag, sectionIndex, state, options) {
+        const toc = this.getExperienceTableOfContents(state, options);
+        const entry = toc.find((e) => e.fileTag === fileTag);
+        if (!entry)
+            return null;
+        const extracted = this.readSectionByHash(entry.fileHash, sectionIndex);
+        if (!extracted)
+            return null;
+        return { title: extracted.title, url: entry.url, content: extracted.body };
+    }
+    buildToc(records) {
         const toc = [];
-        for (let i = 0; i < sorted.length; i++) {
-            const record = sorted[i];
-            const fileHash = basename(record.filePath, '.md');
-            const url = record.data?.url || '';
+        for (const record of records) {
             const sections = listTocHeadings(record.content);
             if (sections.length === 0)
                 continue;
             toc.push({
-                fileTag: indexToLetters(i),
-                fileHash,
-                url,
+                fileTag: indexToLetters(toc.length),
+                fileHash: basename(record.filePath, '.md'),
+                url: record.data?.url || '',
                 sections,
             });
         }
         return toc;
     }
-    getExperienceSection(fileTag, sectionIndex, state, options) {
-        const toc = this.getExperienceTableOfContents(state, options);
-        const entry = toc.find((e) => e.fileTag === fileTag);
-        if (!entry)
-            return null;
-        const filePath = this.findExperienceFileByHash(entry.fileHash);
+    readSectionByHash(fileHash, sectionIndex) {
+        const filePath = this.findExperienceFileByHash(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 };
+        const { content } = this.readExperienceFileAt(filePath);
+        return extractHeadingSection(content, sectionIndex);
     }
     findExperienceFileByHash(fileHash) {
         for (const dir of this.getExperienceDirectories()) {
@@ -359,81 +340,34 @@ export class ExperienceTracker {
             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;
+        return this.buildToc(sorted);
     }
     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);
+        const extracted = this.readSectionByHash(entry.fileHash, 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);
-    const result = [];
-    let index = 0;
-    for (const token of tokens) {
-        if (token.type !== 'heading')
-            continue;
-        const heading = token;
-        if (heading.depth !== 2 && heading.depth !== 3)
-            continue;
-        index++;
-        result.push({ index, level: heading.depth, title: heading.text });
-    }
-    return result;
+    return mdq(content)
+        .query('heading')
+        .meta()
+        .filter((m) => m.depth === 2 || m.depth === 3)
+        .map((m, i) => ({ index: i + 1, level: m.depth, title: m.text }));
 }
 function extractHeadingSection(content, sectionIndex) {
-    const tokens = marked.lexer(content);
-    const matching = [];
-    for (let i = 0; i < tokens.length; i++) {
-        const token = tokens[i];
-        if (token.type !== 'heading')
-            continue;
-        const heading = token;
-        if (heading.depth !== 2 && heading.depth !== 3)
-            continue;
-        matching.push({ tokenIdx: i, depth: heading.depth, text: heading.text });
-    }
+    const sections = mdq(content).query('section').each();
+    const metas = mdq(content).query('section').meta();
+    const matching = metas.map((meta, i) => ({ meta, section: sections[i] })).filter((entry) => entry.meta.depth === 2 || entry.meta.depth === 3);
     if (sectionIndex < 1 || sectionIndex > matching.length)
         return null;
     const target = matching[sectionIndex - 1];
-    let endTokenIdx = tokens.length;
-    for (let j = target.tokenIdx + 1; j < tokens.length; j++) {
-        const token = tokens[j];
-        if (token.type !== 'heading')
-            continue;
-        if (token.depth <= target.depth) {
-            endTokenIdx = j;
-            break;
-        }
-    }
-    const body = tokens
-        .slice(target.tokenIdx, endTokenIdx)
-        .map((t) => t.raw || '')
-        .join('');
-    return { title: target.text, body };
+    return { title: target.meta.text, body: target.section.text() };
 }
 function indexToLetters(index) {
     let n = index;
@@ -499,21 +433,14 @@ function generateActionContent(title, code, explanation) {
     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;
+    return mdq(content)
+        .query('h2')
+        .replaceEach((heading) => {
+        const text = heading.meta()[0]?.text.trim() || '';
+        if (text.startsWith('FLOW:'))
+            return `## HOW to ${text.slice(5).trim()} (multi-step)\n\n`;
+        if (text.startsWith('ACTION:'))
+            return `## HOW to ${text.slice(7).trim()} (single-step)\n\n`;
+        return heading.text();
+    });
 }

package/dist/src/explorbot.d.ts

@@ -39,7 +39,6 @@ export declare class ExplorBot {
     config: ExplorbotConfig;
     options: ExplorBotOptions;
     userResolveFn: UserResolveFunction | null;
-    needsInput: boolean;
     currentPlan?: Plan;
     planFeature?: string;
     lastPlanError: Error | null;
@@ -47,6 +46,8 @@ export declare class ExplorBot {
     agents: Record<string, any>;
     sessionPlans: Plan[];
     lastReportedTestCount: number;
+    _experienceTracker?: ExperienceTracker;
+    _knowledgeTracker?: KnowledgeTracker;
     constructor(options?: ExplorBotOptions);
     get isExploring(): boolean;
     setUserResolve(fn: UserResolveFunction): void;
@@ -58,12 +59,10 @@ export declare class ExplorBot {
     openFreshTab(): Promise<void>;
     getCurrentState(): WebPageState | null;
     getExplorer(): Explorer;
-    getKnowledgeTracker(): KnowledgeTracker;
-    getExperienceTracker(): ExperienceTracker;
+    knowledgeTracker(): KnowledgeTracker;
+    experienceTracker(): ExperienceTracker;
     getConfig(): ExplorbotConfig;
     getOptions(): ExplorBotOptions;
-    isReady(): boolean;
-    getConfigParser(): ConfigParser;
     getProvider(): AIProvider;
     createAgent<T>(factory: (deps: {
         explorer: Explorer;

package/dist/src/explorbot.js

@@ -1,6 +1,5 @@
 import { existsSync, mkdirSync } from 'node:fs';
 import path from 'node:path';
-import { ActionResult } from "./action-result.js";
 import { Captain } from "./ai/captain.js";
 import { Driller } from "./ai/driller.js";
 import { ExperienceCompactor } from "./ai/experience-compactor.js";
@@ -25,6 +24,7 @@ import Explorer from "./explorer.js";
 import { KnowledgeTracker } from "./knowledge-tracker.js";
 import { Stats } from "./stats.js";
 import { Plan } from "./test-plan.js";
+import { browserErrorMessage } from "./utils/browser-errors.js";
 import { setVerboseMode, tag } from "./utils/logger.js";
 import { relativeToCwd } from "./utils/next-steps.js";
 import { sanitizeFilename } from "./utils/strings.js";
@@ -36,7 +36,6 @@ export class ExplorBot {
     config;
     options;
     userResolveFn = null;
-    needsInput = false;
     currentPlan;
     planFeature;
     lastPlanError = null;
@@ -44,6 +43,8 @@ export class ExplorBot {
     agents = {};
     sessionPlans = [];
     lastReportedTestCount = 0;
+    _experienceTracker;
+    _knowledgeTracker;
     constructor(options = {}) {
         this.options = options;
         this.configParser = ConfigParser.getInstance();
@@ -64,16 +65,14 @@ export class ExplorBot {
         }
         try {
             await this.startProviderOnly();
-            this.explorer = new Explorer(this.config, this.provider, this.options);
+            this.explorer = new Explorer(this.config, this.provider, this.options, this.experienceTracker(), this.knowledgeTracker());
             await this.explorer.start();
             if (!this.options.incognito) {
                 await this.agentExperienceCompactor().autocompact();
             }
-            if (this.userResolveFn)
-                this.explorer.setUserResolve(this.userResolveFn);
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
+            const message = browserErrorMessage(error);
             console.error('\nFailed to start:', message);
             process.exit(1);
         }
@@ -105,17 +104,11 @@ export class ExplorBot {
     getExplorer() {
         return this.explorer;
     }
-    getKnowledgeTracker() {
-        if (this.explorer) {
-            return this.explorer.getKnowledgeTracker();
-        }
-        return new KnowledgeTracker();
+    knowledgeTracker() {
+        return (this._knowledgeTracker ||= new KnowledgeTracker());
     }
-    getExperienceTracker() {
-        if (this.explorer) {
-            return this.explorer.getStateManager().getExperienceTracker();
-        }
-        return new ExperienceTracker();
+    experienceTracker() {
+        return (this._experienceTracker ||= new ExperienceTracker(this.knowledgeTracker()));
     }
     getConfig() {
         return this.config;
@@ -123,12 +116,6 @@ export class ExplorBot {
     getOptions() {
         return this.options;
     }
-    isReady() {
-        return this.explorer?.isStarted;
-    }
-    getConfigParser() {
-        return this.configParser;
-    }
     getProvider() {
         return this.provider;
     }
@@ -138,10 +125,8 @@ export class ExplorBot {
             ai: this.provider,
             config: this.config,
         });
-        const agentEmoji = agent.emoji || '';
         const agentName = agent.constructor.name.toLowerCase();
         tag('debug').log(`Created ${agentName} agent`);
-        // Agent is stored by the calling method using a string key
         return agent;
     }
     agentResearcher() {
@@ -149,12 +134,12 @@ export class ExplorBot {
     }
     agentNavigator() {
         return (this.agents.navigator ||= this.createAgent(({ ai, explorer }) => {
-            return new Navigator(explorer, ai, this.agentExperienceCompactor(), explorer.getStateManager().getExperienceTracker());
+            return new Navigator(explorer, ai);
         }));
     }
     agentPlanner() {
         if (!this.agents.planner) {
-            this.agents.planner = this.createAgent(({ ai, explorer }) => new Planner(explorer, ai));
+            this.agents.planner = this.createAgent(({ ai, explorer }) => new Planner(explorer, ai, this.agentResearcher()));
             const fisherman = this.agentFisherman();
             if (fisherman)
                 this.agents.planner.setFisherman(fisherman);
@@ -165,14 +150,8 @@ export class ExplorBot {
         return (this.agents.pilot ||= this.createAgent(({ ai, explorer }) => {
             const researcher = this.agentResearcher();
             const navigator = this.agentNavigator();
-            const stateManager = explorer.getStateManager();
-            const experienceTracker = stateManager.getExperienceTracker();
-            const getState = () => {
-                const state = stateManager.getCurrentState();
-                return state ? ActionResult.fromState(state) : null;
-            };
-            const tools = createAgentTools({ explorer, researcher, navigator, experienceTracker, getState, supervisor: true });
-            return new Pilot(ai, tools, researcher, explorer, experienceTracker);
+            const tools = createAgentTools({ explorer, researcher, navigator, supervisor: true });
+            return new Pilot(ai, tools, researcher, explorer);
         }));
     }
     agentTester() {
@@ -180,13 +159,7 @@ export class ExplorBot {
             this.agents.tester = this.createAgent(({ ai, explorer }) => {
                 const researcher = this.agentResearcher();
                 const navigator = this.agentNavigator();
-                const stateManager = explorer.getStateManager();
-                const experienceTracker = stateManager.getExperienceTracker();
-                const getState = () => {
-                    const state = stateManager.getCurrentState();
-                    return state ? ActionResult.fromState(state) : null;
-                };
-                const tools = createAgentTools({ explorer, researcher, navigator, experienceTracker, getState });
+                const tools = createAgentTools({ explorer, researcher, navigator });
                 return new Tester(explorer, ai, researcher, navigator, tools);
             });
             const qm = this.agentQuartermaster();
@@ -204,15 +177,11 @@ export class ExplorBot {
     agentCaptain() {
         if (!this.agents.captain) {
             this.agents.captain = new Captain(this);
-            const qm = this.agentQuartermaster();
-            if (qm)
-                this.agents.captain.setQuartermaster(qm);
-            this.agents.captain.setHistorian(this.agentHistorian());
         }
         return this.agents.captain;
     }
     agentExperienceCompactor() {
-        return (this.agents.experienceCompactor ||= new ExperienceCompactor(this.provider, this.getExperienceTracker()));
+        return (this.agents.experienceCompactor ||= new ExperienceCompactor(this.provider, this.experienceTracker()));
     }
     agentQuartermaster() {
         const config = this.config.ai?.agents?.quartermaster;
@@ -241,12 +210,9 @@ export class ExplorBot {
             this.agents.rerunner = this.createAgent(({ ai, explorer }) => {
                 const researcher = this.agentResearcher();
                 const navigator = this.agentNavigator();
-                const tools = createAgentTools({ explorer, researcher, navigator });
+                const tools = createAgentTools({ explorer, researcher, navigator, withExperience: false });
                 return new Rerunner(explorer, ai, tools);
             });
-            const qm = this.agentQuartermaster();
-            if (qm)
-                this.agents.rerunner.setQuartermaster(qm);
             this.agents.rerunner.setHistorian(this.agentHistorian());
         }
         return this.agents.rerunner;
@@ -443,7 +409,7 @@ export class ExplorBot {
             this.lastReportedTestCount = tests.length;
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
+            const message = browserErrorMessage(error);
             tag('warning').log(`Session analysis failed: ${message}`);
         }
     }