explorbot 0.1.5 → 0.1.7

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

@@ -3,10 +3,12 @@ import { ActionResult, type Diff } from '../../action-result.js';
 import type Explorer from '../../explorer.ts';
 import type { StateManager } from '../../state-manager.js';
 import { WebPageState } from '../../state-manager.js';
-import { diffAriaSnapshots } from '../../utils/aria.ts';
+import { detectFocusArea, diffAriaSnapshots } from '../../utils/aria.ts';
 import { executionController } from '../../execution-controller.ts';
 import { tag } from '../../utils/logger.js';
+import { mdq } from '../../utils/markdown-query.ts';
 import type { Provider } from '../provider.js';
+import { getCachedResearch, saveResearch } from './cache.ts';
 import { type Constructor, debugLog } from './mixin.ts';
 import { type ResearchElement, parseResearchSections } from './parser.ts';
 import type { ResearchResult } from './research-result.ts';
@@ -76,6 +78,55 @@ export function WithDeepAnalysis<T extends Constructor>(Base: T) {
       }
     }
 
+    async researchOverlay(current: ActionResult, previous: ActionResult, pageStateHash: string): Promise<string | null> {
+      const focusArea = detectFocusArea(current.ariaSnapshot);
+      if (!focusArea.detected || !focusArea.name) return null;
+      if (focusArea.type !== 'dialog' && focusArea.type !== 'modal') return null;
+
+      const cached = getCachedResearch(pageStateHash);
+      if (!cached) return null;
+
+      const escaped = focusArea.name.replace(/"/g, '\\"');
+      if (mdq(cached).query(`section3(~"${escaped}")`).count() > 0) {
+        debugLog(`Overlay "${focusArea.name}" already in cached research, skipping`);
+        return null;
+      }
+
+      const diff = await current.diff(previous);
+      await diff.calculate();
+
+      if (!diff.ariaChanged && diff.htmlParts.length === 0) {
+        debugLog(`No diff between current and previous state for overlay "${focusArea.name}"`);
+        return null;
+      }
+
+      const alreadyExpanded = this._summarizeExpanded(
+        parseResearchSections(cached)
+          .filter((s) => s.elements.length > 0)
+          .map((s) => s.rawMarkdown)
+      );
+
+      tag('substep').log(`Researching overlay: ${focusArea.name}`);
+      const sectionMarkdown = await this._analyzeExpandedAction('', focusArea.name, diff, alreadyExpanded);
+      if (!sectionMarkdown) {
+        debugLog(`Overlay "${focusArea.name}" produced no meaningful expansion`);
+        return null;
+      }
+
+      const extQuery = mdq(cached).query('section1(~"Extended Research")');
+      let updated: string;
+      if (extQuery.count() > 0) {
+        const existing = extQuery.text().trimEnd();
+        updated = extQuery.replace(`${existing}\n\n${sectionMarkdown}\n`);
+      } else {
+        updated = `${cached.trimEnd()}\n\n# Extended Research\n\n${sectionMarkdown}\n`;
+      }
+
+      saveResearch(pageStateHash, updated);
+      tag('substep').log(`Overlay research appended: ${focusArea.name}`);
+      return sectionMarkdown;
+    }
+
     private async _discoverExpandables(researchText: string): Promise<ExpandableElement[]> {
       const allElements = new Map<string, ExpandableElement>();
       for (const section of parseResearchSections(researchText)) {
@@ -314,8 +365,27 @@ export function WithDeepAnalysis<T extends Constructor>(Base: T) {
     private async _analyzeExpandedAction(code: string, description: string, diff: Diff, alreadyExpanded: string[]): Promise<string | null> {
       const alreadyHint = alreadyExpanded.length > 0 ? `\nAlready expanded sections:\n${alreadyExpanded.join('\n')}` : '';
 
+      let intro: string;
+      if (code) {
+        intro = `An action on "${description}" (\`${code}\`) revealed new UI content.`;
+      } else {
+        intro = `An overlay "${description}" appeared on the page.`;
+      }
+
+      let actionBlock = '';
+      if (code) {
+        actionBlock = dedent`
+          Action:
+
+          \`\`\`js
+          ${code}
+          \`\`\`
+
+        `;
+      }
+
       const prompt = dedent`
-        An action on "${description}" (\`${code}\`) revealed new UI content.
+        ${intro}
         Analyze the changes and produce a UI map section.
 
         ARIA changes:
@@ -329,13 +399,7 @@ export function WithDeepAnalysis<T extends Constructor>(Base: T) {
 
         ### <Short descriptive name>
 
-        Action:
-
-        \`\`\`js
-        ${code}
-        \`\`\`
-
-        <One sentence: what appeared — dropdown menu, modal, tab content, expanded panel, etc.>
+        ${actionBlock}<One sentence: what appeared — dropdown menu, modal, tab content, expanded panel, etc.>
 
         | Element | ARIA | CSS |
         |---------|------|-----|
@@ -409,4 +473,5 @@ interface ExpandableElement extends ResearchElement {
 
 export interface DeepAnalysisMethods {
   performDeepAnalysis(state: WebPageState, result: ResearchResult): Promise<void>;
+  researchOverlay(current: ActionResult, previous: ActionResult, pageStateHash: string): Promise<string | null>;
 }

package/src/ai/researcher/sections.ts

@@ -0,0 +1,122 @@
+import dedent from 'dedent';
+import type { ActionResult } from '../../action-result.js';
+import { executionController } from '../../execution-controller.ts';
+import type Explorer from '../../explorer.ts';
+import type { StateManager } from '../../state-manager.js';
+import { tag } from '../../utils/logger.js';
+import { RulesLoader } from '../../utils/rules-loader.ts';
+import type { Provider } from '../provider.js';
+import { locatorRule as generalLocatorRuleText } from '../rules.js';
+import type { Constructor } from './mixin.ts';
+
+export interface SectionMethods {
+  researchBySections(): Promise<string>;
+}
+
+export function WithSections<T extends Constructor>(Base: T) {
+  return class extends Base {
+    declare explorer: Explorer;
+    declare provider: Provider;
+    declare stateManager: StateManager;
+    declare actionResult: ActionResult | undefined;
+
+    async researchBySections(): Promise<string> {
+      const ariaSnapshot = this.actionResult?.getCompactARIA() || '';
+      const configured = (this as any).getConfiguredSections() as Record<string, string>;
+      const focusCss = await this._detectFocusCss();
+
+      let targets: Array<[string, string]>;
+      if (focusCss) {
+        targets = [['Focus', `element bounded by CSS container '${focusCss}'`]];
+        tag('info').log(`Focus element detected via selector '${focusCss}', researching focused area only`);
+      } else {
+        targets = Object.entries(configured);
+        tag('info').log(`Splitting research into ${targets.length} per-section requests`);
+      }
+
+      const parts: string[] = [];
+      for (const [name, description] of targets) {
+        if (executionController.isInterrupted()) break;
+        const text = await this._researchSingleSection(name, description, ariaSnapshot, focusCss);
+        if (!text) continue;
+        const trimmed = text.trim();
+        if (trimmed === 'NOT_PRESENT' || trimmed.startsWith('NOT_PRESENT')) continue;
+        parts.push(trimmed);
+      }
+
+      if (parts.length === 0) {
+        throw new Error('Per-section research produced no sections — AI responses all empty or NOT_PRESENT');
+      }
+
+      let merged = parts.join('\n\n');
+      if (focusCss) merged += '\n\n> Focused: Focus';
+      return merged;
+    }
+
+    private async _detectFocusCss(): Promise<string | null> {
+      const focusSections = (this.explorer.getConfig().ai?.agents?.researcher as any)?.focusSections as string[] | undefined;
+      if (!focusSections?.length) return null;
+
+      for (const css of focusSections) {
+        const count = await this.explorer.playwrightLocatorCount((page: any) => page.locator(css)).catch(() => 0);
+        if (count > 0) return css;
+      }
+      return null;
+    }
+
+    private async _researchSingleSection(name: string, description: string, ariaSnapshot: string, focusCss: string | null): Promise<string> {
+      const currentUrl = this.stateManager.getCurrentState()?.url || '';
+      const rules = RulesLoader.loadRules('researcher', ['ui-map-table', 'list-element', 'container-rules'], currentUrl);
+      const url = this.actionResult?.url || 'Unknown';
+      const title = this.actionResult?.title || 'Unknown';
+
+      let focusHint = '';
+      if (focusCss) {
+        focusHint = dedent`
+          The user's focus is the element matching CSS '${focusCss}'.
+          Use that CSS as the Container for this section.
+        `;
+      }
+
+      const prompt = dedent`
+        <task>
+        Identify the "${name}" section on this page: ${description}
+        If this section is NOT present on the page, respond with ONLY: NOT_PRESENT
+        Otherwise output only this single section in the format below.
+        ${focusHint}
+        </task>
+
+        <section_format>
+        ## ${name}
+
+        > Container: '.semantic-container-selector'
+
+        | Element | ARIA | CSS | eidx |
+        </section_format>
+
+        <rules>
+        - Every element with eidx MUST appear in the table.
+        - Every row needs CSS; ARIA may be "-" for icon-only buttons.
+        - ARIA locator JSON uses keys "role" and "text" (NOT "name").
+        </rules>
+
+        ${generalLocatorRuleText}
+
+        ${rules}
+
+        URL: ${url}
+        Title: ${title}
+
+        <aria>
+        ${ariaSnapshot}
+        </aria>
+      `;
+
+      const conversation = this.provider.startConversation((this as any).getSystemMessage(), 'researcher');
+      conversation.addUserText(prompt);
+
+      const result = await this.provider.invokeConversation(conversation, undefined, { agentName: 'researcher' });
+      return result?.response.text || '';
+    }
+  };
+}

package/src/ai/researcher.ts

@@ -28,6 +28,7 @@ import { detectFocusFromAria, hasFocusedSection, markSectionAsFocused, pickDefau
 import { type LocatorMethods, WithLocators } from './researcher/locators.ts';
 import { extractValidContainers, formatResearchSummary, parseResearchSections } from './researcher/parser.ts';
 import { ResearchResult } from './researcher/research-result.ts';
+import { type SectionMethods, WithSections } from './researcher/sections.ts';
 import { locatorRule as generalLocatorRuleText } from './rules.js';
 import { RulesLoader } from '../utils/rules-loader.ts';
 import { TaskAgent } from './task-agent.ts';
@@ -46,9 +47,9 @@ export const POSSIBLE_SECTIONS = {
   navigation: 'main navigation (top bar, sidebar, breadcrumbs)',
 };
 
-const ResearcherBase = WithDeepAnalysis(WithCoordinates(WithLocators(TaskAgent as unknown as new (...args: any[]) => TaskAgent)));
+const ResearcherBase = WithSections(WithDeepAnalysis(WithCoordinates(WithLocators(TaskAgent as unknown as new (...args: any[]) => TaskAgent))));
 
-export interface Researcher extends LocatorMethods, CoordinateMethods, DeepAnalysisMethods {}
+export interface Researcher extends LocatorMethods, CoordinateMethods, DeepAnalysisMethods, SectionMethods {}
 
 export class Researcher extends ResearcherBase implements Agent {
   protected readonly ACTION_TOOLS = ['click'];
@@ -170,10 +171,12 @@ export class Researcher extends ResearcherBase implements Agent {
       const prompt = await this.buildResearchPrompt();
       conversation.addUserText(prompt);
 
-      let invocationResult: Awaited<ReturnType<typeof this.provider.invokeConversation>>;
+      let researchText: string;
       let activeConversation = conversation;
       try {
-        invocationResult = await this.provider.invokeConversation(conversation, undefined, { agentName: 'researcher' });
+        const invocationResult = await this.provider.invokeConversation(conversation, undefined, { agentName: 'researcher' });
+        if (!invocationResult) throw new Error('Failed to get response from provider');
+        researchText = invocationResult.response.text;
       } catch (error) {
         if (!(error instanceof ContextLengthError) || retriesLeft <= 0) {
           if (error instanceof ContextLengthError) {
@@ -181,15 +184,12 @@ export class Researcher extends ResearcherBase implements Agent {
           }
           throw error;
         }
-        tag('warning').log('Output truncated, retrying with fresh focused conversation (ARIA only)...');
         retriesLeft = 0;
+        researchText = await this.researchBySections();
         activeConversation = this.provider.startConversation(this.getSystemMessage(), 'researcher');
-        activeConversation.addUserText(this.buildFocusedRetryPrompt());
-        invocationResult = await this.provider.invokeConversation(activeConversation, undefined, { agentName: 'researcher' });
       }
-      if (!invocationResult) throw new Error('Failed to get response from provider');
 
-      const result = new ResearchResult(invocationResult.response.text, state.url);
+      const result = new ResearchResult(researchText, state.url);
       debugLog(`Original research response length: ${result.text.length} chars`);
 
       const interrupted = () => executionController.isInterrupted();
@@ -537,44 +537,6 @@ export class Researcher extends ResearcherBase implements Agent {
     `;
   }
 
-  private buildFocusedRetryPrompt(): string {
-    const currentUrl = this.stateManager.getCurrentState()?.url || '';
-    const example = RulesLoader.loadRules('researcher', ['section-example'], currentUrl);
-    const uiMapTable = RulesLoader.loadRules('researcher', ['ui-map-table'], currentUrl);
-    const url = this.actionResult?.url || 'Unknown';
-    const title = this.actionResult?.title || 'Unknown';
-    const aria = this.actionResult?.getCompactARIA() || '';
-    return dedent`
-      Previous response was truncated. Restart with a minimal output.
-
-      <task>
-      Output a UI map for ONE section only — the main interactive area of this page.
-      Skip navigation, sidebar, and footer. Max 15 elements.
-      Every element with an eidx MUST appear. Every row needs CSS; ARIA may be "-" for icon-only.
-      End with a single line: \`> Focused: <section name>\`.
-      </task>
-
-      <section_format>
-      ## Section Name
-
-      > Container: '.container-css-selector'
-
-      | Element | ARIA | CSS | eidx |
-      </section_format>
-
-      ${example}
-
-      ${uiMapTable}
-
-      URL: ${url}
-      Title: ${title}
-
-      <aria>
-      ${aria}
-      </aria>
-    `;
-  }
-
   async textContent(state: WebPageState): Promise<string> {
     const actionResult = ActionResult.fromState(state);
     const html = await actionResult.combinedHtml();

package/src/ai/rules.ts

@@ -135,7 +135,15 @@ export const fileUploadRule = dedent`
 export const protectionRule = dedent`
   <important>
   Do not sign out current user of the application.
-  Do not change current user account settings
+  Do not change current user account settings.
+
+  Pre-existing data on the page belongs to the application, not the test.
+  Items that were not created inside the current test scenario must not be deleted, removed, emptied, reset, archived, or otherwise destroyed.
+  If a scenario needs to verify destructive behaviour, the same scenario must first create a disposable target and then destroy that specific target — never operate on data that was already there when the test started.
+
+  The resource that the current page URL represents is "under test".
+  The test must not destroy the resource it is running against — doing so invalidates every subsequent scenario that starts on the same URL.
+  Do not propose or perform delete/remove/archive actions on the entity that owns the current URL; propose such actions only on disposable children created within the scenario itself.
   </important>
 `;
 

package/src/ai/task-agent.ts

@@ -1,6 +1,6 @@
 import dedent from 'dedent';
 import type { ActionResult } from '../action-result.js';
-import type { ExperienceTracker } from '../experience-tracker.js';
+import { renderExperienceToc, type ExperienceTracker } from '../experience-tracker.js';
 import type { KnowledgeTracker } from '../knowledge-tracker.js';
 import { createDebug, pluralize, tag } from '../utils/logger.js';
 
@@ -56,37 +56,13 @@ export abstract class TaskAgent {
 
   protected getExperience(actionResult: ActionResult): string {
     const tracker = this.getExperienceTracker();
-    const relevantExperience = tracker.getRelevantExperience(actionResult);
+    const toc = tracker.getExperienceTableOfContents(actionResult);
+    if (toc.length === 0) return '';
 
-    if (relevantExperience.length === 0) return '';
-
-    const allContent = relevantExperience
-      .map((e) => e.content)
-      .filter((e) => !!e)
-      .join('\n\n---\n\n');
-
-    const totalChars = allContent.length;
-    let experienceContent: string;
-
-    if (totalChars <= 10_000) {
-      debugLog(`injecting all experience (${Math.round(totalChars / 1000)}k chars)`);
-      experienceContent = allContent;
-    } else {
-      experienceContent = tracker.getSuccessfulExperience(actionResult).join('\n\n---\n\n');
-      debugLog(`injecting success-only experience (${Math.round(experienceContent.length / 1000)}k chars, filtered from ${Math.round(totalChars / 1000)}k)`);
-    }
-
-    if (!experienceContent) return '';
-
-    tag('substep').log(`Found ${relevantExperience.length} experience ${pluralize(relevantExperience.length, 'file')}`);
-    return dedent`
-      <experience>
-      Here is past experience of interacting with this page.
-      Use successful solutions first. Avoid repeating failed actions.
-
-      ${experienceContent}
-      </experience>
-    `;
+    const totalSections = toc.reduce((sum, entry) => sum + entry.sections.length, 0);
+    debugLog(`injecting experience TOC (${toc.length} files, ${totalSections} sections)`);
+    tag('substep').log(`Found ${toc.length} experience ${pluralize(toc.length, 'file')} (${totalSections} sections)`);
+    return renderExperienceToc(toc);
   }
 
   setHistorian(historian: Historian): void {

package/src/ai/tester.ts

@@ -11,19 +11,19 @@ import type Explorer from '../explorer.ts';
 import type { StateTransition, WebPageState } from '../state-manager.ts';
 import { Stats } from '../stats.ts';
 import { type Note, type Test, TestResult, type TestResultType } from '../test-plan.ts';
-import { extractFocusedElement } from '../utils/aria.ts';
+import { detectFocusArea, extractFocusedElement } from '../utils/aria.ts';
 import { HooksRunner } from '../utils/hooks-runner.ts';
 import { codeToMarkdown } from '../utils/html.ts';
 import { createDebug, tag } from '../utils/logger.ts';
 import { loop } from '../utils/loop.ts';
 import type { Agent } from './agent.ts';
+import type { Captain } from './captain.ts';
 import type { Conversation } from './conversation.ts';
 import { Navigator } from './navigator.ts';
-import type { Captain } from './captain.ts';
 import type { Pilot } from './pilot.ts';
 import { Provider } from './provider.ts';
 import { Researcher } from './researcher.ts';
-import { actionRule, focusedElementRule, locatorRule, multipleTabsRule, sectionContextRule } from './rules.ts';
+import { actionRule, focusedElementRule, locatorRule, multipleTabsRule, protectionRule, sectionContextRule } from './rules.ts';
 import { TaskAgent } from './task-agent.ts';
 import { createCodeceptJSTools, createSpecialContextTools } from './tools.ts';
 
@@ -59,6 +59,8 @@ export class Tester extends TaskAgent implements Agent {
   executionLogFile: string | null = null;
   private previousUrl: string | null = null;
   private previousStateHash: string | null = null;
+  private pageStateHash: string | null = null;
+  private pageActionResult: ActionResult | null = null;
   private hooksRunner: HooksRunner;
 
   constructor(explorer: Explorer, provider: Provider, researcher: Researcher, navigator: Navigator, agentTools?: any) {
@@ -117,10 +119,29 @@ export class Tester extends TaskAgent implements Agent {
 
     this.previousUrl = null;
     this.previousStateHash = null;
+    this.pageStateHash = null;
+    this.pageActionResult = null;
     this.explorer.getStateManager().clearHistory();
     this.resetFailureCount();
     this.pilot?.reset();
 
+    const requestStore = this.explorer.getRequestStore();
+    requestStore?.clear();
+    const offFailedRequest = requestStore?.onFailedRequest((r) => {
+      task.addNote(`Network error: ${r.method} ${r.path} → ${r.status}`, TestResult.FAILED);
+    });
+
+    const page = this.explorer.playwrightHelper?.page;
+    const onPageError = (err: Error) => {
+      task.addNote(`Console error: ${err.message}`, TestResult.FAILED);
+    };
+    const onConsoleMessage = (msg: any) => {
+      if (msg.type() !== 'error') return;
+      task.addNote(`Console error: ${msg.text()}`, TestResult.FAILED);
+    };
+    page?.on('pageerror', onPageError);
+    page?.on('console', onConsoleMessage);
+
     const initialState = ActionResult.fromState(state);
 
     const conversation = this.provider.startConversation(this.getSystemMessage(), 'tester');
@@ -351,6 +372,9 @@ export class Tester extends TaskAgent implements Agent {
     await this.getQuartermaster().analyzeSession(task, initialState, conversation);
 
     offStateChange();
+    offFailedRequest?.();
+    page?.off('pageerror', onPageError);
+    page?.off('console', onConsoleMessage);
     await this.finishTest(task);
     await this.explorer.stopTest(task, {
       startUrl: task.startUrl,
@@ -441,7 +465,8 @@ export class Tester extends TaskAgent implements Agent {
 
     if (isNewUrl) {
       const research = await this.researcher.research(currentState);
-      const experience = this.getExperience(currentState);
+      this.pageStateHash = currentStateHash;
+      this.pageActionResult = currentState;
       let uiMapSection = '';
       if (research) {
         uiMapSection = dedent`
@@ -467,8 +492,6 @@ export class Tester extends TaskAgent implements Agent {
         </page_aria>
         ${uiMapSection}
 
-        ${experience}
-
         Use <page_ui_map> to understand the page structure and its main elements.
         However, <page_ui_map> is not always up to date, use <page_aria> and <page_html> to understand the ACTUAL state of the page
         Do not interact with elements that are not listed in <page_aria> and <page_html>
@@ -477,6 +500,19 @@ export class Tester extends TaskAgent implements Agent {
       return context;
     }
 
+    const focusArea = detectFocusArea(currentState.ariaSnapshot);
+    if (focusArea.detected && focusArea.name && this.pageStateHash && this.pageActionResult) {
+      const overlaySection = await this.researcher.researchOverlay(currentState, this.pageActionResult, this.pageStateHash);
+      if (overlaySection) {
+        context += dedent`
+
+          <page_ui_map_overlay>
+          ${overlaySection}
+          </page_ui_map_overlay>
+        `;
+      }
+    }
+
     // if (isStateChanged) {
     //   const combinedHtml = await currentState.combinedHtml();
     //   context += dedent`
@@ -675,6 +711,8 @@ export class Tester extends TaskAgent implements Agent {
       When creating or editing items via form() or type() you should include ${task.sessionName} in the value (if it is not restricted by the application logic)
       Initial page URL: ${actionResult.url}
 
+      ${protectionRule}
+
       ${this.buildDeletionScope(task)}
 
       ${this.buildAvailableFiles()}

package/src/ai/tools.ts

@@ -2,6 +2,7 @@ import { tool } from 'ai';
 import dedent from 'dedent';
 import { z } from 'zod';
 import { ActionResult, type ToolResultMetadata } from '../action-result.ts';
+import type { ExperienceTracker } from '../experience-tracker.ts';
 import type Explorer from '../explorer.ts';
 import { type Task, TestResult } from '../test-plan.js';
 import { extractFocusedElement } from '../utils/aria.ts';
@@ -449,14 +450,18 @@ export function createAgentTools({
   explorer,
   researcher,
   navigator,
+  experienceTracker,
+  getState,
 }: {
   explorer: Explorer;
   researcher: Researcher;
   navigator: Navigator;
+  experienceTracker?: ExperienceTracker;
+  getState?: () => ActionResult | null;
 }): any {
   let visionDisabled = false;
 
-  return {
+  const tools: Record<string, any> = {
     see: tool({
       description: dedent`
         Check the page contents based on current page state and screenshot.
@@ -947,6 +952,33 @@ export function createAgentTools({
       },
     }),
   };
+
+  if (experienceTracker && getState) {
+    tools.learn_experience = tool({
+      description: dedent`
+        Read the full body of a specific experience section listed in <experience>.
+        The TOC shows entries like "A.1 ## Successful Flow: ...". Pass the fileTag and sectionIndex.
+        Only call when a TOC entry looks directly relevant to the current step.
+      `,
+      inputSchema: z.object({
+        fileTag: z.string().describe('File tag from the TOC, e.g. "A", "B", "AA"'),
+        sectionIndex: z.number().int().positive().describe('1-based section index within that file'),
+      }),
+      execute: async ({ fileTag, sectionIndex }) => {
+        const state = getState();
+        if (!state) {
+          return { error: 'No current page state available.' };
+        }
+        const section = experienceTracker.getExperienceSection(fileTag, sectionIndex, state);
+        if (!section) {
+          return { error: 'Section not found. Experience may have been updated; re-read the latest TOC.' };
+        }
+        return section;
+      },
+    });
+  }
+
+  return tools;
 }
 
 const PAGE_DIFF_SUGGESTION = 'Analyze page diff. htmlParts shows what changed and WHERE — each part has a container selector. Use the container as context when clicking elements from the diff.';

package/src/commands/explore-command.ts

@@ -1,8 +1,6 @@
-import { existsSync, readdirSync } from 'node:fs';
 import figureSet from 'figures';
 import path from 'node:path';
 import { getStyles } from '../ai/planner/styles.js';
-import { ConfigParser } from '../config.ts';
 import { getCliName } from '../utils/cli-name.ts';
 import type { Plan } from '../test-plan.js';
 import { jsonToTable } from '../utils/markdown-parser.js';
@@ -116,14 +114,11 @@ export class ExploreCommand extends BaseCommand {
   }
 
   private printRerunSuggestions(): void {
-    const testsDir = ConfigParser.getInstance().getTestsDir();
-    if (!existsSync(testsDir)) return;
+    const savedFiles = this.explorBot.agentHistorian().getSavedFiles();
+    if (savedFiles.length === 0) return;
 
-    const testFiles = readdirSync(testsDir).filter((f) => f.endsWith('.js'));
-    if (testFiles.length === 0) return;
-
-    for (const file of testFiles) {
-      tag('info').log(`Generated: ${file}`);
+    for (const filePath of savedFiles) {
+      tag('info').log(`Generated: ${path.basename(filePath)}`);
     }
     tag('info').log(`List tests: ${getCliName()} runs`);
     tag('info').log(`Re-run with healing: ${getCliName()} rerun <filename> [index]`);

package/src/config.ts

@@ -69,6 +69,7 @@ interface ResearcherAgentConfig extends AgentConfig {
   maxExpandableClicks?: number;
   retries?: number;
   sections?: string[];
+  focusSections?: string[];
   errorPageTimeout?: number;
 }