explorbot 0.1.32-beta.1 → 0.2.1

package/src/ai/conversation.ts

@@ -7,6 +7,12 @@ export interface ToolExecution {
   wasSuccessful: boolean;
 }
 
+export function toToolExecution(toolName: string, input: any, rawOutput: any): ToolExecution {
+  let output = rawOutput;
+  if (rawOutput?.type === 'json' && rawOutput?.value) output = rawOutput.value;
+  return { toolName, input, output, wasSuccessful: output?.success !== false };
+}
+
 export function toolExecutionLabel(input: Record<string, any> | undefined): string {
   return input?.explanation || input?.assertion || input?.reason || input?.request || '';
 }
@@ -15,18 +21,14 @@ const AUTO_COMPACT_ARIA_CHANGES_CUTOFF = 500;
 const AUTO_COMPACT_TARGETED_HTML_CUTOFF = 500;
 
 export class Conversation {
-  id: string;
   messages: ModelMessage[];
   model: any;
-  telemetryFunctionId?: string;
   protectedPrefixCount = 0;
   private autoTrimRules: Map<string, number>;
 
-  constructor(messages: ModelMessage[] = [], model?: any, telemetryFunctionId?: string) {
-    this.id = this.generateId();
+  constructor(messages: ModelMessage[] = [], model?: any) {
     this.messages = messages;
     this.model = model || '';
-    this.telemetryFunctionId = telemetryFunctionId;
     this.autoTrimRules = new Map();
   }
 
@@ -41,20 +43,6 @@ export class Conversation {
     });
   }
 
-  addUserImage(image: string): void {
-    if (!image || image.trim() === '') {
-      console.warn('Warning: Attempting to add empty image to conversation');
-      return;
-    }
-
-    const imageData = image.startsWith('data:') ? image : `data:image/png;base64,${image}`;
-
-    this.messages.push({
-      role: 'user',
-      content: [{ type: 'file', mediaType: 'image/png', data: imageData }],
-    });
-  }
-
   addAssistantText(text: string): void {
     // Skip empty or whitespace-only messages
     if (!text || text.trim() === '') {
@@ -83,7 +71,7 @@ export class Conversation {
   }
 
   clone(): Conversation {
-    return new Conversation([...this.messages], this.model, this.telemetryFunctionId);
+    return new Conversation([...this.messages], this.model);
   }
 
   cleanupTag(tagName: string, replacement: string, keepLast = 0): void {
@@ -222,10 +210,6 @@ export class Conversation {
     return result;
   }
 
-  private generateId(): string {
-    return `conv_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
-
   getToolExecutions(): ToolExecution[] {
     const toolCalls = new Map<string, any>();
     for (const message of this.messages) {
@@ -243,14 +227,7 @@ export class Conversation {
       if (!Array.isArray(message.content)) continue;
       for (const part of message.content) {
         if (part.type !== 'tool-result') continue;
-        const rawOutput = part.output as Record<string, any>;
-        const output = rawOutput?.type === 'json' && rawOutput?.value ? rawOutput.value : rawOutput;
-        executions.push({
-          toolName: part.toolName,
-          input: toolCalls.get(part.toolCallId) || {},
-          output,
-          wasSuccessful: output?.success !== false,
-        });
+        executions.push(toToolExecution(part.toolName, toolCalls.get(part.toolCallId) || {}, part.output));
       }
     }
 

package/src/ai/driller.ts

@@ -3,13 +3,9 @@ import dedent from 'dedent';
 import { z } from 'zod';
 import { ActionResult } from '../action-result.ts';
 import { setActivity } from '../activity.ts';
-import type { ExperienceTracker } from '../experience-tracker.ts';
-import type Explorer from '../explorer.ts';
-import type { KnowledgeTracker } from '../knowledge-tracker.ts';
 import { Observability } from '../observability.ts';
 import { Plan, Test, TestResult } from '../test-plan.ts';
 import { collectInteractiveNodes } from '../utils/aria.ts';
-import { HooksRunner } from '../utils/hooks-runner.ts';
 import {
   EXPLORBOT_ATTRS,
   HTML_COMPOSITE_AREA_HINTS,
@@ -26,12 +22,13 @@ import {
 } from '../utils/html.ts';
 import { createDebug, tag } from '../utils/logger.ts';
 import { loop, pause } from '../utils/loop.ts';
+import { annotatePageElements } from '../utils/web-annotate.ts';
+import { eidxInContainer } from '../utils/web-eidx.ts';
 import { WebElement } from '../utils/web-element.ts';
-import type { Agent } from './agent.ts';
-import type { Conversation } from './conversation.ts';
+import type { Agent, AgentDeps } from './agent.ts';
 import type { Navigator } from './navigator.ts';
 import type { Provider } from './provider.ts';
-import { locatorRule } from './rules.ts';
+import { drillLocatorRule } from './rules.ts';
 import { TaskAgent, isInteractive } from './task-agent.ts';
 import { createCodeceptJSTools } from './tools.ts';
 
@@ -80,44 +77,25 @@ interface DrillOptions {
 export class Driller extends TaskAgent implements Agent {
   protected readonly ACTION_TOOLS = ['click', 'pressKey', 'form'];
   emoji = 'D';
-  private explorer: Explorer;
-  private provider: Provider;
   private navigator: Navigator;
-  private hooksRunner: HooksRunner;
   private currentPlan?: Plan;
-  private currentConversation: Conversation | null = null;
   private allResults: InteractionResult[] = [];
   private verifiedAction: { componentId: string; toolName: string; code?: string; canonicalCode?: string } | null = null;
   private pendingNestedContext: string | null = null;
 
   MAX_COMPONENT_ITERATIONS = 12;
 
-  constructor(explorer: Explorer, provider: Provider, navigator: Navigator) {
-    super();
-    this.explorer = explorer;
-    this.provider = provider;
+  constructor(deps: AgentDeps, navigator: Navigator) {
+    super(deps);
     this.navigator = navigator;
-    this.hooksRunner = new HooksRunner(explorer, explorer.getConfig());
   }
 
   protected getNavigator(): Navigator {
     return this.navigator;
   }
 
-  protected getExperienceTracker(): ExperienceTracker {
-    return this.explorer.getStateManager().getExperienceTracker();
-  }
-
-  protected getKnowledgeTracker(): KnowledgeTracker {
-    return this.explorer.getKnowledgeTracker();
-  }
-
-  protected getProvider(): Provider {
-    return this.provider;
-  }
-
   getSystemMessage(component?: ComponentInfo): string {
-    const currentUrl = this.explorer.getStateManager().getCurrentState()?.url;
+    const currentUrl = this.stateManager.getCurrentState()?.url;
     const customPrompt = this.provider.getSystemPromptForAgent('driller', currentUrl);
 
     return dedent`
@@ -161,7 +139,7 @@ export class Driller extends TaskAgent implements Agent {
 
   async drill(opts: DrillOptions = {}): Promise<Plan> {
     const { knowledgePath, maxComponents = 30, interactive = isInteractive() } = opts;
-    const currentState = this.explorer.getStateManager().getCurrentState();
+    const currentState = this.stateManager.getCurrentState();
     if (!currentState) throw new Error('No page state available');
 
     const sessionName = `driller_${Date.now().toString(36)}`;
@@ -209,15 +187,15 @@ export class Driller extends TaskAgent implements Agent {
 
   private async captureAnnotatedState(): Promise<ActionResult> {
     setActivity(`${this.emoji} Capturing annotated page state...`, 'action');
-    const action = this.explorer.createAction();
+    const action = this.explorer.action();
     try {
       const annotated = await Promise.race([
-        this.explorer.annotateElements(),
+        this.explorer.withPage(annotatePageElements),
         new Promise<never>((_, reject) => {
           setTimeout(() => reject(new Error('annotateElements timeout')), 15000);
         }),
       ]);
-      return action.capturePageState({ ariaSnapshot: annotated.ariaSnapshot });
+      return action.capturePageState();
     } catch (error) {
       tag('warning').log(`Annotated capture failed, falling back to plain page state: ${error instanceof Error ? error.message : error}`);
       return action.capturePageState();
@@ -228,9 +206,10 @@ export class Driller extends TaskAgent implements Agent {
 
   private async collectComponents(state: ActionResult, maxComponents: number): Promise<ComponentInfo[]> {
     setActivity(`${this.emoji} Collecting components...`, 'action');
-    const page = this.explorer.playwrightHelper.page;
-    const eidxList = await this.explorer.getEidxInContainer(null);
-    const webElements = await WebElement.fromEidxList(page, eidxList);
+    const webElements = await this.explorer.withPage(async (page) => {
+      const eidxList = await eidxInContainer(page, null);
+      return WebElement.fromEidxList(page, eidxList);
+    });
     const ariaNodes = collectInteractiveNodes(state.ariaSnapshot);
     const scored = webElements
       .filter((element) => isDrillableElement(element))
@@ -323,11 +302,10 @@ export class Driller extends TaskAgent implements Agent {
     this.verifiedAction = null;
     this.pendingNestedContext = null;
     const conversation = this.provider.startConversation(this.getSystemMessage(component), 'driller');
-    this.currentConversation = conversation;
     conversation.addUserText(await this.buildComponentPrompt(originalState, component));
 
     let finished = false;
-    const actionTools = this.createVerifiedActionTools(createCodeceptJSTools(this.explorer, test), component);
+    const actionTools = this.createVerifiedActionTools(createCodeceptJSTools(this.toolDeps, test), component);
     const tools = { ...actionTools, ...this.createDrillFlowTools(originalState, test, interactive) };
 
     await loop(
@@ -336,7 +314,7 @@ export class Driller extends TaskAgent implements Agent {
         setActivity(`${this.emoji} Drilling ${component.name}...`, 'action');
 
         if (iteration > 1) {
-          const currentState = ActionResult.fromState(this.explorer.getStateManager().getCurrentState() || originalState);
+          const currentState = ActionResult.fromState(this.stateManager.getCurrentState() || originalState);
           conversation.addUserText(await this.buildContextUpdate(currentState, component));
           if (this.pendingNestedContext) {
             conversation.addUserText(this.pendingNestedContext);
@@ -580,7 +558,7 @@ export class Driller extends TaskAgent implements Agent {
         execute: async ({ reason }) => {
           await this.restoreOriginalState(originalState, reason);
           await this.captureAnnotatedState();
-          const currentState = this.explorer.getStateManager().getCurrentState();
+          const currentState = this.stateManager.getCurrentState();
           return { success: true, url: currentState?.url || originalState.url };
         },
       }),
@@ -601,16 +579,16 @@ export class Driller extends TaskAgent implements Agent {
   }
 
   private async restoreOriginalState(originalState: ActionResult, reason: string): Promise<void> {
-    const currentState = this.explorer.getStateManager().getCurrentState();
+    const currentState = this.stateManager.getCurrentState();
     const targetUrl = originalState.fullUrl || originalState.url;
-    const action = this.explorer.createAction();
+    const action = this.explorer.action();
 
     if (currentState?.url !== originalState.url) {
-      await action.attempt(`I.amOnPage(${JSON.stringify(targetUrl)})`, `${reason} (restore URL)`, false);
+      await action.attempt(`I.amOnPage(${JSON.stringify(targetUrl)})`, `${reason} (restore URL)`);
       return;
     }
 
-    await action.attempt('I.pressKey("Escape")', `${reason} (restore state)`, false);
+    await action.attempt('I.pressKey("Escape")', `${reason} (restore state)`);
   }
 
   private async saveToExperience(state: ActionResult, results: InteractionResult[]): Promise<void> {
@@ -668,7 +646,7 @@ export class Driller extends TaskAgent implements Agent {
     const overlayHtml = await this.getVisibleOverlayHtml();
     if (!overlayHtml) return null;
 
-    const state = this.explorer.getStateManager().getCurrentState();
+    const state = this.stateManager.getCurrentState();
     if (!state) return null;
     const currentState = ActionResult.fromState(state);
     return dedent`
@@ -689,40 +667,42 @@ export class Driller extends TaskAgent implements Agent {
   }
 
   private async getVisibleOverlayHtml(): Promise<string> {
-    const page = this.explorer.playwrightHelper.page;
-    return page.evaluate(
-      ({ extractorSource, config }) => {
-        const extract = new Function(`return ${extractorSource}`)() as (config: any) => string;
-        return extract(config);
-      },
-      {
-        extractorSource: getVisibleOverlayHtmlExtractorSource(),
-        config: {
-          interactiveContentSelector: HTML_SELECTORS.interactiveContent,
-          limits: HTML_EXTRACTION_LIMITS,
-          overlaySelectors: HTML_SELECTORS.semanticOverlays,
-          visibilityLimits: HTML_VISIBILITY_LIMITS,
+    return this.explorer.withPage((page) =>
+      page.evaluate(
+        ({ extractorSource, config }) => {
+          const extract = new Function(`return ${extractorSource}`)() as (config: any) => string;
+          return extract(config);
         },
-      }
+        {
+          extractorSource: getVisibleOverlayHtmlExtractorSource(),
+          config: {
+            interactiveContentSelector: HTML_SELECTORS.interactiveContent,
+            limits: HTML_EXTRACTION_LIMITS,
+            overlaySelectors: HTML_SELECTORS.semanticOverlays,
+            visibilityLimits: HTML_VISIBILITY_LIMITS,
+          },
+        }
+      )
     );
   }
 
   private async getComponentScopeHtml(component: ComponentInfo, originalState: ActionResult): Promise<string> {
-    const page = this.explorer.playwrightHelper.page;
-    const scopedHtml = await page.evaluate(
-      ({ eidx, extractorSource, config }) => {
-        const extract = new Function(`return ${extractorSource}`)() as (eidx: string, config: any) => string;
-        return extract(eidx, config);
-      },
-      {
-        eidx: component.eidx,
-        extractorSource: getComponentScopeHtmlExtractorSource(),
-        config: {
-          eidxAttr: EXPLORBOT_ATTRS.eidx,
-          interactiveControlSelector: HTML_SELECTORS.interactiveControl,
-          limits: HTML_EXTRACTION_LIMITS,
+    const scopedHtml = await this.explorer.withPage((page) =>
+      page.evaluate(
+        ({ eidx, extractorSource, config }) => {
+          const extract = new Function(`return ${extractorSource}`)() as (eidx: string, config: any) => string;
+          return extract(eidx, config);
         },
-      }
+        {
+          eidx: component.eidx,
+          extractorSource: getComponentScopeHtmlExtractorSource(),
+          config: {
+            eidxAttr: EXPLORBOT_ATTRS.eidx,
+            interactiveControlSelector: HTML_SELECTORS.interactiveControl,
+            limits: HTML_EXTRACTION_LIMITS,
+          },
+        }
+      )
     );
 
     if (scopedHtml) return scopedHtml;
@@ -789,14 +769,6 @@ export class Driller extends TaskAgent implements Agent {
       tag('step').log(`  ${status} ${componentTest.component?.name || test.scenario}`);
     }
   }
-
-  getCurrentPlan(): Plan | undefined {
-    return this.currentPlan;
-  }
-
-  getConversation(): Conversation | null {
-    return this.currentConversation;
-  }
 }
 
 function formatAriaNode(node: Record<string, unknown>): string {
@@ -1190,5 +1162,3 @@ function isInteractiveElement(element: WebElement): boolean {
   if (element.attrs['aria-haspopup'] || element.attrs['aria-expanded'] || element.attrs['aria-controls']) return true;
   return false;
 }
-
-const drillLocatorRule = locatorRule.replace(/<context_simplification>[\s\S]*?<\/context_simplification>/, '').trim();

package/src/ai/experience-compactor.ts

@@ -1,18 +1,19 @@
 import { unlinkSync } from 'node:fs';
+import { basename } from 'node:path';
 import dedent from 'dedent';
-import { type Tokens, marked } from 'marked';
 import { z } from 'zod';
 import { type ExperienceFile, type ExperienceTracker, RECENT_WINDOW_DAYS } from '../experience-tracker.js';
 import { Observability } from '../observability.js';
 import { createDebug, log, tag } from '../utils/logger.js';
 import { mdq } from '../utils/markdown-query.js';
+import { isNonReusableCode } from '../utils/step-analyzer.js';
 import { generalizeUrl, hasDynamicUrlSegment } from '../utils/url-matcher.js';
 import type { Agent } from './agent.js';
 import type { Provider } from './provider.js';
 
 const debugLog = createDebug('explorbot:experience-compactor');
 
-export type { ExperienceFile };
+export const COMPACT_MAX_LENGTH = 5000;
 
 interface MergeGroup {
   pattern: string;
@@ -23,7 +24,6 @@ export class ExperienceCompactor implements Agent {
   emoji = '🗜️';
   private provider: Provider;
   private experienceTracker: ExperienceTracker;
-  private MAX_LENGTH = 5000;
 
   constructor(provider: Provider, experienceTracker: ExperienceTracker) {
     this.provider = provider;
@@ -32,7 +32,7 @@ export class ExperienceCompactor implements Agent {
 
   async compactExperience(experience: string): Promise<string> {
     const stripped = this.stripNonUsefulEntries(experience);
-    if (stripped.length < this.MAX_LENGTH) {
+    if (stripped.length < COMPACT_MAX_LENGTH) {
       return stripped;
     }
 
@@ -129,7 +129,7 @@ export class ExperienceCompactor implements Agent {
       if (!url || url.startsWith('~')) continue;
       const generalized = generalizeUrl(url);
       if (generalized === url) continue;
-      const stateHash = file.filePath.split('/').pop()?.replace('.md', '') || '';
+      const stateHash = basename(file.filePath, '.md');
       const newData = { ...file.data, url: `~${generalized}~`, mergedFrom: [url] };
       this.experienceTracker.writeExperienceFile(stateHash, file.content, newData);
       tag('substep').log(`Generalized URL: ${url} → ~${generalized}~`);
@@ -139,7 +139,7 @@ export class ExperienceCompactor implements Agent {
   }
 
   async compactFiles(files: ExperienceFile[], options?: { skipSmall?: boolean }): Promise<number> {
-    const workingSet = options?.skipSmall ? files.filter((f) => f.content.length >= this.MAX_LENGTH) : files;
+    const workingSet = options?.skipSmall ? files.filter((f) => f.content.length >= COMPACT_MAX_LENGTH) : files;
 
     let compactedCount = 0;
     const total = workingSet.length;
@@ -151,7 +151,7 @@ export class ExperienceCompactor implements Agent {
 
     for (let i = 0; i < workingSet.length; i++) {
       const experience = workingSet[i];
-      const shortName = experience.filePath.split('/').pop() || experience.filePath;
+      const shortName = basename(experience.filePath);
       const willReview = this.isRecent(experience);
 
       if (total > 1 && willReview) {
@@ -164,8 +164,8 @@ export class ExperienceCompactor implements Agent {
         content = await this.reviewExperienceQuality(content, experience.data);
       }
 
-      if (content.length >= this.MAX_LENGTH) {
-        if (total > 1) tag('substep').log(`[${i + 1}/${total}] compacting ${shortName} (over ${this.MAX_LENGTH} chars)`);
+      if (content.length >= COMPACT_MAX_LENGTH) {
+        if (total > 1) tag('substep').log(`[${i + 1}/${total}] compacting ${shortName} (over ${COMPACT_MAX_LENGTH} chars)`);
         const prompt = this.buildCompactionPrompt(content);
         const model = this.provider.getModelForAgent('experience-compactor');
         const response = await this.provider.chat(
@@ -181,7 +181,7 @@ export class ExperienceCompactor implements Agent {
 
       if (content === experience.content) continue;
 
-      const stateHash = experience.filePath.split('/').pop()?.replace('.md', '') || '';
+      const stateHash = basename(experience.filePath, '.md');
       this.experienceTracker.writeExperienceFile(stateHash, content, experience.data);
       debugLog('Experience file compacted:', experience.filePath);
       compactedCount++;
@@ -314,7 +314,7 @@ export class ExperienceCompactor implements Agent {
     const [targetFile, ...sourceFiles] = group.files;
     const combinedContent = group.files.map((f) => f.content).join('\n\n---\n\n');
 
-    const targetStateHash = targetFile.filePath.split('/').pop()?.replace('.md', '') || '';
+    const targetStateHash = basename(targetFile.filePath, '.md');
     const newFrontmatter = {
       ...targetFile.data,
       url: group.pattern,
@@ -350,7 +350,7 @@ export class ExperienceCompactor implements Agent {
       <rules>
       - Use markdown h2 headers only (##) - NO XML tags or wrappers in output
       - Merge similar flows to remove duplicates
-      - Keep output under ${this.MAX_LENGTH} characters
+      - Keep output under ${COMPACT_MAX_LENGTH} characters
       - Be explicit and short - no proposals or explanations
 
       KEEP only:
@@ -438,28 +438,9 @@ export class ExperienceCompactor implements Agent {
 }
 
 function listSections(content: string): { title: string; raw: string }[] {
-  const tokens = marked.lexer(content);
-  const sections: { title: string; raw: string }[] = [];
-
-  let currentHeading: string | null = null;
-  let currentRaw = '';
-
-  const flush = () => {
-    if (currentHeading !== null) sections.push({ title: currentHeading, raw: currentRaw });
-  };
-
-  for (const token of tokens) {
-    const raw = (token as any).raw || '';
-    if (token.type === 'heading' && (token as Tokens.Heading).depth === 2) {
-      flush();
-      currentHeading = (token as Tokens.Heading).text.trim();
-      currentRaw = raw;
-      continue;
-    }
-    if (currentHeading !== null) currentRaw += raw;
-  }
-  flush();
-  return sections;
+  const sections = mdq(content).query('section2').each();
+  const metas = mdq(content).query('section2').meta();
+  return sections.map((q, i) => ({ title: metas[i].text.trim(), raw: q.text() }));
 }
 
 function dropEmptySections(content: string): string {
@@ -483,7 +464,7 @@ function dropNonReusableSections(content: string): string {
 
   for (const section of sections) {
     const raw = section.text();
-    if (!/\bI\.clickXY\s*\(/.test(raw)) continue;
+    if (!isNonReusableCode(raw)) continue;
     result = result.replace(raw, '');
   }
 

package/src/ai/fisherman-tools.ts

@@ -158,7 +158,7 @@ function extractKeyFields(body: any, result: Record<string, any> = {}, depth = 0
   }
 
   for (const [key, value] of Object.entries(body)) {
-    if (value === null || value === undefined) continue;
+    if (value == null) continue;
     if (typeof value === 'object') {
       extractKeyFields(value, result, depth + 1);
       continue;

package/src/ai/fisherman.ts

@@ -44,10 +44,6 @@ export class Fisherman implements Agent {
     return this.mode !== 'disabled';
   }
 
-  getMode(): string {
-    return this.mode;
-  }
-
   async ensureReady(scopeUrl?: string): Promise<void> {
     await this.detectMode(scopeUrl);
     this.spec ??= await this.specLoader();

package/src/ai/historian/codeceptjs.ts

@@ -2,12 +2,12 @@ import { mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { ActionResult } from '../../action-result.ts';
 import { ConfigParser } from '../../config.ts';
-import { KnowledgeTracker } from '../../knowledge-tracker.ts';
+import type { StateManager } from '../../state-manager.ts';
 import type { Plan } from '../../test-plan.ts';
 import { tag } from '../../utils/logger.ts';
 import { relativeToCwd } from '../../utils/next-steps.ts';
-import { safeFilename } from '../../utils/strings.ts';
 import { CODECEPT_TOOLS, isNonReusableCode, stripComments } from '../../utils/step-analyzer.ts';
+import { safeFilename } from '../../utils/strings.ts';
 import type { Conversation } from '../conversation.ts';
 import { ASSERTION_TOOLS } from '../tools.ts';
 import type { Constructor } from './mixin.ts';
@@ -21,6 +21,7 @@ export interface CodeceptJSMethods {
 export function WithCodeceptJS<T extends Constructor>(Base: T) {
   return class extends Base {
     declare savedFiles: Set<string>;
+    declare stateManager?: StateManager;
 
     toCode(conversation: Conversation, scenario: string): string {
       const toolExecutions = conversation.getToolExecutions();
@@ -108,7 +109,8 @@ export function WithCodeceptJS<T extends Constructor>(Base: T) {
     }
 
     private getKnowledgeLines(url: string, indent = '  '): string[] {
-      const knowledgeTracker = new KnowledgeTracker();
+      const knowledgeTracker = this.stateManager?.getKnowledgeTracker();
+      if (!knowledgeTracker) return [];
       const state = new ActionResult({ url });
       const { wait, waitForElement, code } = knowledgeTracker.getStateParameters(state, ['wait', 'waitForElement', 'code']);
 

package/src/ai/historian/playwright.ts

@@ -2,13 +2,14 @@ import { mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { ActionResult } from '../../action-result.ts';
 import { ConfigParser } from '../../config.ts';
-import { KnowledgeTracker } from '../../knowledge-tracker.ts';
+import type Explorer from '../../explorer.ts';
 import { type PlaywrightRecorder, type TraceCall, renderAssertion, renderCall } from '../../playwright-recorder.ts';
+import type { StateManager } from '../../state-manager.ts';
 import type { Plan } from '../../test-plan.ts';
 import { tag } from '../../utils/logger.ts';
 import { relativeToCwd } from '../../utils/next-steps.ts';
-import { safeFilename } from '../../utils/strings.ts';
 import { CODECEPT_TOOLS } from '../../utils/step-analyzer.ts';
+import { safeFilename } from '../../utils/strings.ts';
 import type { Conversation } from '../conversation.ts';
 import { ASSERTION_TOOLS } from '../tools.ts';
 import type { Constructor } from './mixin.ts';
@@ -23,8 +24,9 @@ export interface PlaywrightMethods {
 
 export function WithPlaywright<T extends Constructor>(Base: T) {
   return class extends Base {
-    declare playwright: { recorder: PlaywrightRecorder; helper: any } | undefined;
+    declare playwright: { recorder: PlaywrightRecorder; explorer: Explorer } | undefined;
     declare savedFiles: Set<string>;
+    declare stateManager?: StateManager;
 
     async toPlaywrightCode(conversation: Conversation, scenario: string): Promise<string> {
       const toolExecutions = conversation.getToolExecutions();
@@ -146,7 +148,8 @@ export function WithPlaywright<T extends Constructor>(Base: T) {
     }
 
     private getPlaywrightKnowledgeLines(url: string, indent = '    '): string[] {
-      const knowledgeTracker = new KnowledgeTracker();
+      const knowledgeTracker = this.stateManager?.getKnowledgeTracker();
+      if (!knowledgeTracker) return [];
       const state = new ActionResult({ url });
       const { wait, waitForElement } = knowledgeTracker.getStateParameters(state, ['wait', 'waitForElement']);
 

package/src/ai/historian/screencast.ts

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 import * as codeceptjs from 'codeceptjs';
 import { outputPath } from '../../config.ts';
 import type { ExplorbotConfig } from '../../config.ts';
+import type Explorer from '../../explorer.ts';
 import type { PlaywrightRecorder } from '../../playwright-recorder.ts';
 import { tag } from '../../utils/logger.ts';
 import { relativeToCwd } from '../../utils/next-steps.ts';
@@ -22,7 +23,7 @@ export function WithScreencast<T extends Constructor>(Base: T) {
   return class extends Base {
     declare config: ExplorbotConfig | undefined;
     declare savedFiles: Set<string>;
-    declare playwright: { recorder: PlaywrightRecorder; helper: any } | undefined;
+    declare playwright: { recorder: PlaywrightRecorder; explorer: Explorer } | undefined;
 
     private screencastPage: any = null;
     private screencastActive = false;
@@ -41,7 +42,7 @@ export function WithScreencast<T extends Constructor>(Base: T) {
     attachScreencast(): void {
       if (this.screencastListenersInstalled) return;
       if (!this.config?.ai?.agents?.historian?.screencast) return;
-      if (!this.playwright?.helper) return;
+      if (!this.playwright?.explorer) return;
 
       this.onTestBefore = (test: any) => {
         void this.startScreencast(test);
@@ -62,7 +63,7 @@ export function WithScreencast<T extends Constructor>(Base: T) {
 
     private async startScreencast(test: any): Promise<void> {
       if (this.screencastActive) return;
-      const page = this.playwright?.helper?.page;
+      const page = this.playwright?.explorer?.page;
       if (!page?.screencast?.start) return;
 
       const task = test?._explorbotTest;

package/src/ai/historian/utils.ts

@@ -1,5 +1,4 @@
 import type { ToolExecution } from '../conversation.ts';
-export { isNonReusableCode, stripComments } from '../../utils/step-analyzer.ts';
 
 export function escapeString(str: string): string {
   return str.replace(/'/g, "\\'").replace(/\n/g, ' ');