explorbot 0.1.0 → 0.1.2

package/dist/src/ai/pilot.js

@@ -222,9 +222,18 @@ export class Pilot {
 
         Plan the test execution for this scenario.
 
-        FIRST: Call precondition() to create fresh data that this test will act on.
-        Ask: "What will this test edit/delete/use?" — create THAT item via precondition.
-        Do not describe what's already on the page — create new disposable items for the test.
+        FIRST: Decide if precondition() is needed.
+
+        Call precondition() WHEN:
+        - The scenario edits/deletes/modifies an item, and you want a DISPOSABLE item to act on safely
+        - The scenario needs specific data clearly NOT on the current page (e.g., items with specific statuses for filtering)
+
+        SKIP precondition() WHEN:
+        - The scenario is "Create X" — the test itself creates the item
+        - The current page already shows the item the test will act on (check <state> and <page_summary>)
+        - The scenario tests navigation, UI behavior, or viewing — no data mutation needed
+
+        If needed, call precondition() now. If not, proceed directly to planning.
 
         THEN: Based on the page elements and current state, outline:
         1. Which elements to interact with and in what order
@@ -608,6 +617,8 @@ export class Pilot {
       - Click succeeded but ariaDiff shows elements unrelated to tester's intention (e.g., clicked "Edit" but dropdown appeared) → wrong button or unexpected behavior. Instruct Tester to Escape and try a different approach.
       - form(I.type()) succeeded → I.type() sends keys to whatever is focused, no guarantee it's the right field. Instruct Tester to verify with see() that text appeared in the correct field. If targetedHtml shows a button/link, text went to wrong element — click the correct field first and retry.
       - ariaDiff shows 5+ elements removed/added after clicking content → page entered a different mode (editor, panel, modal). Instruct Tester to call context() to see current state before guessing selectors.
+      - Dropdown/select opened but contains NO options, or a list/table is empty when items were expected → data doesn't exist yet. Call precondition() to create the missing items (labels, categories, etc.), then instruct Tester to retry.
+      - Tester tries to select/filter/assign something but the option list is empty or expected value is not present → missing auxiliary data. Call precondition() to create it.
 
       Detecting logically wrong successes — review "executed", "element", and "skipped" fields:
       - Click SUCCESS but "executed" command differs from "explanation" intent → wrong element was clicked. The intended element wasn't found and a different one was clicked instead.
@@ -657,23 +668,36 @@ export class Pilot {
       YOUR tools (Pilot-only):
       - precondition(description) — create FRESH test data via API that the test will act on. Do NOT request users.
 
-      PRECONDITIONS — what to create:
+      PRECONDITIONS — when and what to create:
       Preconditions create NEW disposable items that the test will modify, delete, or interact with.
-      Do NOT describe what already exists on the page — describe what NEW data the test needs to act on.
 
       Ask yourself: "What object will this test change/delete/use? Create THAT."
 
-      Examples:
+      When to call precondition():
+      - Scenario edits/deletes/modifies an item → create a disposable target
+      - Scenario needs auxiliary data (labels, categories, statuses to filter by)
+      - Tester failed because required data is missing (empty dropdown, no items to select)
+
+      When to SKIP precondition():
+      - Scenario is "Create X" — the test itself creates the item, no precondition needed
+      - Current page already shows the exact data needed (check <state> h1/title and <page_summary>)
+      - Scenario tests navigation, search UI, or viewing — no data mutation involved
+
+      Examples — when to create:
       - "Edit test description" → precondition("1 test") — the test will edit this item
       - "Delete a comment" → precondition("1 comment") — the test will delete this item
       - "Assign a label to item" → precondition("1 item and 1 label named Bug") — test assigns the label
       - "Filter by status" → precondition("3 items: 2 with status Open, 1 with status Closed")
-      - "Move item between lists" → precondition("1 item in list A")
 
-      WRONG: precondition("1 test suite named Updated Suite with existing tests") — this describes the page, not what to create
+      Examples — when to skip:
+      - "Create a new blog post" → SKIP, the test creates it
+      - "Edit blog post" while on a blog post page → SKIP, data already exists
+      - "View dashboard" → SKIP, no data mutation
+
+      WRONG: precondition("1 test suite named Updated Suite with existing tests") — describes the page, not what to create
       RIGHT: precondition("1 test") — create a fresh test that the scenario will edit
 
-      Call precondition() for EVERY item the scenario will act on. Keep descriptions short and specific.
+      Keep descriptions short and specific.
 
       Response format:
       PROGRESS: <1 sentence assessment>

package/dist/src/ai/planner/session-dedup.js

@@ -25,3 +25,6 @@ export function WithSessionDedup(Base) {
         }
     };
 }
+export function clearSessionDedup() {
+    previousPlans.length = 0;
+}

package/dist/src/ai/planner/styles.js

@@ -12,3 +12,6 @@ export function getStyles() {
 export function getActiveStyle(iteration, override) {
     return RulesLoader.getActiveStyle(getStyles(), iteration, override);
 }
+export function clearStyleCache() {
+    cache = null;
+}

package/dist/src/ai/planner.js

@@ -18,6 +18,7 @@ import { WithSubPages, getPlannedByStateHash, getRegisteredPlan, registerPlan }
 import { findSimilarStateHash } from "./researcher/cache.js";
 import { hasFocusedSection } from "./researcher/focus.js";
 import { POSSIBLE_SECTIONS, Researcher } from "./researcher.js";
+import { Suite } from "../suite.js";
 import { fileUploadRule, protectionRule } from "./rules.js";
 const debugLog = createDebug('explorbot:planner');
 const TasksSchema = z.object({
@@ -46,6 +47,7 @@ export class Planner extends PlannerBase {
     currentPlan = null;
     freshStart = false;
     lastStyleName = '';
+    lastSuite = null;
     researcher;
     fisherman = null;
     constructor(explorer, provider) {
@@ -173,6 +175,9 @@ export class Planner extends PlannerBase {
             if (parentPlan)
                 this.currentPlan.parentPlan = parentPlan;
             const allPreviousScenarios = this.getPreviousSessionScenarios();
+            const existingTestScenarios = this.getExistingTestFileScenarios(state.url);
+            for (const s of existingTestScenarios)
+                allPreviousScenarios.add(s);
             for (const t of tests) {
                 if (allPreviousScenarios.has(t.scenario.toLowerCase()))
                     continue;
@@ -180,8 +185,6 @@ export class Planner extends PlannerBase {
                 t.startUrl = state.url;
                 this.currentPlan.addTest(t);
             }
-            const summary = `Scenarios:\n${this.currentPlan.tests.map((t) => `- [${t.priority}] ${t.scenario}`).join('\n')}`;
-            tag('multiline').log(summary);
         }
         else {
             tag('step').log(`Expanding plan: "${this.currentPlan.title}"`);
@@ -192,7 +195,6 @@ export class Planner extends PlannerBase {
                 tag('multiline').log(summary);
             }
         }
-        this.moveExecutedTestsToEnd();
         const availableStyles = Object.keys(getStyles()).join(', ');
         tag('success').log(`Planning complete! ${this.currentPlan.tests.length} tests in plan: ${this.currentPlan.title}`);
         tag('info').log(`Planning style: ${this.lastStyleName} (available: ${availableStyles})`);
@@ -201,13 +203,8 @@ export class Planner extends PlannerBase {
         this.registerPlanInSession(this.currentPlan);
         return this.currentPlan;
     }
-    moveExecutedTestsToEnd() {
-        if (!this.currentPlan)
-            return;
-        const pending = this.currentPlan.tests.filter((t) => t.result === null);
-        const executed = this.currentPlan.tests.filter((t) => t.result !== null);
-        this.currentPlan.tests = [...pending, ...executed];
-        this.currentPlan.notifyChange();
+    getSuite() {
+        return this.lastSuite;
     }
     addNewTests(tests, defaultStartUrl) {
         if (!this.currentPlan)
@@ -229,6 +226,18 @@ export class Planner extends PlannerBase {
         }
         return added;
     }
+    getExistingTestFileScenarios(currentUrl) {
+        if (!currentUrl)
+            return new Set();
+        try {
+            this.lastSuite = new Suite(currentUrl);
+            return this.lastSuite.getActiveScenarioTitles();
+        }
+        catch (err) {
+            debugLog('Failed to load existing test files: %s', err.message);
+            return new Set();
+        }
+    }
     cleanExperienceFlows(text) {
         const seenTitles = new Set();
         let result = text;
@@ -376,6 +385,16 @@ export class Planner extends PlannerBase {
         `);
             }
         }
+        if (this.lastSuite && this.lastSuite.automatedTestCount > 0) {
+            const automatedNames = this.lastSuite.getAutomatedTestNames();
+            conversation.addUserText(dedent `
+        <existing_automated_tests>
+        The following ${automatedNames.length} tests are already implemented and automated for this URL.
+        Do not propose tests that duplicate these:
+        ${automatedNames.map((n) => `- ${n}`).join('\n')}
+        </existing_automated_tests>
+      `);
+        }
         if (this.currentPlan) {
             tag('step').log('Analyzing current plan to expand testing');
             const allTests = this.currentPlan.getAllTests();

package/dist/src/ai/rerunner.js

@@ -0,0 +1,472 @@
+import { existsSync } from 'node:fs';
+import { relative, resolve } from 'node:path';
+import { tool } from 'ai';
+import { createBashTool } from 'bash-tool';
+import chalk from 'chalk';
+import { highlight } from 'cli-highlight';
+import * as codeceptjs from 'codeceptjs';
+import heal from 'codeceptjs/lib/heal';
+import aiTracePlugin from 'codeceptjs/lib/plugin/aiTrace';
+import figureSet from 'figures';
+import dedent from 'dedent';
+import { z } from 'zod';
+import { ActionResult } from "../action-result.js";
+import { setActivity } from "../activity.js";
+import { Stats } from "../stats.js";
+import { Task, Test, TestResult } from "../test-plan.js";
+import { createDebug, tag } from "../utils/logger.js";
+import { loop } from "../utils/loop.js";
+import { loadTestSuites, printTestList } from "../utils/test-files.js";
+import { toolExecutionLabel } from "./conversation.js";
+import { locatorRule, actionRule, sectionContextRule } from "./rules.js";
+import { TaskAgent } from "./task-agent.js";
+import { RulesLoader } from "../utils/rules-loader.js";
+import { createCodeceptJSTools } from "./tools.js";
+const debugLog = createDebug('explorbot:rerunner');
+export class Rerunner extends TaskAgent {
+    ACTION_TOOLS = ['click', 'pressKey', 'form'];
+    emoji = '🔄';
+    explorer;
+    provider;
+    agentTools;
+    healedSteps = [];
+    traceDir = '';
+    constructor(explorer, provider, agentTools) {
+        super();
+        this.explorer = explorer;
+        this.provider = provider;
+        this.agentTools = agentTools;
+    }
+    getNavigator() {
+        throw new Error('Rerunner does not use Navigator');
+    }
+    getExperienceTracker() {
+        return this.explorer.getStateManager().getExperienceTracker();
+    }
+    getKnowledgeTracker() {
+        return this.explorer.getKnowledgeTracker();
+    }
+    getProvider() {
+        return this.provider;
+    }
+    get rerunnerConfig() {
+        return this.explorer.getConfig().ai?.agents?.rerunner || {};
+    }
+    get healLimit() {
+        return this.rerunnerConfig.healLimit ?? 3;
+    }
+    get healMaxIterations() {
+        return this.rerunnerConfig.healMaxIterations ?? 3;
+    }
+    listTests(testsDir) {
+        printTestList(loadTestSuites(testsDir));
+    }
+    async rerun(filePath, options) {
+        const absPath = resolve(filePath);
+        if (!existsSync(absPath)) {
+            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)}`);
+        setActivity('🔄 Re-running tests...', 'action');
+        this.healedSteps = [];
+        this.setupPlugins();
+        const testMap = new Map();
+        const results = [];
+        const onTestBefore = (mochaTest) => {
+            if (!mochaTest.file)
+                mochaTest.file = absPath;
+            const task = new Test(mochaTest.title, 'normal', [], '');
+            task.start();
+            testMap.set(mochaTest.id || mochaTest.title, task);
+            Stats.tests++;
+            console.log(`\n  ${chalk.green(figureSet.pointer)} ${chalk.bold(mochaTest.title)}`);
+        };
+        const onStepStarted = (step) => {
+            if (!step.toCode)
+                return;
+            const code = highlight(step.toCode(), { language: 'javascript' });
+            console.log(chalk.dim(`    ${code}`));
+        };
+        const onStepPassed = (step) => {
+            const task = this.getCurrentTask(testMap);
+            if (!task || !step.toCode)
+                return;
+            task.addStep(step.toCode(), step.duration, 'passed');
+        };
+        const onStepFailed = (step, error) => {
+            const task = this.getCurrentTask(testMap);
+            if (!task || !step.toCode)
+                return;
+            task.addStep(step.toCode(), step.duration, 'failed', error?.message);
+            console.log(chalk.red(`    ${figureSet.cross} ${step.toCode()} — ${error?.message || 'failed'}`));
+        };
+        const onTestPassed = (mochaTest) => {
+            const task = testMap.get(mochaTest.id || mochaTest.title);
+            if (!task)
+                return;
+            task.finish(TestResult.PASSED);
+            results.push({ test: task, mochaState: 'passed' });
+            console.log(chalk.green(`  ${figureSet.tick} passed`));
+        };
+        const onTestFailed = (mochaTest, error) => {
+            const task = testMap.get(mochaTest.id || mochaTest.title);
+            if (!task)
+                return;
+            task.addNote(`Failed: ${error?.message || 'unknown error'}`, TestResult.FAILED);
+            task.finish(TestResult.FAILED);
+            results.push({ test: task, mochaState: 'failed' });
+            console.log(chalk.red(`  ${figureSet.cross} failed: ${error?.message || 'unknown'}`));
+        };
+        const { dispatcher } = codeceptjs.event;
+        dispatcher.on('test.before', onTestBefore);
+        dispatcher.on('step.start', onStepStarted);
+        dispatcher.on('step.passed', onStepPassed);
+        dispatcher.on('step.failed', onStepFailed);
+        dispatcher.on('test.passed', onTestPassed);
+        dispatcher.on('test.failed', onTestFailed);
+        try {
+            codeceptjs.container.createMocha();
+            const mocha = codeceptjs.container.mocha();
+            mocha.reporter(class {
+            });
+            mocha.files = [absPath];
+            mocha.loadFiles();
+            let testIndex = 0;
+            for (const suite of mocha.suite.suites || []) {
+                for (const test of suite.tests || []) {
+                    if (test.pending) {
+                        testIndex++;
+                        continue;
+                    }
+                    if (options?.testIndices?.length && !options.testIndices.includes(testIndex)) {
+                        test.pending = true;
+                        testIndex++;
+                        continue;
+                    }
+                    if (!hasAssertions(test.body)) {
+                        test.pending = true;
+                        tag('substep').log(`Skipping: ${test.title} (no assertions)`);
+                    }
+                    testIndex++;
+                }
+            }
+            await new Promise((resolveRun) => {
+                mocha.run((failures) => {
+                    debugLog('Mocha run finished with %d failures', failures);
+                    resolveRun();
+                });
+            });
+        }
+        catch (error) {
+            tag('error').log(`Rerun error: ${error instanceof Error ? error.message : error}`);
+        }
+        finally {
+            dispatcher.off('test.before', onTestBefore);
+            dispatcher.off('step.start', onStepStarted);
+            dispatcher.off('step.passed', onStepPassed);
+            dispatcher.off('step.failed', onStepFailed);
+            dispatcher.off('test.passed', onTestPassed);
+            dispatcher.off('test.failed', onTestFailed);
+            this.teardownHealing();
+        }
+        if (this.healedSteps.length > 0) {
+            this.getHistorian().rewriteScenarioInFile(absPath, this.healedSteps);
+            tag('info').log(`Healed ${this.healedSteps.length} step(s), original file updated`);
+        }
+        const passed = results.filter((r) => r.mochaState === 'passed').length;
+        const failed = results.filter((r) => r.mochaState === 'failed').length;
+        const result = {
+            total: results.length,
+            passed,
+            failed,
+            healed: this.healedSteps.length,
+        };
+        this.printResults(result);
+        return result;
+    }
+    getCurrentTask(testMap) {
+        const entries = [...testMap.values()];
+        return entries[entries.length - 1];
+    }
+    setupPlugins() {
+        const healMod = heal.default || heal;
+        healMod.connectToEvents();
+        healMod.addRecipe('explorbot-ai-healer', {
+            priority: 10,
+            fn: async (context) => {
+                return this.healStep(context.step, context.error);
+            },
+        });
+        const userRecipes = (this.rerunnerConfig.recipes || {});
+        for (const [name, recipe] of Object.entries(userRecipes)) {
+            healMod.addRecipe(name, recipe);
+        }
+        let currentTest = null;
+        let healTries = 0;
+        let isHealing = false;
+        let caughtError = null;
+        const healLimit = this.healLimit;
+        codeceptjs.event.dispatcher.on('test.before', (test) => {
+            currentTest = test;
+            healTries = 0;
+            caughtError = null;
+        });
+        codeceptjs.event.dispatcher.on('step.after', (step) => {
+            if (isHealing)
+                return;
+            if (healTries >= healLimit)
+                return;
+            if (!healMod.hasCorrespondingRecipes(step))
+                return;
+            codeceptjs.recorder.catchWithoutStop(async (err) => {
+                isHealing = true;
+                if (caughtError === err)
+                    throw err;
+                caughtError = err;
+                codeceptjs.recorder.session.start('heal');
+                debugLog('Healing started for: %s', step.toCode());
+                await healMod.healStep(step, err, { test: currentTest });
+                healTries++;
+                codeceptjs.recorder.add('close healing session', () => {
+                    codeceptjs.recorder.reset();
+                    codeceptjs.recorder.session.restore('heal');
+                    codeceptjs.recorder.ignoreErr(err);
+                });
+                await codeceptjs.recorder.promise();
+                isHealing = false;
+            });
+        });
+        global.container = codeceptjs.container;
+        codeceptjs.recorder.retry({
+            retries: 3,
+            when: (err) => {
+                if (!err?.message)
+                    return false;
+                return err.message.includes('was not found') || err.message.includes('Timeout') || err.message.includes('exceeded');
+            },
+            minTimeout: 2000,
+            maxTimeout: 5000,
+            factor: 1.5,
+        });
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+        const outputDir = global.output_dir || 'output';
+        this.traceDir = `${outputDir}/rerun_${timestamp}`;
+        const aiTrace = aiTracePlugin.default || aiTracePlugin;
+        aiTrace(this.rerunnerConfig.aiTrace || { output: this.traceDir });
+        import('@testomatio/reporter/codecept')
+            .then((mod) => {
+            const plugin = mod.default || mod;
+            plugin({ enabled: true });
+        })
+            .catch(() => debugLog('Testomatio reporter plugin not available'));
+    }
+    teardownHealing() {
+        const healMod = heal.default || heal;
+        healMod.recipes['explorbot-ai-healer'] = undefined;
+        for (const name of Object.keys(this.rerunnerConfig.recipes || {})) {
+            healMod.recipes[name] = undefined;
+        }
+    }
+    async healStep(step, error) {
+        const failedCode = step.toCode?.() || '';
+        console.log(chalk.yellow(`    ${figureSet.arrowRight} Healing: ${failedCode}`));
+        return async ({ I }) => {
+            const bashTool = await createBashTool({
+                destination: this.traceDir,
+                onBeforeBashCall: ({ command }) => {
+                    if (/>[^>]|>>|\btee\b|\brm\b/.test(command)) {
+                        return { command: 'echo "Read-only" >&2 && exit 1' };
+                    }
+                    return { command };
+                },
+            });
+            const healTask = new Task(`Heal: ${failedCode}`);
+            const codeceptTools = createCodeceptJSTools(this.explorer, healTask);
+            let healed = false;
+            let healedCommand = '';
+            const tools = {
+                bash: bashTool.bash,
+                ...codeceptTools,
+                ...this.agentTools,
+                wait: tool({
+                    description: 'Wait N seconds for page to load. Use when loading indicators are detected.',
+                    inputSchema: z.object({
+                        seconds: z.number().describe('Seconds to wait'),
+                        note: z.string().optional().describe('What are you waiting for'),
+                    }),
+                    execute: async ({ seconds, note }) => {
+                        if (note) {
+                            healTask.addNote(note);
+                            tag('substep').log(note);
+                        }
+                        const action = this.explorer.createAction();
+                        await action.execute(`I.wait(${seconds})`);
+                        const state = this.explorer.getStateManager().getCurrentState();
+                        const ar = state ? ActionResult.fromState(state) : null;
+                        return {
+                            success: true,
+                            message: `Waited ${seconds}s`,
+                            url: state?.url,
+                            title: state?.title,
+                            aria: ar?.getInteractiveARIA(),
+                        };
+                    },
+                }),
+                done: tool({
+                    description: 'Healing succeeded. Report the command that fixed the step.',
+                    inputSchema: z.object({
+                        healedCommand: z.string().describe('The CodeceptJS command that fixed the step'),
+                    }),
+                    execute: async ({ healedCommand: cmd }) => {
+                        healed = true;
+                        healedCommand = cmd;
+                        return { success: true, healedCommand: cmd };
+                    },
+                }),
+                giveUp: tool({
+                    description: 'Cannot heal. The issue is not fixable (missing data, page fundamentally different).',
+                    inputSchema: z.object({
+                        reason: z.string().describe('Why healing is not possible'),
+                    }),
+                    execute: async ({ reason }) => {
+                        console.log(chalk.gray(`    ${figureSet.line} Cannot heal: ${reason}`));
+                        return { success: false, reason };
+                    },
+                }),
+            };
+            const conversation = this.provider.startConversation(this.getHealSystemPrompt(), 'rerunner');
+            conversation.addUserText(this.getHealUserPrompt(failedCode, error));
+            await loop(async ({ stop }) => {
+                if (healed) {
+                    stop();
+                    return;
+                }
+                const result = await this.provider.invokeConversation(conversation, tools, {
+                    maxToolRoundtrips: 5,
+                    toolChoice: 'auto',
+                });
+                if (!result?.toolExecutions?.length) {
+                    stop();
+                    return;
+                }
+                for (const exec of result.toolExecutions) {
+                    const icon = exec.wasSuccessful ? chalk.green(figureSet.tick) : chalk.red(figureSet.cross);
+                    let label = toolExecutionLabel(exec.input) || exec.toolName;
+                    if (exec.toolName === 'bash')
+                        label = `bash [${this.traceDir}]: ${(exec.input?.command || '').substring(0, 100)}`;
+                    tag('substep').log(`${icon} ${label}`);
+                    if (exec.toolName === 'done') {
+                        healed = true;
+                        stop();
+                        return;
+                    }
+                    if (exec.toolName === 'giveUp') {
+                        stop();
+                        throw new Error(exec.input?.reason || 'Healing aborted');
+                    }
+                }
+            }, {
+                maxAttempts: this.healMaxIterations,
+                catch: async ({ error: err, stop }) => {
+                    if (err.message?.includes('Healing aborted'))
+                        throw err;
+                    tag('warning').log(`Healing error: ${err.message}`);
+                    stop();
+                },
+            });
+            if (!healed) {
+                throw new Error(`Could not heal: ${failedCode}`);
+            }
+            this.healedSteps.push({ test: '', original: failedCode, healed: healedCommand });
+            console.log(chalk.green(`    ${figureSet.tick} Healed: ${healedCommand}`));
+        };
+    }
+    getHealSystemPrompt() {
+        const customRules = this.provider.getSystemPromptForAgent('rerunner', this.explorer.getStateManager().getCurrentState()?.url) || '';
+        const currentUrl = this.explorer.getStateManager().getCurrentState()?.url || '';
+        const approach = RulesLoader.loadRules('rerunner', ['healing-approach'], currentUrl);
+        return dedent `
+      <role>
+      You are a senior test automation engineer healing a failed CodeceptJS test step.
+      The failed step did NOT execute. You MUST perform the action it was supposed to do.
+      </role>
+
+      ${approach}
+
+      <tools>
+      - You MUST execute the replacement action — not just diagnose
+      - Use click() for buttons, links — commands array is FALLBACK LOCATORS for the SAME element
+      - Use form() for text input, dropdown selection, file uploads
+      - Use pressKey() for special keys or key combinations
+      - Use wait() when page is loading — returns fresh ARIA automatically
+      - Use research() to understand page structure, sections, and available UI elements
+      - Use xpathCheck() to search large HTML when element can't be found in ARIA
+      - Use see() for visual verification when unsure
+      - Use context() to refresh ARIA/HTML after actions
+      - Use bash to read trace files (cat */trace.md, grep *_console.json, cat *_aria.txt)
+      </tools>
+
+      ${locatorRule}
+
+      ${actionRule}
+
+      ${sectionContextRule}
+
+      ${customRules}
+    `;
+    }
+    getHealUserPrompt(failedCode, error) {
+        const state = this.explorer.getStateManager().getCurrentState();
+        const actionResult = state ? ActionResult.fromState(state) : null;
+        const headings = [];
+        if (state?.h1)
+            headings.push(`H1: ${state.h1}`);
+        if (state?.h2)
+            headings.push(`H2: ${state.h2}`);
+        if (state?.h3)
+            headings.push(`H3: ${state.h3}`);
+        if (state?.h4)
+            headings.push(`H4: ${state.h4}`);
+        return dedent `
+      A test step failed and needs healing.
+
+      <failed_step>
+      Command: ${failedCode}
+      Error: ${error.message}
+      </failed_step>
+
+      <page>
+      URL: ${state?.url || 'unknown'}
+      Title: ${state?.title || 'unknown'}
+      ${headings.join('\n')}
+      </page>
+
+      <page_aria>
+      ${actionResult?.getInteractiveARIA() || 'No ARIA available'}
+      </page_aria>
+
+      Trace directory: ${this.traceDir}
+
+      Diagnose and fix the failed step. You MUST execute the replacement action.
+    `;
+    }
+    printResults(result) {
+        const parts = [];
+        if (result.passed > 0)
+            parts.push(`${result.passed} passed`);
+        if (result.failed > 0)
+            parts.push(`${result.failed} failed`);
+        if (result.healed > 0)
+            parts.push(`${result.healed} healed`);
+        console.log(`\n${chalk.bold(`${result.total}`)} tests — ${parts.join(', ')}`);
+        if (this.traceDir) {
+            console.log(chalk.gray(`Traces: ${this.traceDir}`));
+        }
+    }
+}
+function hasAssertions(body) {
+    if (!body)
+        return false;
+    return /I\.(see|dontSee|seeElement|dontSeeElement|seeInField|seeInSource|dontSeeInSource)\b/.test(body);
+}

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

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { Worker } from 'node:worker_threads';
 import { outputPath } from "../../config.js";
 import { computeHtmlFingerprint } from "../../utils/html-diff.js";
 import { debugLog } from "./mixin.js";
@@ -69,16 +70,16 @@ function findSimilarMatch(combinedHtml) {
             debugLog('Fingerprint worker timed out');
             resolve(null);
         }, FINGERPRINT_WORKER_TIMEOUT_MS);
-        worker.onmessage = (event) => {
+        worker.on('message', (data) => {
             clearTimeout(timeout);
-            const { matchHash, similarity } = event.data;
+            const { matchHash, similarity } = data;
             if (!matchHash) {
                 resolve(null);
                 return;
             }
             debugLog(`Similar fingerprint found: ${matchHash} (${similarity}% similar)`);
             resolve({ hash: matchHash, similarity });
-        };
+        });
         worker.postMessage({
             html: combinedHtml,
             statesDir,