explorbot 0.0.1

package/dist/src/ai/pilot.js

@@ -0,0 +1,684 @@
+import { tool } from 'ai';
+import dedent from 'dedent';
+import { z } from 'zod';
+import { ConfigParser } from "../config.js";
+import { TestResult } from "../test-plan.js";
+import { collectInteractiveNodes, detectFocusArea, extractFocusedElement } from "../utils/aria.js";
+import { createDebug, tag } from "../utils/logger.js";
+const debugLog = createDebug('explorbot:pilot');
+import { truncateJson } from "../utils/strings.js";
+import { isInteractive } from "./task-agent.js";
+const CHECK_TOOLS = ['verify', 'see', 'research', 'context'];
+const META_TOOLS = ['record', 'reset', 'stop', 'finish'];
+export class Pilot {
+    emoji = '🧭';
+    provider;
+    agentTools;
+    conversation = null;
+    researcher;
+    explorer;
+    fisherman = null;
+    constructor(provider, agentTools, researcher, explorer) {
+        this.provider = provider;
+        this.agentTools = agentTools;
+        this.researcher = researcher;
+        this.explorer = explorer;
+    }
+    setFisherman(fisherman) {
+        this.fisherman = fisherman;
+    }
+    get stepsToReview() {
+        return ConfigParser.getInstance().getConfig().ai?.agents?.pilot?.stepsToReview ?? 5;
+    }
+    reset() {
+        this.conversation = null;
+    }
+    getLastAnalysis() {
+        if (!this.conversation)
+            return null;
+        return this.conversation.getLastMessage() || null;
+    }
+    async reviewStop(task, currentState, testerConversation) {
+        return this.reviewDecision('stop', task, currentState, testerConversation);
+    }
+    async reviewFinish(task, currentState, testerConversation) {
+        return this.reviewDecision('finish', task, currentState, testerConversation);
+    }
+    async reviewCompletion(task, currentState, testerConversation) {
+        const verdictType = task.hasAchievedAny() ? 'finish' : 'stop';
+        return this.reviewDecision(verdictType, task, currentState, testerConversation);
+    }
+    async finalReview(task, currentState, testerConversation) {
+        if (task.hasFinished)
+            return false;
+        return this.reviewCompletion(task, currentState, testerConversation);
+    }
+    async reviewDecision(type, task, currentState, testerConversation) {
+        tag('substep').log(`Pilot reviewing ${type} verdict...`);
+        const sessionLog = this.formatSessionLog(testerConversation);
+        const stateContext = this.buildStateContext(currentState);
+        const notes = task.notesToString() || 'No notes recorded.';
+        let visualAnalysis = '';
+        if (this.provider.hasVision()) {
+            try {
+                const action = this.explorer.createAction();
+                const screenshotState = await action.caputrePageWithScreenshot();
+                if (screenshotState.screenshot) {
+                    visualAnalysis = (await this.researcher.answerQuestionAboutScreenshot(screenshotState, `Describe current page state relevant to: ${task.scenario}`)) || '';
+                }
+            }
+            catch {
+                // vision not available, continue without
+            }
+        }
+        const schema = z.object({
+            decision: z.enum(['pass', 'fail', 'continue', 'skipped']).describe('pass = test succeeded, fail = test failed, continue = tester should keep going, skipped = scenario is irrelevant OR systematic execution failures prevented testing'),
+            reason: z.string().describe('What happened and why (1-2 sentences). Do NOT repeat the decision status (e.g. "scenario goal achieved/not achieved") — just explain the evidence. For continue: explain why rejected and suggest alternatives.'),
+            guidance: z.string().nullable().describe('Required for "continue": specific actionable instruction for the tester — what exactly to verify, retry differently, or complete next. Be concrete.'),
+        });
+        const userContent = dedent `
+      Tester wants to ${type} the test.
+
+      <state>
+      ${stateContext}
+      </state>
+
+      ${visualAnalysis ? `<visual_analysis>\n${visualAnalysis}\n</visual_analysis>` : ''}
+
+      ${this.formatExpectations(task)}
+
+      <notes>
+      ${notes}
+      </notes>
+
+      <session_log>
+      ${sessionLog || 'No actions recorded'}
+      </session_log>
+
+      Decide:
+      - "pass" ONLY if the SCENARIO GOAL is fully accomplished (not just milestones)
+      - "fail" if the scenario was attempted but failed
+      - "skipped" if the scenario is irrelevant/inapplicable OR systematic execution failures prevented testing (e.g., repeated LLM errors, navigation crashes, tool failures unrelated to the scenario)
+      - "continue" if tester hasn't completed the scenario goal yet — even if milestones were checked
+      - If evidence is mixed, but final state indicates goal completion, choose "pass"
+      - If evidence is mixed and final state is unclear, prefer "continue" over "fail"
+    `;
+        const messages = [
+            {
+                role: 'system',
+                content: this.buildVerdictSystemPrompt(type, task),
+            },
+            { role: 'user', content: userContent },
+        ];
+        try {
+            const response = await this.provider.generateObject(messages, schema, this.provider.getAgenticModel('pilot'), {
+                agentName: 'pilot',
+                experimental_telemetry: { functionId: 'pilot.reviewVerdict' },
+            });
+            const result = response?.object;
+            if (!result) {
+                task.finish(TestResult.FAILED);
+                return false;
+            }
+            tag('info').log(`Pilot: ${result.decision} — ${result.reason}`);
+            task.summary = result.reason;
+            if (result.decision === 'pass') {
+                task.addNote(`Pilot: ${result.reason}`, TestResult.PASSED);
+                task.finish(TestResult.PASSED);
+                return false;
+            }
+            if (result.decision === 'fail') {
+                task.addNote(`Pilot: ${result.reason}`, TestResult.FAILED);
+                task.finish(TestResult.FAILED);
+                return false;
+            }
+            if (result.decision === 'skipped') {
+                task.addNote(`Pilot: skipped — ${result.reason}`, TestResult.SKIPPED);
+                task.finish(TestResult.SKIPPED);
+                return false;
+            }
+            task.addNote(`Pilot: continue — ${result.reason}`);
+            const guidanceText = result.guidance ? `\n\nWhat to do next: ${result.guidance}` : '';
+            testerConversation.addUserText(`Pilot: ${result.reason}${guidanceText}`);
+            return true;
+        }
+        catch (error) {
+            tag('warning').log(`Pilot verdict failed: ${error.message}`);
+            task.finish(TestResult.FAILED);
+            return false;
+        }
+    }
+    buildVerdictSystemPrompt(type, task) {
+        return dedent `
+      You are Pilot — the final decision maker for test pass/fail.
+      Tester has requested to ${type} the test. Review the evidence and decide.
+
+      SCENARIO: ${task.scenario}
+
+      The SCENARIO is the primary goal. The test can only pass if the scenario goal is fully accomplished.
+      PRIORITY ORDER (strict):
+      1) Final observable state proving the scenario goal
+      2) Verification evidence (if provided)
+      3) Intermediate action/step outcomes
+      If final state evidence proves the scenario goal, PASS even when some intermediate actions failed.
+      Do not fail only because a specific click failed, no toast appeared, or navigation was different than expected.
+      Intermediate failures are diagnostic, not decisive, when end state confirms success.
+      Expected results are helpful milestones but they DO NOT override the scenario goal.
+      NEVER fail a test because an expected result (milestone) was not met when the scenario goal itself IS accomplished.
+      The SCENARIO TITLE defines what must happen. If the title says "Create X and verify it appears" and X was created and appears — that's a PASS, even if some milestone about icons/status/styling was not met.
+      If the scenario says "Create X", then X must be created — opening a form or navigating to /new URL is NOT enough. There must be evidence that the item now exists: visible on page, redirected to the item's page, or a success/confirmation message appeared.
+      If the scenario says "Delete X", then X must be deleted — clicking delete button is not enough. There must be evidence the item is gone.
+      If the scenario says "Edit X", then changes must be saved — opening an edit form is NOT enough.
+      For edit/update/rename scenarios, persisted updated value visible in list/detail view is valid save evidence, even without toast and even if page redirected away from edit view.
+      DO NOT trust Tester's self-assessment in notes (like "scenario goal achieved"). Verify against actual actions and state.
+      EVIDENCE SOURCES: verify(), see(), visual_analysis, and action results in session_log are all evidence. They may disagree — analyze all of them together to reach your decision. No single source automatically overrides the others. Visual analysis from screenshots is strong evidence for UI state (active tabs, visible items, counts, colors). Tester's self-assessment in record() notes is the least reliable — always cross-check against actual evidence.
+      SESSION LOG shows ALL actions grouped by URL. If the scenario requires changing data (edit/create/delete) but all form/click actions FAILED, the test cannot pass — even if a verify() found matching content that existed before the test.
+
+      VERIFICATION RULE: Only the LAST few actions before finish/stop count as verification evidence.
+      - If verify() or see() is among the last actions → use its result as evidence.
+      - If no verification was done → prefer "continue" with guidance telling tester what to verify.
+      - If verify assertion describes a state that was ALREADY TRUE before the test started, the verification proves nothing — reject with "continue".
+
+      GUIDANCE FIELD: When decision is "continue", you MUST provide "guidance" — a specific actionable instruction:
+      - If evidence is insufficient: tell tester to verify with see()/verify(), specify WHAT to check
+      - If approach was wrong: tell tester to try a different method, suggest which one
+      - If remaining steps exist: tell tester which steps to complete next
+      Be concrete. Example: "Use see() to check if the description text appears in the Description tab panel" not "verify the result".
+      Do NOT tell tester to redo the same actions that already succeeded.
+
+      NEGATIVE TESTS: Some scenarios test that something CANNOT or SHOULD NOT happen.
+      Patterns: "without a name", "with invalid data", "empty field", "wrong password", "unauthorized", "duplicate".
+      For negative tests, success means the system PREVENTED the action — error messages, validation, disabled buttons.
+      Example: "Create X without a name" PASSES if X was NOT created and validation appeared.
+
+      SKIPPED TESTS: Choose "skipped" in two cases:
+      1) Scenario is irrelevant: feature doesn't exist on the page, required UI elements are completely absent, scenario prerequisites cannot be met.
+      2) Systematic execution failures: repeated LLM/API errors, navigation crashes, tool failures unrelated to the scenario itself. These are infrastructure problems, not test failures.
+      Do NOT use "skipped" when the feature exists but the test just failed to interact with it — that's "fail" or "continue".
+
+      ${this.buildDeletionScope(task)}
+
+      REASON FORMAT: The "reason" field goes into the test report. Do NOT start with "The scenario goal was/was not achieved" or similar status phrases — the decision field already conveys that. Instead, state what happened: what was verified, what failed, or what evidence was found.
+
+      EXPECTED RESULTS (milestones, not the goal):
+      ${task.expected.map((e) => `- ${e}`).join('\n')}
+    `;
+    }
+    async planTest(task, currentState) {
+        tag('substep').log('Pilot planning test...');
+        debugLog(`planTest: ${task.scenario}, fisherman: ${this.fisherman ? 'available' : 'none'}`);
+        const pageSummary = await this.researcher.summary(currentState, {
+            allowNewResearch: false,
+        });
+        const agenticModel = this.provider.getAgenticModel('pilot');
+        this.conversation = this.provider.startConversation(this.getSystemPrompt(task, currentState, pageSummary), 'pilot', agenticModel);
+        const stateContext = this.buildStateContext(currentState);
+        return this.sendToPilot(dedent `
+        <state>
+        ${stateContext}
+        </state>
+
+        ${pageSummary ? `<page_summary>\n${pageSummary}\n</page_summary>` : ''}
+
+        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.
+
+        THEN: Based on the page elements and current state, outline:
+        1. Which elements to interact with and in what order
+        2. What to verify at each step
+        3. Potential issues to watch for
+
+        Before planning navigation to another page, assume the current page may already contain
+        the elements needed for the scenario. The page summary does not list every element.
+        Prefer interacting with the current page over navigating away.
+
+        Be concise and specific. Tester will follow your plan.
+      `, 'pilot.planTest', { tools: true, maxToolRoundtrips: 3, task });
+    }
+    async reviewNewPage(task, currentState) {
+        if (!this.conversation)
+            return '';
+        tag('substep').log('Pilot reviewing new page...');
+        const pageSummary = await this.researcher.summary(currentState, {
+            allowNewResearch: false,
+        });
+        if (!pageSummary)
+            return '';
+        const stateContext = this.buildStateContext(currentState);
+        this.conversation.cleanupTag('page_summary', '...trimmed...', 1);
+        return this.sendToPilot(dedent `
+        Navigated to new page.
+        START URL: ${task.startUrl}
+
+        <state>
+        ${stateContext}
+        </state>
+
+        <page_summary>
+        ${pageSummary}
+        </page_summary>
+
+        ${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');
+    }
+    async analyzeProgress(task, currentState, testerConversation) {
+        tag('substep').log('Pilot analyzing progress...');
+        if (!this.conversation) {
+            const pageSummary = await this.researcher.summary(currentState, {
+                allowNewResearch: false,
+            });
+            const agenticModel = this.provider.getAgenticModel('pilot');
+            this.conversation = this.provider.startConversation(this.getSystemPrompt(task, currentState, pageSummary), 'pilot', agenticModel);
+        }
+        const toolCalls = testerConversation.getToolExecutions().slice(-this.stepsToReview);
+        const actionsContext = this.formatActions(toolCalls);
+        const stateContext = this.buildStateContext(currentState);
+        this.conversation.cleanupTag('recent_actions', '...trimmed...', 2);
+        const hasFailures = toolCalls.length === 0 || toolCalls.some((t) => !t.wasSuccessful);
+        const text = await this.sendToPilot(dedent `
+        START URL: ${task.startUrl}
+
+        <state>
+        ${stateContext}
+        </state>
+
+        ${this.formatExpectations(task)}
+
+        <recent_actions>
+        ${actionsContext || 'None'}
+        </recent_actions>
+
+        What should Tester do next?
+      `, 'pilot.analyze', { tools: hasFailures, maxToolRoundtrips: hasFailures ? 2 : 0, task });
+        const contextToAttach = await this.fetchRequestedContext(text, currentState);
+        if (contextToAttach) {
+            return `${text}\n\n${contextToAttach}`;
+        }
+        return text;
+    }
+    formatExpectations(task) {
+        const checked = task.getCheckedExpectations();
+        const remaining = task.getRemainingExpectations();
+        return `CHECKED: ${checked.length > 0 ? checked.join(', ') : 'none'}\nREMAINING: ${remaining.length > 0 ? remaining.join(', ') : 'none'}`;
+    }
+    async sendToPilot(userText, functionId, opts = {}) {
+        debugLog(`sendToPilot: ${functionId}, tools: ${!!opts.tools}, roundtrips: ${opts.maxToolRoundtrips ?? 0}`);
+        this.conversation.addUserText(userText);
+        let tools = opts.tools ? this.agentTools : undefined;
+        if (opts.tools && opts.task) {
+            tools = { ...tools, ...this.buildPreconditionTool(opts.task) };
+        }
+        const result = await this.provider.invokeConversation(this.conversation, tools, {
+            maxToolRoundtrips: opts.maxToolRoundtrips ?? 0,
+            agentName: 'pilot',
+            experimental_telemetry: { functionId },
+        });
+        return result?.response?.text || '';
+    }
+    buildPreconditionTool(task) {
+        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".',
+                inputSchema: z.object({
+                    description: z.string().describe('What data is needed, e.g. "1 post and 2 comments in it"'),
+                }),
+                execute: async ({ description }) => {
+                    task.addNote(`Precondition: ${description}`);
+                    tag('info').log(`Precondition: ${description}`);
+                    debugLog(`precondition: ${description}, fisherman: ${this.fisherman?.isAvailable() ? 'available' : 'none'}`);
+                    if (!this.fisherman || !this.fisherman.isAvailable()) {
+                        return { noted: true, prepared: false, reason: 'Fisherman not available' };
+                    }
+                    const result = await this.fisherman.prepareData(description, task.startUrl, task.sessionName);
+                    if (!result.success || result.created.length === 0) {
+                        if (result.summary)
+                            tag('warning').log(`Precondition failed: ${result.summary}`);
+                        return { noted: true, prepared: false, reason: result.summary };
+                    }
+                    const items = result.created.map((c) => {
+                        const parts = [c.type];
+                        if (c.title)
+                            parts.push(`"${c.title}"`);
+                        if (c.id)
+                            parts.push(`(id: ${c.id})`);
+                        return parts.join(' ');
+                    });
+                    const stepText = `Precondition: created ${items.join(', ')}`;
+                    task.addStep(stepText);
+                    tag('success').log(stepText);
+                    return { noted: true, prepared: true, created: result.created };
+                },
+            }),
+        };
+    }
+    buildStateContext(state) {
+        const lines = [];
+        lines.push(`url: ${state.url}`);
+        lines.push(`title: ${state.title || 'unknown'}`);
+        const focused = extractFocusedElement(state.ariaSnapshot);
+        if (focused) {
+            const valuePart = focused.value ? ` (value: "${focused.value}")` : '';
+            lines.push(`focused: ${focused.role} "${focused.name}"${valuePart}`);
+        }
+        lines.push(`h1: ${state.h1 || ''}`);
+        lines.push(`h2: ${state.h2 || ''}`);
+        lines.push(`h3: ${state.h3 || ''}`);
+        lines.push(`h4: ${state.h4 || ''}`);
+        const focusArea = detectFocusArea(state.ariaSnapshot);
+        if (focusArea.detected) {
+            lines.push(`modal: ${focusArea.name || focusArea.type}`);
+        }
+        else {
+            lines.push('modal: none');
+        }
+        if (this.explorer.hasOtherTabs()) {
+            const tabs = this.explorer.getOtherTabsInfo();
+            lines.push(`other tabs: ${tabs.length} (${tabs.map((t) => `${t.url} - ${t.title}`).join(', ')})`);
+        }
+        else {
+            lines.push('other tabs: none');
+        }
+        const verifications = Object.entries(state.verifications ?? {});
+        if (verifications.length > 0) {
+            const verifyLines = verifications.map(([a, v]) => `${v ? 'PASS' : 'FAIL'}: ${a}`);
+            lines.push(`verifications: ${verifyLines.join(', ')}`);
+        }
+        const interactiveNodes = collectInteractiveNodes(state.ariaSnapshot);
+        const disabledButtons = interactiveNodes.filter((n) => n.role === 'button' && n.disabled === true && n.name).map((n) => n.name);
+        lines.push(`disabled buttons: ${disabledButtons.length > 0 ? disabledButtons.join(', ') : 'none'}`);
+        const formFields = interactiveNodes.filter((n) => n.role === 'textbox' || n.role === 'combobox' || n.role === 'select' || n.role === 'searchbox' || n.role === 'spinbutton');
+        if (formFields.length > 0) {
+            const fieldDescriptions = formFields.map((f) => {
+                let desc = `${f.role} "${f.name || ''}"`;
+                if (f.required)
+                    desc += ' [required]';
+                return desc;
+            });
+            lines.push(`active form: ${fieldDescriptions.join(', ')}`);
+        }
+        return lines.join('\n');
+    }
+    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>
+        ${currentState.getInteractiveARIA()}
+        </page_aria>
+      `);
+        }
+        if (text.includes('ATTACH_SUMMARY')) {
+            const summary = await this.researcher.summary(currentState);
+            if (summary) {
+                parts.push(dedent `
+          <page_summary>
+          ${summary}
+          </page_summary>
+        `);
+            }
+        }
+        if (text.includes('ATTACH_UI_MAP')) {
+            const uiMap = await this.researcher.research(currentState);
+            if (uiMap) {
+                parts.push(dedent `
+          <page_ui_map>
+          ${uiMap}
+          </page_ui_map>
+        `);
+            }
+        }
+        return parts.join('\n\n');
+    }
+    formatSessionLog(testerConversation) {
+        const executions = testerConversation.getToolExecutions().filter((t) => !META_TOOLS.includes(t.toolName));
+        const stateHistory = this.explorer.getStateManager().getStateHistory();
+        const initialUrl = stateHistory[0]?.toState?.url || '';
+        let currentUrl = initialUrl;
+        const groups = new Map();
+        const ensureGroup = (url) => {
+            if (!groups.has(url)) {
+                const matchingState = stateHistory.find((t) => t.toState.url === url)?.toState;
+                groups.set(url, {
+                    title: matchingState?.title,
+                    h1: matchingState?.h1,
+                    h3: matchingState?.h3,
+                    lines: [],
+                });
+            }
+        };
+        ensureGroup(currentUrl);
+        for (const exec of executions) {
+            if (!CHECK_TOOLS.includes(exec.toolName) && exec.output?.url && exec.output.url !== currentUrl) {
+                currentUrl = exec.output.url;
+                ensureGroup(currentUrl);
+            }
+            const description = exec.input?.explanation || exec.input?.assertion || exec.input?.request || truncateJson(exec.input);
+            const status = exec.wasSuccessful ? 'OK' : 'FAILED';
+            let line = `${exec.toolName} '${description}' -> ${status}`;
+            if (exec.toolName === 'verify') {
+                if (!exec.wasSuccessful && exec.output?.alreadyVerified) {
+                    line = `${exec.toolName} '${description}' -> BLOCKED (already verified on this state)`;
+                }
+                else if (exec.output?.code) {
+                    line += `\n    code: ${exec.output.code}`;
+                }
+            }
+            const analysisText = exec.output?.analysis;
+            const resultMessage = analysisText ? (analysisText.length > 500 ? `${analysisText.slice(0, 500)}...` : analysisText) : exec.output?.message || exec.output?.result;
+            if (resultMessage && (CHECK_TOOLS.includes(exec.toolName) || !exec.wasSuccessful)) {
+                line += `\n    result: ${resultMessage}`;
+            }
+            groups.get(currentUrl).lines.push(line);
+        }
+        const parts = [];
+        for (const [url, group] of groups) {
+            const header = [url];
+            if (group.title)
+                header.push(`  title: ${group.title}`);
+            if (group.h1)
+                header.push(`  h1: ${group.h1}`);
+            if (group.h3)
+                header.push(`  h3: ${group.h3}`);
+            header.push('');
+            const lines = group.lines.map((l) => `  ${l}`);
+            parts.push([...header, ...lines].join('\n'));
+        }
+        return parts.join('\n\n');
+    }
+    formatActions(toolCalls) {
+        return toolCalls
+            .map((t) => {
+            const status = t.wasSuccessful ? 'SUCCESS' : 'FAILED';
+            const kind = CHECK_TOOLS.includes(t.toolName) ? 'CHECK' : 'ACTION';
+            const description = t.input?.explanation || t.input?.request || truncateJson(t.input);
+            const analysisText = t.output?.analysis;
+            const resultMessage = analysisText ? (analysisText.length > 500 ? `${analysisText.slice(0, 500)}...` : analysisText) : t.output?.message || '';
+            const errorDetail = t.output?.attempts?.find((a) => a.error)?.error;
+            let line = `[${status}] ${kind} ${t.toolName}: ${description}`;
+            const executedCode = t.output?.code;
+            if (executedCode && t.toolName === 'click') {
+                line += `\n   executed: ${executedCode}`;
+            }
+            const targeted = t.output?.targetedHtml;
+            if (targeted) {
+                line += `\n   element: ${targeted}`;
+            }
+            if (resultMessage)
+                line += `\n   result: ${resultMessage}`;
+            if (errorDetail && errorDetail !== resultMessage)
+                line += `\n   error: ${errorDetail}`;
+            const attempts = t.output?.attempts;
+            if (attempts && attempts.length > 1 && t.wasSuccessful) {
+                const failedBefore = attempts.filter((a) => !a.success);
+                if (failedBefore.length > 0) {
+                    line += `\n   skipped: ${failedBefore.map((a) => a.command).join(', ')}`;
+                }
+            }
+            const ariaDiff = t.output?.pageDiff?.ariaChanges;
+            if (ariaDiff)
+                line += `\n   ${ariaDiff}`;
+            return line;
+        })
+            .join('\n\n');
+    }
+    buildDeletionScope(task) {
+        const deletableItems = task.plan
+            ? task.plan
+                .listTests()
+                .filter((t) => t.isSuccessful && t.sessionName)
+                .map((t) => t.sessionName)
+            : [];
+        const scenarioLower = task.scenario.toLowerCase();
+        if (deletableItems.length > 0) {
+            return `For deletion scenarios, items can only be deleted if their title contains: ${deletableItems.join(', ')}`;
+        }
+        if (scenarioLower.includes('delete') || scenarioLower.includes('remove')) {
+            return 'No items available for deletion — test should create an item first';
+        }
+        return '';
+    }
+    getSystemPrompt(task, initialState, pageSummary) {
+        const interactive = isInteractive();
+        const stepsText = task.plannedSteps.length > 0 ? task.plannedSteps.map((s, i) => `${i + 1}. ${s}`).join('\n') : 'No planned steps';
+        return dedent `
+      You are Pilot - a supervisor that detects problems and intervenes only when needed.
+
+      SCENARIO: ${task.scenario}
+      START URL: ${initialState.url}
+      PAGE: ${initialState.title || ''} | ${initialState.h1 || ''}
+
+      EXPECTED RESULTS:
+      ${task.expected.map((e) => `- ${e}`).join('\n')}
+
+      PLANNED STEPS:
+      ${stepsText}
+
+      ${pageSummary ? `PAGE SUMMARY:\n${pageSummary}` : ''}
+
+      Your job:
+      1. Plan test execution by reviewing page elements and scenario requirements
+      2. When Tester navigates to a new page, review available elements and plan next steps
+      3. Detect when Tester is stuck: repeated failures, loops, or wrong direction
+      4. Track which expectations have been checked and which remain
+      5. When problems are detected, suggest concrete alternative approaches
+      6. When everything is going well, give brief encouragement and let Tester continue
+      7. Before suggesting navigation to another page, assume the current page may already have what the scenario needs. The page summary is incomplete — not every element is listed. Prefer exploring the current page first.
+
+      Already-achieved state detection:
+      - When planning or reviewing, check if the scenario goal is ALREADY met in the current state (page_summary, ariaDiff, or state context).
+      - If the goal appears already achieved at start: adapt the scenario — suggest different input values or data to make the test meaningful.
+      - If the goal was achieved by a previous action (SUCCESS in recent_actions with confirming ariaDiff): instruct Tester to verify() the result and finish(). Do NOT repeat the same action.
+      - If Tester keeps re-opening the same panel and re-submitting the same data — STOP. The action was already completed.
+
+      Navigation awareness — always compare current page url to START URL:
+      - subpage navigation (deeper path from START URL) — OK, scenario may need sub-pages
+      - outer-page navigation (parent/sibling path from START URL) — SUSPICIOUS. The scenario target is on the START page. Do NOT rationalize leaving it. Instruct Tester to back() or reset().
+      - outer-site navigation (different domain) — WRONG. Instruct Tester to reset() immediately.
+
+      IMPORTANT — Tool usage policy:
+      - DO NOT use tools (see, context) when Tester is making progress and no failures are recorded
+      - Tester already has full ARIA and HTML context — do not duplicate that work
+      - ONLY use see/context tools when Tester has failed 2+ times on the same element or action
+      - Use xpathCheck proactively when Tester fails to find an element even ONCE (element not found error)
+      - If Tester's ARIA locator used wrong role (e.g. "textbox" instead of "combobox"), use xpathCheck to identify the correct element
+      - After finding the element via xpathCheck, include the discovered locator in your NEXT instruction
+      ${interactive ? '- Use askUser() only as last resort when automated recovery has failed' : ''}
+
+      Diagnosing failures — use <state> context:
+      - Button click failed AND that button is in "disabled buttons" → button is disabled, not missing. Check "active form" for unfilled [required] fields. Instruct Tester to fill required fields first.
+      - Form submit failed → check "active form" for fields that may need values. Instruct Tester to fill them before retrying submit.
+      - "modal: none" but Tester tries to interact with a modal → modal was closed or never opened. Instruct Tester to re-trigger the modal.
+      - Actions succeed but ariaDiff is empty → action may have worked without visible DOM changes. Check result message before assuming failure.
+      - Multiple elements matched (MultipleElementsFound) → use xpathCheck() to inspect the matched elements and determine which one is correct. Then instruct Tester with a precise locator or suggest visualClick() to click the right element by visual appearance.
+      - Tester navigated to a page unrelated to the scenario (e.g., settings instead of feature page) → use getVisitedStates() to check which pages were visited, then suggest back() to return to a relevant page, or reset() if multiple wrong navigations occurred. Do NOT try navigating back via breadcrumbs or links — SPA frameworks make manual back-navigation unreliable.
+      - If diagnosis is unclear, ariaDiff is empty, and your previous advice didn't help → suggest Tester use see() to visually inspect the page. But ONLY as a last resort after other diagnostics failed.
+      - 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.
+
+      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.
+      - Click SUCCESS with "skipped" commands listed → earlier attempts failed, fell through to a different locator. Check if the successful locator actually targets the intended element.
+      - form(I.type()) SUCCESS but "element" shows a button/link instead of input → text went to wrong element. Instruct Tester to click the correct input first.
+      - Action SUCCESS but ariaDiff shows changes unrelated to the stated goal → action hit the wrong target. Instruct Tester to undo (Escape/back) and retry with precise locator.
+      - If Tester's explanation mentions TWO distinct actions in ONE tool call → flag this. Each distinct action should be a separate tool call. Instruct Tester to split into individual steps.
+
+      Complex component patterns — when Tester fails to interact with dropdowns/selects:
+      - Search-and-select dropdowns require a SEQUENCE: click/focus the trigger input, type to filter, then click an option from the dropdown list. Instruct Tester to split this into separate tool calls.
+      - If Tester clicks a generic dropdown trigger and ariaDiff shows unrelated options → wrong dropdown was triggered. Instruct Tester to use a more specific selector with container context.
+      - If Tester types into an input but no dropdown appears → they may need to click the trigger element first. Suggest using context() to check the current DOM state.
+
+      Tester ignoring visible elements:
+      - If <state> shows "active form" fields but Tester is clicking elements not found in ARIA, or trying buttons that don't exist → Tester is ignoring interactive elements that are actually on the page. Instruct Tester to focus on the elements listed in "active form" — these are the real interactive controls on the current page. The UI map may be outdated.
+
+      When Tester IS stuck finding an element, use xpathCheck() with COMBINED XPaths:
+      - NEVER guess one exact text. UI labels differ from scenario wording.
+      - Combine multiple guesses into ONE XPath using "or" operator.
+      - Include: synonyms, partial text, aria-label, title, role, icon classes.
+      - Example: looking for a "create project" button:
+        //*[(contains(., "Create project") or contains(., "New project") or contains(., "Add project") or contains(@aria-label, "project")) or (contains(., "project") and (contains(@class, "add") or contains(@class, "plus") or contains(@class, "create") or .//*[contains(@class, "plus") or contains(@class, "add") or contains(@class, "icon-add")]))][@role="button" or @role="link" or self::button or self::a]
+      - Key: combine text synonyms + icon classes on children (.//*[contains(@class,...)]) + aria attributes
+      - If no results, broaden: drop the role filter, or search by role only, then check results for relevant text.
+      - After finding candidates, narrow down and include discovered XPath in NEXT instruction.
+
+      If you need more page context, mention ATTACH_HTML, ATTACH_ARIA, or ATTACH_UI_MAP — but only when recent actions show failures.
+
+
+      Available Tester tools:
+      - click(locator) — click elements
+      - pressKey(key) — keyboard keys
+      - form(code) — execute multiple commands (fillField, type, selectOption, attachFile)
+      - see(request) — visual screenshot analysis
+      - verify(assertion) — AI-powered DOM assertion (uses I.see, I.seeElement, I.seeInField, I.dontSee)
+      - context() — fresh HTML/ARIA snapshot
+      - research() — get UI map
+      - xpathCheck(xpath) — find elements by XPath
+      - visualClick(element) — coordinate-based click
+      - back() — return to previous page
+      - getVisitedStates() — list all visited pages (deduped by URL)
+      - reset() — return to initial page
+      - stop(reason) — abort test
+      - finish(verify) — complete test successfully
+      - record(notes) — document findings
+
+      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 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:
+      - "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
+      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.
+
+      Response format:
+      PROGRESS: <1 sentence assessment>
+      NEXT: <specific actionable instruction for Tester>
+    `;
+    }
+}
+//# sourceMappingURL=pilot.js.map