explorbot 0.1.28 → 0.1.29

package/dist/src/ai/tools.js

@@ -11,7 +11,7 @@ import { WebElement } from "../utils/web-element.js";
 import { sectionContextRule } from "./rules.js";
 import { isInteractive } from "./task-agent.js";
 const debugLog = createDebug('explorbot:tools');
-export const CODECEPT_TOOLS = ['click', 'pressKey', 'form'];
+export const CODECEPT_TOOLS = ['click', 'hover', 'pressKey', 'form'];
 export const ASSERTION_TOOLS = ['verify'];
 export function createCodeceptJSTools(explorer, task) {
     const stateManager = explorer.getStateManager();
@@ -133,6 +133,71 @@ export function createCodeceptJSTools(explorer, task) {
                 }, action.lastError);
             },
         }),
+        hover: tool({
+            description: dedent `
+        Move the mouse cursor to an element to reveal hover-only controls.
+
+        Use this before clicking row actions, icon buttons, menus, or toolbars that appear only
+        when the user hovers a list item, table row, card, or tree node.
+
+        This tool ONLY accepts I.moveCursorTo(locator) commands. It does not click.
+        After hovering, use context(), see(), or click() the revealed control.
+      `,
+            inputSchema: z.object({
+                commands: z.array(z.string()).describe(dedent `
+          FALLBACK LOCATORS for ONE element to hover.
+          Order by reliability:
+          1. I.moveCursorTo(text, container)
+          2. I.moveCursorTo(ARIA, container)
+          3. I.moveCursorTo(CSS, container)
+          4. I.moveCursorTo(CSS) or I.moveCursorTo(XPath)
+        `),
+                explanation: z.string().describe('Why you are hovering this element'),
+            }),
+            execute: async ({ commands: rawCommands, explanation }) => {
+                const activeNote = task.startNote(explanation);
+                if (rawCommands.length === 0) {
+                    activeNote.commit(TestResult.FAILED);
+                    return failedToolResult('hover', 'No commands provided');
+                }
+                const invalidCommands = rawCommands.map((cmd) => cmd.trim()).filter((cmd) => cmd.startsWith('I.') && !cmd.startsWith('I.moveCursorTo'));
+                if (invalidCommands.length > 0) {
+                    activeNote.commit(TestResult.FAILED);
+                    return failedToolResult('hover', `Invalid commands: ${invalidCommands.join(', ')}. Hover tool only accepts I.moveCursorTo() commands.`, {
+                        suggestion: 'Use click() to click elements, or form() for typing/selecting.',
+                    });
+                }
+                const commands = rawCommands.map((cmd) => {
+                    const trimmed = cmd.trim();
+                    if (trimmed.startsWith('I.moveCursorTo'))
+                        return trimmed;
+                    return `I.moveCursorTo(${JSON.stringify(trimmed)})`;
+                });
+                const previousState = ActionResult.fromState(stateManager.getCurrentState());
+                const action = explorer.createAction();
+                const attempts = [];
+                for (const command of commands) {
+                    const success = await action.attempt(command, explanation, true);
+                    attempts.push({
+                        command,
+                        success,
+                        ...(action.lastError && { error: action.lastError.toString() }),
+                    });
+                    if (!success)
+                        continue;
+                    const toolResult = await ActionResult.fromState(stateManager.getCurrentState()).toToolResult(previousState, command);
+                    activeNote.commit(TestResult.PASSED);
+                    return successToolResult('hover', { ...toolResult, attempts, code: command }, action);
+                }
+                const toolResult = await ActionResult.fromState(stateManager.getCurrentState()).toToolResult(previousState, commands[0]);
+                activeNote.commit(TestResult.FAILED);
+                return failedToolResult('hover', 'All hover commands failed', {
+                    ...toolResult,
+                    attempts,
+                    suggestion: 'Use xpathCheck() to locate the row/card/tree node, or visualClick() if the hover target is only visually identifiable.',
+                }, action.lastError);
+            },
+        }),
         pressKey: tool({
             description: dedent `
         Press a keyboard key or key combination. Use this for special keys like Enter, Escape, Tab, Arrow keys, or key combinations with modifiers.
@@ -404,6 +469,7 @@ export function createAgentTools({ explorer, researcher, navigator, experienceTr
         Check the page contents based on current page state and screenshot.
         This tool will trigger visual research to check the page contents on request.
         Use it to verify the actions were performed correctly and the page is in the expected state.
+        Input schema has exactly one field: request. Do not pass text, reason, assertion, or other fields.
 
         <example>
         request: "Check current state of the Login form"

package/dist/src/explorbot.js

@@ -23,11 +23,12 @@ import { ConfigParser } from "./config.js";
 import { ExperienceTracker } from "./experience-tracker.js";
 import Explorer from "./explorer.js";
 import { KnowledgeTracker } from "./knowledge-tracker.js";
+import { Stats } from "./stats.js";
 import { Plan } from "./test-plan.js";
-import { parsePlansFromMarkdown } from "./utils/test-plan-markdown.js";
 import { setVerboseMode, tag } from "./utils/logger.js";
 import { relativeToCwd } from "./utils/next-steps.js";
 import { sanitizeFilename } from "./utils/strings.js";
+import { parsePlansFromMarkdown } from "./utils/test-plan-markdown.js";
 export class ExplorBot {
     configParser;
     explorer;
@@ -427,7 +428,11 @@ export class ExplorBot {
             tag('info').log(`Session report saved: ${relativeToCwd(filePath)}`);
             const reporter = this.explorer?.getReporter();
             if (reporter?.isEnabled()) {
-                await reporter.setRunDescription(markdown);
+                let description = markdown;
+                const modelsTable = Stats.modelsTable(this.provider.getConfiguredModels());
+                if (modelsTable)
+                    description = `${markdown}\n\n${modelsTable}`;
+                await reporter.setRunDescription(description);
             }
             this.lastReportedTestCount = tests.length;
         }

package/dist/src/stats.js

@@ -39,6 +39,22 @@ export class Stats {
         }
         return String(num);
     }
+    static modelsTable(roleModels) {
+        const usedModels = Object.entries(Stats.models).filter(([, tokens]) => tokens.total > 0);
+        if (usedModels.length === 0)
+            return '';
+        const rolesByModel = {};
+        for (const [role, model] of Object.entries(roleModels)) {
+            if (!rolesByModel[model])
+                rolesByModel[model] = [];
+            rolesByModel[model].push(role);
+        }
+        const rows = usedModels.map(([model, tokens]) => {
+            const roles = rolesByModel[model]?.join(', ') || '-';
+            return `| ${roles} | ${model} | ${Stats.humanizeTokens(tokens.total)} |`;
+        });
+        return ['## Models', '', '| Role | Model | Tokens |', '| --- | --- | --- |', ...rows].join('\n');
+    }
     static hasActivity() {
         if (Stats.tests > 0 || Stats.plans > 0 || Stats.researches > 0)
             return true;

package/dist/src/utils/aria.js

@@ -334,6 +334,56 @@ const detectRenames = (prev, curr, prevTotals, currTotals) => {
     }
     return { added, removed };
 };
+// Interactive controls keep a stable role+name across a state flip; only an ARIA state
+// attribute changes. Report those flips on their own line so the model always sees
+// "now checked / now collapsed", in both directions, regardless of other page churn.
+const STATE_WORDS = {
+    checked: { on: 'checked', off: 'unchecked' },
+    selected: { on: 'selected', off: 'unselected' },
+    pressed: { on: 'pressed', off: 'unpressed' },
+    expanded: { on: 'expanded', off: 'collapsed' },
+};
+const STATE_ATTRS = Object.keys(STATE_WORDS);
+const stateWord = (attr, value) => {
+    if (attr === 'checked' && value === 'mixed')
+        return 'partially checked';
+    const words = STATE_WORDS[attr];
+    if (value === true || value === 'true')
+        return words.on;
+    return words.off;
+};
+// Pair entries by path; when role and name match but a state attr differs, it's a toggle.
+const detectToggles = (prev, curr) => {
+    const toggled = [];
+    const togglePaths = new Set();
+    const currByPath = new Map(curr.map((e) => [e.path, e]));
+    for (const before of prev) {
+        const after = currByPath.get(before.path);
+        if (!after)
+            continue;
+        if (before.entry.role !== after.entry.role)
+            continue;
+        if (before.entry.name !== after.entry.name)
+            continue;
+        const transitions = [];
+        for (const attr of STATE_ATTRS) {
+            const was = stateWord(attr, before.entry[attr]);
+            const now = stateWord(attr, after.entry[attr]);
+            if (was === now)
+                continue;
+            transitions.push(`${was} -> ${now}`);
+        }
+        if (transitions.length === 0)
+            continue;
+        togglePaths.add(before.path);
+        let label = String(after.entry.role);
+        const name = after.entry.name;
+        if (typeof name === 'string' && name.trim())
+            label += ` "${name.trim()}"`;
+        toggled.push(`${label}: ${transitions.join(', ')}`);
+    }
+    return { toggled, togglePaths };
+};
 const TOP_DIFF_ITEMS = 10;
 const formatDiffSection = (label, items) => {
     const summary = countBy(items);
@@ -357,10 +407,17 @@ const formatDiffSection = (label, items) => {
     }
     return lines;
 };
-const formatDiff = (added, removed) => {
-    if (added.length === 0 && removed.length === 0)
+const formatDiff = (added, removed, toggled) => {
+    if (added.length === 0 && removed.length === 0 && toggled.length === 0)
         return null;
-    return ['ariaDiff:', ...formatDiffSection('added', added), ...formatDiffSection('removed', removed)].join('\n');
+    const sections = ['ariaDiff:'];
+    if (toggled.length > 0) {
+        sections.push('  toggled:');
+        for (const line of toggled)
+            sections.push(`    - ${line}`);
+    }
+    sections.push(...formatDiffSection('added', added), ...formatDiffSection('removed', removed));
+    return sections.join('\n');
 };
 const CLOSE_OVERLAY_BUTTON_RE = /^close\s+(modal|dialog|popup|drawer|panel|sheet)\b/i;
 const findOverlayByCloseButton = (nodeList) => {
@@ -424,13 +481,16 @@ export const diffAriaSnapshots = (previous, current) => {
         tree = dropEmpty(tree);
         return flatten(tree);
     };
-    const prev = flat(previous);
-    const curr = flat(current);
+    const prevAll = flat(previous);
+    const currAll = flat(current);
+    const { toggled, togglePaths } = detectToggles(prevAll, currAll);
+    const prev = prevAll.filter((e) => !togglePaths.has(e.path));
+    const curr = currAll.filter((e) => !togglePaths.has(e.path));
     const prevTotals = countBy(prev.map((e) => e.summary));
     const currTotals = countBy(curr.map((e) => e.summary));
     const byCount = diffByCount(prevTotals, currTotals);
     const renames = detectRenames(prev, curr, prevTotals, currTotals);
-    return formatDiff([...byCount.added, ...renames.added], [...byCount.removed, ...renames.removed]);
+    return formatDiff([...byCount.added, ...renames.added], [...byCount.removed, ...renames.removed], toggled);
 };
 export const detectFocusArea = (snapshot) => {
     let tree = parseSnapshot(snapshot);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "explorbot",
-  "version": "0.1.28",
+  "version": "0.1.29",
   "description": "CLI app built with React Ink, CodeceptJS, and Playwright",
   "license": "Elastic-2.0",
   "type": "module",
@@ -65,9 +65,10 @@
   },
   "author": "",
   "dependencies": {
-    "@ai-sdk/anthropic": "^3.0",
-    "@ai-sdk/groq": "^3.0",
-    "@ai-sdk/openai": "^3.0",
+    "@ai-sdk/anthropic": "^4.0",
+    "@ai-sdk/groq": "^4.0",
+    "@ai-sdk/openai": "^4.0",
+    "@ai-sdk/otel": "^1.0.2",
     "@axe-core/playwright": "^4.11.0",
     "@codeceptjs/reflection": "^0.5.2",
     "@faker-js/faker": "^10.4.0",
@@ -82,8 +83,8 @@
     "@opentelemetry/sdk-trace-base": "^2.2.0",
     "@opentelemetry/semantic-conventions": "^1.38.0",
     "@scalar/openapi-parser": "^0.25.6",
-    "@testomatio/reporter": "^2.8.4",
-    "ai": "^6.0.6",
+    "@testomatio/reporter": "^2.9.1",
+    "ai": "^7.0.2",
     "axe-core": "^4.11.1",
     "bash-tool": "^1.3.15",
     "cli-highlight": "^2.1.11",
@@ -110,6 +111,7 @@
     "parse5": "^8.0.0",
     "playwright": "^1.60",
     "react": "^19.1.1",
+    "sambanova-ai-provider": "^1.2.2",
     "strip-ansi": "^7.1.2",
     "turndown": "^7.2.1",
     "unique-names-generator": "^4.7.1",

package/rules/navigator/verification-actions.md

@@ -113,6 +113,8 @@ For input field values, ALWAYS use I.seeInField() — never check value via CSS
 Prefer text locators (label, name, placeholder) for form fields: I.seeInField('Search', 'value') over I.seeInField('input[name="search"]', 'value').
 Only use locators that exist in the provided HTML or ARIA snapshot.
 Verify exact conditions, not approximate matches.
+When the claim contains a concrete quoted value, generated assertion code MUST include that whole value. Do not shorten names, IDs, titles, emails, URLs, or other user-created values.
+For exact visible text, prefer a text assertion scoped to a specific container or an ARIA locator with the complete text. Partial text is not valid evidence for a claim about the full value.
 NEVER use `:has-text(...)` inside a seeElement/dontSeeElement locator. Checking text inside an element is the job of I.see(text, context) — the `:has-text()` form duplicates that capability with a fragile selector.
 NEVER emit two assertions that check the same fact with different shapes. `I.see(text, locator)` and `I.seeElement("<locator>:has-text('text')")` verify the same thing — pick one (prefer I.see). One claim, one assertion.
 </verification_rules>

package/src/ai/fisherman.ts

@@ -9,6 +9,7 @@ import { loop } from '../utils/loop.ts';
 import type { Agent } from './agent.ts';
 import { type FishermanResult, createFishermanTools } from './fisherman-tools.ts';
 import type { Provider } from './provider.ts';
+import { dataProtectionRules } from './rules.ts';
 
 const MAX_ITERATIONS = 15;
 const MAX_TOOL_ROUNDTRIPS = 5;
@@ -85,7 +86,7 @@ export class Fisherman implements Agent {
       baseEndpoint: this.baseEndpoint,
     });
 
-    const conversation = this.provider.startConversation(this.buildSystemPrompt(endpointList, scopeUrl), 'fisherman');
+    const conversation = this.provider.startConversation(this.buildSystemPrompt(endpointList, Object.keys(tools), scopeUrl), 'fisherman');
     conversation.addUserText(this.buildTaskPrompt(instructions));
 
     await loop(
@@ -187,7 +188,7 @@ export class Fisherman implements Agent {
     return lines.join('\n');
   }
 
-  private buildSystemPrompt(endpointList: string, scopeUrl?: string): string {
+  private buildSystemPrompt(endpointList: string, toolNames: string[], scopeUrl?: string): string {
     const scopeBlock = scopeUrl ? `\n\nSCOPE: You are operating within ${scopeUrl}.\nAll created items must belong to this scope.` : '';
 
     return dedent`
@@ -197,6 +198,11 @@ export class Fisherman implements Agent {
       ${endpointList}
       ${scopeBlock}
 
+      AVAILABLE TOOLS:
+      ${toolNames.join(', ')}.
+      Use tool names exactly as listed. Do not invent aliases, combined names, or names with channel markers such as "commentary".
+      Match each tool input schema exactly. Do not invent parameter names or pass extra fields.
+
       WORKFLOW:
       1. Call getEndpointSpec to see the request body example for the endpoint
       2. Make requests — the response automatically extracts IDs, names, and status fields
@@ -208,6 +214,8 @@ export class Fisherman implements Agent {
       - Chain requests logically — create parent resources before children
       - If a request fails, try once more with adjusted data before reporting failure
       - Use realistic but unique data for each item (vary names, titles)
+
+      ${dataProtectionRules}
     `;
   }
 
@@ -217,7 +225,10 @@ export class Fisherman implements Agent {
 
       ${instructions}
 
-      Execute the necessary API requests to create this data. When done, call finish with the summary.
+      ${dataProtectionRules}
+
+      If data preparation is allowed by these rules, execute the necessary API requests to create this data.
+      When done, call finish with the summary. If data preparation is forbidden, call stop with the reason.
     `;
   }
 }

package/src/ai/pilot.ts

@@ -18,6 +18,7 @@ import type { Fisherman } from './fisherman.ts';
 import type { Navigator } from './navigator.ts';
 import type { Provider } from './provider.ts';
 import type { Researcher } from './researcher.ts';
+import { capabilityGroundingRule, dataProtectionRules } from './rules.ts';
 import { isInteractive } from './task-agent.ts';
 
 const CHECK_TOOLS = ['verify', 'see', 'research', 'context'];
@@ -91,7 +92,7 @@ export class Pilot implements Agent {
 
     let visualAnalysis = '';
     let screenshotState: ActionResult | null = null;
-    if (this.provider.hasVision()) {
+    if (type === 'finish' && this.provider.hasVision()) {
       try {
         screenshotState = await this.explorer.capturePageWithScreenshot();
         if (screenshotState.screenshot) {
@@ -164,7 +165,7 @@ export class Pilot implements Agent {
     try {
       const response = await this.provider.generateObject(messages, schema, this.provider.getAgenticModel('pilot'), {
         agentName: 'pilot',
-        experimental_telemetry: { functionId: 'pilot.reviewVerdict' },
+        telemetry: { functionId: 'pilot.reviewVerdict' },
       });
 
       const result = response?.object;
@@ -266,7 +267,7 @@ export class Pilot implements Agent {
     try {
       const response = await this.provider.generateObject(messages, schema, this.provider.getAgenticModel('pilot'), {
         agentName: 'pilot',
-        experimental_telemetry: { functionId: 'pilot.reviewReset' },
+        telemetry: { functionId: 'pilot.reviewReset' },
       });
 
       const result = response?.object;
@@ -378,6 +379,8 @@ export class Pilot implements Agent {
       You are Pilot — final decision maker for test pass/fail. Tester requested ${type}. Review the
       evidence and commit to a verdict; "continue" only when evidence is genuinely insufficient.
 
+      ${capabilityGroundingRule}
+
       ${this.buildSharedEvidenceRules(task)}
 
       DECISION:
@@ -386,6 +389,8 @@ export class Pilot implements Agent {
         Pick assertions DOM can express; for non-DOM regions (iframes, canvas, Monaco/CodeMirror), target a
         stable landmark (container, ARIA role) instead of literal inner text. Your "pass" stands even if the
         DOM assertion can't be made.
+        Do not pass when Tester achieved only a related navigation/filter/tab/status outcome instead of the
+        requested action, workflow, or entity detail goal.
       - "fail": scenario was attempted but the goal was not achieved.
       - "skipped": scenario is irrelevant to the app, OR systematic infrastructure failures (LLM errors,
         crashes) prevented testing. NOT for "test failed to interact" — that's "fail" or "continue".
@@ -424,6 +429,10 @@ export class Pilot implements Agent {
 
         FIRST: Decide if precondition() is needed.
 
+        ${capabilityGroundingRule}
+
+        ${dataProtectionRules}
+
         Call precondition() WHEN:
         - The scenario edits/deletes/modifies an item, and you want a DISPOSABLE item to act on safely
         - The scenario needs specific data clearly NOT on the current page (e.g., items with specific statuses for filtering)
@@ -576,7 +585,7 @@ export class Pilot implements Agent {
       maxToolRoundtrips: opts.maxToolRoundtrips ?? 0,
       agentName: 'pilot',
       stopWhen: opts.task ? () => opts.task!.hasFinished : undefined,
-      experimental_telemetry: { functionId },
+      telemetry: { functionId },
     });
     const text = result?.response?.text || '';
     const learned = (result?.toolExecutions || []).filter((e: any) => e.toolName === 'learnExperience' && e.output?.content).map((e: any) => e.output.content);
@@ -1029,9 +1038,13 @@ export class Pilot implements Agent {
 
       Tester tools: click, pressKey, form, see, verify, 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}
 
       YOUR Pilot-only tool: precondition(description) — create FRESH disposable test data via API. Never
       request users. Use when:
+
       - Scenario edits/deletes/modifies an item → create a disposable target ("1 post").
       - Scenario needs auxiliary data (labels, categories, statuses for filtering).
       - Tester failed because required data is missing (empty dropdown, empty list).
@@ -1041,6 +1054,8 @@ export class Pilot implements Agent {
       - Current page already shows the exact data needed.
       - Scenario tests navigation, search UI, or viewing.
 
+      ${dataProtectionRules}
+
       Describe WHAT to create, not what exists. RIGHT: precondition("1 test"). WRONG:
       precondition("1 test suite named Updated Suite with existing tests"). Keep descriptions short.
 

package/src/ai/planner.ts

@@ -24,7 +24,7 @@ import type { Provider } from './provider.js';
 import { POSSIBLE_SECTIONS, Researcher } from './researcher.ts';
 import { findSimilarStateHash } from './researcher/cache.ts';
 import { hasFocusedSection } from './researcher/focus.ts';
-import { fileUploadRule, protectionRule } from './rules.ts';
+import { capabilityGroundingRule, dataProtectionRules, fileUploadRule } from './rules.ts';
 
 const debugLog = createDebug('explorbot:planner');
 
@@ -35,7 +35,7 @@ const TasksSchema = z.object({
       z.object({
         scenario: z.string().describe('A single sentence describing what to test'),
         priority: z.enum(['critical', 'important', 'high', 'normal', 'low']).describe('Priority of the task based on business importance'),
-        startUrl: z.string().nullable().describe('Start URL for the test if different from plan URL (only for tests on visited subpages)'),
+        startUrl: z.string().nullable().describe('Start URL for the test if different from plan URL. Use only stable feature/list/detail pages, not transient create/edit/modal URLs unless the scenario specifically starts inside that form.'),
         steps: z.array(z.string()).describe('List of steps to perform for this scenario. Each step should be a specific action (e.g., "Open the form", "Enter required data", "Submit the form"). Keep steps atomic and actionable.'),
         expectedOutcomes: z
           .array(z.string())
@@ -90,6 +90,9 @@ export class Planner extends PlannerBase implements Agent {
     const featureDirective = feature
       ? `\n    IMPORTANT: The user requested to focus specifically on: "${feature}"\n    ALL scenarios MUST be directly related to this feature. Do not propose generic page tests unrelated to it.\n    Use the user's exact wording to guide scenario names — do not substitute different entities (e.g., do not plan "suite" actions when user said "test").`
       : '';
+    const focusExistingDataDirective = feature
+      ? '\n    If this focus asks for search, filter, tabs, sorting, or list behavior involving existing items, only use item names/values visible in the provided page research. If no concrete visible item names/values are present, do NOT propose scenarios that require an existing known item; propose no-match search, empty-state, clear-search, tab/filter empty-list, or other read-only list behavior instead.'
+      : '';
     return dedent`
     <role>
     You are ISTQB certified senior manual QA planning exploratory testing session of a web application.
@@ -113,7 +116,7 @@ export class Planner extends PlannerBase implements Agent {
       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}
+      If two scenarios cannot run independently (one requires the other to run first), merge them into one.${featureDirective}${focusExistingDataDirective}
     </task>
 
     ${customPrompt || ''}
@@ -341,6 +344,11 @@ export class Planner extends PlannerBase implements Agent {
       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 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.
+      If the list is empty or no concrete item names are visible, do not invent "known" or "existing" items. Prefer empty-state, no-match search, clear-search, or read-only list behavior scenarios.
+      Search, filter, sorting, tab, and list scenarios must start from a stable page where those controls are visible; avoid transient create/edit/new URLs unless the scenario tests that form.
+      For option values and list items, use only visible or previously observed data; do not add create/update/delete setup unless the user explicitly requests that workflow.
+      Detail-view scenarios must target visible data entities from list rows, cards, tree nodes, or detail links; do not use filter tabs, counters, status tabs, breadcrumbs, or navigation controls as detail targets.
       DO NOT propose "verification-only" tests that merely open a UI element (modal, dropdown, panel) and check it exists.
       Every test must complete a meaningful action that changes application state or produces a business outcome.
       Opening a modal is NOT a test — performing an action INSIDE the modal IS a test.
@@ -351,7 +359,8 @@ export class Planner extends PlannerBase implements Agent {
       Tests that only switch views, toggle filters, or paginate are LESS valuable — propose them only after data-changing tests are covered.
       If multiple ways to create or modify data exist (different types, different forms), propose a separate test for each.
       </priority_order>
-      ${protectionRule}
+      ${capabilityGroundingRule}
+      ${dataProtectionRules}
       ${fileUploadRule}
       </rules>
 
@@ -514,7 +523,9 @@ export class Planner extends PlannerBase implements Agent {
           .join('\n')}
 
         You MAY propose tests starting from these pages if they are relevant to the plan "${this.currentPlan.title}".
-        Set startUrl for such tests. Ignore pages that belong to a different feature area.
+        Set startUrl for such tests only when the page is a stable feature/list/detail page.
+        Do not use create/edit/new/modal URLs as startUrl for scenarios that need the underlying page.
+        Ignore pages that belong to a different feature area.
         </context_from_previous_tests>
 
         Propose ONLY new scenarios that are NOT in the existing tests list.