explorbot 0.2.5 → 0.3.0

package/dist/src/action.js

@@ -17,6 +17,8 @@ const debugLog = createDebug('explorbot:action');
 const CAPTURE_NAVIGATION_TRANSITION_ATTEMPTS = 3;
 const DEFAULT_ACTION_TIMEOUT = 3000;
 const DEFAULT_PAGE_TIMEOUT = 3000;
+const MAX_NETWORK_CALLS = 10;
+const IMPORTANT_LOG_LEVELS = new Set(['info', 'error', 'warning', 'warn']);
 class Action {
     actor;
     stateManager;
@@ -32,6 +34,8 @@ class Action {
     recorder;
     recovery;
     mainDocumentStatus = undefined;
+    networkRequests = [];
+    baseOrigin;
     constructor(actor, stateManager, recorder, recovery) {
         this.actor = actor;
         this.stateManager = stateManager;
@@ -39,6 +43,7 @@ class Action {
         this.playwrightHelper = container.helpers('Playwright');
         this.recorder = recorder;
         this.recovery = recovery || ((fn) => fn());
+        this.baseOrigin = URL.parse(this.config.playwright?.url || '')?.origin || '';
     }
     async saveScreenshot() {
         const currentState = this.stateManager.getCurrentState();
@@ -117,9 +122,7 @@ class Action {
             const logPath = join(statesDir, logFile);
             const formattedLogs = browserLogs.map((log) => {
                 const logTimestamp = new Date().toISOString();
-                const level = (log.type || log.level || 'LOG').toUpperCase();
-                const message = log.text || log.message || String(log);
-                return `[${logTimestamp}] ${level}: ${message}`;
+                return `[${logTimestamp}] ${log.type.toUpperCase()}: ${log.text}`;
             });
             fs.writeFileSync(logPath, `${formattedLogs.join('\n')}\n`, 'utf8');
             debugLog('Page:', { url, title, size: html.length, html: html.substring(0, 100) });
@@ -142,12 +145,15 @@ class Action {
                 fs.writeFileSync(ariaPath, ariaSnapshot, 'utf8');
                 ariaSnapshotFile = ariaFileName;
             }
+            const networkRequests = this.networkRequests;
+            this.networkRequests = [];
             const result = new ActionResult({
                 html,
                 title,
                 httpStatus: await this.captureMainDocumentStatus(),
                 url,
                 browserLogs,
+                networkRequests,
                 htmlFile,
                 logFile,
                 screenshotFile,
@@ -192,27 +198,52 @@ class Action {
             return undefined;
         }
     }
-    captureMainDocumentResponse() {
+    captureResponses() {
         const page = this.playwrightHelper.page;
         if (!page?.on || !page?.off)
             return () => { };
         this.mainDocumentStatus = undefined;
+        this.networkRequests = [];
         const handler = (response) => {
             const request = response.request();
-            if (request.resourceType() !== 'document')
-                return;
-            if (response.frame() !== page.mainFrame())
-                return;
             const status = response.status();
             if (typeof status !== 'number')
                 return;
             if (status <= 0)
                 return;
-            this.mainDocumentStatus = status;
+            if (request.resourceType() === 'document') {
+                if (response.frame() !== page.mainFrame())
+                    return;
+                this.mainDocumentStatus = status;
+                return;
+            }
+            this.recordNetworkCall(request, status);
         };
         page.on('response', handler);
         return () => page.off('response', handler);
     }
+    recordNetworkCall(request, status) {
+        const resourceType = request.resourceType();
+        if (resourceType !== 'xhr' && resourceType !== 'fetch')
+            return;
+        const url = URL.parse(request.url());
+        if (!url)
+            return;
+        if (url.origin !== this.baseOrigin)
+            return;
+        const call = { method: request.method(), path: url.pathname, status };
+        if (this.networkRequests.some((r) => r.method === call.method && r.path === call.path && r.status === call.status))
+            return;
+        if (this.networkRequests.length >= MAX_NETWORK_CALLS) {
+            if (status < 400)
+                return;
+            const succeeded = this.networkRequests.findIndex((r) => r.status < 400);
+            if (succeeded === -1)
+                return;
+            this.networkRequests.splice(succeeded, 1);
+        }
+        this.networkRequests.push(call);
+    }
     /**
      * Capture HTML snapshots of all iframes on the page
      */
@@ -249,12 +280,7 @@ class Action {
     async captureBrowserLogs() {
         try {
             const logs = await this.actor.grabBrowserLogs();
-            // Filter for important logs (info, error, warning)
-            const importantLogs = logs.filter((log) => {
-                const level = log.type || log.level;
-                return ['info', 'error', 'warning', 'warn'].includes(level);
-            });
-            return importantLogs;
+            return logs.map(toBrowserLog).filter((log) => IMPORTANT_LOG_LEVELS.has(log.type));
         }
         catch (error) {
             debugLog('Failed to capture browser logs:', error);
@@ -270,7 +296,7 @@ class Action {
         const stepListener = attachStepLogger(executedSteps, assertionSteps);
         const groupId = this.recorder ? await this.recorder.beginAction(codeString) : null;
         this.playwrightGroupId = groupId;
-        const detachMainDocumentResponse = this.captureMainDocumentResponse();
+        const detachResponses = this.captureResponses();
         const activeSpan = Observability.getSpan();
         const tracer = trace.getTracer('ai');
         const stepSpan = activeSpan ? tracer.startSpan('codeceptjs.step', undefined, trace.setSpan(context.active(), activeSpan)) : null;
@@ -314,7 +340,7 @@ class Action {
         }
         finally {
             this.restorePageTimeout();
-            detachMainDocumentResponse();
+            detachResponses();
             if (groupId)
                 await this.recorder.endAction();
             detachStepLogger(stepListener);
@@ -393,6 +419,11 @@ async function captureHtml(page, frame, actor) {
         return actor.grabSource();
     throw new Error('Playwright page is unavailable for HTML capture');
 }
+function toBrowserLog(log) {
+    const type = typeof log.type === 'function' ? log.type() : log.type || log.level || 'log';
+    const text = typeof log.text === 'function' ? log.text() : log.text || log.message || String(log);
+    return { type, text: text.replace(/\s+/g, ' ').trim() };
+}
 async function captureTitle(page, actor) {
     if (page?.title)
         return page.title();

package/dist/src/ai/captain/web-mode.js

@@ -15,7 +15,7 @@ export function WithWebMode(Base) {
                 researcher: ctx.explorBot.agentResearcher(),
                 navigator: ctx.explorBot.agentNavigator(),
             });
-            const { see, context, visualClick, learnExperience } = agentTools;
+            const { see, context, visualClick } = agentTools;
             const tools = {
                 navigate: tool({
                     description: 'Navigate to a URL or page description using AI-powered navigation.',
@@ -115,7 +115,6 @@ export function WithWebMode(Base) {
                 }),
                 ...codeceptTools,
                 context,
-                learnExperience,
             };
             if (see)
                 tools.see = see;

package/dist/src/ai/captain.d.ts

@@ -59,6 +59,16 @@ export declare class Captain extends CaptainBase implements Agent {
     planSummary(): string;
     reinjectContextIfNeeded(conversation: Conversation, currentState: WebPageState): Promise<void>;
     coreTools(task: Task, onDone: (summary: string) => void): {
+        learnExperience: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            fileTag: any;
+            sectionIndex: any;
+        }, {
+            title: string;
+            url: string;
+            content: string;
+        } | {
+            error: string;
+        }, import("@ai-sdk/provider-utils").Context>>;
         done: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
             summary: string;
             details?: string;
@@ -91,6 +101,16 @@ export declare class Captain extends CaptainBase implements Agent {
         }, import("@ai-sdk/provider-utils").Context>>;
     };
     tools(task: Task, onDone: (summary: string) => void): Promise<{
+        learnExperience: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            fileTag: any;
+            sectionIndex: any;
+        }, {
+            title: string;
+            url: string;
+            content: string;
+        } | {
+            error: string;
+        }, import("@ai-sdk/provider-utils").Context>>;
         done: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
             summary: string;
             details?: string;

package/dist/src/ai/captain.js

@@ -15,7 +15,7 @@ import { WithWebMode } from "./captain/web-mode.js";
 import { toolExecutionLabel } from './conversation.js';
 import { Researcher } from "./researcher.js";
 import { TaskAgent } from "./task-agent.js";
-import { withdrawVisionTools } from "./tools.js";
+import { createLearnExperienceTool, withdrawVisionTools } from "./tools.js";
 const MAX_STEPS = 15;
 const CaptainBase = WithTestMode(WithWebMode(WithIdleMode(TaskAgent)));
 export class Captain extends CaptainBase {
@@ -216,6 +216,15 @@ export class Captain extends CaptainBase {
     }
     coreTools(task, onDone) {
         return {
+            learnExperience: createLearnExperienceTool({
+                getExperienceTracker: () => this.getExperienceTracker(),
+                getState: () => {
+                    const state = this.explorBot.stateManager().getCurrentState();
+                    if (!state)
+                        return null;
+                    return ActionResult.fromState(state);
+                },
+            }),
             done: tool({
                 description: 'Call when the user request is fulfilled.',
                 inputSchema: z.object({

package/dist/src/ai/driller.js

@@ -14,7 +14,7 @@ import { eidxInContainer } from "../utils/web-eidx.js";
 import { WebElement } from "../utils/web-element.js";
 import { drillLocatorRule } from "./rules.js";
 import { TaskAgent, isInteractive } from "./task-agent.js";
-import { createCodeceptJSTools } from "./tools.js";
+import { createCodeceptJSTools, createLearnExperienceTool } from "./tools.js";
 const debugLog = createDebug('explorbot:driller');
 export class Driller extends TaskAgent {
     ACTION_TOOLS = ['click', 'pressKey', 'form'];
@@ -234,7 +234,11 @@ export class Driller extends TaskAgent {
         conversation.addUserText(await this.buildComponentPrompt(originalState, component));
         let finished = false;
         const actionTools = this.createVerifiedActionTools(createCodeceptJSTools(this.toolDeps, test), component);
-        const tools = { ...actionTools, ...this.createDrillFlowTools(originalState, test, interactive) };
+        const learnExperience = createLearnExperienceTool({
+            getExperienceTracker: () => this.getExperienceTracker(),
+            getState: () => ActionResult.fromState(this.stateManager.getCurrentState() || originalState),
+        });
+        const tools = { ...actionTools, learnExperience, ...this.createDrillFlowTools(originalState, test, interactive) };
         await loop(async ({ stop, iteration }) => {
             debugLog(`Drilling component ${component.name}, iteration ${iteration}`);
             setActivity(`${this.emoji} Drilling ${component.name}...`, 'action');

package/dist/src/ai/fisherman-tools.d.ts

@@ -9,18 +9,49 @@ export declare function createFishermanTools(apiClient: ApiClient, requestStore:
             method: any;
             path: any;
         }, {
+            source: string;
+            method: any;
+            path: any;
+            definition: string;
+            rejectedCapture: {
+                status: number;
+                requestBody: any;
+            };
+            usable?: undefined;
+            rejectedRequestBody?: undefined;
+            status?: undefined;
+            requestBody?: undefined;
+            error?: undefined;
+        } | {
+            source: string;
+            method: any;
+            path: any;
+            usable: boolean;
+            rejectedRequestBody: any;
+            status: number;
+            definition?: undefined;
+            rejectedCapture?: undefined;
+            requestBody?: undefined;
+            error?: undefined;
+        } | {
             source: string;
             method: string;
             path: string;
             status: number;
             requestBody: any;
             definition?: undefined;
+            rejectedCapture?: undefined;
+            usable?: undefined;
+            rejectedRequestBody?: undefined;
             error?: undefined;
         } | {
             source: string;
             definition: string;
             method?: undefined;
             path?: undefined;
+            rejectedCapture?: undefined;
+            usable?: undefined;
+            rejectedRequestBody?: undefined;
             status?: undefined;
             requestBody?: undefined;
             error?: undefined;
@@ -29,20 +60,25 @@ export declare function createFishermanTools(apiClient: ApiClient, requestStore:
             error: any;
             method?: undefined;
             path?: undefined;
+            definition?: undefined;
+            rejectedCapture?: undefined;
+            usable?: undefined;
+            rejectedRequestBody?: undefined;
             status?: undefined;
             requestBody?: undefined;
-            definition?: undefined;
         }, import("@ai-sdk/provider-utils").Context>>;
         request: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<any, {
             success: boolean;
             error: string;
             status?: undefined;
             statusText?: undefined;
+            category?: undefined;
             errorPreview?: undefined;
         } | {
             success: boolean;
             status: number;
             statusText: string;
+            category: ResponseCategory;
             errorPreview: string;
             error?: undefined;
         } | {
@@ -50,6 +86,7 @@ export declare function createFishermanTools(apiClient: ApiClient, requestStore:
             status: number;
             error?: undefined;
             statusText?: undefined;
+            category?: undefined;
             errorPreview?: undefined;
         }, import("@ai-sdk/provider-utils").Context>>;
         finish: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
@@ -88,3 +125,5 @@ export interface FishermanResult {
         reason: string;
     }>;
 }
+type ResponseCategory = 'validation' | 'authorization' | 'not_found' | 'conflict' | 'temporary' | 'server' | 'client';
+export {};

package/dist/src/ai/fisherman-tools.js

@@ -23,6 +23,29 @@ export function createFishermanTools(apiClient, requestStore, opts) {
                 tag('step').log(`Fisherman: spec lookup ${method} ${path}`);
                 const captured = requestStore.findCapturedRequest(method, path);
                 if (captured) {
+                    if (captured.status >= 400) {
+                        const rejectedCapture = {
+                            status: captured.status,
+                            requestBody: captured.requestBody || 'no body',
+                        };
+                        if (opts.spec) {
+                            try {
+                                const definition = extractEndpointDefinition(opts.spec, path, opts.baseEndpoint);
+                                return { source: 'spec', method, path, definition, rejectedCapture };
+                            }
+                            catch {
+                                return { source: 'captured', method, path, usable: false, rejectedRequestBody: captured.requestBody || 'no body', status: captured.status };
+                            }
+                        }
+                        return {
+                            source: 'captured',
+                            method: captured.method,
+                            path: captured.path,
+                            status: captured.status,
+                            usable: false,
+                            rejectedRequestBody: captured.requestBody || 'no body',
+                        };
+                    }
                     return {
                         source: 'captured',
                         method: captured.method,
@@ -74,6 +97,7 @@ export function createFishermanTools(apiClient, requestStore, opts) {
                         success: false,
                         status: reqResult.status,
                         statusText: reqResult.statusText,
+                        category: responseCategory(reqResult.status),
                         errorPreview: reqResult.rawResponseBody.substring(0, 300),
                     };
                 }
@@ -127,6 +151,21 @@ export function createFishermanTools(apiClient, requestStore, opts) {
     };
     return { tools, getResult, isFinished };
 }
+function responseCategory(status) {
+    if (status === 400 || status === 422)
+        return 'validation';
+    if (status === 401 || status === 403)
+        return 'authorization';
+    if (status === 404)
+        return 'not_found';
+    if (status === 409)
+        return 'conflict';
+    if (status === 408 || status === 425 || status === 429)
+        return 'temporary';
+    if (status >= 500)
+        return 'server';
+    return 'client';
+}
 function extractKeyFields(body, result = {}, depth = 0) {
     if (!body || typeof body !== 'object' || depth > 5)
         return result;

package/dist/src/ai/fisherman.js

@@ -170,7 +170,8 @@ export class Fisherman {
       RULES:
       - Always call getEndpointSpec before your first request to an unfamiliar endpoint
       - Chain requests logically — create parent resources before children
-      - If a request fails, try once more with adjusted data before reporting failure
+      - Use the response category and error text to decide what failed: validation requires corrected data, authorization requires valid access, not_found requires a valid path or parent, and conflict requires resolving the conflicting state
+      - Retry temporary or server failures once. Retry other failures only when the specification or error text gives a concrete correction
       - Use realistic but unique data for each item (vary names, titles)
 
       ${dataProtectionRules}

package/dist/src/ai/navigator.d.ts

@@ -39,12 +39,13 @@ declare class Navigator implements Agent {
     resolveState(message: string, actionResult: ActionResult, opts?: {
         action?: Action;
         expectedUrl?: string;
+        experience?: string;
         onAttempt?: (attempt: {
             code: string;
             error?: string;
         }) => void;
     }): Promise<boolean>;
-    buildResolutionPrompt(message: string, actionResult: ActionResult): Promise<string>;
+    buildResolutionPrompt(message: string, actionResult: ActionResult, injectedExperience?: string): Promise<string>;
     buildRetryFeedback(failures: BatchFailure[], includeHtml: boolean, actionResult: ActionResult): Promise<string>;
     executeAttempt(action: Action, codeBlock: string, message: string): Promise<{
         ok: boolean;

package/dist/src/ai/navigator.js

@@ -200,7 +200,7 @@ class Navigator {
         const expectedUrl = opts?.expectedUrl;
         const knowledge = this.knowledgeTracker.renderRelevantContext(actionResult);
         const conversation = this.provider.startConversation(this.systemPrompt, 'navigator');
-        conversation.addUserText(await this.buildResolutionPrompt(message, actionResult));
+        conversation.addUserText(await this.buildResolutionPrompt(message, actionResult, opts?.experience));
         let stopReason = null;
         const tools = {
             stop: tool({
@@ -333,14 +333,10 @@ class Navigator {
         }
         return resolved;
     }
-    async buildResolutionPrompt(message, actionResult) {
-        let experience = '';
-        if (!actionResult.isInsideIframe) {
-            const successful = this.experienceTracker.getSuccessfulExperience(actionResult);
-            if (successful.length > 0) {
-                tag('operation').log(`Found ${successful.length} experience ${pluralize(successful.length, 'file')} for: ${actionResult.url}`);
-                experience = `<experience>\nPast successful recipes recorded from prior runs for this page. Prefer these solutions first if they match the goal.\n\n${successful.join('\n\n')}\n</experience>`;
-            }
+    async buildResolutionPrompt(message, actionResult, injectedExperience) {
+        let experience = injectedExperience || '';
+        if (!experience && !actionResult.isInsideIframe) {
+            experience = this.experienceTracker.renderExperienceFor(actionResult);
         }
         return dedent `
       <message>

package/dist/src/ai/pilot.js

@@ -15,6 +15,8 @@ import { isInteractive } from "./task-agent.js";
 import { withdrawVisionTools } from "./tools.js";
 const CHECK_TOOLS = ['verify', 'see', 'research', 'context'];
 const META_TOOLS = ['record', 'reset', 'stop', 'finish'];
+const PILOT_MESSAGE_LIMIT = 2;
+const PILOT_MESSAGE_MAX_LENGTH = 160;
 export class Pilot {
     emoji = '🧭';
     provider;
@@ -411,9 +413,13 @@ export class Pilot {
         the elements needed for the scenario. The page summary does not list every element.
         Prefer interacting with the current page over navigating away.
 
-        If you load a recipe via learnExperience, do NOT rewrite its code in your plan — the
-        raw recipe is forwarded to Tester automatically. Reference it by step ("apply recipe
-        steps 1–3, then…") and call out anywhere your scenario diverges from it.
+        Tester never sees <experience> — a recorded recipe reaches it only when you open one.
+        The entries listed are what was recorded on the page you are on now; recipes for the
+        pages this test moves to are listed when it gets there. Open the ones whose titles fit a
+        step taken from here, and say so in the plan when none of them fit.
+        Do NOT rewrite a loaded recipe's code — the raw recipe is forwarded to Tester
+        automatically. Reference it by step ("apply recipe steps 1–3, then…") and call out
+        anywhere your scenario diverges from it.
 
         Be concise and specific. Tester will follow your plan.
       `, 'pilot.planTest', { tools: true, maxToolRoundtrips: 3, task });
@@ -452,7 +458,9 @@ export class Pilot {
         ${this.formatExpectations(task)}
 
         First: evaluate whether this navigation makes sense for the scenario goal. If the page is unrelated, instruct Tester to back() or reset(). Then plan next steps.
-      `, 'pilot.reviewNewPage', { task });
+
+        Tester holds no recipe for this page until you load one — open the <experience> entries whose titles fit a step you are about to instruct.
+      `, 'pilot.reviewNewPage', { tools: true, maxToolRoundtrips: 2, task });
     }
     async analyzeProgress(task, currentState, testerConversation) {
         tag('substep').log('Pilot analyzing progress...');
@@ -479,6 +487,8 @@ export class Pilot {
         </recent_actions>
 
         What should Tester do next?
+
+        Before proposing new locators for a step that keeps failing, check <experience> for a recorded recipe covering it and load it.
       `, 'pilot.analyze', { tools: hasFailures, maxToolRoundtrips: hasFailures ? 2 : 0, task });
         const contextToAttach = await this.fetchRequestedContext(text, currentState);
         if (contextToAttach) {
@@ -580,10 +590,10 @@ export class Pilot {
         debugLog(`sendToPilot: ${functionId}, tools: ${!!opts.tools}, roundtrips: ${opts.maxToolRoundtrips ?? 0}`);
         let finalUserText = userText;
         if (opts.tools) {
+            this.conversation.cleanupTag('experience', '...cleaned experience index...');
             const tocBlock = this.getExperienceToc();
-            if (tocBlock) {
+            if (tocBlock)
                 finalUserText = `${tocBlock}\n\n${userText}`;
-            }
         }
         this.conversation.addUserText(finalUserText);
         const tools = { ...this.pickPlanningTools(), ...this.buildPreconditionTool(opts.task) };
@@ -595,9 +605,10 @@ export class Pilot {
             telemetry: { functionId },
         });
         const text = result?.response?.text || '';
-        const learned = (result?.toolExecutions || []).filter((e) => e.toolName === 'learnExperience' && e.output?.content).map((e) => e.output.content);
+        const learned = (result?.toolExecutions || []).filter((e) => e.toolName === 'learnExperience' && e.output?.content).map((e) => ({ url: e.output.url, content: e.output.content }));
         if (learned.length === 0)
             return text;
+        opts.task.applyExperience(learned);
         return dedent `
       ${text}
 
@@ -605,7 +616,7 @@ export class Pilot {
       Recipes from prior successful runs that Pilot judged relevant. Locators worked then; the page may have changed since.
       Treat code blocks below as a starting hypothesis. If a locator misses, fall back to ARIA/UI-map.
 
-      ${learned.join('\n\n')}
+      ${learned.map((recipe) => recipe.content).join('\n\n')}
       </applied_experience>
     `;
     }
@@ -638,6 +649,7 @@ export class Pilot {
         return planning;
     }
     buildPreconditionTool(task) {
+        const unavailable = 'Data was not created and cannot be created automatically. Do not call precondition again for this test — continue with what the page already shows.';
         return {
             precondition: tool({
                 description: 'Create fresh disposable data that the test will act on (edit, delete, filter). Describe WHAT to create, not what exists. Do NOT request users. Examples: "1 post", "1 comment", "1 label named Bug".',
@@ -652,7 +664,7 @@ export class Pilot {
                         const skipReason = await this.checkDataAvailability(task, description, 'Fisherman not available');
                         if (skipReason)
                             return { noted: true, prepared: false, skipped: true, reason: skipReason };
-                        return { noted: true, prepared: false, reason: 'Fisherman not available' };
+                        return { noted: true, prepared: false, reason: unavailable };
                     }
                     const result = await this.fisherman.prepareData(description, task.startUrl, task.sessionName);
                     if (!result.success || result.created.length === 0) {
@@ -661,7 +673,7 @@ export class Pilot {
                         const skipReason = await this.checkDataAvailability(task, description, result.summary);
                         if (skipReason)
                             return { noted: true, prepared: false, skipped: true, reason: skipReason };
-                        return { noted: true, prepared: false, reason: result.summary };
+                        return { noted: true, prepared: false, reason: `${result.summary || 'Data preparation failed'}. ${unavailable}` };
                     }
                     const items = result.created.map((c) => {
                         const parts = [c.type];
@@ -696,7 +708,7 @@ export class Pilot {
 
       Reply with YES or NO on the first line, then a one-sentence reason on the second line.
     `;
-        const answer = await this.researcher.answerQuestionAboutScreenshot(screenshotState, question);
+        const answer = await this.researcher.answerQuestionAboutScreenshot(screenshotState, question).catch(() => null);
         if (!answer)
             return null;
         const firstLine = answer.split('\n')[0]?.trim().toUpperCase() ?? '';
@@ -779,14 +791,6 @@ export class Pilot {
     }
     async fetchRequestedContext(text, currentState) {
         const parts = [];
-        if (text.includes('ATTACH_HTML')) {
-            const html = await currentState.simplifiedHtml();
-            parts.push(dedent `
-        <page_html>
-        ${html}
-        </page_html>
-      `);
-        }
         if (text.includes('ATTACH_ARIA')) {
             parts.push(dedent `
         <page_aria>
@@ -942,6 +946,19 @@ export class Pilot {
             const ariaDiff = t.output?.pageDiff?.ariaChanges;
             if (ariaDiff)
                 line += `\n   ${ariaDiff}`;
+            if (t.output?.pageDiff?.urlChanged)
+                line += `\n   moved: ${t.output.pageDiff.previousUrl} → ${t.output.pageDiff.currentUrl}`;
+            const failedRequests = (t.output?.pageDiff?.requests ?? []).filter((r) => r.status >= 400);
+            if (failedRequests.length > 0) {
+                line += `\n   requests: ${failedRequests.map((r) => `${r.method} ${r.path} → ${r.status}`).join(', ')}`;
+            }
+            const messages = (t.output?.pageDiff?.messages ?? []).slice(0, PILOT_MESSAGE_LIMIT);
+            if (messages.length > 0) {
+                line += `\n   messages: ${messages.map((m) => m.slice(0, PILOT_MESSAGE_MAX_LENGTH)).join(' | ')}`;
+            }
+            const consoleError = t.output?.pageDiff?.consoleErrors?.[0];
+            if (consoleError)
+                line += `\n   console: ${consoleError.slice(0, PILOT_MESSAGE_MAX_LENGTH)}`;
             return line;
         })
             .join('\n\n');
@@ -1007,10 +1024,10 @@ export class Pilot {
       role, icon classes with "or" in one XPath. If empty, broaden (drop role filter). Pass discovered
       XPath into NEXT instruction.
 
-      To request more context, mention ATTACH_HTML, ATTACH_ARIA, or ATTACH_UI_MAP — only when recent actions show failures.
+      To request more context, mention ATTACH_ARIA, ATTACH_SUMMARY, or ATTACH_UI_MAP — only when recent actions show failures.
 
-      Tester tools: click, pressKey, form, see, verify, context, research, xpathCheck, visualClick,
-      back, getVisitedStates, reset, stop, finish, record.
+      Tester tools: click, pressKey, form, see, verify, interact, context, research, xpathCheck,
+      visualClick, back, getVisitedStates, reset, stop, finish, record.
       Use tool names exactly as listed. Do not invent combined names, aliases, or names with channel markers such as "commentary".
 
       ${capabilityGroundingRule}

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

@@ -1,7 +1,7 @@
 import dedent from 'dedent';
 import { z } from 'zod';
 import { normalizeUrl } from "../../state-manager.js";
-import { isDynamicSegment } from "../../utils/url-matcher.js";
+import { isSamePageFamily } from "../../utils/url-matcher.js";
 const planRegistry = new Map();
 export function registerPlan(url, plan, feature, stateHash) {
     const key = buildKey(url, feature);
@@ -28,21 +28,7 @@ function buildKey(url, feature) {
     return normalized;
 }
 export function isTemplateMatch(urlA, urlB) {
-    const partsA = normalizeUrl(urlA).split('/');
-    const partsB = normalizeUrl(urlB).split('/');
-    if (partsA.length !== partsB.length)
-        return false;
-    let diffCount = 0;
-    for (let i = 0; i < partsA.length; i++) {
-        if (partsA[i] === partsB[i])
-            continue;
-        diffCount++;
-        if (diffCount > 1)
-            return false;
-        if (!isDynamicSegment(partsA[i]) && !isDynamicSegment(partsB[i]))
-            return false;
-    }
-    return diffCount === 1;
+    return isSamePageFamily(urlA, urlB);
 }
 export function getPlannedByStateHash(hash) {
     for (const record of planRegistry.values()) {

package/dist/src/ai/planner.js

@@ -127,7 +127,7 @@ export class Planner extends PlannerBase {
             }
             const actionResult = ActionResult.fromState(state);
             const combinedHtml = await actionResult.combinedHtml();
-            const similarHash = await findSimilarStateHash(combinedHtml);
+            const similarHash = await findSimilarStateHash(combinedHtml, state.url);
             if (similarHash) {
                 const planned = getPlannedByStateHash(similarHash);
                 if (planned) {