explorbot 0.1.17 → 0.1.19

package/src/ai/driller.ts

@@ -168,7 +168,7 @@ export class Driller extends TaskAgent implements Agent {
     this.allResults = [];
 
     return Observability.run(`driller: ${currentState.url}`, { tags: ['driller'], sessionId: sessionName }, async () => {
-      tag('info').log(`Driller starting on ${currentState.url}`);
+      tag('step').log(`Drilling page: ${currentState.url}`);
       await this.hooksRunner.runBeforeHook('driller', currentState.url);
 
       const originalState = await this.captureAnnotatedState();

package/src/ai/navigator.ts

@@ -80,8 +80,48 @@ class Navigator implements Agent {
     this.hooksRunner = new HooksRunner(explorer, explorer.getConfig());
   }
 
+  private getBaseOrigin(): string | null {
+    const baseUrl = this.explorer.getConfig().playwright.url;
+    try {
+      return new URL(baseUrl).origin;
+    } catch {
+      return null;
+    }
+  }
+
+  private getComparableCurrentUrl(stateManager: any, expectedUrl: string): string {
+    const currentState = stateManager.getCurrentState();
+    if (!currentState) return '';
+    const current = /^https?:\/\//i.test(expectedUrl) ? currentState.fullUrl || currentState.url || '' : currentState.url || '';
+    return current;
+  }
+
+  private isSameExpectedOrigin(expectedUrl: string, stateManager: any): boolean {
+    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);
+    }
+  }
+
   private isOnExpectedPage(expectedUrl: string, stateManager: any): boolean {
-    const currentUrl = stateManager.getCurrentState()?.url || '';
+    if (!this.isSameExpectedOrigin(expectedUrl, stateManager)) {
+      return false;
+    }
+    const currentUrl = this.getComparableCurrentUrl(stateManager, expectedUrl);
     return normalizeUrl(currentUrl) === normalizeUrl(expectedUrl);
   }
 
@@ -282,7 +322,8 @@ class Navigator implements Agent {
             }
           }
           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;
 

package/src/ai/pilot.ts

@@ -313,6 +313,9 @@ export class Pilot implements Agent {
       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.
@@ -355,6 +358,8 @@ export class Pilot implements Agent {
 
       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.
     `;
   }
 

package/src/ai/planner.ts

@@ -80,6 +80,10 @@ export class Planner extends PlannerBase implements Agent {
     return ConfigParser.getInstance().getConfig().ai?.agents?.researcher?.sections || Object.keys(POSSIBLE_SECTIONS);
   }
 
+  private getDefaultStartUrl(state: { url: string; fullUrl?: string }): string {
+    return state.fullUrl || state.url;
+  }
+
   getSystemMessage(feature?: string): string {
     const currentUrl = this.stateManager.getCurrentState()?.url;
     const customPrompt = this.provider.getSystemPromptForAgent('planner', currentUrl);
@@ -160,7 +164,6 @@ export class Planner extends PlannerBase implements Agent {
     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'];
@@ -188,7 +191,8 @@ export class Planner extends PlannerBase implements Agent {
         throw new Error('No tasks were created successfully');
       }
 
-      const fromPlanning = aiResult.object.scenarios.map((s: any) => 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: any) => new Test(s.scenario, s.priority, s.expectedOutcomes, s.startUrl || defaultStartUrl, s.steps || []));
 
       return { tests: fromPlanning, planName: aiResult.object.planName };
     });
@@ -200,7 +204,8 @@ export class Planner extends PlannerBase implements Agent {
       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();
       const existingTestScenarios = this.getExistingTestFileScenarios(state.url);
@@ -208,13 +213,13 @@ export class Planner extends PlannerBase implements Agent {
       for (const t of tests) {
         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);
@@ -331,6 +336,13 @@ export class Planner extends PlannerBase implements Agent {
       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.
@@ -566,10 +578,15 @@ export class Planner extends PlannerBase implements Agent {
          - 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/src/ai/rerunner.ts

@@ -87,7 +87,7 @@ export class Rerunner extends TaskAgent implements Agent {
       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 = [];

package/src/ai/researcher/coordinates.ts

@@ -198,7 +198,7 @@ export function WithCoordinates<T extends Constructor>(Base: T) {
       const eidxWithoutCoords: string[] = [];
       for (const section of sections) {
         for (const el of section.elements) {
-          if (el.eidx && !el.coordinates) eidxWithoutCoords.push(el.eidx);
+          if (el.eidx && /^e\d+$/i.test(el.eidx) && !el.coordinates) eidxWithoutCoords.push(el.eidx);
         }
       }
       if (eidxWithoutCoords.length === 0) return;

package/src/ai/researcher/deep-analysis.ts

@@ -24,7 +24,7 @@ export function WithDeepAnalysis<T extends Constructor>(Base: T) {
 
     async performDeepAnalysis(state: WebPageState, result: ResearchResult): Promise<void> {
       tag('info').log('Starting deep analysis of expandable elements');
-      await (this as any).navigateTo(state.url);
+      await (this as any).navigateTo(state.fullUrl || state.url);
 
       let expandables = await this._discoverExpandables(result.text);
       if (expandables.length === 0) {
@@ -35,7 +35,7 @@ export function WithDeepAnalysis<T extends Constructor>(Base: T) {
 
       const maxClicks = (this.explorer.getConfig().ai?.agents?.researcher as any)?.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})`);
       }
 
@@ -177,7 +177,14 @@ export function WithDeepAnalysis<T extends Constructor>(Base: T) {
         visionCall = this.provider.processImage(visionPrompt, screenshot.toString('base64'));
       }
 
-      const [textRes, visionRes] = await Promise.all([textCall, visionCall]);
+      let textRes: { text?: string } | null = null;
+      let visionRes: { text?: string } | null = 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<string>();
       const parseRefs = (text: string | undefined) => {
@@ -244,10 +251,16 @@ export function WithDeepAnalysis<T extends Constructor>(Base: T) {
       `;
 
       const model = this.provider.getModelForAgent('researcher');
-      const r = await this.provider.chat([{ role: 'user', content: prompt }], model, {
-        agentName: 'researcher',
-        telemetryFunctionId: 'researcher.selectExpandables',
-      });
+      let r: { text?: string };
+      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));

package/src/ai/researcher/parser.ts

@@ -64,6 +64,9 @@ export function mapRowToElement(row: Record<string, string>): ResearchElement |
 
   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 || '-');
 

package/src/ai/researcher.ts

@@ -121,10 +121,11 @@ export class Researcher extends ResearcherBase implements Agent {
 
     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();
@@ -150,10 +151,10 @@ export class Researcher extends ResearcherBase implements Agent {
       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;
         }
@@ -284,7 +285,11 @@ export class Researcher extends ResearcherBase implements Agent {
       }
 
       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) {
@@ -310,7 +315,7 @@ export class Researcher extends ResearcherBase implements Agent {
       }
 
       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) {
         const screenshotPath = outputPath('states', this.actionResult.screenshotFile);

package/src/ai/session-analyst.ts

@@ -120,6 +120,24 @@ export class SessionAnalyst implements Agent {
       .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}">
@@ -127,6 +145,12 @@ export class SessionAnalyst implements Agent {
       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/src/ai/tester.ts

@@ -118,7 +118,6 @@ export class Tester extends TaskAgent implements Agent {
     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;
@@ -678,7 +677,6 @@ export class Tester extends TaskAgent implements Agent {
     if (!task.hasFinished) {
       task.finish(TestResult.FAILED);
     }
-    tag('info').log(`Finished: ${task.scenario}`);
 
     if (task.isSuccessful) {
       tag('success').log(`Successful test: ${task.scenario}`);
@@ -882,7 +880,9 @@ export class Tester extends TaskAgent implements Agent {
             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/src/ai/tools.ts

@@ -854,12 +854,13 @@ export function createAgentTools({
       }),
       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: string | null = 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/src/commands/explore-command.ts

@@ -38,6 +38,11 @@ export class ExploreCommand extends BaseCommand {
   private oldTestRefs = new Set<Test>();
   private priorityFilter?: Set<string>;
 
+  private getCurrentPageUrl(): string | undefined {
+    const state = this.explorBot.getExplorer().getStateManager().getCurrentState();
+    return state?.fullUrl || state?.url;
+  }
+
   async execute(args: string): Promise<void> {
     const { opts, args: remaining } = this.parseArgs(args);
     if (opts.maxTests) {
@@ -51,7 +56,7 @@ export class ExploreCommand extends BaseCommand {
     if (this.dryRun) 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/src/components/LogPane.tsx

@@ -7,21 +7,32 @@ import { parseMarkdownToTerminal } from '../utils/markdown-terminal.js';
 
 import { Box, Text } from 'ink';
 import type { LogType, TaggedLogEntry } from '../utils/logger.js';
-import { isDebugMode, registerLogPane, setVerboseMode, unregisterLogPane } from '../utils/logger.js';
+import { isDebugMode, registerLogPane, unregisterLogPane } from '../utils/logger.js';
 
 // marked.use(new markedTerminal());
 
-type LogEntry = TaggedLogEntry;
+type LogEntry = TaggedLogEntry & { collapsedCount?: number };
 
 interface LogPaneProps {
   verboseMode: boolean;
 }
 
 const LogPane: React.FC<LogPaneProps> = React.memo(({ verboseMode }) => {
-  const [logs, setLogs] = useState<TaggedLogEntry[]>([]);
-  const pendingLogsRef = React.useRef<TaggedLogEntry[]>([]);
+  const [logs, setLogs] = useState<LogEntry[]>([]);
+  const pendingLogsRef = React.useRef<LogEntry[]>([]);
   const flushTimeoutRef = React.useRef<ReturnType<typeof setTimeout> | null>(null);
 
+  const MAX_MULTILINE_LINES = 16;
+  const MAX_STEP_LINES = 8;
+  const MAX_SUBSTEP_LINES = 6;
+
+  const formatCollapsedContent = useCallback((lines: string[], collapsedCount: number, label: string) => {
+    if (collapsedCount <= 0) {
+      return lines.join('\n');
+    }
+    return [`... ${collapsedCount} earlier ${label}`, ...lines].join('\n');
+  }, []);
+
   const flushLogs = useCallback(() => {
     if (pendingLogsRef.current.length === 0) return;
 
@@ -29,7 +40,7 @@ const LogPane: React.FC<LogPaneProps> = React.memo(({ verboseMode }) => {
     pendingLogsRef.current = [];
     flushTimeoutRef.current = null;
 
-    setLogs((prevLogs: TaggedLogEntry[]) => {
+    setLogs((prevLogs: LogEntry[]) => {
       const result = [...prevLogs];
 
       for (const logEntry of newLogs) {
@@ -43,12 +54,35 @@ const LogPane: React.FC<LogPaneProps> = React.memo(({ verboseMode }) => {
           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: TaggedLogEntry) => {
@@ -112,12 +146,11 @@ const LogPane: React.FC<LogPaneProps> = 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 (
         <Box key={index} borderStyle="classic" borderLeft={false} borderRight={false} marginY={1} padding={1} borderColor="dim" overflow="hidden">
           <Text color="gray" dimColor>
-            {parsed}
+            {truncated}
           </Text>
         </Box>
       );

package/src/config.ts

@@ -266,6 +266,7 @@ export class ConfigParser {
   private static instance: ConfigParser;
   private config: ExplorbotConfig | null = null;
   private configPath: string | null = null;
+  private runtimeBaseUrlOverride: string | null = null;
 
   private constructor() {}
 
@@ -285,8 +286,9 @@ export class ConfigParser {
   public async loadConfig(options?: {
     config?: string;
     path?: string;
+    baseUrl?: string;
   }): Promise<ExplorbotConfig> {
-    if (this.config && !options?.config && !options?.path) {
+    if (this.config && !options?.config && !options?.path && this.runtimeBaseUrlOverride === (options?.baseUrl || null)) {
       return this.config;
     }
 
@@ -317,7 +319,8 @@ export class ConfigParser {
         throw new Error('Configuration file is empty or invalid');
       }
 
-      this.config = this.resolveConfig(loadedConfig as ExplorbotConfig);
+      this.config = this.resolveConfig(loadedConfig as ExplorbotConfig, options);
+      this.runtimeBaseUrlOverride = options?.baseUrl || null;
       this.configPath = resolvedPath;
 
       log(`Configuration loaded from: ${resolvedPath}`);
@@ -372,6 +375,7 @@ export class ConfigParser {
     if (ConfigParser.instance) {
       ConfigParser.instance.config = null;
       ConfigParser.instance.configPath = null;
+      ConfigParser.instance.runtimeBaseUrlOverride = null;
     }
   }
 
@@ -455,11 +459,17 @@ export class ConfigParser {
     }
   }
 
-  private resolveConfig(config: ExplorbotConfig): ExplorbotConfig {
+  private resolveConfig(config: ExplorbotConfig, options?: { baseUrl?: string }): ExplorbotConfig {
     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;
   }
 

package/src/explorbot.ts

@@ -34,6 +34,7 @@ import { sanitizeFilename } from './utils/strings.ts';
 
 export interface ExplorBotOptions {
   from?: string;
+  baseUrl?: string;
   verbose?: boolean;
   config?: string;
   path?: string;

package/src/explorer.ts

@@ -8,6 +8,7 @@ import { createTest } from 'codeceptjs/lib/mocha/test';
 import { ActionResult } from './action-result.ts';
 import Action from './action.js';
 import { AIProvider } from './ai/provider.js';
+import type { BrowserContextOptions } from 'playwright';
 import { visuallyAnnotateContainers } from './ai/researcher/coordinates.ts';
 import { RequestStore } from './api/request-store.ts';
 import { XhrCapture } from './api/xhr-capture.ts';
@@ -238,7 +239,17 @@ 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: BrowserContextOptions = {
+      ...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/src/state-manager.ts

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

package/src/utils/url-matcher.ts

@@ -82,10 +82,13 @@ export function matchesUrl(pattern: string, path: string): boolean {
 }
 
 export function extractStatePath(url: string): string {
-  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/src/utils/web-element.ts

@@ -122,7 +122,8 @@ export class WebElement {
   }
 
   static async fromEidxList(page: any, eidxList: string[]): Promise<WebElement[]> {
-    if (eidxList.length === 0) return [];
+    const validEidxList = eidxList.filter((eidx) => /^e\d+$/i.test(eidx));
+    if (validEidxList.length === 0) return [];
 
     const rawList: RawElementData[] = await page.evaluate(
       ([list, extractFnStr, config]: [string[], string, ElementExtractionConfig]) => {
@@ -136,7 +137,7 @@ export class WebElement {
         }
         return results;
       },
-      [eidxList, getElementDataExtractorSource(), ELEMENT_EXTRACTION_CONFIG] as [string[], string, ElementExtractionConfig]
+      [validEidxList, getElementDataExtractorSource(), ELEMENT_EXTRACTION_CONFIG] as [string[], string, ElementExtractionConfig]
     );
 
     return rawList.map((d) => WebElement.fromRawData(d));