agentic-browser 2.7.1 → 2.8.1

package/README.md

@@ -128,7 +128,8 @@ agentic-browser agent elements
 agentic-browser agent elements --roles button,link --limit 20
 agentic-browser agent elements --href /news/ --text "gta"
 agentic-browser agent screenshot --out ./page.png --full-page
-agentic-browser agent memory-search "navigate:example.com" --domain example.com
+agentic-browser agent click e3 --intent "open top story"
+agentic-browser agent memory-search "open the top story" --domain example.com
 agentic-browser agent stop
 agentic-browser agent cleanup --dry-run --max-age-days 7
 ```
@@ -143,7 +144,7 @@ agentic-browser agent elements --roles button,link,input --visible-only --limit
 agentic-browser agent elements --selector "#main-content"
 ```
 
-Returns a JSON array of elements with selectors and fallback selectors usable in the typed agent commands like `agent click`, `agent type`, and `agent select`:
+Returns a JSON array of elements with selectors and fallback selectors usable in the typed agent commands like `agent click`, `agent type`, and `agent select`. Main-content elements come first; header, nav and footer links come last. Each element also gets a short ref (`e1`, `e2`, ...): `agent click e3` resolves it to the stored selector. Refs stay valid while the page URL is unchanged; after navigating, run `agent elements` again:
 
 ```json
 {
@@ -274,9 +275,9 @@ agentic-browser memory:stats
 
 1. `agent start` — launch Chrome and persist session.
 2. `agent elements` — discover what's on the page.
-3. `agent navigate`, `agent click`, `agent type`, `agent select`, and related typed commands — execute actions using discovered selectors.
+3. `agent navigate`, `agent click`, `agent type`, `agent select`, and related typed commands — execute actions using element refs or selectors. Pass `--intent "<task>"` (an `agent`-level option, accepted before or after the subcommand) to group the steps of one task in memory. Consecutive steps with the same intent form one run; a new run replaces the stored recipe, so it always holds the latest run's steps in order.
 4. `agent content` — read page content after actions.
-5. `agent memory-search` — reuse known selectors for repeated tasks.
+5. `agent memory-search "<task>"` — matching is fuzzy; results include a `recipe` with the steps that worked last time (`needsInput` marks typed text that was redacted).
 6. `agent stop` — terminate when done.
 
 ## Anti-Detection

package/dist/cli/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as isConnectionError, o as ensurePrivateDir, r as createCliRuntime, s as writePrivateFileSync } from "../runtime-CnexYwrf.mjs";
+import { c as writePrivateFileSync, o as isConnectionError, r as createCliRuntime, s as ensurePrivateDir } from "../runtime-CgX6XW9u.mjs";
 import fs from "node:fs";
 import path from "node:path";
 import crypto from "node:crypto";
@@ -87,7 +87,8 @@ async function executeAgentCommand(runtime, input) {
 	const attempt = () => runtime.api.executeCommand(sessionId, {
 		commandId: nextCommandId(),
 		type: input.type,
-		payload: input.payload
+		payload: input.payload,
+		intent: input.intent
 	});
 	const retryAfterRestart = async () => {
 		await runtime.api.restartSession(sessionId);
@@ -111,12 +112,12 @@ async function executeAgentCommand(runtime, input) {
 async function agentNavigate(runtime, input) {
 	const result = await executeAgentCommand(runtime, {
 		type: "navigate",
-		payload: { url: input.url }
+		payload: { url: input.url },
+		intent: input.intent
 	});
 	let cookieBanner;
 	if (result.resultStatus === "success") try {
-		const sessionId = requireSessionId(runtime);
-		const dismissed = await runtime.api.dismissCookieBanner(sessionId);
+		const dismissed = await runtime.api.dismissCookieBanner(result.sessionId);
 		if (dismissed.dismissed) cookieBanner = dismissed;
 	} catch {}
 	const page = await tryPageState(runtime, result.sessionId);
@@ -128,10 +129,13 @@ async function agentNavigate(runtime, input) {
 		cookieBanner
 	};
 }
+/** `selector` may be a ref ("e3") from `agent elements`; the core resolves it. */
 async function agentInteract(runtime, input) {
+	const { intent, ...payload } = input;
 	const result = await executeAgentCommand(runtime, {
 		type: "interact",
-		payload: input
+		payload,
+		intent
 	});
 	const page = await tryPageState(runtime, result.sessionId);
 	return {
@@ -473,6 +477,7 @@ async function runMemoryStats(runtime) {
 // src/cli/index.ts
 const collect = (value, previous = []) => [...previous, value];
 const FRAME_HELP = "iframe selector to run in (cross-origin frames supported)";
+const INTENT_HELP = "task this step belongs to, e.g. \"log in\"; memory groups steps by it (see agent memory-search)";
 /** Resolves `<selector>` or `--text` (substring; `--exact` for exact match) to one locator. */
 function resolveTarget(selector, options) {
 	if (selector && options.text) throw new Error("Pass either a selector or --text, not both");
@@ -554,7 +559,9 @@ async function main() {
 		const result = await runMemoryStats(runtime);
 		console.log(JSON.stringify(result));
 	});
-	const agent = program.command("agent").description("Stateful agent wrapper with session persistence and auto-retry");
+	const agent = program.command("agent").description("Stateful agent wrapper with session persistence and auto-retry").option("--intent <task>", INTENT_HELP);
+	/** --intent of the current agent step command; memory groups steps by it. */
+	const stepIntent = () => agent.opts().intent;
 	agent.command("start").option("--cdp-url <url>", "connect to existing Chrome via CDP endpoint URL").option("--user-profile <path>", "use 'default' for system Chrome profile or an absolute path").option("--headless", "run Chrome in headless mode (no visible window)").option("--user-agent <string>", "override the browser user-agent string").action(async (options) => {
 		if (options.cdpUrl) runtime.context.config.cdpUrl = options.cdpUrl;
 		if (options.userProfile) runtime.context.config.userProfileDir = options.userProfile === "true" || options.userProfile === "default" ? "default" : options.userProfile;
@@ -572,19 +579,23 @@ async function main() {
 		console.log(JSON.stringify(result));
 	});
 	agent.command("navigate").argument("<url>").action(async (url) => {
-		const result = await agentNavigate(runtime, { url });
+		const result = await agentNavigate(runtime, {
+			url,
+			intent: stepIntent()
+		});
 		console.log(JSON.stringify(result));
 	});
-	agent.command("click").argument("[selector]", "CSS selector or composed locator (a >>> b)").option("--text <text>", "click the element with this visible text instead of a selector").option("--exact", "with --text: require an exact text match").option("--frame <selector>", FRAME_HELP).option("--fallback <selector>", "backup CSS selector", collect, []).action(async (selector, options) => {
+	agent.command("click").argument("[selector]", "element ref (e3) from agent elements, CSS selector, or composed locator (a >>> b)").option("--text <text>", "click the element with this visible text instead of a selector").option("--exact", "with --text: require an exact text match").option("--frame <selector>", FRAME_HELP).option("--fallback <selector>", "backup CSS selector", collect, []).action(async (selector, options) => {
 		const result = await agentInteract(runtime, {
 			action: "click",
 			selector: resolveTarget(selector, options),
 			frame: options.frame,
-			fallbackSelectors: options.fallback
+			fallbackSelectors: options.fallback,
+			intent: stepIntent()
 		});
 		console.log(JSON.stringify(result));
 	});
-	agent.command("type").argument("<selectorOrText>", "CSS selector, or the text to type when --into-text is used").argument("[text]").option("--into-text <label>", "target the field by its visible text/label/placeholder").option("--frame <selector>", FRAME_HELP).option("--fallback <selector>", "backup CSS selector", collect, []).action(async (first, second, options) => {
+	agent.command("type").argument("<selectorOrText>", "element ref (e3), CSS selector, or the text to type when --into-text is used").argument("[text]").option("--into-text <label>", "target the field by its visible text/label/placeholder").option("--frame <selector>", FRAME_HELP).option("--fallback <selector>", "backup CSS selector", collect, []).action(async (first, second, options) => {
 		const selector = options.intoText ? `text=${options.intoText}` : first;
 		const text = options.intoText ? first : second;
 		if (text === void 0) throw new Error("Missing text to type");
@@ -593,14 +604,16 @@ async function main() {
 			selector,
 			text,
 			frame: options.frame,
-			fallbackSelectors: options.fallback
+			fallbackSelectors: options.fallback,
+			intent: stepIntent()
 		});
 		console.log(JSON.stringify(result));
 	});
 	agent.command("press").argument("<key>").action(async (key) => {
 		const result = await agentInteract(runtime, {
 			action: "press",
-			key
+			key,
+			intent: stepIntent()
 		});
 		console.log(JSON.stringify(result));
 	});
@@ -620,7 +633,8 @@ async function main() {
 			action: "hover",
 			selector: resolveTarget(selector, options),
 			frame: options.frame,
-			fallbackSelectors: options.fallback
+			fallbackSelectors: options.fallback,
+			intent: stepIntent()
 		});
 		console.log(JSON.stringify(result));
 	});
@@ -630,7 +644,8 @@ async function main() {
 			selector,
 			value,
 			frame: options.frame,
-			fallbackSelectors: options.fallback
+			fallbackSelectors: options.fallback,
+			intent: stepIntent()
 		});
 		console.log(JSON.stringify(result));
 	});
@@ -639,7 +654,8 @@ async function main() {
 			action: "toggle",
 			selector,
 			frame: options.frame,
-			fallbackSelectors: options.fallback
+			fallbackSelectors: options.fallback,
+			intent: stepIntent()
 		});
 		console.log(JSON.stringify(result));
 	});
@@ -648,6 +664,7 @@ async function main() {
 			action: "scroll",
 			selector: options.selector,
 			fallbackSelectors: options.fallback,
+			intent: stepIntent(),
 			scrollX: Number.parseInt(options.x, 10),
 			scrollY: Number.parseInt(options.y, 10)
 		});

package/dist/index.d.mts

@@ -49,6 +49,8 @@ interface InteractiveElement {
   ariaLabel?: string;
   placeholder?: string;
   currentValue?: string;
+  /** Short handle ("e3") usable in place of the selector until the page changes. */
+  ref?: string;
 }
 interface InteractiveElementsOptions {
   roles?: InteractiveElementRole[];
@@ -171,6 +173,7 @@ declare const TaskInsightSchema: z.ZodObject<{
     selector: z.ZodOptional<z.ZodString>;
     payload: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
   }, z.core.$strip>>;
+  recipeRunId: z.ZodOptional<z.ZodString>;
   expectedOutcome: z.ZodString;
   confidence: z.ZodNumber;
   successCount: z.ZodNumber;
@@ -255,6 +258,14 @@ interface SiteProfileSummary {
   };
   visitCount: number;
 }
+/** One replayable step of a remembered task. */
+interface RecipeStepSummary {
+  action: string;
+  selector?: string;
+  url?: string;
+  /** Typed text or a selected value was not stored; supply it again on replay. */
+  needsInput?: true;
+}
 interface MemorySearchResult {
   insightId: string;
   taskIntent: string;
@@ -262,6 +273,8 @@ interface MemorySearchResult {
   confidence: number;
   freshness: InsightFreshness;
   lastVerifiedAt: string;
+  /** The steps that completed this task last time, in order. */
+  recipe: RecipeStepSummary[];
   selectorHints: string[];
   selectorAliases: SelectorAlias[];
   score: number;
@@ -398,6 +411,11 @@ interface RecordExecutionInput {
   expectedOutcome: string;
   url?: string;
   selector?: string;
+  /**
+   * Run this step belongs to. A step from a new run starts the recipe over, so
+   * the recipe is always the latest run's steps in order. Defaults to commandId.
+   */
+  runId?: string;
 }
 declare class MemoryService {
   private readonly store;
@@ -451,6 +469,7 @@ declare class MemoryService {
   private createEvidence;
   private maybeGenerateAliases;
   private deriveAliasName;
+  /** Same run: append the step. New run: its first step replaces the old recipe. */
   private mergeRecipe;
 }
 interface AppContext {
@@ -460,12 +479,43 @@ interface AppContext {
   tokenService: SessionTokenService;
   memoryService: MemoryService;
 }
+/**
+ * Short, stable handles ("e1", "e2", …) an agent can point at instead of
+ * authoring CSS selectors — the way a human points at what they see rather
+ * than reasoning about the DOM.
+ *
+ * Refs are ephemeral per "look": each element listing replaces the session's
+ * ref set, and a ref only resolves while the page URL is the one it was taken
+ * on. SessionManager persists them on the session record, so the CLI (one
+ * process per command) and the MCP server share the same mechanism.
+ */
+interface ResolvedRef {
+  selector: string;
+  fallbackSelectors?: string[];
+  /** Iframe the element was discovered in, so the ref acts inside it. */
+  frame?: string;
+}
+interface StoredRefs {
+  /** Page the refs were taken on; on any other page they are stale. */
+  url?: string;
+  byRef: Record<string, ResolvedRef>;
+}
 interface StoredSessionRecord {
   session: Session;
   cdpUrl: string;
   targetWsUrl: string;
   pid: number;
   lastUrl?: string;
+  /** Element refs from the last element listing. */
+  refs?: StoredRefs;
+  /**
+   * The task run in progress: consecutive commands with the same explicit
+   * intent share `runId`, so memory can rebuild that task's recipe per run.
+   */
+  intentRun?: {
+    intent: string;
+    runId: string;
+  };
 }
 interface CreateSessionInput {
   browser: "chrome";
@@ -474,6 +524,8 @@ interface ExecuteCommandInput$1 {
   commandId: string;
   type: CommandType;
   payload: Record<string, unknown>;
+  /** Task this step belongs to (e.g. "log in"); memory groups steps by it. */
+  intent?: string;
 }
 interface CleanupInput {
   maxAgeDays?: number;
@@ -494,9 +546,15 @@ declare class SessionManager {
   getSession(sessionId: string): Session;
   /** Return a healthy session, recovering automatically if needed. */
   ensureSession(sessionId: string): Promise<StoredSessionRecord>;
-  executeCommand(sessionId: string, input: ExecuteCommandInput$1): Promise<Command>;
+  executeCommand(sessionId: string, rawInput: ExecuteCommandInput$1): Promise<Command>;
   getContent(sessionId: string, options: PageContentOptions): Promise<PageContentResult>;
-  getInteractiveElements(sessionId: string, options: InteractiveElementsOptions): Promise<InteractiveElementsResult>;
+  /** Lists interactive elements and assigns fresh refs (e1, e2, …) for this page. */
+  getInteractiveElements(sessionId: string, options: InteractiveElementsOptions): Promise<{
+    totalFound: number;
+    truncated: boolean;
+    crossOriginFrames?: CrossOriginFrameInfo[];
+    elements: InteractiveElement[];
+  }>;
   screenshot(sessionId: string, options?: ScreenshotOptions): Promise<ScreenshotResult>;
   getCurrentUrl(sessionId: string): Promise<string>;
   getPageState(sessionId: string): Promise<PageState>;
@@ -534,6 +592,7 @@ declare class SessionManager {
       selector?: string | undefined;
       payload: Record<string, unknown>;
     }[];
+    recipeRunId?: string | undefined;
     expectedOutcome: string;
     confidence: number;
     successCount: number;
@@ -571,6 +630,7 @@ declare class SessionManager {
       selector?: string | undefined;
       payload: Record<string, unknown>;
     }[];
+    recipeRunId?: string | undefined;
     expectedOutcome: string;
     confidence: number;
     successCount: number;
@@ -615,6 +675,12 @@ declare class SessionManager {
   private mustGetRecord;
   private recordEvent;
   private buildMemoryContext;
+  private resolveRef;
+  /**
+   * Consecutive commands with the same explicit intent form one run; any other
+   * command ends it. Commands without an intent are each their own run.
+   */
+  private trackIntentRun;
   private parseUrl;
 }
 declare class ControlApi {
@@ -643,6 +709,7 @@ declare class ControlApi {
     commandId: string;
     type: "navigate" | "interact" | "restart" | "terminate";
     payload: Record<string, unknown>;
+    intent?: string;
   }): Promise<{
     commandId: string;
     sessionId: string;
@@ -667,7 +734,12 @@ declare class ControlApi {
     selector?: string;
     maxChars?: number;
   }): Promise<PageContentResult>;
-  getInteractiveElements(sessionId: string, options: InteractiveElementsOptions): Promise<InteractiveElementsResult>;
+  getInteractiveElements(sessionId: string, options: InteractiveElementsOptions): Promise<{
+    totalFound: number;
+    truncated: boolean;
+    crossOriginFrames?: CrossOriginFrameInfo[];
+    elements: InteractiveElement[];
+  }>;
   dismissCookieBanner(sessionId: string): Promise<DismissCookieBannerResult>;
   screenshot(sessionId: string, options?: ScreenshotOptions): Promise<ScreenshotResult>;
   getCurrentUrl(sessionId: string): Promise<string>;
@@ -709,6 +781,7 @@ declare class ControlApi {
       selector?: string | undefined;
       payload: Record<string, unknown>;
     }[];
+    recipeRunId?: string | undefined;
     expectedOutcome: string;
     confidence: number;
     successCount: number;
@@ -746,6 +819,7 @@ declare class ControlApi {
       selector?: string | undefined;
       payload: Record<string, unknown>;
     }[];
+    recipeRunId?: string | undefined;
     expectedOutcome: string;
     confidence: number;
     successCount: number;
@@ -796,6 +870,8 @@ interface ExecuteCommandInput {
   commandId?: string;
   type: CommandType;
   payload: Record<string, unknown>;
+  /** Task this step belongs to (e.g. "log in"); memory groups steps by it. */
+  intent?: string;
 }
 export declare class AgenticBrowserCore {
   readonly context: AppContext;
@@ -853,7 +929,12 @@ export declare class AgenticBrowserCore {
     href?: string;
     text?: string;
     frame?: string;
-  }): Promise<InteractiveElementsResult>;
+  }): Promise<{
+    totalFound: number;
+    truncated: boolean;
+    crossOriginFrames?: CrossOriginFrameInfo[];
+    elements: InteractiveElement[];
+  }>;
   dismissCookieBanner(sessionId: string): Promise<DismissCookieBannerResult>;
   screenshot(sessionId: string, options?: ScreenshotOptions): Promise<ScreenshotResult>;
   getCurrentUrl(sessionId: string): Promise<string>;
@@ -895,6 +976,7 @@ export declare class AgenticBrowserCore {
       selector?: string | undefined;
       payload: Record<string, unknown>;
     }[];
+    recipeRunId?: string | undefined;
     expectedOutcome: string;
     confidence: number;
     successCount: number;
@@ -932,6 +1014,7 @@ export declare class AgenticBrowserCore {
       selector?: string | undefined;
       payload: Record<string, unknown>;
     }[];
+    recipeRunId?: string | undefined;
     expectedOutcome: string;
     confidence: number;
     successCount: number;

package/dist/index.mjs

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export { t as AgenticBrowserCore, n as createAgenticBrowserCore, i as createMockAgenticBrowserCore } from "./runtime-CnexYwrf.mjs";
+export { t as AgenticBrowserCore, n as createAgenticBrowserCore, i as createMockAgenticBrowserCore } from "./runtime-CgX6XW9u.mjs";

package/dist/mcp/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as createAgenticBrowserCore } from "../runtime-CnexYwrf.mjs";
+import { a as StaleRefError, n as createAgenticBrowserCore } from "../runtime-CgX6XW9u.mjs";
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -204,46 +204,6 @@ function compactMemoryResults(results) {
 		return compact;
 	}) };
 }
-// src/mcp/element-refs.ts
-var ElementRefRegistry = class {
-	bySession = /* @__PURE__ */ new Map();
-	/**
-	* Assign fresh refs to a freshly-discovered element list, replacing any prior
-	* refs for the session. Elements without a selector (nothing to act on) are
-	* still returned but get no ref.
-	*/
-	assign(sessionId, elements) {
-		const map = /* @__PURE__ */ new Map();
-		let n = 0;
-		const annotated = elements.map((el) => {
-			if (!el.selector) return {
-				...el,
-				ref: ""
-			};
-			const ref = `e${++n}`;
-			map.set(ref, {
-				selector: el.selector,
-				fallbackSelectors: el.fallbackSelectors,
-				text: el.text,
-				role: el.role
-			});
-			return {
-				...el,
-				ref
-			};
-		});
-		this.bySession.set(sessionId, map);
-		return { elements: annotated };
-	}
-	/** Resolve a ref to its selector target, or undefined if unknown/stale. */
-	resolve(sessionId, ref) {
-		return this.bySession.get(sessionId)?.get(ref);
-	}
-	/** Drop a session's refs (on stop/restart) so stale handles can't resolve. */
-	clear(sessionId) {
-		this.bySession.delete(sessionId);
-	}
-};
 // src/mcp/session-resolver.ts
 /**
 * Tracks the active session and auto-starts one on demand. Concurrent callers
@@ -318,7 +278,6 @@ function getCore() {
 function genId(prefix) {
 	return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 }
-const refs = new ElementRefRegistry();
 /**
 * Discover interactive elements, assign fresh refs for the session, and return
 * the compact agent-facing view (refs + role/text, no raw selectors). This is
@@ -334,8 +293,7 @@ async function snapshotElements(sessionId, opts = {}) {
 		selector: opts.selector,
 		roles: opts.roles
 	});
-	const { elements } = refs.assign(sessionId, result.elements);
-	return compactInteractiveElementsResult(elements, {
+	return compactInteractiveElementsResult(result.elements, {
 		totalFound: result.totalFound,
 		truncated: result.truncated
 	}, visibleOnly);
@@ -347,6 +305,7 @@ async function snapshotElements(sessionId, opts = {}) {
 async function resolveSession(sessionId) {
 	return sessionResolver.resolve(sessionId);
 }
+const intentParam = z.string().optional().describe("Task this step belongs to, in your own words (e.g. \"log in\", \"search products\"). Steps sharing an intent are remembered together and returned as a recipe by browser_search_memory");
 const server = new McpServer({
 	name: "agentic-browser",
 	version: readPackageVersion()
@@ -362,14 +321,16 @@ server.tool("browser_start_session", "Start a new Chrome browser session (or ret
 });
 server.tool("browser_navigate", "Navigate the browser to a URL. A session is auto-started if needed.", {
 	url: z.string().describe("The URL to navigate to"),
+	intent: intentParam,
 	sessionId: z.string().optional().describe("Session ID (auto-resolved if omitted)")
-}, async ({ url, sessionId }) => {
+}, async ({ url, intent, sessionId }) => {
 	const sid = await resolveSession(sessionId);
 	const result = await getCore().runCommand({
 		sessionId: sid,
 		commandId: genId("nav"),
 		type: "navigate",
-		payload: { url }
+		payload: { url },
+		intent
 	});
 	let cookieBanner;
 	if (result.resultStatus === "success") try {
@@ -416,38 +377,40 @@ server.tool("browser_interact", "Interact with a page element or perform browser
 	scrollX: z.number().optional().describe("Horizontal scroll delta in pixels (for \"scroll\" action)"),
 	scrollY: z.number().optional().describe("Vertical scroll delta in pixels (for \"scroll\" action, positive = down)"),
 	timeoutMs: z.number().optional().describe("Timeout in milliseconds (for \"waitFor\" action, default 4000)"),
+	intent: intentParam,
 	sessionId: z.string().optional().describe("Session ID (auto-resolved if omitted)")
-}, async ({ action, ref, selector, fallbackSelectors, text, key, value, scrollX, scrollY, timeoutMs, sessionId }) => {
+}, async ({ action, ref, selector, fallbackSelectors, text, key, value, scrollX, scrollY, timeoutMs, intent, sessionId }) => {
 	const sid = await resolveSession(sessionId);
 	const payload = { action };
-	if (!selector && ref) {
-		const resolved = refs.resolve(sid, ref);
-		if (!resolved) return { content: [{
+	const target = selector ?? ref;
+	if (target) payload.selector = target;
+	if (fallbackSelectors) payload.fallbackSelectors = fallbackSelectors;
+	if (text) payload.text = text;
+	if (key) payload.key = key;
+	if (value) payload.value = value;
+	if (scrollX !== void 0) payload.scrollX = scrollX;
+	if (scrollY !== void 0) payload.scrollY = scrollY;
+	if (timeoutMs) payload.timeoutMs = timeoutMs;
+	let result;
+	try {
+		result = await getCore().runCommand({
+			sessionId: sid,
+			commandId: genId("int"),
+			type: "interact",
+			payload,
+			intent
+		});
+	} catch (error) {
+		if (!(error instanceof StaleRefError)) throw error;
+		return { content: [{
 			type: "text",
 			text: JSON.stringify({
 				resultStatus: "failed",
-				resultMessage: `Unknown or stale ref "${ref}". Call browser_get_elements to refresh element refs.`,
+				resultMessage: error.message,
 				errorCode: "SELECTOR_NOT_FOUND"
 			})
 		}] };
-		payload.selector = resolved.selector;
-		if (resolved.fallbackSelectors) payload.fallbackSelectors = resolved.fallbackSelectors;
-	} else {
-		if (selector) payload.selector = selector;
-		if (fallbackSelectors) payload.fallbackSelectors = fallbackSelectors;
 	}
-	if (text) payload.text = text;
-	if (key) payload.key = key;
-	if (value) payload.value = value;
-	if (scrollX !== void 0) payload.scrollX = scrollX;
-	if (scrollY !== void 0) payload.scrollY = scrollY;
-	if (timeoutMs) payload.timeoutMs = timeoutMs;
-	const result = await getCore().runCommand({
-		sessionId: sid,
-		commandId: genId("int"),
-		type: "interact",
-		payload
-	});
 	let currentUrl;
 	try {
 		currentUrl = await getCore().getCurrentUrl(sid);
@@ -523,8 +486,8 @@ server.tool("browser_get_elements", "Discover interactive elements on the curren
 		text: JSON.stringify(snapshot)
 	}] };
 });
-server.tool("browser_search_memory", "Search task memory for previously learned selectors, selector aliases, and interaction patterns. Results include selectorHints (proven selectors) and selectorAliases (human-readable names mapped to selectors with fallbacks). Use this before interacting with a known site to reuse proven selectors instead of rediscovering them.", {
-	taskIntent: z.string().describe("What you want to do, e.g. \"login:github.com\" or \"search:amazon.de\""),
+server.tool("browser_search_memory", "Search task memory for previously learned selectors, selector aliases, and interaction patterns. Matching is fuzzy, so a rephrased task still finds earlier runs. Results include recipe (the ordered steps that worked; needsInput marks steps whose typed text was redacted), selectorHints (proven selectors) and selectorAliases (human-readable names mapped to selectors with fallbacks). Use this before interacting with a known site to reuse proven selectors instead of rediscovering them.", {
+	taskIntent: z.string().describe("What you want to do, e.g. \"log in\" or \"search products\". Use the same wording you passed as intent to navigate/interact"),
 	siteDomain: z.string().optional().describe("Domain to scope the search"),
 	limit: z.number().default(5).describe("Maximum number of results")
 }, async ({ taskIntent, siteDomain, limit }) => {
@@ -574,7 +537,6 @@ server.tool("browser_stop_session", "Stop the browser session and terminate Chro
 		})
 	}] };
 	await getCore().stopSession(sid);
-	refs.clear(sid);
 	if (sessionResolver.current() === sid) sessionResolver.clear();
 	return { content: [{
 		type: "text",

package/dist/{runtime-CnexYwrf.mjs → runtime-CgX6XW9u.mjs}

@@ -454,6 +454,22 @@ function resolveDefaultProfileDir() {
 	return path.join(home, ".config", "google-chrome");
 }
 const CONTENT_TRUNCATION_HINT = "Use a CSS selector to scope the content, or use mode=\"summary\" for a lower-token overview.";
+/**
+* In-page visibility check shared by element discovery and cookie dismissal.
+* Uses the element's own window so it also works inside same-origin iframes.
+*/
+const IN_PAGE_IS_VISIBLE = String.raw`
+      function isVisible(el) {
+        if (!el) return false;
+        const view = (el.ownerDocument && el.ownerDocument.defaultView) || window;
+        const style = view.getComputedStyle(el);
+        if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') {
+          return false;
+        }
+        const rect = el.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0;
+      }
+`;
 const LOCATOR_RUNTIME_HELPERS = String.raw`
       const LOCATOR_SEPARATOR = ' >>> ';
 
@@ -2234,7 +2250,24 @@ var ChromeCdpBrowserController = class {
           }
           current = parent;
         }
-        return parts.join(' > ');
+        // Prefer the shortest unique tail of the path: long nth-of-type chains
+        // cost tokens and break on the slightest layout change. A longer tail
+        // matches a subset of a shorter one, so uniqueness is monotonic in the
+        // tail length and a binary search finds the shortest unique tail.
+        let best = parts.join(' > ');
+        let lo = 1;
+        let hi = parts.length - 1;
+        while (lo <= hi) {
+          const size = (lo + hi) >> 1;
+          const candidate = tryUniqueSelector(root, parts.slice(-size).join(' > '));
+          if (candidate) {
+            best = candidate;
+            hi = size - 1;
+          } else {
+            lo = size + 1;
+          }
+        }
+        return best;
       }
 
       function buildFallbackSelectors(root, path, el, primarySelector) {
@@ -2328,18 +2361,7 @@ var ChromeCdpBrowserController = class {
         }
       }
 
-      function viewForElement(el) {
-        return el.ownerDocument && el.ownerDocument.defaultView ? el.ownerDocument.defaultView : window;
-      }
-
-      function isVisible(el) {
-        const style = viewForElement(el).getComputedStyle(el);
-        if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') {
-          return false;
-        }
-        const rect = el.getBoundingClientRect();
-        return rect.width > 0 && rect.height > 0;
-      }
+${IN_PAGE_IS_VISIBLE}
 
       function getText(el) {
         const ariaLabel = el.getAttribute('aria-label');
@@ -2392,7 +2414,7 @@ var ChromeCdpBrowserController = class {
         return [root];
       }
 
-      const results = [];
+      const candidates = [];
       const crossOriginFrames = [];
       let totalFound = 0;
 
@@ -2431,8 +2453,38 @@ var ChromeCdpBrowserController = class {
         }
 
         totalFound += 1;
-        if (results.length >= limit) return;
+        candidates.push({ root, path, el, role, visible, rank: rankElement(el, visible) });
+      }
+
+      // Lower rank sorts first: main content, then the rest of the page, then
+      // site chrome (header, nav, footer), then hidden elements. Ties keep
+      // document order.
+      // Region flags per ancestor, memoized so siblings share the walk up the
+      // tree instead of each element running three closest() scans.
+      const FOOTER = 1, MAIN = 2, CHROME = 4;
+      const regionMemo = new Map();
+      function regionFlags(el) {
+        if (!el) return 0;
+        let flags = regionMemo.get(el);
+        if (flags !== undefined) return flags;
+        flags = regionFlags(el.parentElement);
+        if (el.matches('footer, [role="contentinfo"]')) flags |= FOOTER;
+        if (el.matches('main, [role="main"], article')) flags |= MAIN;
+        if (el.matches('header, nav, [role="banner"], [role="navigation"]')) flags |= CHROME;
+        regionMemo.set(el, flags);
+        return flags;
+      }
+      function rankElement(el, visible) {
+        if (!visible) return 3;
+        const flags = regionFlags(el);
+        if (flags & FOOTER) return 2;
+        if (flags & MAIN) return 0;
+        if (flags & CHROME) return 2;
+        return 1;
+      }
 
+      function buildEntry(candidate) {
+        const { root, path, el, role, visible } = candidate;
         const selector = composeLocator(path, buildSelector(root, el));
         const entry = {
           selector,
@@ -2457,13 +2509,15 @@ var ChromeCdpBrowserController = class {
           entry.currentValue = el.value.slice(0, 200);
         }
 
-        results.push(entry);
+        return entry;
       }
 
+      // Depth-first in document order, so a capped listing follows reading
+      // order instead of favouring shallow page chrome.
       function walkRoot(root, path) {
-        const queue = rootEntries(root).slice();
-        while (queue.length) {
-          const current = queue.shift();
+        const stack = rootEntries(root).slice().reverse();
+        while (stack.length) {
+          const current = stack.pop();
           if (!current || current.nodeType !== 1) continue;
 
           maybeRecordElement(root, path, current);
@@ -2491,13 +2545,17 @@ var ChromeCdpBrowserController = class {
             }
           }
 
-          for (const child of Array.from(current.children)) {
-            queue.push(child);
+          const children = current.children;
+          for (let i = children.length - 1; i >= 0; i -= 1) {
+            stack.push(children[i]);
           }
         }
       }
 
       walkRoot(document, []);
+      // Array sort is stable, so ties keep document order.
+      candidates.sort((a, b) => a.rank - b.rank);
+      const results = candidates.slice(0, limit).map(buildEntry);
       const output = { elements: results, totalFound, truncated: totalFound > results.length };
       if (crossOriginFrames.length) output.crossOriginFrames = crossOriginFrames;
       return output;
@@ -2577,16 +2635,12 @@ var ChromeCdpBrowserController = class {
 		}
 		return {
 			dismissed: false,
-			detail: notes.size ? [...notes].join("; ") : "no consent banner or accept button found (page, consent iframes, a11y tree)"
+			detail: notes.size ? [...notes].join("; ") : "no consent banner found on the page, in consent iframes or the a11y tree (it may already be dismissed)"
 		};
 	}
 	async dismissViaDom(targetWsUrl) {
 		const expression = `(() => {
-      function isVisible(el) {
-        if (!el) return false;
-        const style = getComputedStyle(el);
-        return style.display !== 'none' && style.visibility !== 'hidden' && style.opacity !== '0' && el.offsetWidth > 0;
-      }
+${IN_PAGE_IS_VISIBLE}
 
       // Comprehensive CMP selectors (ordered by specificity/popularity)
       const selectors = [
@@ -2889,10 +2943,49 @@ var ChromeCdpBrowserController = class {
         'iframe[src*="consentmanager"]',
       ];
 
+      // Consent prompts overlay the page: the frame or a close ancestor is
+      // fixed/sticky or stacked high. In-flow frames (ads, embeds) are skipped.
+      function isOverlay(iframe) {
+        let el = iframe;
+        for (let depth = 0; el && el !== document.body && depth < 10; depth++) {
+          const style = getComputedStyle(el);
+          if (style.position === 'fixed' || style.position === 'sticky') return true;
+          if ((parseInt(style.zIndex, 10) || 0) >= 1000) return true;
+          el = el.parentElement;
+        }
+        return false;
+      }
+      function isShown(iframe) {
+        const rect = iframe.getBoundingClientRect();
+        if (rect.width < 2 || rect.height < 2) return false;
+        const style = getComputedStyle(iframe);
+        return style.display !== 'none' && style.visibility !== 'hidden';
+      }
+      // A src keyword must sit in host or path: ad and tracking frames often
+      // carry "cookie=" or "privacy=" in their query string.
+      function srcKeywordMatches(iframe, sel) {
+        const prefix = 'iframe[src*="';
+        if (!sel.startsWith(prefix)) return true;
+        const keyword = sel.slice(prefix.length, sel.indexOf('"', prefix.length));
+        try {
+          const url = new URL(iframe.src, location.href);
+          return (url.hostname + url.pathname).toLowerCase().includes(keyword);
+        } catch {
+          return false;
+        }
+      }
+      function findFrame(sel) {
+        for (const iframe of document.querySelectorAll(sel)) {
+          if (!isShown(iframe) || !srcKeywordMatches(iframe, sel) || !isOverlay(iframe)) continue;
+          return iframe;
+        }
+        return null;
+      }
+
       // Cross-origin consent frames are handed back so the caller can attach to them.
       const crossOrigin = [];
       for (const sel of iframeSelectors) {
-        const iframe = document.querySelector(sel);
+        const iframe = findFrame(sel);
         if (!iframe) continue;
         let doc = null;
         try {
@@ -3354,6 +3447,40 @@ z.object({
 	createdAt: z.string().datetime(),
 	severity: EventSeveritySchema
 });
+// src/session/element-refs.ts
+/** Matches "e3" or "@e3"; group 1 is the bare ref. */
+const REF_PATTERN = /^@?(e\d+)$/;
+/**
+* Number elements e1, e2, … Elements without a selector (nothing to act on)
+* are still returned but get no ref.
+*/
+function assignRefs(elements, frame) {
+	const byRef = {};
+	let n = 0;
+	return {
+		elements: elements.map((el) => {
+			if (!el.selector) return el;
+			const ref = `e${++n}`;
+			byRef[ref] = {
+				selector: el.selector,
+				fallbackSelectors: el.fallbackSelectors,
+				frame
+			};
+			return {
+				...el,
+				ref
+			};
+		}),
+		byRef
+	};
+}
+/** A ref that was never assigned, or was taken on a different page. */
+var StaleRefError = class extends Error {
+	constructor(ref) {
+		super(`Unknown or stale ref "${ref}". List the page's elements again (agent elements / browser_get_elements) to get fresh refs.`);
+		this.name = "StaleRefError";
+	}
+};
 // src/session/session-store.ts
 var SessionStore = class {
 	filePath;
@@ -3398,12 +3525,16 @@ var SessionStore = class {
 		}
 	}
 	setLastUrl(sessionId, lastUrl) {
+		this.update(sessionId, { lastUrl });
+	}
+	/** Merge fields into a stored record; `undefined` values clear the field. */
+	update(sessionId, patch) {
 		const state = this.read();
 		const existing = state.sessions[sessionId];
 		if (!existing) throw new Error("Session not found in store");
 		state.sessions[sessionId] = {
 			...existing,
-			lastUrl
+			...patch
 		};
 		this.write(state);
 	}
@@ -3566,8 +3697,13 @@ var SessionManager = class {
 		}
 		throw new Error("Session is terminated. Start a new session.");
 	}
-	async executeCommand(sessionId, input) {
+	async executeCommand(sessionId, rawInput) {
 		const record = await this.ensureSession(sessionId);
+		const input = rawInput.type === "interact" ? {
+			...rawInput,
+			payload: await this.resolveRef(record, rawInput.payload)
+		} : rawInput;
+		const runId = this.trackIntentRun(sessionId, record, input);
 		const command = {
 			commandId: input.commandId,
 			sessionId,
@@ -3596,6 +3732,8 @@ var SessionManager = class {
 				const parsedPayload = InteractPayloadSchema.safeParse(input.payload);
 				if (!parsedPayload.success) throw new Error(`Invalid interact payload: ${parsedPayload.error.message}`);
 				resultMessage = `Interaction result: ${await this.browser.interact(record.targetWsUrl, parsedPayload.data)}`;
+				const currentUrl = await this.browser.getCurrentUrl(record.targetWsUrl).catch(() => void 0);
+				if (currentUrl) this.store.setLastUrl(sessionId, currentUrl);
 			} else if (input.type === "restart") {
 				await this.restartSession(sessionId);
 				resultMessage = "Session restarted";
@@ -3622,7 +3760,8 @@ var SessionManager = class {
 			expectedOutcome: resultMessage,
 			step: memoryContext.step,
 			selector: memoryContext.selector,
-			url: memoryContext.url
+			url: memoryContext.url,
+			runId
 		});
 		else this.ctx.memoryService.recordFailure({
 			commandId: input.commandId,
@@ -3652,9 +3791,20 @@ var SessionManager = class {
 		}
 		return result;
 	}
+	/** Lists interactive elements and assigns fresh refs (e1, e2, …) for this page. */
 	async getInteractiveElements(sessionId, options) {
 		const record = await this.ensureSession(sessionId);
-		return await this.browser.getInteractiveElements(record.targetWsUrl, options);
+		const result = await this.browser.getInteractiveElements(record.targetWsUrl, options);
+		const { elements, byRef } = assignRefs(result.elements, options.frame);
+		const url = await this.browser.getCurrentUrl(record.targetWsUrl).catch(() => void 0);
+		this.store.update(sessionId, { refs: {
+			url,
+			byRef
+		} });
+		return {
+			...result,
+			elements
+		};
 	}
 	async screenshot(sessionId, options) {
 		const record = await this.ensureSession(sessionId);
@@ -3789,7 +3939,8 @@ var SessionManager = class {
 			session: restarted,
 			cdpUrl: relaunched.cdpUrl,
 			targetWsUrl: relaunched.targetWsUrl,
-			pid: relaunched.pid
+			pid: relaunched.pid,
+			intentRun: record.intentRun
 		});
 		this.recordEvent(sessionId, "lifecycle", "info", "Session restarted");
 		return restarted;
@@ -3933,7 +4084,7 @@ var SessionManager = class {
 		const parsed = this.parseUrl(inputUrl);
 		const action = typeof input.payload.action === "string" ? input.payload.action : void 0;
 		const defaultIntent = input.type === "navigate" ? `navigate:${parsed.domain}` : input.type === "interact" ? `interact:${action ?? "action"}:${parsed.domain}` : `${input.type}:${parsed.domain}`;
-		const taskIntent = typeof input.payload.intent === "string" && input.payload.intent.trim() ? input.payload.intent : defaultIntent;
+		const taskIntent = explicitIntent(input) ?? defaultIntent;
 		const expectedOutcome = typeof input.payload.expectedOutcome === "string" && input.payload.expectedOutcome.trim() ? input.payload.expectedOutcome : `${input.type} command succeeds`;
 		return {
 			taskIntent,
@@ -3950,6 +4101,36 @@ var SessionManager = class {
 			url: inputUrl
 		};
 	}
+	async resolveRef(record, payload) {
+		const selector = typeof payload.selector === "string" ? payload.selector : void 0;
+		const ref = selector ? REF_PATTERN.exec(selector)?.[1] : void 0;
+		if (!selector || !ref) return payload;
+		const { refs } = record;
+		const stored = refs?.byRef[ref];
+		const onSamePage = !refs?.url || await this.browser.getCurrentUrl(record.targetWsUrl).catch(() => void 0) === refs.url;
+		if (!stored || !onSamePage) throw new StaleRefError(selector);
+		const extra = Array.isArray(payload.fallbackSelectors) ? payload.fallbackSelectors : [];
+		return {
+			...payload,
+			selector: stored.selector,
+			fallbackSelectors: [...stored.fallbackSelectors ?? [], ...extra],
+			frame: payload.frame ?? stored.frame
+		};
+	}
+	/**
+	* Consecutive commands with the same explicit intent form one run; any other
+	* command ends it. Commands without an intent are each their own run.
+	*/
+	trackIntentRun(sessionId, record, input) {
+		const intent = explicitIntent(input);
+		if (intent && record.intentRun?.intent === intent) return record.intentRun.runId;
+		const intentRun = intent ? {
+			intent,
+			runId: input.commandId
+		} : void 0;
+		if (intentRun || record.intentRun) this.store.update(sessionId, { intentRun });
+		return input.commandId;
+	}
 	parseUrl(rawUrl) {
 		if (!rawUrl) return {
 			domain: "unknown",
@@ -3960,7 +4141,7 @@ var SessionManager = class {
 			const firstSegment = parsed.pathname.split("/").filter(Boolean)[0];
 			const pathPattern = firstSegment ? `/${firstSegment}/*` : "/";
 			return {
-				domain: parsed.hostname.toLowerCase(),
+				domain: parsed.hostname.toLowerCase() || parsed.protocol.replace(/:$/, ""),
 				pathPattern
 			};
 		} catch {
@@ -3971,6 +4152,11 @@ var SessionManager = class {
 		}
 	}
 };
+/** The caller's task intent, if any. payload.intent is the older spelling, still honored. */
+function explicitIntent(input) {
+	const raw = input.intent ?? input.payload.intent;
+	return typeof raw === "string" && raw.trim() ? raw.trim() : void 0;
+}
 // src/transport/control-api.ts
 var ControlApi = class {
 	sessions;
@@ -4210,6 +4396,61 @@ var SessionTokenService = class {
 function normalize(value) {
 	return value.trim().toLowerCase();
 }
+const STOPWORDS = /* @__PURE__ */ new Set([
+	"a",
+	"an",
+	"the",
+	"to",
+	"on",
+	"in",
+	"of",
+	"and",
+	"or",
+	"for",
+	"with",
+	"at",
+	"my",
+	"from",
+	"by",
+	"into"
+]);
+/**
+* Words of an intent, minus the site domain and filler words, with a trailing
+* plural "s" dropped — so "open the newest stories" and "newest story" share
+* tokens.
+*/
+function intentTokens(value, domain) {
+	let text = normalize(value);
+	if (domain) text = text.split(normalize(domain)).join(" ");
+	const tokens = /* @__PURE__ */ new Set();
+	for (const raw of text.split(/[^\p{L}\p{N}]+/u)) {
+		if (raw.length < 2 || STOPWORDS.has(raw)) continue;
+		tokens.add(raw.length > 3 && raw.endsWith("s") ? raw.slice(0, -1) : raw);
+	}
+	return tokens;
+}
+/** 0 = unrelated; 1 = identical intent. Word overlap covers rephrased queries. */
+function intentSimilarity(insight, normalizedIntent, query) {
+	const insightIntent = normalize(insight.taskIntent);
+	if (insightIntent === normalizedIntent) return 1;
+	if (insightIntent.includes(normalizedIntent) || normalizedIntent.includes(insightIntent)) return .65;
+	if (!query.size) return 0;
+	const stored = intentTokens(insightIntent, insight.siteDomain);
+	let shared = 0;
+	for (const token of query) if (stored.has(token)) shared += 1;
+	if (!shared) return 0;
+	return .3 + .5 * (shared / query.size);
+}
+function buildRecipe(insight) {
+	return insight.actionRecipe.map((step) => {
+		const payload = step.payload ?? {};
+		const summary = { action: typeof payload.action === "string" ? payload.action : step.type };
+		if (step.selector) summary.selector = step.selector;
+		if (typeof payload.url === "string") summary.url = payload.url;
+		if (payload.redacted === true) summary.needsInput = true;
+		return summary;
+	});
+}
 function freshnessWeight(freshness) {
 	if (freshness === "fresh") return 1;
 	if (freshness === "suspect") return .65;
@@ -4242,15 +4483,19 @@ function selectorSignal(insight) {
 	const evidenceStrength = Math.min(selectorEvidence / 5, 1);
 	return .7 * recipeCoverage + .3 * evidenceStrength;
 }
-function scoreInsight(insight, normalizedIntent, normalizedDomain, profileLookup) {
-	const insightIntent = normalize(insight.taskIntent);
-	const intentMatch = insightIntent === normalizedIntent ? 1 : 0;
-	const intentPartial = intentMatch === 1 || insightIntent.includes(normalizedIntent) || normalizedIntent.includes(insightIntent) ? .65 : 0;
-	const intentSignal = Math.max(intentMatch, intentPartial);
+function scoreInsight(insight, normalizedIntent, queryTokens, normalizedDomain) {
+	const intentSignal = intentSimilarity(insight, normalizedIntent, queryTokens);
 	const domainMatch = normalizedDomain && normalize(insight.siteDomain) === normalizedDomain ? 1 : normalizedDomain ? 0 : .6;
 	const reliability = .6 * confidenceFromCounts(insight.successCount, insight.failureCount) + .4 * freshnessWeight(insight.freshness);
 	const selectorQuality = selectorSignal(insight);
-	const score = .5 * intentSignal + .2 * domainMatch + .15 * reliability + .15 * selectorQuality;
+	return {
+		insight,
+		score: .5 * intentSignal + .2 * domainMatch + .15 * reliability + .15 * selectorQuality,
+		intentSignal
+	};
+}
+/** Builds the full result (recipe, hints, profile) — only for insights that are returned. */
+function toSearchResult({ insight, score }, profileLookup) {
 	const result = {
 		insightId: insight.insightId,
 		taskIntent: insight.taskIntent,
@@ -4258,6 +4503,7 @@ function scoreInsight(insight, normalizedIntent, normalizedDomain, profileLookup
 		confidence: insight.confidence,
 		freshness: insight.freshness,
 		lastVerifiedAt: insight.lastVerifiedAt,
+		recipe: buildRecipe(insight),
 		selectorHints: buildSelectorHints(insight),
 		selectorAliases: buildSelectorAliases(insight),
 		score
@@ -4269,10 +4515,7 @@ function scoreInsight(insight, normalizedIntent, normalizedDomain, profileLookup
 		cookieBanner: profile.cookieBanner,
 		visitCount: profile.visitCount
 	};
-	return {
-		result,
-		intentSignal
-	};
+	return result;
 }
 var MemoryIndex = class {
 	/** Domain → insights index, rebuilt lazily when insight list changes. */
@@ -4295,6 +4538,7 @@ var MemoryIndex = class {
 	}
 	search(insights, input, profileLookup) {
 		const normalizedIntent = normalize(input.taskIntent);
+		const queryTokens = intentTokens(normalizedIntent);
 		const normalizedDomain = input.siteDomain ? normalize(input.siteDomain) : void 0;
 		const limit = input.limit ?? 10;
 		this.ensureIndex(insights);
@@ -4303,16 +4547,16 @@ var MemoryIndex = class {
 		if (limit === 1 && normalizedDomain) {
 			let best;
 			for (const insight of candidates) {
-				const scored = scoreInsight(insight, normalizedIntent, normalizedDomain, profileLookup);
+				const scored = scoreInsight(insight, normalizedIntent, queryTokens, normalizedDomain);
 				if (!relevant(scored)) continue;
-				if (!best || scored.result.score > best.result.score) {
+				if (!best || scored.score > best.score) {
 					best = scored;
-					if (best.result.score >= 1) break;
+					if (best.score >= 1) break;
 				}
 			}
-			return best ? [best.result] : [];
+			return best ? [toSearchResult(best, profileLookup)] : [];
 		}
-		return candidates.map((insight) => scoreInsight(insight, normalizedIntent, normalizedDomain, profileLookup)).filter(relevant).toSorted((a, b) => b.result.score - a.result.score).slice(0, limit).map((scored) => scored.result);
+		return candidates.map((insight) => scoreInsight(insight, normalizedIntent, queryTokens, normalizedDomain)).filter(relevant).toSorted((a, b) => b.score - a.score).slice(0, limit).map((scored) => toSearchResult(scored, profileLookup));
 	}
 };
 // src/memory/staleness-detector.ts
@@ -4456,6 +4700,8 @@ const TaskInsightSchema = z.object({
 	siteDomain: z.string().min(1),
 	sitePathPattern: z.string().min(1),
 	actionRecipe: z.array(TaskStepSchema),
+	/** Run that produced actionRecipe; steps from another run start it over. */
+	recipeRunId: z.string().optional(),
 	expectedOutcome: z.string().min(1),
 	confidence: z.number().min(0).max(1),
 	successCount: z.number().int().nonnegative(),
@@ -4870,6 +5116,7 @@ var MemoryService = class {
 				siteDomain: input.siteDomain,
 				sitePathPattern: input.sitePathPattern,
 				actionRecipe: [input.step],
+				recipeRunId: input.runId ?? input.commandId,
 				expectedOutcome: input.expectedOutcome,
 				confidence: 1,
 				successCount: 1,
@@ -4892,7 +5139,7 @@ var MemoryService = class {
 			...matched,
 			useCount: matched.useCount + 1,
 			evidence: [...matched.evidence.slice(-49), evidence],
-			actionRecipe: this.mergeRecipe(matched.actionRecipe, input.step),
+			...this.mergeRecipe(matched, input.step, input.runId ?? input.commandId),
 			expectedOutcome: input.expectedOutcome
 		});
 		if (matched.freshness === "suspect" || matched.freshness === "stale") {
@@ -5101,9 +5348,16 @@ var MemoryService = class {
 		const testMatch = selector.match(/\[data-test="([^"]+)"\]/);
 		if (testMatch) return testMatch[1];
 	}
-	mergeRecipe(recipe, step) {
-		if (recipe.find((existing) => existing.summary === step.summary && existing.selector === step.selector)) return recipe;
-		return [...recipe, step].slice(-8);
+	/** Same run: append the step. New run: its first step replaces the old recipe. */
+	mergeRecipe(insight, step, runId) {
+		if (insight.recipeRunId !== runId) return {
+			actionRecipe: [step],
+			recipeRunId: runId
+		};
+		return {
+			actionRecipe: [...insight.actionRecipe, step].slice(-8),
+			recipeRunId: runId
+		};
 	}
 };
 // src/cli/app.ts
@@ -5153,7 +5407,8 @@ var AgenticBrowserCore = class {
 		return await this.api.executeCommand(input.sessionId, {
 			commandId,
 			type: input.type,
-			payload: input.payload
+			payload: input.payload,
+			intent: input.intent
 		});
 	}
 	async getPageContent(input) {
@@ -5230,4 +5485,4 @@ function createMockAgenticBrowserCore(env) {
 function createCliRuntime() {
 	return createAgenticBrowserCore();
 }
-export { isConnectionError as a, createMockAgenticBrowserCore as i, createAgenticBrowserCore as n, ensurePrivateDir as o, createCliRuntime as r, writePrivateFileSync as s, AgenticBrowserCore as t };
+export { StaleRefError as a, writePrivateFileSync as c, createMockAgenticBrowserCore as i, createAgenticBrowserCore as n, isConnectionError as o, createCliRuntime as r, ensurePrivateDir as s, AgenticBrowserCore as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-browser",
-  "version": "2.7.1",
+  "version": "2.8.1",
   "description": "CLI and MCP server for AI agents to control Chrome via CDP",
   "keywords": [
     "agent",