explorbot 0.1.31 → 0.2.0

package/dist/src/experience-tracker.js

@@ -1,11 +1,11 @@
-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";
 import { extractStatePath } from './utils/url-matcher.js';
 const debugLog = createDebug('explorbot:experience');
@@ -32,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);
         }
@@ -83,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 };
@@ -93,23 +88,9 @@ export class ExperienceTracker {
             return;
         }
         const filePath = this.getExperienceFilePath(stateHash);
-        const fileContent = matter.stringify(content, frontmatter || {});
+        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`);
     }
@@ -153,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;
         }
@@ -178,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;
         }
@@ -199,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);
@@ -241,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,
@@ -285,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()) {
@@ -358,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;
@@ -498,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

@@ -0,0 +1,106 @@
+import { Captain } from './ai/captain.js';
+import { Driller } from './ai/driller.js';
+import { ExperienceCompactor } from './ai/experience-compactor.js';
+import { Fisherman } from './ai/fisherman.js';
+import { Historian } from './ai/historian.js';
+import { Navigator } from './ai/navigator.js';
+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 { Rerunner } from './ai/rerunner.js';
+import { Researcher } from './ai/researcher.js';
+import { SessionAnalyst } from './ai/session-analyst.js';
+import { Tester } from './ai/tester.js';
+import type { ExplorbotConfig } from './config.js';
+import { ConfigParser } from './config.js';
+import { ExperienceTracker } from './experience-tracker.js';
+import Explorer from './explorer.js';
+import { KnowledgeTracker } from './knowledge-tracker.js';
+import { WebPageState } from './state-manager.js';
+import type { Suite } from './suite.js';
+import { Plan, type Test } from './test-plan.js';
+export interface ExplorBotOptions {
+    from?: string;
+    baseUrl?: string;
+    verbose?: boolean;
+    config?: string;
+    path?: string;
+    show?: boolean;
+    headless?: boolean;
+    incognito?: boolean;
+    session?: string;
+}
+export type UserResolveFunction = (error?: Error, showWelcome?: boolean) => Promise<string | null>;
+export declare class ExplorBot {
+    configParser: ConfigParser;
+    explorer: Explorer;
+    provider: AIProvider;
+    config: ExplorbotConfig;
+    options: ExplorBotOptions;
+    userResolveFn: UserResolveFunction | null;
+    currentPlan?: Plan;
+    planFeature?: string;
+    lastPlanError: Error | null;
+    lastSavedPlanPath: string | null;
+    agents: Record<string, any>;
+    sessionPlans: Plan[];
+    lastReportedTestCount: number;
+    _experienceTracker?: ExperienceTracker;
+    _knowledgeTracker?: KnowledgeTracker;
+    constructor(options?: ExplorBotOptions);
+    get isExploring(): boolean;
+    setUserResolve(fn: UserResolveFunction): void;
+    start(): Promise<void>;
+    startProviderOnly(): Promise<void>;
+    stop(): Promise<void>;
+    visitInitialState(): Promise<void>;
+    visit(url: string): Promise<void>;
+    openFreshTab(): Promise<void>;
+    getCurrentState(): WebPageState | null;
+    getExplorer(): Explorer;
+    knowledgeTracker(): KnowledgeTracker;
+    experienceTracker(): ExperienceTracker;
+    getConfig(): ExplorbotConfig;
+    getOptions(): ExplorBotOptions;
+    getProvider(): AIProvider;
+    createAgent<T>(factory: (deps: {
+        explorer: Explorer;
+        ai: AIProvider;
+        config: ExplorbotConfig;
+    }) => T): T;
+    agentResearcher(): Researcher;
+    agentNavigator(): Navigator;
+    agentPlanner(): Planner;
+    agentPilot(): Pilot;
+    agentTester(): Tester;
+    agentCaptain(): Captain;
+    agentExperienceCompactor(): ExperienceCompactor;
+    agentQuartermaster(): Quartermaster | null;
+    agentHistorian(): Historian;
+    agentRerunner(): Rerunner;
+    agentDriller(): Driller;
+    agentSessionAnalyst(): SessionAnalyst;
+    agentFisherman(): Fisherman | null;
+    getCurrentPlan(): Plan | undefined;
+    getSuite(): Suite | null;
+    getPlanFeature(): string | undefined;
+    clearPlan(): void;
+    plan(feature?: string, opts?: {
+        fresh?: boolean;
+        style?: string;
+        extend?: Plan;
+        completedPlans?: Plan[];
+        noSave?: boolean;
+    }): Promise<Plan>;
+    getPlansDir(): string;
+    savePlan(filename?: string): string | null;
+    savePlans(plans: Plan[], filename?: string): string | null;
+    generatePlanFilename(feature?: string): string;
+    resolvePlanPath(filename: string): string;
+    loadPlan(filename: string): Plan;
+    loadPlans(filename: string): Plan[];
+    setCurrentPlan(plan?: Plan): void;
+    getSessionTests(): Test[];
+    printSessionAnalysis(): Promise<void>;
+}

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}`);
         }
     }