agentic-browser 2.2.0 → 2.4.0

package/dist/{runtime-CRkUsvhV.mjs → runtime-PnWvjdzU.mjs}

@@ -224,19 +224,78 @@ async function createTarget(cdpUrl, url = "about:blank") {
 	} catch {}
 	return await ensurePageWebSocketUrl(cdpUrl);
 }
-/** Verify the page is ready and optionally set a custom user-agent, using a single connection. */
+/**
+* Apply stealth patches that remove common automation fingerprints.
+* These run before any page loads so sites cannot detect the bot.
+*/
+const STEALTH_SCRIPT = `
+  // Remove navigator.webdriver flag
+  Object.defineProperty(navigator, 'webdriver', { get: () => undefined });
+
+  // Provide realistic plugins array (empty = headless fingerprint)
+  Object.defineProperty(navigator, 'plugins', {
+    get: () => {
+      const plugins = [
+        { name: 'Chrome PDF Plugin', filename: 'internal-pdf-viewer', description: 'Portable Document Format' },
+        { name: 'Chrome PDF Viewer', filename: 'mhjfbmdgcfjbbpaeojofohoefgiehjai', description: '' },
+        { name: 'Native Client', filename: 'internal-nacl-plugin', description: '' },
+      ];
+      plugins.length = 3;
+      Object.setPrototypeOf(plugins, PluginArray.prototype);
+      return plugins;
+    }
+  });
+
+  // Provide realistic languages
+  Object.defineProperty(navigator, 'languages', { get: () => ['en-US', 'en'] });
+
+  // Patch chrome.runtime to look like a real Chrome
+  if (!window.chrome) window.chrome = {};
+  if (!window.chrome.runtime) window.chrome.runtime = { id: undefined };
+
+  // Remove the CDP-injected sourceURL comment from Runtime.evaluate calls
+  const origToString = Function.prototype.toString;
+  Function.prototype.toString = function() {
+    if (this === Function.prototype.toString) return 'function toString() { [native code] }';
+    return origToString.call(this);
+  };
+
+  // Patch permissions query to report "prompt" instead of "denied" for notifications
+  const origQuery = window.Permissions?.prototype?.query;
+  if (origQuery) {
+    window.Permissions.prototype.query = function(params) {
+      if (params?.name === 'notifications') {
+        return Promise.resolve({ state: 'prompt', onchange: null });
+      }
+      return origQuery.call(this, params);
+    };
+  }
+`;
+/** Verify the page is ready, apply stealth, and optionally set a custom user-agent. */
 async function initTarget(targetWsUrl, userAgent) {
 	const conn = await CdpConnection.connect(targetWsUrl);
 	try {
 		const enables = [conn.send("Page.enable"), conn.send("Runtime.enable")];
-		if (userAgent) enables.push(conn.send("Network.enable"));
+		enables.push(conn.send("Network.enable"));
 		await Promise.all(enables);
+		await conn.send("Page.addScriptToEvaluateOnNewDocument", { source: STEALTH_SCRIPT });
+		await conn.send("Runtime.evaluate", {
+			expression: STEALTH_SCRIPT,
+			returnByValue: true
+		});
 		await conn.send("Runtime.evaluate", {
 			expression: "window.location.href",
 			returnByValue: true,
 			awaitPromise: true
 		});
 		if (userAgent) await conn.send("Network.setUserAgentOverride", { userAgent });
+		else try {
+			const { userAgent: currentUA } = await conn.send("Browser.getVersion");
+			if (currentUA?.includes("HeadlessChrome")) {
+				const cleanUA = currentUA.replace(/HeadlessChrome/g, "Chrome");
+				await conn.send("Network.setUserAgentOverride", { userAgent: cleanUA });
+			}
+		} catch {}
 	} finally {
 		conn.close();
 	}
@@ -732,7 +791,10 @@ var ChromeCdpBrowserController = class {
 				`--remote-debugging-port=${port}`,
 				`--user-data-dir=${profileDir}`,
 				"--no-first-run",
-				"--no-default-browser-check"
+				"--no-default-browser-check",
+				"--disable-blink-features=AutomationControlled",
+				"--disable-infobars",
+				"--excludeSwitches=enable-automation"
 			];
 			if (attempt.headless) args.push("--headless=new");
 			args.push("about:blank");
@@ -1076,6 +1138,38 @@ var ChromeCdpBrowserController = class {
 			})).result.value ?? "";
 		});
 	}
+	async screenshot(targetWsUrl, options) {
+		return await this.withRetry(targetWsUrl, async (conn) => {
+			await this.ensureEnabled(targetWsUrl);
+			const format = options?.format ?? "jpeg";
+			const params = {
+				format,
+				quality: format === "jpeg" ? options?.quality ?? 60 : void 0
+			};
+			if (options?.fullPage) {
+				const metrics = await conn.send("Page.getLayoutMetrics");
+				params.clip = {
+					x: 0,
+					y: 0,
+					width: metrics.contentSize.width,
+					height: metrics.contentSize.height,
+					scale: 1
+				};
+			}
+			return {
+				data: (await conn.send("Page.captureScreenshot", params)).data,
+				mimeType: format === "png" ? "image/png" : "image/jpeg"
+			};
+		});
+	}
+	async getCurrentUrl(targetWsUrl) {
+		return await this.withRetry(targetWsUrl, async (conn) => {
+			return (await conn.send("Runtime.evaluate", {
+				expression: "window.location.href",
+				returnByValue: true
+			})).result.value ?? "";
+		});
+	}
 	async getContent(targetWsUrl, options) {
 		if (options.mode === "summary") return await this.getSummaryContent(targetWsUrl, options);
 		if (options.mode === "a11y") {
@@ -1149,7 +1243,8 @@ var ChromeCdpBrowserController = class {
 				fallbackSelectors: element.fallbackSelectors,
 				inputType: element.inputType,
 				placeholder: element.placeholder,
-				ariaLabel: element.ariaLabel
+				ariaLabel: element.ariaLabel,
+				currentValue: element.currentValue
 			});
 			if (primaryActions.length >= 8 && inputs.length >= 8) break;
 		}
@@ -1261,11 +1356,84 @@ var ChromeCdpBrowserController = class {
         };
       });
 
+      // Extract a readable content excerpt so the LLM understands what the page is about
+      function extractContentExcerpt(root, maxChars) {
+        const skipTags = new Set(['SCRIPT','STYLE','NOSCRIPT','SVG','PATH','META','LINK','BR','HR','IMG']);
+        const blocks = [];
+        let totalChars = 0;
+        const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT, {
+          acceptNode: function(node) {
+            const parent = node.parentElement;
+            if (!parent) return NodeFilter.FILTER_REJECT;
+            if (skipTags.has(parent.tagName)) return NodeFilter.FILTER_REJECT;
+            const view = (parent.ownerDocument && parent.ownerDocument.defaultView) ? parent.ownerDocument.defaultView : window;
+            const style = view.getComputedStyle(parent);
+            if (style.display === 'none' || style.visibility === 'hidden') return NodeFilter.FILTER_REJECT;
+            return NodeFilter.FILTER_ACCEPT;
+          }
+        });
+        let node;
+        while ((node = walker.nextNode())) {
+          const text = node.textContent.replace(/\\s+/g, ' ').trim();
+          if (!text || text.length < 2) continue;
+          if (totalChars + text.length > maxChars) {
+            const remaining = maxChars - totalChars;
+            if (remaining > 20) blocks.push(text.slice(0, remaining));
+            break;
+          }
+          blocks.push(text);
+          totalChars += text.length;
+        }
+        return blocks.join(' ').replace(/\\s+/g, ' ').trim();
+      }
+
+      // Group inputs by their parent form for contextual understanding
+      function discoverForms(root) {
+        const forms = [];
+        for (const form of Array.from(root.querySelectorAll('form')).slice(0, 6)) {
+          const formInputs = Array.from(form.querySelectorAll('input:not([type="hidden"]), select, textarea'));
+          if (!formInputs.length) continue;
+          const submitBtn = form.querySelector('button[type="submit"], input[type="submit"], button:not([type])');
+          forms.push({
+            action: form.getAttribute('action') || undefined,
+            method: (form.getAttribute('method') || 'get').toUpperCase(),
+            fields: formInputs.slice(0, 10).map(function(el) {
+              const tag = el.tagName.toLowerCase();
+              return {
+                name: el.getAttribute('name') || undefined,
+                type: tag === 'select' ? 'select' : tag === 'textarea' ? 'textarea' : (el.type || 'text'),
+                label: (function() {
+                  const id = el.id;
+                  if (id) {
+                    const label = root.querySelector('label[for="' + CSS.escape(id) + '"]');
+                    if (label) return textOf(label).slice(0, 60);
+                  }
+                  const closest = el.closest('label');
+                  if (closest) return textOf(closest).slice(0, 60);
+                  const ariaLabel = el.getAttribute('aria-label');
+                  if (ariaLabel) return ariaLabel.slice(0, 60);
+                  return el.getAttribute('placeholder') || undefined;
+                })(),
+                required: el.required || el.getAttribute('aria-required') === 'true' || false,
+                currentValue: ('value' in el && typeof el.value === 'string' && el.value) ? el.value.slice(0, 100) : undefined,
+              };
+            }),
+            submitText: submitBtn ? textOf(submitBtn).slice(0, 40) : undefined,
+          });
+        }
+        return forms;
+      }
+
+      const contentExcerpt = extractContentExcerpt(scopeRoot, 1500);
+      const forms = discoverForms(scopeRoot);
+
       return {
         url: window.location.href,
         title: document.title ?? '',
+        contentExcerpt,
         headings,
         landmarks,
+        forms: forms.length ? forms : undefined,
         alerts,
         frames,
         crossOriginFrameCount: allFrames.filter((frame) => {
@@ -1697,6 +1865,9 @@ var ChromeCdpBrowserController = class {
         if (ariaLabel) entry.ariaLabel = ariaLabel;
         const placeholder = el.getAttribute('placeholder');
         if (placeholder) entry.placeholder = placeholder;
+        if ('value' in el && typeof el.value === 'string' && el.value) {
+          entry.currentValue = el.value.slice(0, 200);
+        }
 
         results.push(entry);
       }
@@ -1978,6 +2149,15 @@ var MockBrowserController = class {
 		if (payload.action === "dialog") return payload.text === "dismiss" ? "dismissed confirm: mock dialog" : "accepted confirm: mock dialog";
 		return `interacted:${payload.action}`;
 	}
+	async screenshot(_targetWsUrl, options) {
+		return {
+			data: "bW9jaw==",
+			mimeType: (options?.format ?? "jpeg") === "png" ? "image/png" : "image/jpeg"
+		};
+	}
+	async getCurrentUrl(cdpUrl) {
+		return this.pages.get(cdpUrl)?.url ?? "about:blank";
+	}
 	async getContent(cdpUrl, options) {
 		const page = this.pages.get(cdpUrl);
 		if (!page) throw new Error("mock page missing");
@@ -2114,7 +2294,7 @@ var SessionManager = class {
 	constructor(ctx, browser) {
 		this.ctx = ctx;
 		this.browser = browser;
-		this.store = new SessionStore(this.ctx.config.logDir);
+		this.store = new SessionStore(this.ctx.config.dataDir);
 	}
 	async createSession(input) {
 		if (input.browser !== "chrome") throw new Error("Only chrome is supported");
@@ -2235,15 +2415,38 @@ var SessionManager = class {
 	}
 	async getContent(sessionId, options) {
 		const record = await this.ensureSession(sessionId);
-		return await this.browser.getContent(record.targetWsUrl, options);
+		const result = await this.browser.getContent(record.targetWsUrl, options);
+		if (options.mode === "summary" && result.structuredContent) {
+			const sc = result.structuredContent;
+			const url = typeof sc.url === "string" ? sc.url : record.lastUrl;
+			const parsed = this.parseUrl(url);
+			const headingTexts = (sc.headings ?? []).map((h) => typeof h === "string" ? h : h.text ?? "");
+			const landmarkTexts = (sc.landmarks ?? []).map((l) => typeof l === "string" ? l : l.role ?? "");
+			this.ctx.memoryService.updateProfileFromContent(parsed.domain, parsed.pathPattern, {
+				headings: headingTexts,
+				landmarks: landmarkTexts
+			});
+		}
+		return result;
 	}
 	async getInteractiveElements(sessionId, options) {
 		const record = await this.ensureSession(sessionId);
 		return await this.browser.getInteractiveElements(record.targetWsUrl, options);
 	}
+	async screenshot(sessionId, options) {
+		const record = await this.ensureSession(sessionId);
+		return await this.browser.screenshot(record.targetWsUrl, options);
+	}
+	async getCurrentUrl(sessionId) {
+		const record = await this.ensureSession(sessionId);
+		return await this.browser.getCurrentUrl(record.targetWsUrl);
+	}
 	async dismissCookieBanner(sessionId) {
 		const record = await this.ensureSession(sessionId);
-		return await this.browser.dismissCookieBanner(record.targetWsUrl);
+		const result = await this.browser.dismissCookieBanner(record.targetWsUrl);
+		const parsed = this.parseUrl(record.lastUrl);
+		this.ctx.memoryService.updateProfileCookieBanner(parsed.domain, result);
+		return result;
 	}
 	setStatus(status, reason) {
 		const active = this.store.getActive();
@@ -2361,7 +2564,7 @@ var SessionManager = class {
 			removedSessionIds.push(record.session.sessionId);
 		}
 		const keepIds = new Set(keep.map((record) => record.session.sessionId));
-		const profilesDir = path.join(this.ctx.config.logDir, "profiles");
+		const profilesDir = path.join(this.ctx.config.dataDir, "profiles");
 		const removedProfileDirs = [];
 		if (fs.existsSync(profilesDir)) for (const entry of fs.readdirSync(profilesDir)) {
 			const fullPath = path.join(profilesDir, entry);
@@ -2513,6 +2716,12 @@ var ControlApi = class {
 	async dismissCookieBanner(sessionId) {
 		return await this.sessions.dismissCookieBanner(sessionId);
 	}
+	async screenshot(sessionId, options) {
+		return await this.sessions.screenshot(sessionId, options);
+	}
+	async getCurrentUrl(sessionId) {
+		return await this.sessions.getCurrentUrl(sessionId);
+	}
 	listEvents(sessionId, limit = 100) {
 		return { events: this.eventStore.list(sessionId, limit) };
 	}
@@ -2549,7 +2758,7 @@ function loadConfig(env = process.env) {
 		host: env.AGENTIC_BROWSER_HOST ?? "127.0.0.1",
 		wsPort,
 		commandTimeoutMs,
-		logDir: env.AGENTIC_BROWSER_LOG_DIR ?? path.resolve(process.cwd(), ".agentic-browser"),
+		dataDir: env.AGENTIC_BROWSER_DIR ?? path.join(os.homedir(), ".agentic-browser"),
 		browserExecutablePath: env.AGENTIC_BROWSER_CHROME_EXECUTABLE_PATH ?? env.AGENTIC_BROWSER_CHROME_PATH,
 		cdpUrl: env.AGENTIC_BROWSER_CDP_URL,
 		userProfileDir,
@@ -2751,7 +2960,7 @@ function selectorSignal(insight) {
 	const evidenceStrength = Math.min(selectorEvidence / 5, 1);
 	return .7 * recipeCoverage + .3 * evidenceStrength;
 }
-function scoreInsight(insight, normalizedIntent, normalizedDomain) {
+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;
@@ -2759,7 +2968,7 @@ function scoreInsight(insight, normalizedIntent, normalizedDomain) {
 	const reliability = .6 * confidenceFromCounts(insight.successCount, insight.failureCount) + .4 * freshnessWeight(insight.freshness);
 	const selectorQuality = selectorSignal(insight);
 	const score = .5 * Math.max(intentMatch, intentPartial) + .2 * domainMatch + .15 * reliability + .15 * selectorQuality;
-	return {
+	const result = {
 		insightId: insight.insightId,
 		taskIntent: insight.taskIntent,
 		siteDomain: insight.siteDomain,
@@ -2770,6 +2979,14 @@ function scoreInsight(insight, normalizedIntent, normalizedDomain) {
 		selectorAliases: buildSelectorAliases(insight),
 		score
 	};
+	const profile = profileLookup?.(insight.siteDomain);
+	if (profile) result.siteProfile = {
+		selectorPatterns: profile.selectorPatterns.slice(0, 5),
+		layoutFingerprints: profile.layoutFingerprints.slice(0, 3),
+		cookieBanner: profile.cookieBanner,
+		visitCount: profile.visitCount
+	};
+	return result;
 }
 var MemoryIndex = class {
 	/** Domain → insights index, rebuilt lazily when insight list changes. */
@@ -2790,7 +3007,7 @@ var MemoryIndex = class {
 		}
 		this.indexedRefs = insights.slice();
 	}
-	search(insights, input) {
+	search(insights, input, profileLookup) {
 		const normalizedIntent = normalize(input.taskIntent);
 		const normalizedDomain = input.siteDomain ? normalize(input.siteDomain) : void 0;
 		const limit = input.limit ?? 10;
@@ -2799,7 +3016,7 @@ var MemoryIndex = class {
 		if (limit === 1 && normalizedDomain) {
 			let best;
 			for (const insight of candidates) {
-				const result = scoreInsight(insight, normalizedIntent, normalizedDomain);
+				const result = scoreInsight(insight, normalizedIntent, normalizedDomain, profileLookup);
 				if (result.score > 0 && (!best || result.score > best.score)) {
 					best = result;
 					if (best.score >= .95) break;
@@ -2807,7 +3024,7 @@ var MemoryIndex = class {
 			}
 			return best ? [best] : [];
 		}
-		return candidates.map((insight) => scoreInsight(insight, normalizedIntent, normalizedDomain)).filter((result) => result.score > 0).sort((a, b) => b.score - a.score).slice(0, limit);
+		return candidates.map((insight) => scoreInsight(insight, normalizedIntent, normalizedDomain, profileLookup)).filter((result) => result.score > 0).sort((a, b) => b.score - a.score).slice(0, limit);
 	}
 };
 //#endregion
@@ -2838,6 +3055,20 @@ function applyFailure(insight, signal) {
 		updatedAt: now
 	};
 }
+function applyAgeStaleness(insight) {
+	const ageDays = (Date.now() - Date.parse(insight.lastVerifiedAt)) / (1440 * 60 * 1e3);
+	if (insight.freshness === "fresh" && ageDays > 30) return {
+		...insight,
+		freshness: "suspect",
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	if (insight.freshness === "suspect" && ageDays > 44) return {
+		...insight,
+		freshness: "stale",
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	return insight;
+}
 function applySuccess(insight) {
 	const now = (/* @__PURE__ */ new Date()).toISOString();
 	const successCount = insight.successCount + 1;
@@ -2904,6 +3135,147 @@ const TaskInsightSchema = z.object({
 	selectorAliases: z.array(SelectorAliasSchema).default([])
 });
 const MemoryStateSchema = z.object({ insights: z.array(TaskInsightSchema) });
+const SelectorPatternSchema = z.object({
+	pattern: z.string().min(1),
+	frequency: z.number().int().nonnegative(),
+	lastSeenAt: z.string().datetime()
+});
+const PageLayoutFingerprintSchema = z.object({
+	pathPattern: z.string().min(1),
+	headings: z.array(z.string()).default([]),
+	landmarks: z.array(z.string()).default([]),
+	lastSeenAt: z.string().datetime()
+});
+const SiteProfileSchema = z.object({
+	domain: z.string().min(1),
+	selectorPatterns: z.array(SelectorPatternSchema).default([]),
+	layoutFingerprints: z.array(PageLayoutFingerprintSchema).default([]),
+	navigationPaths: z.array(z.string()).default([]),
+	cookieBanner: z.object({
+		detected: z.boolean(),
+		autoDismissed: z.boolean().optional(),
+		method: z.string().optional()
+	}).optional(),
+	visitCount: z.number().int().nonnegative().default(0),
+	lastVisitAt: z.string().datetime(),
+	createdAt: z.string().datetime()
+});
+const SiteProfileStateSchema = z.object({ profiles: z.array(SiteProfileSchema) });
+//#endregion
+//#region src/memory/site-profile-store.ts
+const EMPTY_STATE$1 = { profiles: [] };
+const FLUSH_DELAY_MS$1 = 500;
+const REGISTERED_EXIT_HANDLERS$1 = Symbol.for("agentic-browser.site-profile-store.exit-handlers");
+const REGISTERED_STORES$1 = Symbol.for("agentic-browser.site-profile-store.instances");
+var SiteProfileStore = class {
+	filePath;
+	cached = null;
+	dirty = false;
+	flushTimer = null;
+	constructor(baseDir) {
+		const memoryDir = path.join(baseDir, "memory");
+		fs.mkdirSync(memoryDir, { recursive: true });
+		this.filePath = path.join(memoryDir, "site-profiles.json");
+		const tmpPath = `${this.filePath}.tmp`;
+		try {
+			if (fs.existsSync(tmpPath)) fs.unlinkSync(tmpPath);
+		} catch {}
+		if (!fs.existsSync(this.filePath)) this.writeDisk(EMPTY_STATE$1);
+		this.registerProcessHandlers();
+	}
+	list() {
+		return this.getCache();
+	}
+	get(domain) {
+		const normalized = domain.toLowerCase();
+		return this.getCache().find((p) => p.domain === normalized);
+	}
+	upsert(profile) {
+		SiteProfileSchema.parse(profile);
+		const profiles = this.getCache();
+		const index = profiles.findIndex((p) => p.domain === profile.domain);
+		if (index >= 0) profiles[index] = profile;
+		else profiles.push(profile);
+		this.markDirty();
+	}
+	flushSync() {
+		if (this.flushTimer) {
+			clearTimeout(this.flushTimer);
+			this.flushTimer = null;
+		}
+		if (this.dirty && this.cached) {
+			this.writeDisk({ profiles: this.cached });
+			this.dirty = false;
+		}
+	}
+	getCache() {
+		if (this.cached) return this.cached;
+		this.cached = this.readDisk().profiles;
+		return this.cached;
+	}
+	markDirty() {
+		this.dirty = true;
+		if (!this.flushTimer) this.flushTimer = setTimeout(() => {
+			this.flushTimer = null;
+			this.flushSync();
+		}, FLUSH_DELAY_MS$1);
+	}
+	readDisk() {
+		let raw;
+		try {
+			raw = JSON.parse(fs.readFileSync(this.filePath, "utf8"));
+		} catch {
+			this.backupAndReset();
+			return EMPTY_STATE$1;
+		}
+		try {
+			return SiteProfileStateSchema.parse(raw);
+		} catch {
+			const obj = raw;
+			if (Array.isArray(obj?.profiles)) {
+				const salvaged = obj.profiles.filter((item) => SiteProfileSchema.safeParse(item).success);
+				if (salvaged.length > 0) {
+					const state = { profiles: salvaged };
+					this.backupAndReset();
+					this.writeDisk(state);
+					return state;
+				}
+			}
+			this.backupAndReset();
+			return EMPTY_STATE$1;
+		}
+	}
+	backupAndReset() {
+		const corruptPath = `${this.filePath}.corrupt-${Date.now()}`;
+		try {
+			fs.copyFileSync(this.filePath, corruptPath);
+		} catch {}
+	}
+	writeDisk(state) {
+		const tempPath = `${this.filePath}.tmp`;
+		fs.writeFileSync(tempPath, JSON.stringify(state, null, 2), "utf8");
+		fs.renameSync(tempPath, this.filePath);
+	}
+	registerProcessHandlers() {
+		const proc = process;
+		const stores = proc[REGISTERED_STORES$1] ??= /* @__PURE__ */ new Set();
+		stores.add(this);
+		if (proc[REGISTERED_EXIT_HANDLERS$1]) return;
+		proc[REGISTERED_EXIT_HANDLERS$1] = true;
+		const flushAll = () => {
+			for (const store of stores) store.flushSync();
+		};
+		process.on("exit", flushAll);
+		process.on("SIGINT", () => {
+			flushAll();
+			process.exit(0);
+		});
+		process.on("SIGTERM", () => {
+			flushAll();
+			process.exit(0);
+		});
+	}
+};
 //#endregion
 //#region src/memory/task-insight-store.ts
 const EMPTY_STATE = { insights: [] };
@@ -3030,25 +3402,42 @@ var TaskInsightStore = class {
 //#endregion
 //#region src/memory/memory-service.ts
 const SEARCH_CACHE_TTL_MS = 2e3;
+const MAX_NAVIGATION_PATHS = 20;
+const MAX_LAYOUT_FINGERPRINTS = 10;
+const MAX_SELECTOR_PATTERNS = 15;
 var MemoryService = class {
 	store;
+	profileStore;
 	index;
 	/** Simple TTL cache for search results keyed by intent+domain+limit. */
 	searchCache = /* @__PURE__ */ new Map();
 	constructor(baseDir) {
 		this.store = new TaskInsightStore(baseDir);
+		this.profileStore = new SiteProfileStore(baseDir);
 		this.index = new MemoryIndex();
 	}
 	/** Force an immediate synchronous flush of pending writes. */
 	flushSync() {
 		this.store.flushSync();
+		this.profileStore.flushSync();
 	}
 	search(input) {
 		const cacheKey = `${input.taskIntent}\0${input.siteDomain ?? ""}\0${input.limit ?? 10}`;
 		const now = Date.now();
 		const cached = this.searchCache.get(cacheKey);
 		if (cached && now - cached.ts < SEARCH_CACHE_TTL_MS) return cached.results;
-		const results = this.index.search(this.store.list(), input);
+		const insights = this.store.list();
+		let mutated = false;
+		for (let i = 0; i < insights.length; i++) {
+			const decayed = applyAgeStaleness(insights[i]);
+			if (decayed.freshness !== insights[i].freshness) {
+				insights[i] = decayed;
+				this.store.upsert(decayed);
+				mutated = true;
+			}
+		}
+		if (mutated) this.searchCache.clear();
+		const results = this.index.search(insights, input, (domain) => this.profileStore.get(domain));
 		this.searchCache.set(cacheKey, {
 			results,
 			ts: now
@@ -3092,6 +3481,7 @@ var MemoryService = class {
 		return verified;
 	}
 	recordSuccess(input) {
+		this.updateSiteProfile(input.siteDomain, input.selector, input.url, input.sitePathPattern);
 		const insights = this.store.list();
 		const matched = this.findBestExactMatch(insights, input);
 		const evidence = this.createEvidence(input, "success");
@@ -3149,6 +3539,7 @@ var MemoryService = class {
 		return withAliases;
 	}
 	recordFailure(input, errorMessage) {
+		this.updateSiteProfile(input.siteDomain, input.selector, input.url, input.sitePathPattern);
 		const insights = this.store.list();
 		const matched = this.findBestExactMatch(insights, input);
 		if (!matched) return;
@@ -3163,6 +3554,91 @@ var MemoryService = class {
 		this.invalidateSearchCache();
 		return failed;
 	}
+	/** Update site profile from page content (call after getContent with mode="summary"). */
+	updateProfileFromContent(domain, pathPattern, structuredContent) {
+		if (!domain || domain === "unknown") return;
+		const normalized = domain.toLowerCase();
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const profile = this.profileStore.get(normalized) ?? this.createEmptyProfile(normalized, now);
+		const fingerprint = {
+			pathPattern,
+			headings: (structuredContent.headings ?? []).slice(0, 8),
+			landmarks: (structuredContent.landmarks ?? []).slice(0, 8),
+			lastSeenAt: now
+		};
+		const fpIndex = profile.layoutFingerprints.findIndex((fp) => fp.pathPattern === pathPattern);
+		if (fpIndex >= 0) profile.layoutFingerprints[fpIndex] = fingerprint;
+		else {
+			profile.layoutFingerprints.push(fingerprint);
+			if (profile.layoutFingerprints.length > MAX_LAYOUT_FINGERPRINTS) profile.layoutFingerprints = profile.layoutFingerprints.sort((a, b) => b.lastSeenAt.localeCompare(a.lastSeenAt)).slice(0, MAX_LAYOUT_FINGERPRINTS);
+		}
+		profile.lastVisitAt = now;
+		this.profileStore.upsert(profile);
+	}
+	/** Update site profile with cookie banner behavior. */
+	updateProfileCookieBanner(domain, result) {
+		if (!domain || domain === "unknown") return;
+		const normalized = domain.toLowerCase();
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const profile = this.profileStore.get(normalized) ?? this.createEmptyProfile(normalized, now);
+		profile.cookieBanner = {
+			detected: true,
+			autoDismissed: result.dismissed,
+			method: result.method
+		};
+		profile.lastVisitAt = now;
+		this.profileStore.upsert(profile);
+	}
+	/** Look up a site profile by domain. */
+	getSiteProfile(domain) {
+		return this.profileStore.get(domain);
+	}
+	updateSiteProfile(domain, selector, url, pathPattern) {
+		if (!domain || domain === "unknown") return;
+		const normalized = domain.toLowerCase();
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const profile = this.profileStore.get(normalized) ?? this.createEmptyProfile(normalized, now);
+		profile.visitCount += 1;
+		profile.lastVisitAt = now;
+		if (selector) {
+			const pattern = this.classifySelectorPattern(selector);
+			if (pattern) {
+				const existing = profile.selectorPatterns.find((p) => p.pattern === pattern);
+				if (existing) {
+					existing.frequency += 1;
+					existing.lastSeenAt = now;
+				} else if (profile.selectorPatterns.length < MAX_SELECTOR_PATTERNS) profile.selectorPatterns.push({
+					pattern,
+					frequency: 1,
+					lastSeenAt: now
+				});
+			}
+		}
+		if (pathPattern && pathPattern !== "/") {
+			if (!profile.navigationPaths.includes(pathPattern) && profile.navigationPaths.length < MAX_NAVIGATION_PATHS) profile.navigationPaths.push(pathPattern);
+		}
+		this.profileStore.upsert(profile);
+	}
+	createEmptyProfile(domain, now) {
+		return {
+			domain,
+			selectorPatterns: [],
+			layoutFingerprints: [],
+			navigationPaths: [],
+			visitCount: 0,
+			lastVisitAt: now,
+			createdAt: now
+		};
+	}
+	classifySelectorPattern(selector) {
+		if (selector.includes("[data-testid=")) return "data-testid";
+		if (selector.includes("[data-cy=")) return "data-cy";
+		if (selector.includes("[data-test=")) return "data-test";
+		if (selector.includes("[aria-label=")) return "aria-label";
+		if (selector.includes("[name=")) return "name-attribute";
+		if (/^#[\w-]+$/.test(selector)) return "id-selector";
+		if (selector.includes("[role=")) return "role-attribute";
+	}
 	findBestExactMatch(insights, input) {
 		const intentLower = input.taskIntent.toLowerCase();
 		const domainLower = input.siteDomain.toLowerCase();
@@ -3251,7 +3727,7 @@ var MemoryService = class {
 function createAppContext(env = process.env) {
 	const config = loadConfig(env);
 	const logger = new Logger("app");
-	const eventStore = new EventStore(config.logDir);
+	const eventStore = new EventStore(config.dataDir);
 	const tokenService = new SessionTokenService();
 	return {
 		config,
@@ -3263,7 +3739,7 @@ function createAppContext(env = process.env) {
 			port: config.wsPort,
 			tokenService
 		}),
-		memoryService: new MemoryService(config.logDir)
+		memoryService: new MemoryService(config.dataDir)
 	};
 }
 //#endregion
@@ -3284,8 +3760,9 @@ var AgenticBrowserCore = class {
 		return this.api.getSession(sessionId);
 	}
 	async runCommand(input) {
+		const commandId = input.commandId ?? `${input.type}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 		return await this.api.executeCommand(input.sessionId, {
-			commandId: input.commandId,
+			commandId,
 			type: input.type,
 			payload: input.payload
 		});
@@ -3308,6 +3785,12 @@ var AgenticBrowserCore = class {
 	async dismissCookieBanner(sessionId) {
 		return await this.api.dismissCookieBanner(sessionId);
 	}
+	async screenshot(sessionId, options) {
+		return await this.api.screenshot(sessionId, options);
+	}
+	async getCurrentUrl(sessionId) {
+		return await this.api.getCurrentUrl(sessionId);
+	}
 	async restartSession(sessionId) {
 		return await this.api.restartSession(sessionId);
 	}
@@ -3332,7 +3815,7 @@ var AgenticBrowserCore = class {
 };
 function createAgenticBrowserCore(options = {}) {
 	const context = createAppContext(options.env);
-	return new AgenticBrowserCore(context, options.browserController ?? new ChromeCdpBrowserController(context.config.logDir));
+	return new AgenticBrowserCore(context, options.browserController ?? new ChromeCdpBrowserController(context.config.dataDir));
 }
 function createMockAgenticBrowserCore(env) {
 	return new AgenticBrowserCore(createAppContext(env), new MockBrowserController());