explorbot 0.3.5 → 0.4.1

package/dist/src/ai/driller.js

@@ -6,10 +6,9 @@ import { setActivity } from "../activity.js";
 import { Observability } from "../observability.js";
 import { Plan, Test, TestResult } from "../test-plan.js";
 import { collectInteractiveNodes } from "../utils/aria.js";
-import { EXPLORBOT_ATTRS, HTML_COMPOSITE_AREA_HINTS, HTML_COMPOSITE_TARGET_ROLES, HTML_EXTRACTION_LIMITS, HTML_FORM_CONTROL_ROLES, HTML_FORM_CONTROL_TAGS, HTML_INTERACTIVE_ROLES, HTML_SELECTORS, HTML_VISIBILITY_LIMITS, getComponentScopeHtmlExtractorSource, getVisibleOverlayHtmlExtractorSource, inferHtmlRole, } from "../utils/html.js";
+import { EXPLORBOT_ATTRS, HTML_COMPOSITE_AREA_HINTS, HTML_COMPOSITE_TARGET_ROLES, HTML_EXTRACTION_LIMITS, HTML_FORM_CONTROL_ROLES, HTML_FORM_CONTROL_TAGS, HTML_INTERACTIVE_ROLES, HTML_SELECTORS, getComponentScopeHtmlExtractorSource, inferHtmlRole } from "../utils/html.js";
 import { createDebug, tag } from "../utils/logger.js";
 import { loop, pause } from "../utils/loop.js";
-import { OVERLAY_SELECTORS } from "../utils/overlay.js";
 import { annotatePageElements } from "../utils/web-annotate.js";
 import { eidxInContainer } from "../utils/web-eidx.js";
 import { WebElement } from "../utils/web-element.js";
@@ -547,8 +546,12 @@ export class Driller extends TaskAgent {
     async detectNestedOverlayContext(component, result) {
         if (!result?.pageDiff?.ariaChanges || result.pageDiff.urlChanged)
             return null;
-        const overlayHtml = await this.getVisibleOverlayHtml();
-        if (!overlayHtml)
+        const parts = result.pageDiff.htmlParts ?? [];
+        let appeared = parts.filter((part) => part.added?.length > 0);
+        if (result.pageDiff.areaOfInterest)
+            appeared = parts;
+        const appearedHtml = appeared.map((part) => part.subtree).join('\n');
+        if (!appearedHtml)
             return null;
         const state = this.stateManager.getCurrentState();
         if (!state)
@@ -561,7 +564,7 @@ export class Driller extends TaskAgent {
       Keep the recorded code reusable and include the parent-opening action when the nested element requires the overlay to be open.
 
       <overlay_html>
-      ${overlayHtml}
+      ${appearedHtml}
       </overlay_html>
 
       <current_page_aria>
@@ -570,21 +573,6 @@ export class Driller extends TaskAgent {
       </nested_overlay>
     `;
     }
-    async getVisibleOverlayHtml() {
-        return this.explorer.withPage((page) => page.evaluate(({ extractorSource, config }) => {
-            const extract = new Function(`return ${extractorSource}`)();
-            return extract(config);
-        }, {
-            extractorSource: getVisibleOverlayHtmlExtractorSource(),
-            config: {
-                interactiveContentSelector: HTML_SELECTORS.interactiveContent,
-                limits: HTML_EXTRACTION_LIMITS,
-                overlaySelectors: OVERLAY_SELECTORS.semanticOverlays,
-                overlaySemanticSelector: OVERLAY_SELECTORS.overlaySemanticSelector,
-                visibilityLimits: HTML_VISIBILITY_LIMITS,
-            },
-        }));
-    }
     async getComponentScopeHtml(component, originalState) {
         const scopedHtml = await this.explorer.withPage((page) => page.evaluate(({ eidx, extractorSource, config }) => {
             const extract = new Function(`return ${extractorSource}`)();

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

@@ -74,6 +74,7 @@ export declare function createFishermanTools(apiClient: ApiClient, requestStore:
             statusText?: undefined;
             category?: undefined;
             errorPreview?: undefined;
+            extracted?: undefined;
         } | {
             success: boolean;
             status: number;
@@ -81,9 +82,11 @@ export declare function createFishermanTools(apiClient: ApiClient, requestStore:
             category: ResponseCategory;
             errorPreview: string;
             error?: undefined;
+            extracted?: undefined;
         } | {
             success: boolean;
             status: number;
+            extracted: Record<string, any>;
             error?: undefined;
             statusText?: undefined;
             category?: undefined;
@@ -102,6 +105,10 @@ export declare function createFishermanTools(apiClient: ApiClient, requestStore:
             }[];
         }, {
             finished: boolean;
+            error: string;
+        } | {
+            finished: boolean;
+            error?: undefined;
         }, import("@ai-sdk/provider-utils").Context>>;
         stop: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
             reason: any;
@@ -111,6 +118,7 @@ export declare function createFishermanTools(apiClient: ApiClient, requestStore:
     };
     getResult: () => FishermanResult;
     isFinished: () => boolean;
+    finishFromText: (text?: string) => void;
 };
 export interface FishermanResult {
     success: boolean;
@@ -119,6 +127,7 @@ export interface FishermanResult {
         type: string;
         id?: string | number;
         title?: string;
+        request?: string;
     }>;
     failed: Array<{
         type: string;

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

@@ -3,11 +3,23 @@ import dedent from 'dedent';
 import { z } from 'zod';
 import { extractEndpointDefinition } from "../api/spec-reader.js";
 import { tag } from "../utils/logger.js";
+import { RequestMap } from "../utils/request-map.js";
+import { isDynamicSegment } from "../utils/url-matcher.js";
 export function createFishermanTools(apiClient, requestStore, opts) {
     let finished = false;
-    let result = { success: false, summary: '', created: [], failed: [] };
-    const getResult = () => result;
+    let result = null;
+    const ledgerStart = requestStore.getMadeRequests().length;
+    const runRequests = () => requestStore.getMadeRequests().slice(ledgerStart);
+    const successfulWrites = () => runRequests().filter((r) => r.isWrite && !r.error && r.status >= 200 && r.status < 400);
+    const getResult = () => result ?? synthesizeResult(runRequests(), successfulWrites(), false);
     const isFinished = () => finished;
+    const finishFromText = (text) => {
+        finished = true;
+        const synthesized = synthesizeResult(runRequests(), successfulWrites(), true);
+        if (text && synthesized.success)
+            synthesized.summary = text;
+        result = synthesized;
+    };
     const tools = {
         getEndpointSpec: tool({
             description: dedent `
@@ -69,7 +81,7 @@ export function createFishermanTools(apiClient, requestStore, opts) {
         request: tool({
             description: dedent `
         Make an HTTP request to the API.
-        Returns status, timing, and auto-extracted IDs and names from the response.
+        Returns status, plus IDs and names auto-extracted from the response under 'extracted'.
       `,
             inputSchema: z.object({
                 method: z.enum(['GET', 'POST', 'PUT', 'PATCH', 'DELETE']).describe('HTTP method'),
@@ -106,7 +118,7 @@ export function createFishermanTools(apiClient, requestStore, opts) {
                 return {
                     success: true,
                     status: reqResult.status,
-                    ...extracted,
+                    extracted,
                 };
             },
         }),
@@ -130,9 +142,30 @@ export function createFishermanTools(apiClient, requestStore, opts) {
                     .describe('List of items that could not be created'),
             }),
             execute: async ({ summary, created, failed }) => {
+                const writes = successfulWrites();
+                if (writes.length === 0) {
+                    tag('warning').log('Fisherman: finish rejected — no successful write request in this run');
+                    return { finished: false, error: 'No successful write request was made in this run, so nothing was created. Keep working, or call stop if the data cannot be prepared.' };
+                }
+                const createdRequests = new RequestMap(writes);
+                const verified = [];
+                for (const item of created) {
+                    if (item.id === undefined) {
+                        verified.push(item);
+                        continue;
+                    }
+                    const request = createdRequests.get(item.id);
+                    if (!request) {
+                        tag('warning').log(`Fisherman: dropped unverified created item ${item.type} (id: ${item.id})`);
+                        continue;
+                    }
+                    verified.push({ ...item, request: request.toEndpoint() });
+                }
+                if (verified.length === 0)
+                    verified.push(...writes.map(toCreatedItem));
                 tag('success').log(`Fisherman done: ${summary}`);
                 finished = true;
-                result = { success: true, summary, created, failed: failed || [] };
+                result = { success: true, summary, created: verified, failed: failed || [] };
                 return { finished: true };
             },
         }),
@@ -149,7 +182,20 @@ export function createFishermanTools(apiClient, requestStore, opts) {
             },
         }),
     };
-    return { tools, getResult, isFinished };
+    return { tools, getResult, isFinished, finishFromText };
+}
+function synthesizeResult(made, writes, declaredDone) {
+    const failures = made.filter((r) => r.status >= 400 || r.error);
+    let summary = `Stopped before finishing: ${made.length} requests, ${writes.length} successful writes, ${failures.length} failed`;
+    const lastFailure = failures[failures.length - 1];
+    if (lastFailure)
+        summary += `; last failure: ${lastFailure.toSummary()}`;
+    return { success: declaredDone && writes.length > 0, summary, created: writes.map(toCreatedItem), failed: [] };
+}
+function toCreatedItem(write) {
+    const { id, title } = write.extractIdAndTitle();
+    const segments = write.path.split('/').filter((s) => s && !isDynamicSegment(s));
+    return { type: segments[segments.length - 1] || 'item', id, title, request: write.toEndpoint() };
 }
 function responseCategory(status) {
     if (status === 400 || status === 422)

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

@@ -9,14 +9,15 @@ export declare class Fisherman implements Agent {
     apiClient: ApiClient;
     requestStore: RequestStore;
     specLoader: () => Promise<any | null>;
-    cookieProvider: () => Promise<Record<string, string>>;
+    browserHeaderProvider: () => Promise<Record<string, string>>;
     configHeaders: Record<string, string>;
     sessionName?: string;
     baseEndpoint: string;
     spec: any | null;
     mode: 'replicate' | 'achieve' | 'disabled';
     hasApiConfig: boolean;
-    constructor(provider: Provider, apiClient: ApiClient, requestStore: RequestStore, specLoader: () => Promise<any | null>, baseEndpoint: string, cookieProvider: () => Promise<Record<string, string>>, configHeaders?: Record<string, string>, hasApiConfig?: boolean);
+    scopeDegraded: boolean;
+    constructor(provider: Provider, apiClient: ApiClient, requestStore: RequestStore, specLoader: () => Promise<any | null>, baseEndpoint: string, browserHeaderProvider: () => Promise<Record<string, string>>, configHeaders?: Record<string, string>, hasApiConfig?: boolean);
     isAvailable(): boolean;
     ensureReady(scopeUrl?: string): Promise<void>;
     getEndpointList(scopeUrl?: string): string;
@@ -25,5 +26,6 @@ export declare class Fisherman implements Agent {
     refreshAuth(): Promise<void>;
     buildEndpointList(scopeUrl?: string): string;
     buildSystemPrompt(endpointList: string, toolNames: string[], scopeUrl?: string): string;
+    isStuckOnEndpoint(ledgerStart: number): boolean;
     buildTaskPrompt(instructions: string): string;
 }

package/dist/src/ai/fisherman.js

@@ -7,26 +7,28 @@ import { createFishermanTools } from "./fisherman-tools.js";
 import { dataProtectionRules } from "./rules.js";
 const MAX_ITERATIONS = 15;
 const MAX_TOOL_ROUNDTRIPS = 5;
+const REPEATED_FAILURE_LIMIT = 4;
 export class Fisherman {
     emoji = '🎣';
     provider;
     apiClient;
     requestStore;
     specLoader;
-    cookieProvider;
+    browserHeaderProvider;
     configHeaders;
     sessionName;
     baseEndpoint;
     spec = null;
     mode = 'disabled';
     hasApiConfig;
-    constructor(provider, apiClient, requestStore, specLoader, baseEndpoint, cookieProvider, configHeaders = {}, hasApiConfig = false) {
+    scopeDegraded = false;
+    constructor(provider, apiClient, requestStore, specLoader, baseEndpoint, browserHeaderProvider, configHeaders = {}, hasApiConfig = false) {
         this.provider = provider;
         this.apiClient = apiClient;
         this.requestStore = requestStore;
         this.specLoader = specLoader;
         this.baseEndpoint = baseEndpoint;
-        this.cookieProvider = cookieProvider;
+        this.browserHeaderProvider = browserHeaderProvider;
         this.configHeaders = configHeaders;
         this.hasApiConfig = hasApiConfig;
         this.mode = hasApiConfig ? 'achieve' : 'replicate';
@@ -59,17 +61,17 @@ export class Fisherman {
         }
         await this.refreshAuth();
         debugLog(`auth headers: ${Object.keys(this.apiClient.getHeaders()).join(', ')}`);
-        const { tools, getResult, isFinished } = createFishermanTools(this.apiClient, this.requestStore, {
+        const { tools, getResult, isFinished, finishFromText } = createFishermanTools(this.apiClient, this.requestStore, {
             spec: this.spec,
             baseEndpoint: this.baseEndpoint,
         });
+        const ledgerStart = this.requestStore.getMadeRequests().length;
         const conversation = this.provider.startConversation(this.buildSystemPrompt(endpointList, Object.keys(tools), scopeUrl), 'fisherman');
         conversation.addUserText(this.buildTaskPrompt(instructions));
         await loop(async ({ stop, iteration }) => {
             debugLog(`iteration ${iteration}`);
             const invokeResult = await this.provider.invokeConversation(conversation, tools, {
                 maxToolRoundtrips: MAX_TOOL_ROUNDTRIPS,
-                toolChoice: 'required',
                 agentName: 'fisherman',
             });
             debugLog(`iteration ${iteration} done, text: ${invokeResult?.response?.text?.slice(0, 200) || '(none)'}`);
@@ -77,6 +79,17 @@ export class Fisherman {
                 stop();
                 return;
             }
+            if (!invokeResult?.toolExecutions?.length) {
+                debugLog('no tool call in this turn — treating as finish');
+                finishFromText(invokeResult?.response?.text);
+                stop();
+                return;
+            }
+            if (this.isStuckOnEndpoint(ledgerStart)) {
+                tag('warning').log('Fisherman: repeated failures on the same endpoint — stopping');
+                stop();
+                return;
+            }
             if (iteration >= MAX_ITERATIONS) {
                 tag('warning').log('Fisherman: max iterations reached');
                 stop();
@@ -114,41 +127,40 @@ export class Fisherman {
         this.mode = 'disabled';
     }
     async refreshAuth() {
-        const cookies = await this.cookieProvider();
-        if (Object.keys(cookies).length > 0) {
-            this.apiClient.setHeaders(cookies);
-        }
-        const xhrHeaders = this.requestStore.extractAuthHeaders();
-        if (Object.keys(xhrHeaders).length > 0) {
-            this.apiClient.setHeaders(xhrHeaders);
+        if (this.mode === 'replicate') {
+            const xhrHeaders = this.requestStore.extractAuthHeaders();
+            if (Object.keys(xhrHeaders).length > 0) {
+                this.apiClient.setHeaders(xhrHeaders);
+            }
+            const browserHeaders = await this.browserHeaderProvider();
+            if (Object.keys(browserHeaders).length > 0) {
+                this.apiClient.setHeaders(browserHeaders);
+            }
         }
         if (Object.keys(this.configHeaders).length > 0) {
             this.apiClient.setHeaders(this.configHeaders);
         }
     }
     buildEndpointList(scopeUrl) {
+        this.scopeDegraded = false;
         if (this.mode === 'achieve' && this.spec) {
             const specEndpoints = listAllEndpoints(this.spec, this.baseEndpoint);
             if (specEndpoints)
                 return specEndpoints;
         }
-        let writeRequests = this.requestStore.getWriteRequestsForScope(scopeUrl || '/');
-        if (writeRequests.length === 0) {
-            writeRequests = this.requestStore.getWriteRequestsForScope('/');
-        }
-        const seen = new Set();
-        const lines = [];
-        for (const req of writeRequests) {
-            const key = `${req.method} ${req.path}`;
-            if (seen.has(key))
-                continue;
-            seen.add(key);
-            lines.push(key);
-        }
-        return lines.join('\n');
+        const scoped = this.requestStore.toEndpointList(scopeUrl || '/');
+        if (scoped)
+            return scoped;
+        this.scopeDegraded = true;
+        return this.requestStore.toEndpointList();
     }
     buildSystemPrompt(endpointList, toolNames, scopeUrl) {
-        const scopeBlock = scopeUrl ? `\n\nSCOPE: You are operating within ${scopeUrl}.\nAll created items must belong to this scope.` : '';
+        let scopeBlock = '';
+        if (scopeUrl) {
+            scopeBlock = `\n\nSCOPE: You are operating within ${scopeUrl}.\nAll created items must belong to this scope.`;
+            if (this.scopeDegraded)
+                scopeBlock += '\nThe endpoint list could not be narrowed to this scope and may include endpoints belonging to other scopes. Before writing, confirm the target belongs to this scope.';
+        }
         return dedent `
       You are Fisherman — a data preparation agent. You create test data by making API requests.
 
@@ -172,11 +184,20 @@ export class Fisherman {
       - Chain requests logically — create parent resources before children
       - 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
+      - Create only the resource types that were requested. If no endpoint creates a requested type, call stop — never create a different type as a substitute
       - Use realistic but unique data for each item (vary names, titles)
 
       ${dataProtectionRules}
     `;
     }
+    isStuckOnEndpoint(ledgerStart) {
+        const made = this.requestStore.getMadeRequests().slice(ledgerStart);
+        if (made.length < REPEATED_FAILURE_LIMIT)
+            return false;
+        const recent = made.slice(-REPEATED_FAILURE_LIMIT);
+        const first = recent[0];
+        return recent.every((r) => (r.status >= 400 || r.error) && r.method === first.method && r.path === first.path);
+    }
     buildTaskPrompt(instructions) {
         return dedent `
       Prepare the following test data:

package/dist/src/ai/historian/codeceptjs.js

@@ -45,7 +45,7 @@ export function WithCodeceptJS(Base) {
             lines.push('');
             lines.push(`Feature('${escapeString(plan.title)}')`);
             lines.push('');
-            const startUrl = plan.url || plan.tests[0]?.startUrl;
+            const startUrl = plan.startUrl;
             if (startUrl) {
                 lines.push('Before(({ I }) => {');
                 lines.push(`  I.amOnPage('${escapeString(startUrl)}');`);

package/dist/src/ai/historian/playwright.js

@@ -78,7 +78,7 @@ export function WithPlaywright(Base) {
             lines.push(`import { test, expect } from '@playwright/test';`);
             lines.push('');
             lines.push(`test.describe('${escapeString(plan.title)}', () => {`);
-            const startUrl = plan.url || plan.tests[0]?.startUrl;
+            const startUrl = plan.startUrl;
             if (startUrl) {
                 lines.push('  test.beforeEach(async ({ page }) => {');
                 lines.push(`    await page.goto('${escapeString(startUrl)}');`);

package/dist/src/ai/navigator.js

@@ -522,7 +522,7 @@ class Navigator {
             return null;
         }
         const currentActionResult = actionResult || ActionResult.fromState(state);
-        const research = Researcher.getCachedResearch(state) || '';
+        const research = Researcher.getCachedResearch(currentActionResult) || '';
         const combinedHtml = await currentActionResult.combinedHtml();
         const history = stateManager.getStateHistory();
         const visitCounts = new Map();

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

@@ -71,6 +71,7 @@ export declare class Pilot implements Agent {
                 type: string;
                 id?: string | number;
                 title?: string;
+                request?: string;
             }[];
             skipped?: undefined;
             reason?: undefined;

package/dist/src/ai/pilot.js

@@ -687,6 +687,8 @@ export class Pilot {
                             parts.push(`"${c.title}"`);
                         if (c.id)
                             parts.push(`(id: ${c.id})`);
+                        if (c.request)
+                            parts.push(`via ${c.request}`);
                         return parts.join(' ');
                     });
                     const stepText = `Precondition: created ${items.join(', ')}`;
@@ -741,7 +743,16 @@ export class Pilot {
         lines.push(`h4: ${state.h4 || ''}`);
         const focusArea = state.overlay;
         if (focusArea.detected) {
-            lines.push(`modal: ${focusArea.name || focusArea.type}`);
+            let line = `modal: ${focusArea.name || focusArea.type}`;
+            if (focusArea.root)
+                line += ` (root: ${focusArea.root})`;
+            lines.push(line);
+        }
+        else if (focusArea.present) {
+            let line = `region: ${focusArea.name || 'unnamed'} (inline`;
+            if (focusArea.root)
+                line += `, root: ${focusArea.root}`;
+            lines.push(`${line})`);
         }
         else {
             lines.push('modal: none');
@@ -1024,6 +1035,7 @@ export class Pilot {
       Diagnostic patterns (use <state>, executed/element/skipped fields, ariaDiff):
       - Click failed + button in "disabled buttons" → required field missing. Instruct fill first.
       - "modal: none" but Tester targets a modal → modal closed; re-trigger.
+      - "region:" in <state> → a large area appeared in place without navigation (subview, wizard step, panel). Direct Tester to act inside it; the rest of the page is still usable.
       - Action SUCCESS but ariaDiff empty → may have worked without visible DOM change; check result message.
       - MultipleElementsFound → xpathCheck() to identify the right one, then precise locator or visualClick().
       - Wrong page (settings vs feature) → getVisitedStates() then back() or reset(). Don't try breadcrumbs (SPA back-nav is unreliable).

package/dist/src/ai/planner.js

@@ -96,11 +96,15 @@ export class Planner extends PlannerBase {
       Tests must be relevant to the page
       Tests must be achievable from UI
       Tests must be verifiable from UI
-      NEVER split one workflow into multiple tests. Each test must be a complete end-to-end flow.
+      One test verifies ONE business operation: the steps that reach it, the action itself, and its verification.
+      Steps that only reach the action — opening a form, expanding a panel, creating or locating the item to act on — belong to that test. A second operation with its own verification does not.
       Bad: "Open delete dropdown" + "Confirm deletion" — these are ONE test, not two.
       Bad: "Search for X" + "Verify search results" — searching and verifying is ONE test.
       Bad: "Leave field empty" + "Click submit" — that's one negative test, not two.
-      If two scenarios cannot run independently (one requires the other to run first), merge them into one.${featureDirective}${focusExistingDataDirective}
+      Bad: "Create a record, rename it, delete it" — three verified operations, so THREE tests, not one.
+      Good: "Rename existing record and verify the new title" — ONE test; creating is skipped, we assume record already exists, only the rename is verified.
+      You may rely on another test having run first in case we deal with empty state and no relevant data was created yet and we expect another our test creates it
+      When the page reports a record is missing or unavailable, it is not a testable surface — plan list-level or recovery behavior instead of operations on that record.${featureDirective}${focusExistingDataDirective}
     </task>
 
     ${customPrompt || ''}
@@ -166,9 +170,6 @@ export class Planner extends PlannerBase {
             if (!aiResult?.object?.scenarios) {
                 throw new Error('No tasks were created successfully');
             }
-            if (aiResult.object.scenarios.length === 0 && !this.currentPlan) {
-                throw new Error('No tasks were created successfully');
-            }
             const defaultStartUrl = this.getDefaultStartUrl(state);
             const fromPlanning = aiResult.object.scenarios.map((s) => new Test(s.scenario, s.priority, s.expectedOutcomes, s.startUrl || defaultStartUrl, s.steps || []));
             return { tests: fromPlanning, planName: aiResult.object.planName };
@@ -295,6 +296,7 @@ export class Planner extends PlannerBase {
       <task>
       Based on the page research, create ${this.MIN_TASKS}-${this.MAX_TASKS} exploratory testing scenarios.
       For each scenario provide specific steps and expected outcomes.
+      Exception: if the page reports the requested resource is missing, shows a failure state, or holds no content and no controls, return an empty scenarios list. Never invent tests for a page with nothing to exercise.
       </task>
 
       <rules>
@@ -308,13 +310,13 @@ export class Planner extends PlannerBase {
       Focus on error or success messages as outcome.
       Focus on URL page change or data persistency after page reload.
       If there are subpages (pages with same URL path) plan testing of those subpages as well
-      If you plan to test CRUD operations, plan them in correct order: create, read, update.
+      Plan CRUD operations in order: create, read, update, delete.
       Do not invent specific route names, success messages, validation texts, badge counts, or welcome messages unless they are visible in research, visited pages, or prior observed flows.
       When validation placement or wording was not observed, require feedback associated with the invalid input without inventing a specific location or message.
       If exact wording is unknown, describe the expected result generically, for example "an authentication error is shown" or "the user stays on the login page" instead of guessing the literal text.
       If exact redirect destination is unknown, describe the destination by visible page identity, for example "the dashboard page opens" or "the current workspace home page opens" instead of inventing a URL slug.
       Only propose scenarios whose prerequisites are evident from page research, visited pages, or API data preparation context.
-      If a scenario needs existing records, recipients, results, notifications, or other target data, propose it only when that data is visible or API preconditions can create it.
+      If a scenario needs existing records, recipients, results, notifications, or other target data, propose it only when that data is visible, API preconditions can create it, or the scenario itself creates the record as its setup.
       If the page appears read-only, degraded, demo-limited, maintenance-like, or lacks write controls, prefer read-only scenarios such as opening panels, inspecting visible lists, filtering, searching, or verifying current state.
       Do not assume hidden data exists just because a control is present.
       For scenarios that act on existing items or search/filter by existing values, use only item names or values visible in research, visited pages, or prior observed flows.

package/dist/src/ai/provider.js

@@ -385,9 +385,19 @@ export class Provider {
         const config = this.buildGenerateConfig({ tools: toolsWithCommentary, maxOutputTokens: 16384, toolChoice: 'auto', experimental_repairToolCall: repairToolCall }, { stopWhen: stopConditions, model }, options);
         let attemptMessages = messages;
         let invalidRequestFeedbackAdded = false;
+        const executedStepMessages = [];
         try {
             const response = await this.withModelRequestSlot(() => withRetry(async () => {
-                const result = (await this.raceWithIdleTimeout((signal) => generateText({ messages: attemptMessages, ...config, abortSignal: signal }), config.timeout || 30000).catch((error) => {
+                const stepMessages = [];
+                const onStepEnd = (step) => {
+                    stepMessages.push(...(step.response?.messages || []));
+                };
+                const result = (await this.raceWithIdleTimeout((signal) => generateText({ messages: attemptMessages, ...config, abortSignal: signal, onStepEnd }), config.timeout || 30000).catch((error) => {
+                    if (stepMessages.length > 0) {
+                        tag('warning').log(`Keeping ${stepMessages.length} messages from tool steps that already ran before the failure`);
+                        executedStepMessages.push(...stepMessages);
+                        attemptMessages = [...attemptMessages, ...stepMessages];
+                    }
                     if (!invalidRequestFeedbackAdded) {
                         const amended = withInvalidRequestFeedback(attemptMessages, error);
                         invalidRequestFeedbackAdded = amended !== attemptMessages;
@@ -403,6 +413,7 @@ export class Provider {
                 return result;
             }, this.getRetryOptions(options)));
             clearActivity();
+            withExecutedSteps(response, executedStepMessages);
             // Log tool usage summary
             if (response.toolCalls && response.toolCalls.length > 0) {
                 responseLog(response.toolCalls);
@@ -416,14 +427,15 @@ export class Provider {
         catch (error) {
             clearActivity();
             if (error?.message?.includes('Tool choice is required')) {
-                return { text: '', toolCalls: [], toolResults: [], response: { messages: [] }, usage: null };
+                return { text: '', toolCalls: [], toolResults: [], responseMessages: executedStepMessages, usage: null };
             }
             if (error?.name === 'AbortError')
                 throw error;
             if (error instanceof ContextLengthError)
                 throw error;
             if (Provider.isContextLengthError(error)) {
-                return this.recoverFromContextLength(error, messages, options, (m, o) => this.generateWithTools(m, model, tools, o));
+                const recovered = await this.recoverFromContextLength(error, attemptMessages, options, (m, o) => this.generateWithTools(m, model, tools, o));
+                return withExecutedSteps(recovered, executedStepMessages);
             }
             if (error.constructor?.name === 'AI_APICallError') {
                 responseLog(error.message);
@@ -630,6 +642,11 @@ function repairToolCall(options) {
         return repairChannelMarker(options);
     return repairHarmonyChannel(options);
 }
+function withExecutedSteps(result, executed) {
+    if (executed.length === 0)
+        return result;
+    return Object.defineProperty(result, 'responseMessages', { value: [...executed, ...(result.responseMessages || [])], configurable: true, enumerable: true });
+}
 function withInvalidRequestFeedback(messages, error) {
     if (!(error instanceof APICallError) || error.statusCode !== 400)
         return messages;

package/dist/src/ai/researcher/deep-analysis.js

@@ -63,9 +63,7 @@ export function WithDeepAnalysis(Base) {
         }
         async researchOverlay(current, previous, pageStateHash) {
             const focusArea = current.overlay;
-            if (!focusArea.detected || !focusArea.name)
-                return null;
-            if (focusArea.type !== 'dialog' && focusArea.type !== 'modal')
+            if (!focusArea.present || !focusArea.name)
                 return null;
             const cached = getCachedResearch(pageStateHash);
             if (!cached)

package/dist/src/ai/researcher.js

@@ -53,7 +53,9 @@ export class Researcher extends ResearcherBase {
         throw new Error('not implemented');
     }
     static getCachedResearch(state) {
-        return getCachedResearch(state.hash || '');
+        if (state instanceof ActionResult)
+            return getCachedResearch(state.baseHash);
+        return getCachedResearch(ActionResult.fromState(state).baseHash);
     }
     getSystemMessage() {
         const currentUrl = this.stateManager.getCurrentState()?.url;
@@ -71,7 +73,7 @@ export class Researcher extends ResearcherBase {
         const maxRetries = this.config.ai?.agents?.researcher?.retries ?? 2;
         let retriesLeft = opts._retriesLeft ?? maxRetries;
         this.actionResult = ActionResult.fromState(state);
-        const stateHash = state.hash || this.actionResult.getStateHash();
+        const stateHash = this.actionResult.baseHash;
         const researchState = { ...state, hash: stateHash };
         if (!force && stateHash) {
             const cached = getCachedResearch(stateHash);
@@ -223,7 +225,7 @@ export class Researcher extends ResearcherBase {
             }
             if (!interrupted() && deep) {
                 try {
-                    await this.performDeepAnalysis(state, result);
+                    await this.performDeepAnalysis(researchState, result);
                 }
                 catch (err) {
                     tag('warning').log(`Deep analysis failed, continuing with best-effort research: ${err instanceof Error ? err.message : err}`);

package/dist/src/ai/rules.js

@@ -145,11 +145,11 @@ export const protectionRule = dedent `
 
   Pre-existing data on the page belongs to the application, not the test.
   Items that were not created inside the current test scenario must not be deleted, removed, emptied, reset, archived, or otherwise destroyed.
-  If a scenario needs to verify destructive behaviour, the same scenario must first create a disposable target and then destroy that specific target — never operate on data that was already there when the test started.
+  If a scenario needs to verify destructive behaviour, the same scenario must first create its own target and then destroy that specific target — never operate on data that was already there when the test started.
 
   The resource that the current page URL represents is "under test".
   The test must not destroy the resource it is running against — doing so invalidates every subsequent scenario that starts on the same URL.
-  Do not propose or perform delete/remove/archive actions on the entity that owns the current URL; propose such actions only on disposable children created within the scenario itself.
+  Do not propose or perform delete/remove/archive actions on the entity that owns the current URL; propose such actions only on children created within the scenario itself.
   </important>
 `;
 export const dataProtectionRules = dedent `
@@ -164,7 +164,7 @@ export const dataProtectionRules = dedent `
   filter, tab, or list-inspection constraint. Use visible existing data when it is available.
   If no suitable data exists, report the missing precondition instead of creating data.
 
-  Destructive actions are allowed only against disposable data created by the current scenario
+  Destructive actions are allowed only against data created by the current scenario
   or prepared for that scenario by Fisherman/API preconditions. Existing application data must
   remain unchanged.
   </data_protection_rules>