explorbot 0.1.17 → 0.1.19

package/dist/src/ai/navigator.js

@@ -68,8 +68,48 @@ class Navigator {
         this.experienceTracker = experienceTracker || new ExperienceTracker();
         this.hooksRunner = new HooksRunner(explorer, explorer.getConfig());
     }
+    getBaseOrigin() {
+        const baseUrl = this.explorer.getConfig().playwright.url;
+        try {
+            return new URL(baseUrl).origin;
+        }
+        catch {
+            return null;
+        }
+    }
+    getComparableCurrentUrl(stateManager, expectedUrl) {
+        const currentState = stateManager.getCurrentState();
+        if (!currentState)
+            return '';
+        const current = /^https?:\/\//i.test(expectedUrl) ? currentState.fullUrl || currentState.url || '' : currentState.url || '';
+        return current;
+    }
+    isSameExpectedOrigin(expectedUrl, stateManager) {
+        const currentState = stateManager.getCurrentState();
+        if (!currentState)
+            return false;
+        const currentFullUrl = currentState.fullUrl || currentState.url || '';
+        if (!currentFullUrl)
+            return false;
+        try {
+            const currentOrigin = new URL(currentFullUrl).origin;
+            if (/^https?:\/\//i.test(expectedUrl)) {
+                return currentOrigin === new URL(expectedUrl).origin;
+            }
+            const baseOrigin = this.getBaseOrigin();
+            if (!baseOrigin)
+                return true;
+            return currentOrigin === baseOrigin;
+        }
+        catch {
+            return !/^https?:\/\//i.test(expectedUrl);
+        }
+    }
     isOnExpectedPage(expectedUrl, stateManager) {
-        const currentUrl = stateManager.getCurrentState()?.url || '';
+        if (!this.isSameExpectedOrigin(expectedUrl, stateManager)) {
+            return false;
+        }
+        const currentUrl = this.getComparableCurrentUrl(stateManager, expectedUrl);
         return normalizeUrl(currentUrl) === normalizeUrl(expectedUrl);
     }
     async visit(url) {
@@ -249,7 +289,8 @@ class Navigator {
                     }
                 }
                 const freshState = await action.capturePageState();
-                const urlMatches = normalizeUrl(freshState.url || '') === normalizeUrl(expectedUrl);
+                const currentUrl = /^https?:\/\//i.test(expectedUrl) ? freshState.fullUrl || freshState.url || '' : freshState.url || '';
+                const urlMatches = this.isSameExpectedOrigin(expectedUrl, action.stateManager) && normalizeUrl(currentUrl) === normalizeUrl(expectedUrl);
                 const stateChanged = freshState.getStateHash() !== actionResult.getStateHash();
                 resolved = urlMatches && stateChanged;
                 if (!resolved && attemptOk) {

package/dist/src/ai/pilot.js

@@ -270,6 +270,9 @@ export class Pilot {
       overrides the others — weigh them together. Tester's record() notes are the LEAST reliable; always
       cross-check against actual actions and state. Visual screenshot analysis is strong for UI state
       (active tabs, visible counts, colors).
+      If the final page clearly shows an equivalent success state in a different UI form, do not fail only
+      because one narrow assertion targeted a specific badge, count, toast, or wording that the product
+      represents differently.
 
       SCENARIO TITLE defines what must happen. Action verbs require persisted evidence:
       - "Create X" → X must exist (visible, redirected to its page, or success message). Opening a form is NOT enough.
@@ -311,6 +314,8 @@ export class Pilot {
 
       GUIDANCE (required for "continue"): a specific next action on the current page — which tool, what
       to verify, how to record. Do not suggest repeating actions that already succeeded.
+      If progress is blocked only because the page lacks target data for the scenario, prefer precondition()
+      over repeated UI attempts.
     `;
     }
     buildVerdictSystemPrompt(type, task) {

package/dist/src/ai/planner.js

@@ -64,6 +64,9 @@ export class Planner extends PlannerBase {
     get sectionOrder() {
         return ConfigParser.getInstance().getConfig().ai?.agents?.researcher?.sections || Object.keys(POSSIBLE_SECTIONS);
     }
+    getDefaultStartUrl(state) {
+        return state.fullUrl || state.url;
+    }
     getSystemMessage(feature) {
         const currentUrl = this.stateManager.getCurrentState()?.url;
         const customPrompt = this.provider.getSystemPromptForAgent('planner', currentUrl);
@@ -138,7 +141,6 @@ export class Planner extends PlannerBase {
         }
         this.freshStart = false;
         setActivity(`${this.emoji} Planning...`, 'action');
-        tag('info').log(`Planning test scenarios for ${state.url}`);
         if (style)
             tag('info').log(`Planning style: ${style}`);
         const tags = ['planner'];
@@ -162,7 +164,8 @@ export class Planner extends PlannerBase {
             if (aiResult.object.scenarios.length === 0 && !this.currentPlan) {
                 throw new Error('No tasks were created successfully');
             }
-            const fromPlanning = aiResult.object.scenarios.map((s) => new Test(s.scenario, s.priority, s.expectedOutcomes, s.startUrl || state.url, s.steps || []));
+            const defaultStartUrl = this.getDefaultStartUrl(state);
+            const fromPlanning = aiResult.object.scenarios.map((s) => new Test(s.scenario, s.priority, s.expectedOutcomes, s.startUrl || defaultStartUrl, s.steps || []));
             return { tests: fromPlanning, planName: aiResult.object.planName };
         });
         const tests = result.tests;
@@ -171,7 +174,8 @@ export class Planner extends PlannerBase {
             const cached = state.url ? getRegisteredPlan(state.url) : null;
             const planName = feature || cached?.plan.title || result.planName || state.url;
             this.currentPlan = new Plan(planName);
-            this.currentPlan.url = state.url;
+            this.currentPlan.url = this.getDefaultStartUrl(state);
+            const defaultStartUrl = this.getDefaultStartUrl(state);
             if (parentPlan)
                 this.currentPlan.parentPlan = parentPlan;
             const allPreviousScenarios = this.getPreviousSessionScenarios();
@@ -182,14 +186,14 @@ export class Planner extends PlannerBase {
                 if (allPreviousScenarios.has(t.scenario.toLowerCase()))
                     continue;
                 t.style = this.lastStyleName;
-                t.startUrl = state.url;
+                t.startUrl = defaultStartUrl;
                 this.currentPlan.addTest(t);
             }
         }
         else {
             tag('step').log(`Expanding plan: "${this.currentPlan.title}"`);
             this.currentPlan.nextIteration();
-            const newTests = this.addNewTests(tests, state.url);
+            const newTests = this.addNewTests(tests, this.getDefaultStartUrl(state));
             if (newTests.length > 0) {
                 const summary = `New scenarios:\n${newTests.map((t) => `+ [${t.priority}] ${t.scenario}`).join('\n')}`;
                 tag('multiline').log(summary);
@@ -292,6 +296,13 @@ export class Planner extends PlannerBase {
       Focus on URL page change or data persistency after page reload.
       If there are subpages (pages with same URL path) plan testing of those subpages as well
       If you plan to test CRUD operations, plan them in correct order: create, read, update.
+      Do not invent specific route names, success messages, validation texts, badge counts, or welcome messages unless they are visible in research, visited pages, or prior observed flows.
+      If exact wording is unknown, describe the expected result generically, for example "an authentication error is shown" or "the user stays on the login page" instead of guessing the literal text.
+      If exact redirect destination is unknown, describe the destination by visible page identity, for example "the dashboard page opens" or "the current workspace home page opens" instead of inventing a URL slug.
+      Only propose scenarios whose prerequisites are evident from page research, visited pages, or API data preparation context.
+      If a scenario needs existing records, recipients, results, notifications, or other target data, propose it only when that data is visible or API preconditions can create it.
+      If the page appears read-only, degraded, demo-limited, maintenance-like, or lacks write controls, prefer read-only scenarios such as opening panels, inspecting visible lists, filtering, searching, or verifying current state.
+      Do not assume hidden data exists just because a control is present.
       DO NOT propose "verification-only" tests that merely open a UI element (modal, dropdown, panel) and check it exists.
       Every test must complete a meaningful action that changes application state or produces a business outcome.
       Opening a modal is NOT a test — performing an action INSIDE the modal IS a test.
@@ -516,10 +527,15 @@ export class Planner extends PlannerBase {
          - Good: "New suite 'My New Suite' appears in the suite list"
          - Good: "Suite appears under Starred filter tab"
          - Good: "Success message 'Suite created' is displayed"
+         - Good when wording is unknown: "An authentication error is displayed"
+         - Good when route is unknown: "The workspace home page is displayed"
          - Bad: "Modal is displayed" (just verifying existence, no business value)
          - Bad: "Dropdown menu is visible" (just verifying existence)
+         - Bad: "Welcome message is displayed" if no welcome message is visible in research
+         - Bad: "Redirected to /dashboard" if no such route was observed
          - Each outcome should be independently verifiable
          - Avoid combining multiple checks into one outcome
+         - Prefer durable user-facing results over fragile micro-signals
          - Expected outcomes describe WHAT TO VERIFY
 
          FORMATTING RULES:

package/dist/src/ai/rerunner.js

@@ -67,7 +67,7 @@ export class Rerunner extends TaskAgent {
             tag('error').log(`Test file not found: ${absPath}`);
             return { total: 0, passed: 0, failed: 0, healed: 0 };
         }
-        tag('info').log(`Re-running tests from: ${relative(process.cwd(), absPath)}`);
+        tag('step').log(`Re-running tests from: ${relative(process.cwd(), absPath)}`);
         setActivity('🔄 Re-running tests...', 'action');
         this.healedSteps = [];
         this.setupPlugins();

package/dist/src/ai/researcher/coordinates.js

@@ -182,7 +182,7 @@ export function WithCoordinates(Base) {
             const eidxWithoutCoords = [];
             for (const section of sections) {
                 for (const el of section.elements) {
-                    if (el.eidx && !el.coordinates)
+                    if (el.eidx && /^e\d+$/i.test(el.eidx) && !el.coordinates)
                         eidxWithoutCoords.push(el.eidx);
                 }
             }

package/dist/src/ai/researcher/deep-analysis.js

@@ -12,7 +12,7 @@ export function WithDeepAnalysis(Base) {
     return class extends Base {
         async performDeepAnalysis(state, result) {
             tag('info').log('Starting deep analysis of expandable elements');
-            await this.navigateTo(state.url);
+            await this.navigateTo(state.fullUrl || state.url);
             let expandables = await this._discoverExpandables(result.text);
             if (expandables.length === 0) {
                 tag('info').log('No expandable elements identified by AI');
@@ -21,7 +21,7 @@ export function WithDeepAnalysis(Base) {
             tag('substep').log(`Identified ${expandables.length} expandable elements`);
             const maxClicks = this.explorer.getConfig().ai?.agents?.researcher?.maxExpandableClicks ?? DEFAULT_MAX_EXPANDABLE_CLICKS;
             if (expandables.length > maxClicks) {
-                expandables = await this._selectExpandables(expandables, state.url, maxClicks);
+                expandables = await this._selectExpandables(expandables, state.fullUrl || state.url, maxClicks);
                 tag('substep').log(`Selected ${expandables.length} expandables to click (max: ${maxClicks})`);
             }
             const elements = expandables
@@ -144,7 +144,15 @@ export function WithDeepAnalysis(Base) {
         `;
                 visionCall = this.provider.processImage(visionPrompt, screenshot.toString('base64'));
             }
-            const [textRes, visionRes] = await Promise.all([textCall, visionCall]);
+            let textRes = null;
+            let visionRes = null;
+            try {
+                [textRes, visionRes] = await Promise.all([textCall, visionCall]);
+            }
+            catch (err) {
+                tag('warning').log(`Expandable discovery failed, skipping deep analysis: ${err instanceof Error ? err.message : err}`);
+                return [];
+            }
             const eidxSet = new Set();
             const parseRefs = (text) => {
                 if (!text)
@@ -204,10 +212,17 @@ export function WithDeepAnalysis(Base) {
         - Respond with comma-separated numbers to keep, e.g.: 1, 3, 5
       `;
             const model = this.provider.getModelForAgent('researcher');
-            const r = await this.provider.chat([{ role: 'user', content: prompt }], model, {
-                agentName: 'researcher',
-                telemetryFunctionId: 'researcher.selectExpandables',
-            });
+            let r;
+            try {
+                r = await this.provider.chat([{ role: 'user', content: prompt }], model, {
+                    agentName: 'researcher',
+                    telemetryFunctionId: 'researcher.selectExpandables',
+                });
+            }
+            catch (err) {
+                tag('warning').log(`Expandable selection failed, using first ${maxClicks}: ${err instanceof Error ? err.message : err}`);
+                return expandables.slice(0, maxClicks);
+            }
             const nums = (r.text || '').match(/\d+/g)?.map(Number) || [];
             const selected = expandables.filter((_, i) => nums.includes(i + 1));
             return selected.length > 0 ? selected.slice(0, maxClicks) : expandables.slice(0, maxClicks);

package/dist/src/ai/researcher/parser.js

@@ -40,6 +40,9 @@ export function mapRowToElement(row) {
     let eidxRaw = (colMap.eidx || '').trim();
     if (eidxRaw && /^\d+$/.test(eidxRaw))
         eidxRaw = `e${eidxRaw}`;
+    if (eidxRaw && !/^e\d+$/i.test(eidxRaw)) {
+        eidxRaw = '';
+    }
     const aria = parseAriaLocator(colMap.aria || '-');
     return {
         name,

package/dist/src/ai/researcher.js

@@ -90,9 +90,10 @@ export class Researcher extends ResearcherBase {
         Stats.researches++;
         const sessionName = `researcher: ${state.url}`;
         return Observability.run(sessionName, { tags: ['researcher'], sessionId: stateHash }, async () => {
-            tag('info').log(`Researching ${state.url} to understand the context...`);
+            const displayUrl = state.fullUrl || state.url;
+            tag('info').log(`Researching ${displayUrl} to understand the context...`);
             setActivity(`${this.emoji} Researching...`, 'action');
-            await this.ensureNavigated(state.url, screenshot && this.provider.hasVision());
+            await this.ensureNavigated(displayUrl, screenshot && this.provider.hasVision());
             await this.hooksRunner.runBeforeHook('researcher', state.url);
             const annotatedElements = await this.explorer.annotateElements();
             debugLog(`Annotated ${annotatedElements.length} interactive elements with eidx`);
@@ -113,11 +114,11 @@ export class Researcher extends ResearcherBase {
             if (!deep && !force) {
                 const similar = await findSimilarResearch(combinedHtml);
                 if (similar) {
-                    tag('info').log('Similar research found, reusing cached result');
+                    tag('substep').log('Similar research found, reusing cached result');
                     if (stateHash)
                         saveResearch(stateHash, similar, combinedHtml);
                     tag('multiline').log(formatResearchSummary(similar));
-                    tag('success').log(`Research complete! ${similar.length} characters (reused)`);
+                    tag('success').log('Research complete (reused)');
                     await this.hooksRunner.runAfterHook('researcher', state.url);
                     return similar;
                 }
@@ -235,7 +236,12 @@ export class Researcher extends ResearcherBase {
                     markSectionAsFocused(result, fallback);
             }
             if (!interrupted() && deep) {
-                await this.performDeepAnalysis(state, result);
+                try {
+                    await this.performDeepAnalysis(state, result);
+                }
+                catch (err) {
+                    tag('warning').log(`Deep analysis failed, continuing with best-effort research: ${err instanceof Error ? err.message : err}`);
+                }
             }
             if (!interrupted() && data) {
                 const extractedData = await this.extractData(state);
@@ -256,7 +262,7 @@ export class Researcher extends ResearcherBase {
                     this.experienceTracker.updateSummary(this.actionResult, summaryLine);
             }
             tag('multiline').log(formatResearchSummary(result.text, { visionUsed: this.hasScreenshotToAnalyze }));
-            tag('success').log(`Research complete! ${result.text.length} characters`);
+            tag('success').log('Research complete');
             if (researchFile)
                 tag('substep').log(`Research file saved to: ${researchFile}`);
             if (this.actionResult?.screenshotFile) {

package/dist/src/ai/session-analyst.js

@@ -105,12 +105,36 @@ export class SessionAnalyst {
             .slice(-30)
             .map((entry) => `  - [${entry.type}] ${entry.content}`)
             .join('\n');
+        const checked = test.getCheckedExpectations().join(' | ') || '(none)';
+        const remaining = test.getRemainingExpectations().join(' | ') || '(none)';
+        const notes = test
+            .getPrintableNotes()
+            .slice(-12)
+            .map((note) => `  - ${note}`)
+            .join('\n');
+        const visitedUrls = test.getVisitedUrls({ localOnly: true }).join(' | ') || '(none)';
+        const verification = test.verification
+            ? dedent `
+          verification_status: ${test.verification.status || 'unknown'}
+          verification_message: ${test.verification.message || '(none)'}
+          verification_url: ${test.verification.url || '(none)'}
+          verification_page: ${test.verification.pageLabel || '(none)'}
+          verification_details:
+          ${(test.verification.details.length > 0 ? test.verification.details : ['(none)']).map((detail) => `  - ${detail}`).join('\n')}
+        `
+            : 'verification_status: none';
         return dedent `
       <test ref="#${ref}">
       url: ${test.startUrl || '/'}
       scenario: ${test.scenario}
       result: ${test.result || 'unknown'}
       expected: ${test.expected.join(' | ') || '(none)'}
+      checked_expectations: ${checked}
+      remaining_expectations: ${remaining}
+      visited_urls: ${visitedUrls}
+      ${verification}
+      notes:
+      ${notes || '  - (none)'}
       log:
       ${log}
       </test>

package/dist/src/ai/tester.js

@@ -92,7 +92,6 @@ export class Tester extends TaskAgent {
         const state = this.explorer.getStateManager().getCurrentState();
         if (!state)
             throw new Error('No state found');
-        tag('info').log(`Testing scenario: ${task.scenario}`);
         setActivity(`🧪 Testing: ${task.scenario}`, 'action');
         this.previousUrl = null;
         this.previousStateHash = null;
@@ -595,7 +594,6 @@ export class Tester extends TaskAgent {
         if (!task.hasFinished) {
             task.finish(TestResult.FAILED);
         }
-        tag('info').log(`Finished: ${task.scenario}`);
         if (task.isSuccessful) {
             tag('success').log(`Successful test: ${task.scenario}`);
         }
@@ -792,7 +790,9 @@ export class Tester extends TaskAgent {
                     if (this.getCurrentState().isInsideIframe) {
                         await this.explorer.switchToMainFrame();
                     }
-                    if (this.explorer.getStateManager().getCurrentState()?.url === resetUrl) {
+                    const currentState = this.explorer.getStateManager().getCurrentState();
+                    const currentUrl = currentState?.fullUrl || currentState?.url;
+                    if (currentUrl === resetUrl) {
                         return {
                             success: false,
                             message: 'Reset failed - already on initial page!',

package/dist/src/ai/tools.js

@@ -731,11 +731,12 @@ export function createAgentTools({ explorer, researcher, navigator, experienceTr
             }),
             execute: async ({ reason }) => {
                 const stateManager = explorer.getStateManager();
-                const currentUrl = stateManager.getCurrentState()?.url;
+                const currentState = stateManager.getCurrentState();
+                const currentUrl = currentState?.fullUrl || currentState?.url;
                 const history = stateManager.getStateHistory();
                 let targetUrl = null;
                 for (let i = history.length - 1; i >= 0; i--) {
-                    const url = history[i].toState.url;
+                    const url = history[i].toState.fullUrl || history[i].toState.url;
                     if (url !== currentUrl) {
                         targetUrl = url;
                         break;

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

@@ -34,6 +34,10 @@ export class ExploreCommand extends BaseCommand {
     failedSubPages = new Set();
     oldTestRefs = new Set();
     priorityFilter;
+    getCurrentPageUrl() {
+        const state = this.explorBot.getExplorer().getStateManager().getCurrentState();
+        return state?.fullUrl || state?.url;
+    }
     async execute(args) {
         const { opts, args: remaining } = this.parseArgs(args);
         if (opts.maxTests) {
@@ -49,7 +53,7 @@ export class ExploreCommand extends BaseCommand {
             tag('info').log('Dry-run mode: planner runs to discover new tests; test execution is skipped');
         Stats.mode ??= 'explore';
         Stats.focus ??= feature;
-        const mainUrl = this.explorBot.getExplorer().getStateManager().getCurrentState()?.url;
+        const mainUrl = this.getCurrentPageUrl();
         if (cfg.enabled) {
             await this.runReuseMode(mainUrl, feature, cfg);
         }

package/dist/src/components/LogPane.js

@@ -10,6 +10,15 @@ const LogPane = React.memo(({ verboseMode }) => {
     const [logs, setLogs] = useState([]);
     const pendingLogsRef = React.useRef([]);
     const flushTimeoutRef = React.useRef(null);
+    const MAX_MULTILINE_LINES = 16;
+    const MAX_STEP_LINES = 8;
+    const MAX_SUBSTEP_LINES = 6;
+    const formatCollapsedContent = useCallback((lines, collapsedCount, label) => {
+        if (collapsedCount <= 0) {
+            return lines.join('\n');
+        }
+        return [`... ${collapsedCount} earlier ${label}`, ...lines].join('\n');
+    }, []);
     const flushLogs = useCallback(() => {
         if (pendingLogsRef.current.length === 0)
             return;
@@ -27,11 +36,33 @@ const LogPane = React.memo(({ verboseMode }) => {
                 if (lastLog.type === logEntry.type && lastLog.content === logEntry.content && Math.abs((lastLog.timestamp?.getTime() || 0) - (logEntry.timestamp?.getTime() || 0)) < 1000) {
                     continue;
                 }
+                if ((logEntry.type === 'step' || logEntry.type === 'substep') && lastLog.type === logEntry.type && Math.abs((lastLog.timestamp?.getTime() || 0) - (logEntry.timestamp?.getTime() || 0)) < 1500) {
+                    const currentLines = String(logEntry.content)
+                        .split('\n')
+                        .filter((line) => line.length > 0);
+                    const previousLines = String(lastLog.content)
+                        .split('\n')
+                        .filter((line) => line.length > 0);
+                    const visiblePreviousLines = lastLog.collapsedCount ? previousLines.slice(1) : previousLines;
+                    const maxLines = logEntry.type === 'step' ? MAX_STEP_LINES : MAX_SUBSTEP_LINES;
+                    const mergedLines = [...visiblePreviousLines, ...currentLines];
+                    const overflow = Math.max(0, mergedLines.length - maxLines);
+                    const collapsedCount = (lastLog.collapsedCount || 0) + overflow;
+                    const visibleLines = mergedLines.slice(-maxLines);
+                    const label = logEntry.type === 'step' ? 'steps' : 'details';
+                    result[result.length - 1] = {
+                        ...lastLog,
+                        content: formatCollapsedContent(visibleLines, collapsedCount, label),
+                        timestamp: logEntry.timestamp,
+                        collapsedCount,
+                    };
+                    continue;
+                }
                 result.push(logEntry);
             }
             return result;
         });
-    }, []);
+    }, [formatCollapsedContent]);
     const addLog = useCallback((logEntry) => {
         pendingLogsRef.current.push(logEntry);
         if (!flushTimeoutRef.current) {
@@ -85,10 +116,9 @@ const LogPane = React.memo(({ verboseMode }) => {
             const cleaned = stripAnsi(dedent(log.content));
             const parsed = parseMarkdownToTerminal(cleaned);
             const lines = parsed.split('\n');
-            const maxLines = 30;
-            const truncated = lines.length > maxLines ? `${lines.slice(0, maxLines).join('\n')}\n... (${lines.length - maxLines} more lines)` : cleaned;
+            const truncated = lines.length > MAX_MULTILINE_LINES ? `${lines.slice(0, MAX_MULTILINE_LINES).join('\n')}\n... (${lines.length - MAX_MULTILINE_LINES} more lines)` : parsed;
             return (React.createElement(Box, { key: index, borderStyle: "classic", borderLeft: false, borderRight: false, marginY: 1, padding: 1, borderColor: "dim", overflow: "hidden" },
-                React.createElement(Text, { color: "gray", dimColor: true }, parsed)));
+                React.createElement(Text, { color: "gray", dimColor: true }, truncated)));
         }
         if (log.type === 'html') {
             // Convert HTML to markdown, then render as multiline

package/dist/src/config.js

@@ -24,6 +24,7 @@ export class ConfigParser {
     static instance;
     config = null;
     configPath = null;
+    runtimeBaseUrlOverride = null;
     constructor() { }
     static loadEnv(filePath) {
         const resolved = resolve(filePath);
@@ -38,7 +39,7 @@ export class ConfigParser {
         return ConfigParser.instance;
     }
     async loadConfig(options) {
-        if (this.config && !options?.config && !options?.path) {
+        if (this.config && !options?.config && !options?.path && this.runtimeBaseUrlOverride === (options?.baseUrl || null)) {
             return this.config;
         }
         // Store the initial working directory for reference
@@ -61,7 +62,8 @@ export class ConfigParser {
             if (!loadedConfig) {
                 throw new Error('Configuration file is empty or invalid');
             }
-            this.config = this.resolveConfig(loadedConfig);
+            this.config = this.resolveConfig(loadedConfig, options);
+            this.runtimeBaseUrlOverride = options?.baseUrl || null;
             this.configPath = resolvedPath;
             log(`Configuration loaded from: ${resolvedPath}`);
             // Restore original directory after successful config load
@@ -108,6 +110,7 @@ export class ConfigParser {
         if (ConfigParser.instance) {
             ConfigParser.instance.config = null;
             ConfigParser.instance.configPath = null;
+            ConfigParser.instance.runtimeBaseUrlOverride = null;
         }
     }
     // For testing purposes only - sets up minimal default config
@@ -185,11 +188,15 @@ export class ConfigParser {
             return JSON.parse(content);
         }
     }
-    resolveConfig(config) {
+    resolveConfig(config, options) {
         if (config.web?.url && !config.playwright?.url) {
             config.playwright = config.playwright || { browser: 'chromium', url: '' };
             config.playwright.url = config.web.url;
         }
+        if (options?.baseUrl) {
+            config.playwright = config.playwright || { browser: 'chromium', url: '' };
+            config.playwright.url = options.baseUrl;
+        }
         return config;
     }
     validateConfig(config) {

package/dist/src/explorer.js

@@ -189,7 +189,20 @@ class Explorer {
         }
         await this.connectOrLaunchBrowser();
         const hasSession = this.options?.session && existsSync(this.options.session);
-        const contextOptions = hasSession ? { storageState: this.options.session } : undefined;
+        const helperOptions = this.playwrightHelper.options || {};
+        // CodeceptJS skips _createContextPage when sessions/storageState are involved, so we
+        // build contextOptions ourselves. Most keys share a name with Playwright's
+        // BrowserContextOptions and are copied as-is; `emulate` must be flattened, `basicAuth`
+        // renamed to `httpCredentials`, and `storageState` comes from the --session flag.
+        const contextOptions = {
+            ...helperOptions,
+        };
+        if (helperOptions.emulate)
+            Object.assign(contextOptions, helperOptions.emulate);
+        if (helperOptions.basicAuth)
+            contextOptions.httpCredentials = helperOptions.basicAuth;
+        if (hasSession)
+            contextOptions.storageState = this.options.session;
         await this.playwrightHelper._createContextPage(contextOptions);
         await this.playwrightRecorder.start(this.playwrightHelper.browserContext);
         this.setupXhrCapture();

package/dist/src/state-manager.js

@@ -416,6 +416,9 @@ export class StateManager {
     }
 }
 export function normalizeUrl(url) {
+    if (url.startsWith('/')) {
+        return url.replace(/^\/+/, '').replace(/\/+$/g, '');
+    }
     try {
         const parsed = new URL(url, 'http://localhost');
         const path = parsed.pathname.replace(/^\/+|\/+$/g, '');

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

@@ -90,11 +90,13 @@ export function matchesUrl(pattern, path) {
     }
 }
 export function extractStatePath(url) {
-    if (url.startsWith('/'))
-        return url;
+    if (url.startsWith('/')) {
+        return `/${url.replace(/^\/+/, '')}`;
+    }
     try {
         const urlObj = new URL(url);
-        return `${urlObj.pathname}${urlObj.search}${urlObj.hash}`;
+        const normalizedPathname = `/${urlObj.pathname.replace(/^\/+/, '')}`;
+        return `${normalizedPathname}${urlObj.search}${urlObj.hash}`;
     }
     catch {
         return url;

package/dist/src/utils/web-element.js

@@ -109,7 +109,8 @@ export class WebElement {
         return WebElement.fromPlaywrightLocator(page.locator(`[${EXPLORBOT_ATTRS.eidx}="${eidx}"]`));
     }
     static async fromEidxList(page, eidxList) {
-        if (eidxList.length === 0)
+        const validEidxList = eidxList.filter((eidx) => /^e\d+$/i.test(eidx));
+        if (validEidxList.length === 0)
             return [];
         const rawList = await page.evaluate(([list, extractFnStr, config]) => {
             const extract = new Function(`return ${extractFnStr}`)();
@@ -123,7 +124,7 @@ export class WebElement {
                     results.push(data);
             }
             return results;
-        }, [eidxList, getElementDataExtractorSource(), ELEMENT_EXTRACTION_CONFIG]);
+        }, [validEidxList, getElementDataExtractorSource(), ELEMENT_EXTRACTION_CONFIG]);
         return rawList.map((d) => WebElement.fromRawData(d));
     }
     static async findByXPath(html, xpath) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "explorbot",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "CLI app built with React Ink, CodeceptJS, and Playwright",
   "license": "Elastic-2.0",
   "type": "module",
@@ -20,6 +20,9 @@
     "src/**/*.tsx",
     "bin/**/*.ts",
     "boat/api-tester/src/**/*.ts",
+    "boat/doc-collector/src/**/*.ts",
+    "boat/doc-collector/bin/**/*.ts",
+    "boat/doc-collector/package.json",
     "rules/",
     "assets/sample-files/"
   ],

package/src/action.ts

@@ -2,7 +2,6 @@ import fs from 'node:fs';
 import { join } from 'node:path';
 import { faker } from '@faker-js/faker';
 import { context, trace } from '@opentelemetry/api';
-import { highlight } from 'cli-highlight';
 import { container, recorder } from 'codeceptjs';
 import * as codeceptjs from 'codeceptjs';
 import { hopeThat, retryTo, tryTo, within } from 'codeceptjs/lib/effects';
@@ -21,7 +20,7 @@ import type { PlaywrightRecorder } from './playwright-recorder.ts';
 import type { StateManager } from './state-manager.js';
 import { extractCodeBlocks } from './utils/code-extractor.js';
 import { htmlCombinedSnapshot, minifyHtml } from './utils/html.js';
-import { createDebug, log, setStepSpanParent, tag } from './utils/logger.js';
+import { createDebug, setStepSpanParent, tag } from './utils/logger.js';
 import { safeFilename } from './utils/strings.ts';
 import { throttle } from './utils/throttle.ts';
 
@@ -296,7 +295,13 @@ class Action {
   async expect(codeOrFunction: string | ((I: CodeceptJS.I) => void)): Promise<Action> {
     const codeString = typeof codeOrFunction === 'string' ? codeOrFunction : codeOrFunction.toString();
     this.expectation = codeString.toString();
-    log('Expecting', highlight(codeString, { language: 'javascript' }));
+    const expectationPreview = sanitizeCodeBlock(codeString)
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .slice(0, 2)
+      .join(' ');
+    tag('step').log(`Expecting: ${expectationPreview || 'assertion'}`);
     try {
       debugLog('Executing expectation:', codeString);