explorbot 0.1.27 → 0.1.29

package/src/ai/captain.ts

@@ -26,7 +26,6 @@ const MAX_STEPS = 15;
 const CaptainBase = WithTestMode(WithWebMode(WithIdleMode(TaskAgent as unknown as new (...args: any[]) => TaskAgent)));
 
 export class Captain extends CaptainBase implements Agent {
-  protected readonly ACTION_TOOLS = ['click', 'pressKey', 'form', 'navigate'];
   emoji = '🧑‍✈️';
   private explorBot: ExplorBot;
   private conversation: Conversation | null = null;
@@ -72,6 +71,12 @@ export class Captain extends CaptainBase implements Agent {
 
   protected trackToolExecutions(toolExecutions: any[]): void {
     super.trackToolExecutions(toolExecutions);
+    if (toolExecutions.length > 0) {
+      this.recentToolCalls.push(...toolExecutions);
+      if (this.recentToolCalls.length > 20) {
+        this.recentToolCalls = this.recentToolCalls.slice(-20);
+      }
+    }
     for (const exec of toolExecutions) {
       const label = toolExecutionLabel(exec.input);
       if (!label) continue;
@@ -80,14 +85,19 @@ export class Captain extends CaptainBase implements Agent {
     }
   }
 
-  private detectMode(): CaptainMode {
-    if (this.explorBot.getExplorer().activeTest) return 'test';
-    if (this.explorBot.getExplorer().getStateManager().getCurrentState()) return 'web';
+  getMode(): CaptainMode {
+    const explorer = this.explorBot.getExplorer();
+    const activeTest = explorer.activeTest;
+    const page = explorer.playwrightHelper?.page;
+
+    if (activeTest && (!page || page.isClosed?.())) return 'heal';
+    if (activeTest) return 'test';
+    if (explorer.getStateManager().getCurrentState()) return 'web';
     return 'idle';
   }
 
   private systemPrompt(): string {
-    const mode = this.detectMode();
+    const mode = this.getMode();
     const currentUrl = this.explorBot.getExplorer().getStateManager().getCurrentState()?.url;
     const customPrompt = this.explorBot.getProvider().getSystemPromptForAgent('captain', currentUrl);
 
@@ -101,18 +111,21 @@ export class Captain extends CaptainBase implements Agent {
     - idle: plan management, file operations, knowledge. Always available.
     - web: page interaction, navigation, browser diagnostics. When working with a web page.
     - test: test analysis, state inspection. When a test is running or analyzing results.
+    - heal: browser/test recovery. When a test is running and browser state is broken or unavailable.
     </modes>
 
     ${this.idleModePrompt()}
-    ${mode === 'web' ? this.webModePrompt() : ''}
-    ${mode === 'test' ? this.testModePrompt() : ''}
+    ${mode === 'web' || mode === 'heal' ? this.webModePrompt() : ''}
+    ${mode === 'test' || mode === 'heal' ? this.testModePrompt() : ''}
 
     <rules>
     - After a successful action, if the pageDiff confirms the goal, call done() immediately — do not verify with see() or context() unless the user explicitly asked for verification
     - Prefer completing in fewer tool calls over thoroughness
     - NEVER run tests unless the user explicitly asks
-    ${mode === 'web' ? this.webModeRules() : ''}
-    ${mode === 'test' ? this.testModeRules() : ''}
+    - If you are answering with information rather than completing a browser action, include the actual user-facing answer in done({ details }). Do not only say that it was shown or explained.
+    ${mode === 'web' || mode === 'heal' ? this.webModeRules() : ''}
+    ${mode === 'test' || mode === 'heal' ? this.testModeRules() : ''}
+    ${mode === 'heal' ? '- First diagnose browser availability, then recover the browser/page before continuing test analysis.' : ''}
     </rules>
 
     ${customPrompt || ''}
@@ -250,9 +263,20 @@ export class Captain extends CaptainBase implements Agent {
         description: 'Call when the user request is fulfilled.',
         inputSchema: z.object({
           summary: z.string().describe('What was done'),
+          details: z.string().optional().describe('Actual user-facing content. Required when the user asked to show, display, explain, summarize, compare, or diagnose information.'),
         }),
-        execute: async ({ summary }) => {
+        execute: async ({ summary, details }) => {
           debugLog('done', summary);
+          if (!details?.trim() && !this.canCompleteWithoutDetails()) {
+            return {
+              success: false,
+              message: 'No user-facing result was provided. Call done() again with the actual answer in details, or complete a browser action first.',
+            };
+          }
+          if (details?.trim()) {
+            tag('details').log(details);
+            task.addNote(details);
+          }
           task.addNote(summary);
           onDone(summary);
           return { success: true, summary };
@@ -261,6 +285,9 @@ export class Captain extends CaptainBase implements Agent {
       runCommand: tool({
         description: dedent`
           Execute a TUI command. Returns log output from command execution.
+          Use only when the user explicitly asks to run a slash command.
+          Never use this to analyze files, reports, logs, plans, generated tests, knowledge, or experience.
+          Never run a slash command unless the user request itself starts with that slash command.
           ${this.commandDescriptions
             .map((c) => {
               const opts = c.options ? ` (${c.options})` : '';
@@ -274,6 +301,13 @@ export class Captain extends CaptainBase implements Agent {
         execute: async ({ command }) => {
           if (!this.commandExecutor) return { success: false, message: 'Command executor not available' };
           const cmd = command.startsWith('/') ? command : `/${command}`;
+          if (!isExplicitSlashRequest(task.description, cmd)) {
+            return {
+              success: false,
+              command: cmd,
+              message: 'Command blocked: slash commands require an explicit matching slash-command request from the user.',
+            };
+          }
           startLogCapture();
           try {
             await this.commandExecutor(cmd);
@@ -286,11 +320,12 @@ export class Captain extends CaptainBase implements Agent {
   }
 
   private async tools(task: Task, onDone: (summary: string) => void) {
-    const mode = this.detectMode();
+    const mode = this.getMode();
     const ctx: ModeContext = { explorBot: this.explorBot, task };
     const core = this.coreTools(task, onDone);
     const idle = await this.idleModeTools(ctx);
 
+    if (mode === 'heal') return { ...core, ...idle, ...this.testModeTools(ctx), ...this.webModeTools(ctx) };
     if (mode === 'test') return { ...core, ...idle, ...this.testModeTools(ctx) };
     if (mode === 'web') return { ...core, ...idle, ...this.webModeTools(ctx) };
     return { ...core, ...idle };
@@ -365,20 +400,28 @@ export class Captain extends CaptainBase implements Agent {
     return result.object;
   }
 
+  async processExecutionError(error: Error, activeTest: Test): Promise<ExecutionRecoveryAction> {
+    const explorer = this.explorBot.getExplorer();
+    const result = await explorer.handleExecutionError(error);
+    return {
+      ...result,
+      message: result.recovered ? `${result.message}\nContinue the test "${activeTest.scenario}" from the restored page.` : result.message,
+    };
+  }
+
+  private canCompleteWithoutDetails(): boolean {
+    return (this.recentToolCalls || []).some(hasBrowserCompletionEvidence);
+  }
+
   async handle(input: string, options: { reset?: boolean } = {}): Promise<string | null> {
     const stateManager = this.explorBot.getExplorer().getStateManager();
     const initialState = stateManager.getCurrentState();
 
-    if (!initialState) {
-      tag('warning').log('No page loaded. Use /navigate or I.amOnPage() first.');
-      return null;
-    }
-
     const conversation = options.reset ? this.resetConversation() : this.ensureConversation();
     let isDone = false;
     let finalSummary: string | null = null;
 
-    const startUrl = initialState.url || '';
+    const startUrl = initialState?.url || '';
     const task = new Task(input, startUrl);
     const onDone = (summary: string) => {
       isDone = true;
@@ -421,12 +464,14 @@ export class Captain extends CaptainBase implements Agent {
         }
 
         const currentState = stateManager.getCurrentState();
-        if (!currentState) {
+        if (!currentState && this.getMode() !== 'idle') {
           stop();
           return;
         }
 
-        await this.reinjectContextIfNeeded(conversation, currentState);
+        if (currentState) {
+          await this.reinjectContextIfNeeded(conversation, currentState);
+        }
 
         if (userInput) {
           const newContext = await this.getPageContext();
@@ -463,7 +508,7 @@ export class Captain extends CaptainBase implements Agent {
 
         if (result?.toolExecutions?.length) {
           const lastExec = result.toolExecutions[result.toolExecutions.length - 1];
-          if (lastExec.wasSuccessful && this.ACTION_TOOLS.includes(lastExec.toolName)) {
+          if (hasBrowserCompletionEvidence(lastExec)) {
             conversation.addUserText('Action succeeded. If the goal is achieved, call done() now with a brief summary.');
           }
         }
@@ -500,3 +545,32 @@ interface SupervisorAction {
   action: 'inject' | 'stop' | 'pass' | 'skip';
   message: string;
 }
+
+interface ExecutionRecoveryAction {
+  action: 'continue' | 'stop';
+  message: string;
+  recovered?: boolean;
+}
+
+function isExplicitSlashRequest(input: string, command: string): boolean {
+  const requested = slashCommandToken(input);
+  const actual = slashCommandToken(command);
+  if (!requested || !actual) return false;
+  return requested === actual;
+}
+
+function slashCommandToken(value: string): string | null {
+  const trimmed = value.trim();
+  if (!trimmed.startsWith('/')) return null;
+
+  for (let i = 1; i < trimmed.length; i++) {
+    if (trimmed[i] <= ' ') return trimmed.slice(0, i);
+  }
+  return trimmed;
+}
+
+function hasBrowserCompletionEvidence(execution: any): boolean {
+  if (!execution?.wasSuccessful) return false;
+  const output = execution.output || {};
+  return Boolean(output.pageDiff || output.code || output.playwrightGroupId);
+}

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/historian/screencast.ts

@@ -10,6 +10,8 @@ import { relativeToCwd } from '../../utils/next-steps.ts';
 import { safeFilename } from '../../utils/strings.ts';
 import { type Constructor, debugLog } from './mixin.ts';
 
+const FATAL_SCREENCAST_STOP_ERRORS = /Target page, context or browser has been closed|Target closed|Session closed|Protocol error/i;
+
 export interface ScreencastMethods {
   attachScreencast(): void;
   isScreencastActive(): boolean;
@@ -113,17 +115,24 @@ export function WithScreencast<T extends Constructor>(Base: T) {
       if (!this.screencastActive) return;
       const path = this.screencastPath;
       const task = this.screencastTask;
+      let stopped = false;
       try {
         await this.screencastPage.screencast.stop();
+        stopped = true;
       } catch (err) {
-        tag('operation').log(`Screencast stop failed: ${(err as Error).message}`);
+        const message = (err as Error).message;
+        if (FATAL_SCREENCAST_STOP_ERRORS.test(message)) {
+          tag('operation').log('Screencast skipped: browser was closed before recording could be finalized');
+        } else {
+          tag('operation').log(`Screencast stop failed: ${message}`);
+        }
       }
       this.screencastActive = false;
       this.screencastPage = null;
       this.screencastPath = null;
       this.screencastTask = null;
       this.screencastLastChapter = null;
-      if (path) {
+      if (path && stopped) {
         this.savedFiles.add(path);
         task?.addArtifact?.(path);
         tag('operation').log(`Saved screencast: ${relativeToCwd(path)}`);

package/src/ai/navigator.ts

@@ -136,6 +136,10 @@ class Navigator implements Agent {
   }
 
   async visit(url: string): Promise<void> {
+    return this.explorer.runWithBrowserRecovery('navigator.visit', () => this.visitOnce(url));
+  }
+
+  private async visitOnce(url: string): Promise<void> {
     try {
       const action = this.explorer.createAction();
 
@@ -170,7 +174,7 @@ class Navigator implements Agent {
           throw new Error(`Navigation to ${url} failed: ${action.lastError?.message}`);
         }
       }
-      await action.caputrePageWithScreenshot();
+      await this.explorer.capturePageWithScreenshot();
       await this.hooksRunner.runAfterHook('navigator', url);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -382,7 +386,7 @@ class Navigator implements Agent {
               // URL did not transition to expectedUrl within timeout
             }
           }
-          const freshState = await action.capturePageState();
+          const freshState = await this.explorer.capturePageState();
           const currentUrl = /^https?:\/\//i.test(expectedUrl) ? freshState.fullUrl || freshState.url || '' : freshState.url || '';
           const urlMatches = this.isSameExpectedOrigin(expectedUrl, action.stateManager) && normalizeUrl(currentUrl) === normalizeUrl(expectedUrl);
           const stateChanged = freshState.getStateHash() !== actionResult.getStateHash();

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'];
@@ -67,7 +68,7 @@ export class Pilot implements Agent {
   }
 
   async reviewCompletion(task: Test, currentState: ActionResult, testerConversation: Conversation, navigator?: Navigator): Promise<boolean> {
-    const verdictType = task.hasAchievedAny() ? 'finish' : 'stop';
+    const verdictType = this.hasCompletionEvidence(task, currentState, testerConversation) ? 'finish' : 'stop';
     return this.reviewDecision(verdictType, task, currentState, testerConversation, navigator);
   }
 
@@ -86,14 +87,14 @@ export class Pilot implements Agent {
 
     const sessionLog = this.formatSessionLog(testerConversation);
     const stateContext = this.buildStateContext(currentState);
+    const successfulAssertions = this.formatSuccessfulAssertions(currentState, testerConversation);
     const notes = task.notesToString() || 'No notes recorded.';
 
     let visualAnalysis = '';
     let screenshotState: ActionResult | null = null;
-    if (this.provider.hasVision()) {
+    if (type === 'finish' && this.provider.hasVision()) {
       try {
-        const action = this.explorer.createAction();
-        screenshotState = await action.caputrePageWithScreenshot();
+        screenshotState = await this.explorer.capturePageWithScreenshot();
         if (screenshotState.screenshot) {
           visualAnalysis = (await this.researcher.answerQuestionAboutScreenshot(screenshotState, `Describe current page state relevant to: ${task.scenario}`)) || '';
         }
@@ -125,6 +126,10 @@ export class Pilot implements Agent {
 
       ${this.formatExpectations(task)}
 
+      <successful_assertions>
+      ${successfulAssertions || 'None'}
+      </successful_assertions>
+
       <notes>
       ${notes}
       </notes>
@@ -160,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;
@@ -262,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;
@@ -374,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:
@@ -382,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".
@@ -420,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)
@@ -572,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);
@@ -658,8 +671,7 @@ export class Pilot implements Agent {
   private async checkDataAvailability(task: Test, requestedData: string, fishermanReason: string | undefined): Promise<string | null> {
     if (!this.provider.hasVision()) return null;
 
-    const action = this.explorer.createAction();
-    const screenshotState = await action.caputrePageWithScreenshot().catch(() => null);
+    const screenshotState = await this.explorer.capturePageWithScreenshot().catch(() => null);
     if (!screenshotState?.screenshot) return null;
 
     const question = dedent`
@@ -882,6 +894,32 @@ export class Pilot implements Agent {
     return parts.join('\n\n');
   }
 
+  private hasCompletionEvidence(task: Test, currentState: ActionResult, testerConversation: Conversation): boolean {
+    if (task.hasAchievedAny()) return true;
+    return this.hasSuccessfulCheckEvidence(currentState, testerConversation);
+  }
+
+  private hasSuccessfulCheckEvidence(currentState: ActionResult, testerConversation: Conversation): boolean {
+    if (Object.values(currentState.verifications ?? {}).some(Boolean)) return true;
+    return testerConversation.getToolExecutions().some((t) => CHECK_TOOLS.includes(t.toolName) && t.wasSuccessful);
+  }
+
+  private formatSuccessfulAssertions(currentState: ActionResult, testerConversation: Conversation): string {
+    const lines: string[] = [];
+    for (const [assertion, passed] of Object.entries(currentState.verifications ?? {})) {
+      if (passed) lines.push(`PASS state verification: ${assertion}`);
+    }
+
+    for (const exec of testerConversation.getToolExecutions()) {
+      if (!CHECK_TOOLS.includes(exec.toolName) || !exec.wasSuccessful) continue;
+      const description = exec.input?.assertion || exec.input?.request || truncateJson(exec.input);
+      const result = exec.output?.message || exec.output?.analysis || exec.output?.result;
+      lines.push(`PASS ${exec.toolName}: ${description}${result ? ` -> ${result}` : ''}`);
+    }
+
+    return [...new Set(lines)].join('\n');
+  }
+
   private formatActions(toolCalls: any[]): string {
     return toolCalls
       .map((t) => {
@@ -1000,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).
@@ -1012,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.