@hasna/browser 0.0.7 → 0.1.0

package/dist/cli/index.js

@@ -2309,6 +2309,55 @@ function runMigrations(db) {
         CREATE INDEX IF NOT EXISTS idx_gallery_favorite ON gallery_entries(is_favorite);
         CREATE INDEX IF NOT EXISTS idx_gallery_created ON gallery_entries(created_at);
       `
+    },
+    {
+      version: 3,
+      sql: `
+        -- Session lock/claim for multi-agent ownership
+        ALTER TABLE sessions ADD COLUMN locked_by TEXT;
+        ALTER TABLE sessions ADD COLUMN locked_at TEXT;
+      `
+    },
+    {
+      version: 4,
+      sql: `
+        CREATE TABLE IF NOT EXISTS session_events (
+          id TEXT PRIMARY KEY,
+          session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+          event_type TEXT NOT NULL,
+          details TEXT DEFAULT '{}',
+          timestamp TEXT DEFAULT (datetime('now'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_session_events_session ON session_events(session_id, timestamp);
+      `
+    },
+    {
+      version: 5,
+      sql: `
+        CREATE TABLE IF NOT EXISTS session_tags (
+          session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+          tag TEXT NOT NULL,
+          PRIMARY KEY (session_id, tag)
+        );
+        CREATE INDEX IF NOT EXISTS idx_session_tags_tag ON session_tags(tag);
+      `
+    },
+    {
+      version: 6,
+      sql: `
+        CREATE TABLE IF NOT EXISTS auth_flows (
+          id                 TEXT PRIMARY KEY,
+          name               TEXT NOT NULL UNIQUE,
+          domain             TEXT NOT NULL,
+          recording_id       TEXT REFERENCES recordings(id),
+          storage_state_path TEXT,
+          created_at         TEXT DEFAULT (datetime('now')),
+          last_used          TEXT
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_auth_flows_domain ON auth_flows(domain);
+        CREATE INDEX IF NOT EXISTS idx_auth_flows_name ON auth_flows(name);
+      `
     }
   ];
   for (const m of migrations) {
@@ -2324,6 +2373,28 @@ var _db = null, _dbPath = null;
 var init_schema = () => {};
 
 // src/db/sessions.ts
+var exports_sessions = {};
+__export(exports_sessions, {
+  updateSessionStatus: () => updateSessionStatus,
+  unlockSession: () => unlockSession,
+  transferSession: () => transferSession,
+  renameSession: () => renameSession,
+  removeSessionTag: () => removeSessionTag,
+  lockSession: () => lockSession,
+  listSessionsByTag: () => listSessionsByTag,
+  listSessions: () => listSessions,
+  isSessionLocked: () => isSessionLocked,
+  getSessionTags: () => getSessionTags,
+  getSessionByName: () => getSessionByName,
+  getSession: () => getSession,
+  getDefaultActiveSession: () => getDefaultActiveSession,
+  getActiveSessionForAgent: () => getActiveSessionForAgent,
+  deleteSession: () => deleteSession,
+  createSession: () => createSession,
+  countActiveSessions: () => countActiveSessions,
+  closeSession: () => closeSession,
+  addSessionTag: () => addSessionTag
+});
 import { randomUUID } from "crypto";
 function createSession(data) {
   const db = getDatabase();
@@ -2376,8 +2447,81 @@ function updateSessionStatus(id, status) {
   return getSession(id);
 }
 function closeSession(id) {
+  const db = getDatabase();
+  db.prepare("UPDATE sessions SET locked_by = NULL, locked_at = NULL WHERE id = ?").run(id);
   return updateSessionStatus(id, "closed");
 }
+function lockSession(id, agentId) {
+  const db = getDatabase();
+  const session = getSession(id);
+  if (session.status !== "active")
+    throw new SessionNotFoundError(id);
+  const row = db.query("SELECT locked_by FROM sessions WHERE id = ?").get(id);
+  if (row?.locked_by && row.locked_by !== agentId) {
+    throw new Error(`Session locked by agent ${row.locked_by}`);
+  }
+  db.prepare("UPDATE sessions SET locked_by = ?, locked_at = datetime('now') WHERE id = ?").run(agentId, id);
+  return getSession(id);
+}
+function unlockSession(id, agentId) {
+  const db = getDatabase();
+  if (agentId) {
+    const row = db.query("SELECT locked_by FROM sessions WHERE id = ?").get(id);
+    if (row?.locked_by && row.locked_by !== agentId) {
+      throw new Error(`Session locked by agent ${row.locked_by}, not ${agentId}`);
+    }
+  }
+  db.prepare("UPDATE sessions SET locked_by = NULL, locked_at = NULL WHERE id = ?").run(id);
+  return getSession(id);
+}
+function isSessionLocked(id) {
+  const db = getDatabase();
+  const row = db.query("SELECT locked_by, locked_at FROM sessions WHERE id = ?").get(id);
+  if (!row)
+    throw new SessionNotFoundError(id);
+  return { locked: !!row.locked_by, locked_by: row.locked_by ?? undefined, locked_at: row.locked_at ?? undefined };
+}
+function transferSession(id, toAgentId) {
+  const db = getDatabase();
+  db.prepare("UPDATE sessions SET agent_id = ?, locked_by = ?, locked_at = datetime('now') WHERE id = ?").run(toAgentId, toAgentId, id);
+  return getSession(id);
+}
+function getActiveSessionForAgent(agentId) {
+  const db = getDatabase();
+  return db.query("SELECT * FROM sessions WHERE agent_id = ? AND status = 'active' ORDER BY created_at DESC LIMIT 1").get(agentId) ?? null;
+}
+function getDefaultActiveSession() {
+  const db = getDatabase();
+  const rows = db.query("SELECT * FROM sessions WHERE status = 'active' ORDER BY created_at DESC LIMIT 2").all();
+  return rows.length === 1 ? rows[0] : null;
+}
+function countActiveSessions() {
+  const db = getDatabase();
+  const row = db.query("SELECT COUNT(*) as count FROM sessions WHERE status = 'active'").get();
+  return row?.count ?? 0;
+}
+function deleteSession(id) {
+  const db = getDatabase();
+  db.prepare("DELETE FROM sessions WHERE id = ?").run(id);
+}
+function addSessionTag(id, tag) {
+  const db = getDatabase();
+  db.prepare("INSERT OR IGNORE INTO session_tags (session_id, tag) VALUES (?, ?)").run(id, tag);
+  return getSessionTags(id);
+}
+function removeSessionTag(id, tag) {
+  const db = getDatabase();
+  db.prepare("DELETE FROM session_tags WHERE session_id = ? AND tag = ?").run(id, tag);
+  return getSessionTags(id);
+}
+function getSessionTags(id) {
+  const db = getDatabase();
+  return db.query("SELECT tag FROM session_tags WHERE session_id = ? ORDER BY tag").all(id).map((r) => r.tag);
+}
+function listSessionsByTag(tag) {
+  const db = getDatabase();
+  return db.query("SELECT s.* FROM sessions s JOIN session_tags t ON s.id = t.session_id WHERE t.tag = ? ORDER BY s.created_at DESC").all(tag);
+}
 var init_sessions = __esm(() => {
   init_schema();
   init_types();
@@ -2403,10 +2547,52 @@ async function getPage(browser, options) {
   });
   return context.newPage();
 }
-async function closeBrowser(browser) {
-  try {
-    await browser.close();
-  } catch {}
+
+class BrowserPool {
+  pool = [];
+  maxSize;
+  options;
+  constructor(maxSize = 3, options) {
+    this.maxSize = maxSize;
+    this.options = options;
+  }
+  async acquire(headless = true) {
+    const available = this.pool.find((e) => !e.inUse);
+    if (available) {
+      available.inUse = true;
+      return available.browser;
+    }
+    if (this.pool.length < this.maxSize) {
+      const browser = await launchPlaywright({ ...this.options, headless });
+      this.pool.push({ browser, inUse: true, createdAt: Date.now() });
+      return browser;
+    }
+    return new Promise((resolve) => {
+      const interval = setInterval(() => {
+        const free = this.pool.find((e) => !e.inUse);
+        if (free) {
+          clearInterval(interval);
+          free.inUse = true;
+          resolve(free.browser);
+        }
+      }, 100);
+    });
+  }
+  release(browser) {
+    const entry = this.pool.find((e) => e.browser === browser);
+    if (entry)
+      entry.inUse = false;
+  }
+  async destroyAll() {
+    await Promise.all(this.pool.map((e) => e.browser.close().catch(() => {})));
+    this.pool = [];
+  }
+  get size() {
+    return this.pool.length;
+  }
+  get available() {
+    return this.pool.filter((e) => !e.inUse).length;
+  }
 }
 var DEFAULT_VIEWPORT;
 var init_playwright = __esm(() => {
@@ -3287,6 +3473,188 @@ var init_dialogs = __esm(() => {
   pendingDialogs = new Map;
 });
 
+// src/engines/cdp.ts
+var exports_cdp = {};
+__export(exports_cdp, {
+  connectToExistingBrowser: () => connectToExistingBrowser,
+  CDPClient: () => CDPClient
+});
+async function connectToExistingBrowser(cdpUrl) {
+  const { chromium: chromium3 } = await import("playwright");
+  try {
+    return await chromium3.connectOverCDP(cdpUrl);
+  } catch (err) {
+    throw new BrowserError(`Failed to connect to browser at ${cdpUrl}: ${err instanceof Error ? err.message : String(err)}. Start Chrome with: google-chrome --remote-debugging-port=9222`, "CDP_CONNECT_FAILED", true);
+  }
+}
+
+class CDPClient {
+  session;
+  networkEnabled = false;
+  performanceEnabled = false;
+  constructor(session) {
+    this.session = session;
+  }
+  static async fromPage(page) {
+    try {
+      const session = await page.context().newCDPSession(page);
+      return new CDPClient(session);
+    } catch (err) {
+      throw new BrowserError(`Failed to create CDP session: ${err instanceof Error ? err.message : String(err)}`, "CDP_SESSION_FAILED");
+    }
+  }
+  async send(method, params) {
+    try {
+      return await this.session.send(method, params);
+    } catch (err) {
+      throw new BrowserError(`CDP command '${method}' failed: ${err instanceof Error ? err.message : String(err)}`, "CDP_COMMAND_FAILED");
+    }
+  }
+  on(event, handler) {
+    this.session.on(event, handler);
+  }
+  off(event, handler) {
+    this.session.off(event, handler);
+  }
+  async enableNetwork() {
+    if (!this.networkEnabled) {
+      await this.send("Network.enable");
+      this.networkEnabled = true;
+    }
+  }
+  async enablePerformance() {
+    if (!this.performanceEnabled) {
+      await this.send("Performance.enable");
+      this.performanceEnabled = true;
+    }
+  }
+  async getPerformanceMetrics() {
+    await this.enablePerformance();
+    const result = await this.send("Performance.getMetrics");
+    const m = {};
+    for (const metric of result.metrics) {
+      m[metric.name] = metric.value;
+    }
+    return {
+      js_heap_size_used: m["JSHeapUsedSize"],
+      js_heap_size_total: m["JSHeapTotalSize"],
+      dom_interactive: m["DOMInteractive"],
+      dom_complete: m["DOMComplete"],
+      load_event: m["LoadEventEnd"]
+    };
+  }
+  async startJSCoverage() {
+    await this.send("Profiler.enable");
+    await this.send("Debugger.enable");
+    await this.send("Profiler.startPreciseCoverage", {
+      callCount: false,
+      detailed: true
+    });
+  }
+  async stopJSCoverage() {
+    const result = await this.send("Profiler.takePreciseCoverage");
+    await this.send("Profiler.stopPreciseCoverage");
+    return result.result.filter((r) => r.url && !r.url.startsWith("v8-snapshot://")).map((r) => ({
+      url: r.url,
+      text: "",
+      ranges: r.functions.flatMap((f) => f.ranges.filter((rng) => rng.count > 0).map((rng) => ({ start: rng.startOffset, end: rng.endOffset })))
+    }));
+  }
+  async getCoverage() {
+    await this.startJSCoverage();
+    const js = await this.stopJSCoverage();
+    const totalBytes = js.reduce((acc, e) => acc + e.ranges.reduce((sum, r) => sum + (r.end - r.start), 0), 0);
+    return { js, css: [], totalBytes, usedBytes: totalBytes, unusedPercent: 0 };
+  }
+  async captureHAREntries(page, handler) {
+    await this.enableNetwork();
+    const requestTimings = new Map;
+    const onRequest = (params) => {
+      requestTimings.set(params.requestId, params.timestamp);
+    };
+    const onResponse = (params) => {
+      const start = requestTimings.get(params.requestId);
+      const duration = start != null ? (params.timestamp - start) * 1000 : 0;
+      handler({
+        method: "GET",
+        url: params.response.url,
+        status: params.response.status,
+        duration
+      });
+    };
+    this.on("Network.requestWillBeSent", onRequest);
+    this.on("Network.responseReceived", onResponse);
+    return () => {
+      this.off("Network.requestWillBeSent", onRequest);
+      this.off("Network.responseReceived", onResponse);
+    };
+  }
+  async detach() {
+    try {
+      await this.session.detach();
+    } catch {}
+  }
+}
+var init_cdp = __esm(() => {
+  init_types();
+});
+
+// src/lib/storage-state.ts
+var exports_storage_state = {};
+__export(exports_storage_state, {
+  saveStateFromPage: () => saveStateFromPage,
+  saveState: () => saveState,
+  loadStatePath: () => loadStatePath,
+  listStates: () => listStates,
+  deleteState: () => deleteState
+});
+import { mkdirSync as mkdirSync3, existsSync, readdirSync, unlinkSync } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+function ensureDir() {
+  mkdirSync3(STATES_DIR, { recursive: true });
+}
+function statePath(name) {
+  return join3(STATES_DIR, `${name}.json`);
+}
+async function saveState(context, name) {
+  ensureDir();
+  const path = statePath(name);
+  const state = await context.storageState({ path });
+  return path;
+}
+async function saveStateFromPage(page, name) {
+  return saveState(page.context(), name);
+}
+function loadStatePath(name) {
+  const path = statePath(name);
+  return existsSync(path) ? path : null;
+}
+function listStates() {
+  ensureDir();
+  return readdirSync(STATES_DIR).filter((f) => f.endsWith(".json")).map((f) => {
+    const path = join3(STATES_DIR, f);
+    const stat = Bun.file(path);
+    return {
+      name: f.replace(".json", ""),
+      path,
+      modified: new Date(stat.lastModified).toISOString()
+    };
+  }).sort((a, b) => b.modified.localeCompare(a.modified));
+}
+function deleteState(name) {
+  const path = statePath(name);
+  if (existsSync(path)) {
+    unlinkSync(path);
+    return true;
+  }
+  return false;
+}
+var STATES_DIR;
+var init_storage_state = __esm(() => {
+  STATES_DIR = join3(process.env["BROWSER_DATA_DIR"] ?? join3(homedir3(), ".browser"), "states");
+});
+
 // src/lib/session.ts
 var exports_session = {};
 __export(exports_session, {
@@ -3294,6 +3662,7 @@ __export(exports_session, {
   renameSession: () => renameSession2,
   listSessions: () => listSessions2,
   isBunSession: () => isBunSession,
+  isAutoGallery: () => isAutoGallery,
   hasActiveHandle: () => hasActiveHandle,
   getTokenBudget: () => getTokenBudget,
   getSessionPage: () => getSessionPage,
@@ -3302,15 +3671,50 @@ __export(exports_session, {
   getSessionBunView: () => getSessionBunView,
   getSessionBrowser: () => getSessionBrowser,
   getSession: () => getSession2,
+  getDefaultSession: () => getDefaultSession,
   getActiveSessions: () => getActiveSessions,
+  getActiveSessionForAgent: () => getActiveSessionForAgent2,
   createSession: () => createSession2,
+  countActiveSessions: () => countActiveSessions2,
   closeSession: () => closeSession2,
-  closeAllSessions: () => closeAllSessions
+  closeAllSessions: () => closeAllSessions,
+  browserPool: () => pool
 });
 function createBunProxy(view) {
   return view;
 }
 async function createSession2(opts = {}) {
+  if (opts.cdpUrl) {
+    const { connectToExistingBrowser: connectToExistingBrowser2 } = await Promise.resolve().then(() => (init_cdp(), exports_cdp));
+    const cdpBrowser = await connectToExistingBrowser2(opts.cdpUrl);
+    const contexts = cdpBrowser.contexts();
+    const context = contexts.length > 0 ? contexts[0] : await cdpBrowser.newContext();
+    const pages = context.pages();
+    const page2 = pages.length > 0 ? pages[0] : await context.newPage();
+    const session2 = createSession({
+      engine: "cdp",
+      projectId: opts.projectId,
+      agentId: opts.agentId,
+      startUrl: page2.url(),
+      name: opts.name ?? "attached"
+    });
+    const cleanups2 = [];
+    if (opts.captureNetwork !== false) {
+      try {
+        cleanups2.push(enableNetworkLogging(page2, session2.id));
+      } catch {}
+    }
+    if (opts.captureConsole !== false) {
+      try {
+        cleanups2.push(enableConsoleCapture(page2, session2.id));
+      } catch {}
+    }
+    try {
+      cleanups2.push(setupDialogHandler(page2, session2.id));
+    } catch {}
+    handles.set(session2.id, { browser: cdpBrowser, bunView: null, page: page2, engine: "cdp", cleanups: cleanups2, tokenBudget: { total: 0, used: 0 }, lastActivity: Date.now(), autoGallery: opts.autoGallery ?? false });
+    return { session: session2, page: page2 };
+  }
   const engine = opts.engine === "auto" || !opts.engine ? selectEngine(opts.useCase ?? "spa_navigate" /* SPA_NAVIGATE */, opts.engine) : opts.engine;
   const resolvedEngine = engine === "auto" ? "playwright" : engine;
   let browser = null;
@@ -3335,12 +3739,23 @@ async function createSession2(opts = {}) {
     const context = await browser.newContext({ viewport: opts.viewport ?? { width: 1280, height: 720 } });
     page = await context.newPage();
   } else {
-    browser = await launchPlaywright({
-      headless: opts.headless ?? true,
-      viewport: opts.viewport,
-      userAgent: opts.userAgent
-    });
-    page = await getPage(browser, { viewport: opts.viewport, userAgent: opts.userAgent });
+    browser = await pool.acquire(opts.headless ?? true);
+    if (opts.storageState) {
+      const { loadStatePath: loadStatePath2 } = await Promise.resolve().then(() => (init_storage_state(), exports_storage_state));
+      const statePath2 = loadStatePath2(opts.storageState);
+      if (statePath2) {
+        const context = await browser.newContext({
+          viewport: opts.viewport ?? { width: 1280, height: 720 },
+          userAgent: opts.userAgent,
+          storageState: statePath2
+        });
+        page = await context.newPage();
+      } else {
+        page = await getPage(browser, { viewport: opts.viewport, userAgent: opts.userAgent });
+      }
+    } else {
+      page = await getPage(browser, { viewport: opts.viewport, userAgent: opts.userAgent });
+    }
   }
   const sessionName = opts.name ?? (opts.startUrl ? (() => {
     try {
@@ -3393,7 +3808,7 @@ async function createSession2(opts = {}) {
       } catch {}
     }
   }
-  handles.set(session.id, { browser, bunView, page, engine: bunView ? "bun" : resolvedEngine, cleanups, tokenBudget: { total: 0, used: 0 } });
+  handles.set(session.id, { browser, bunView, page, engine: bunView ? "bun" : resolvedEngine, cleanups, tokenBudget: { total: 0, used: 0 }, lastActivity: Date.now(), autoGallery: opts.autoGallery ?? false });
   if (opts.startUrl) {
     try {
       if (bunView) {
@@ -3419,6 +3834,7 @@ function getSessionPage(sessionId) {
     handles.delete(sessionId);
     throw new SessionNotFoundError(sessionId);
   }
+  handle.lastActivity = Date.now();
   return handle.page;
 }
 function getSessionBunView(sessionId) {
@@ -3466,10 +3882,8 @@ async function closeSession2(sessionId) {
       try {
         await handle.page.context().close();
       } catch {}
-      try {
-        if (handle.browser)
-          await closeBrowser(handle.browser);
-      } catch {}
+      if (handle.browser)
+        pool.release(handle.browser);
     }
     handles.delete(sessionId);
   }
@@ -3488,6 +3902,7 @@ async function closeAllSessions() {
   for (const [id] of handles) {
     await closeSession2(id).catch(() => {});
   }
+  await pool.destroyAll();
 }
 function getSessionByName2(name) {
   return getSessionByName(name);
@@ -3499,7 +3914,49 @@ function getTokenBudget(sessionId) {
   const handle = handles.get(sessionId);
   return handle ? handle.tokenBudget : null;
 }
-var handles;
+function getActiveSessionForAgent2(agentId) {
+  const session = getActiveSessionForAgent(agentId);
+  if (!session)
+    return null;
+  const handle = handles.get(session.id);
+  if (!handle)
+    return null;
+  try {
+    if (handle.bunView)
+      handle.bunView.url();
+    else
+      handle.page.url();
+  } catch {
+    handles.delete(session.id);
+    return null;
+  }
+  return { session, page: handle.page };
+}
+function getDefaultSession() {
+  const session = getDefaultActiveSession();
+  if (!session)
+    return null;
+  const handle = handles.get(session.id);
+  if (!handle)
+    return null;
+  try {
+    if (handle.bunView)
+      handle.bunView.url();
+    else
+      handle.page.url();
+  } catch {
+    handles.delete(session.id);
+    return null;
+  }
+  return { session, page: handle.page };
+}
+function isAutoGallery(sessionId) {
+  return handles.get(sessionId)?.autoGallery ?? false;
+}
+function countActiveSessions2() {
+  return countActiveSessions();
+}
+var handles, pool, SESSION_TTL_MS, ttlInterval;
 var init_session = __esm(() => {
   init_types();
   init_types();
@@ -3513,6 +3970,20 @@ var init_session = __esm(() => {
   init_stealth();
   init_dialogs();
   handles = new Map;
+  pool = new BrowserPool(5);
+  SESSION_TTL_MS = parseInt(process.env["SESSION_TTL_MINUTES"] ?? "10", 10) * 60000;
+  ttlInterval = setInterval(async () => {
+    const now = Date.now();
+    for (const [id, handle] of handles) {
+      if (now - handle.lastActivity > SESSION_TTL_MS) {
+        try {
+          await closeSession2(id);
+        } catch {}
+      }
+    }
+  }, 60000);
+  if (ttlInterval.unref)
+    ttlInterval.unref();
 });
 
 // src/lib/snapshot.ts
@@ -3789,6 +4260,66 @@ var init_snapshot = __esm(() => {
   ];
 });
 
+// src/lib/self-heal.ts
+async function healSelector(page, selector, sessionId) {
+  const attempts = [];
+  attempts.push(`selector: ${selector}`);
+  try {
+    const loc = page.locator(selector).first();
+    if (await loc.count() > 0) {
+      return { found: true, locator: loc, method: "original", healed: false, attempts };
+    }
+  } catch {}
+  if (!selector.startsWith("#") && !selector.startsWith(".") && !selector.startsWith("[") && !selector.includes(">") && !selector.includes(" ")) {
+    attempts.push(`text: "${selector}"`);
+    try {
+      const loc = page.getByText(selector, { exact: false }).first();
+      if (await loc.count() > 0) {
+        return { found: true, locator: loc, method: "text", healed: true, attempts };
+      }
+    } catch {}
+  }
+  const roleMap = {
+    button: ["button", "submit", "reset"],
+    link: ["a"],
+    input: ["input", "textarea"],
+    heading: ["h1", "h2", "h3", "h4", "h5", "h6"]
+  };
+  const nameHint = selector.replace(/^[#.]/, "").replace(/[-_]/g, " ").toLowerCase();
+  for (const [role, tags] of Object.entries(roleMap)) {
+    attempts.push(`role: ${role} name~="${nameHint}"`);
+    try {
+      const loc = page.getByRole(role, { name: new RegExp(nameHint.split(" ")[0], "i") }).first();
+      if (await loc.count() > 0) {
+        return { found: true, locator: loc, method: "role", healed: true, attempts };
+      }
+    } catch {}
+  }
+  if (selector.startsWith("#")) {
+    const idPart = selector.slice(1).split("-").pop() ?? selector.slice(1);
+    const partialSel = `[id*="${idPart}"]`;
+    attempts.push(`partial_id: ${partialSel}`);
+    try {
+      const loc = page.locator(partialSel).first();
+      if (await loc.count() > 0) {
+        return { found: true, locator: loc, method: "partial_id", healed: true, attempts };
+      }
+    } catch {}
+  }
+  if (selector.startsWith(".")) {
+    const classPart = selector.slice(1).split("-").pop() ?? selector.slice(1);
+    const partialSel = `[class*="${classPart}"]`;
+    attempts.push(`partial_class: ${partialSel}`);
+    try {
+      const loc = page.locator(partialSel).first();
+      if (await loc.count() > 0) {
+        return { found: true, locator: loc, method: "partial_class", healed: true, attempts };
+      }
+    } catch {}
+  }
+  return { found: false, locator: null, method: "none", healed: false, attempts };
+}
+
 // src/lib/actions.ts
 var exports_actions = {};
 __export(exports_actions, {
@@ -3830,11 +4361,22 @@ async function click(page, selector, opts) {
       delay: opts?.delay,
       timeout: opts?.timeout ?? 1e4
     });
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("not found")) {
+    return {};
+  } catch (originalError) {
+    if (opts?.selfHeal !== false) {
+      const result = await healSelector(page, selector);
+      if (result.found && result.locator) {
+        await result.locator.click({
+          button: opts?.button ?? "left",
+          timeout: opts?.timeout ?? 1e4
+        });
+        return { healed: true, method: result.method, attempts: result.attempts };
+      }
+    }
+    if (originalError instanceof Error && originalError.message.includes("not found")) {
       throw new ElementNotFoundError(selector);
     }
-    throw new BrowserError(`Click failed on '${selector}': ${err instanceof Error ? err.message : String(err)}`, "CLICK_FAILED");
+    throw new BrowserError(`Click failed on '${selector}': ${originalError instanceof Error ? originalError.message : String(originalError)}`, "CLICK_FAILED");
   }
 }
 async function type(page, selector, text, opts) {
@@ -3843,17 +4385,35 @@ async function type(page, selector, text, opts) {
       await page.fill(selector, "", { timeout: opts?.timeout ?? 1e4 });
     }
     await page.type(selector, text, { delay: opts?.delay, timeout: opts?.timeout ?? 1e4 });
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("not found")) {
+    return {};
+  } catch (originalError) {
+    if (opts?.selfHeal !== false) {
+      const result = await healSelector(page, selector);
+      if (result.found && result.locator) {
+        if (opts?.clear)
+          await result.locator.fill("", { timeout: opts?.timeout ?? 1e4 });
+        await result.locator.pressSequentially(text, { delay: opts?.delay, timeout: opts?.timeout ?? 1e4 });
+        return { healed: true, method: result.method, attempts: result.attempts };
+      }
+    }
+    if (originalError instanceof Error && originalError.message.includes("not found")) {
       throw new ElementNotFoundError(selector);
     }
-    throw new BrowserError(`Type failed on '${selector}': ${err instanceof Error ? err.message : String(err)}`, "TYPE_FAILED");
+    throw new BrowserError(`Type failed on '${selector}': ${originalError instanceof Error ? originalError.message : String(originalError)}`, "TYPE_FAILED");
   }
 }
-async function fill(page, selector, value, timeout = 1e4) {
+async function fill(page, selector, value, timeout = 1e4, selfHeal = true) {
   try {
     await page.fill(selector, value, { timeout });
-  } catch (err) {
+    return {};
+  } catch (originalError) {
+    if (selfHeal) {
+      const result = await healSelector(page, selector);
+      if (result.found && result.locator) {
+        await result.locator.fill(value, { timeout });
+        return { healed: true, method: result.method, attempts: result.attempts };
+      }
+    }
     throw new ElementNotFoundError(selector);
   }
 }
@@ -3978,12 +4538,39 @@ async function clickText(page, text, opts) {
     }
   }, { retries: opts?.retries ?? 1 });
 }
-async function fillForm(page, fields, submitSelector) {
+async function fillForm(page, fields, submitSelector, selfHeal = true) {
   let filled = 0;
   const errors = [];
+  const healedFields = [];
   for (const [selector, value] of Object.entries(fields)) {
     try {
-      const el = await page.$(selector);
+      let el = await page.$(selector);
+      if (!el && selfHeal) {
+        const result = await healSelector(page, selector);
+        if (result.found && result.locator) {
+          const handle = await result.locator.elementHandle();
+          if (handle) {
+            el = handle;
+            healedFields.push(selector);
+            const tagName2 = await result.locator.evaluate((e) => e.tagName.toLowerCase());
+            const inputType2 = await result.locator.evaluate((e) => e.type?.toLowerCase() ?? "text");
+            if (tagName2 === "select") {
+              await result.locator.selectOption(String(value));
+            } else if (tagName2 === "input" && (inputType2 === "checkbox" || inputType2 === "radio")) {
+              if (Boolean(value))
+                await result.locator.check();
+              else
+                await result.locator.uncheck();
+            } else {
+              await result.locator.fill(String(value));
+            }
+            filled++;
+            continue;
+          }
+        }
+        errors.push(`${selector}: element not found`);
+        continue;
+      }
       if (!el) {
         errors.push(`${selector}: element not found`);
         continue;
@@ -4010,11 +4597,21 @@ async function fillForm(page, fields, submitSelector) {
   if (submitSelector) {
     try {
       await page.click(submitSelector);
-    } catch (err) {
-      errors.push(`submit(${submitSelector}): ${err instanceof Error ? err.message : String(err)}`);
+    } catch (submitErr) {
+      if (selfHeal) {
+        const result = await healSelector(page, submitSelector);
+        if (result.found && result.locator) {
+          await result.locator.click();
+          healedFields.push(submitSelector);
+        } else {
+          errors.push(`submit(${submitSelector}): ${submitErr instanceof Error ? submitErr.message : String(submitErr)}`);
+        }
+      } else {
+        errors.push(`submit(${submitSelector}): ${submitErr instanceof Error ? submitErr.message : String(submitErr)}`);
+      }
     }
   }
-  return { filled, errors, fields_attempted: Object.keys(fields).length };
+  return { filled, errors, fields_attempted: Object.keys(fields).length, ...healedFields.length > 0 ? { healed_fields: healedFields } : {} };
 }
 async function waitForText(page, text, opts) {
   const timeout = opts?.timeout ?? 1e4;
@@ -10870,17 +11467,17 @@ var init_gallery = __esm(() => {
 });
 
 // src/lib/screenshot.ts
-import { join as join3 } from "path";
-import { mkdirSync as mkdirSync3 } from "fs";
-import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+import { mkdirSync as mkdirSync4 } from "fs";
+import { homedir as homedir4 } from "os";
 function getDataDir2() {
-  return process.env["BROWSER_DATA_DIR"] ?? join3(homedir3(), ".browser");
+  return process.env["BROWSER_DATA_DIR"] ?? join4(homedir4(), ".browser");
 }
 function getScreenshotDir(projectId) {
-  const base = join3(getDataDir2(), "screenshots");
+  const base = join4(getDataDir2(), "screenshots");
   const date = new Date().toISOString().split("T")[0];
-  const dir = projectId ? join3(base, projectId, date) : join3(base, date);
-  mkdirSync3(dir, { recursive: true });
+  const dir = projectId ? join4(base, projectId, date) : join4(base, date);
+  mkdirSync4(dir, { recursive: true });
   return dir;
 }
 async function compressBuffer(raw, format, quality, maxWidth) {
@@ -10895,7 +11492,7 @@ async function compressBuffer(raw, format, quality, maxWidth) {
   }
 }
 async function generateThumbnail(raw, dir, stem) {
-  const thumbPath = join3(dir, `${stem}.thumb.webp`);
+  const thumbPath = join4(dir, `${stem}.thumb.webp`);
   const thumbBuffer = await import_sharp.default(raw).resize({ width: 200, withoutEnlargement: true }).webp({ quality: 70, effort: 3 }).toBuffer();
   await Bun.write(thumbPath, thumbBuffer);
   return { path: thumbPath, base64: thumbBuffer.toString("base64") };
@@ -10952,7 +11549,7 @@ async function takeScreenshot(page, opts) {
     const compressedSizeBytes = finalBuffer.length;
     const compressionRatio = originalSizeBytes > 0 ? compressedSizeBytes / originalSizeBytes : 1;
     const ext = format;
-    const screenshotPath = opts?.path ?? join3(dir, `${stem}.${ext}`);
+    const screenshotPath = opts?.path ?? join4(dir, `${stem}.${ext}`);
     await Bun.write(screenshotPath, finalBuffer);
     let thumbnailPath;
     let thumbnailBase64;
@@ -11012,12 +11609,12 @@ async function takeScreenshot(page, opts) {
 }
 async function generatePDF(page, opts) {
   try {
-    const base = join3(getDataDir2(), "pdfs");
+    const base = join4(getDataDir2(), "pdfs");
     const date = new Date().toISOString().split("T")[0];
-    const dir = opts?.projectId ? join3(base, opts.projectId, date) : join3(base, date);
-    mkdirSync3(dir, { recursive: true });
+    const dir = opts?.projectId ? join4(base, opts.projectId, date) : join4(base, date);
+    mkdirSync4(dir, { recursive: true });
     const timestamp = Date.now();
-    const pdfPath = opts?.path ?? join3(dir, `${timestamp}.pdf`);
+    const pdfPath = opts?.path ?? join4(dir, `${timestamp}.pdf`);
     const buffer = await page.pdf({
       path: pdfPath,
       format: opts?.format ?? "A4",
@@ -11344,6 +11941,17 @@ var init_recordings = __esm(() => {
 });
 
 // src/lib/recorder.ts
+var exports_recorder = {};
+__export(exports_recorder, {
+  stopRecording: () => stopRecording,
+  startRecording: () => startRecording,
+  replayRecording: () => replayRecording,
+  recordStep: () => recordStep,
+  listRecordings: () => listRecordings,
+  getRecording: () => getRecording,
+  exportRecording: () => exportRecording,
+  attachPageListeners: () => attachPageListeners
+});
 function startRecording(sessionId, name, startUrl) {
   const steps = [];
   const recording = createRecording({ name, start_url: startUrl, steps });
@@ -11354,6 +11962,23 @@ function startRecording(sessionId, name, startUrl) {
   });
   return recording;
 }
+function attachPageListeners(page, recordingId) {
+  const active = activeRecordings.get(recordingId);
+  if (!active)
+    throw new BrowserError(`No active recording: ${recordingId}`, "RECORDING_NOT_ACTIVE");
+  const onFrameNav = () => {
+    active.steps.push({
+      type: "navigate",
+      url: page.url(),
+      timestamp: Date.now()
+    });
+  };
+  page.on("framenavigated", onFrameNav);
+  const cleanup = () => {
+    page.off("framenavigated", onFrameNav);
+  };
+  active.cleanup = cleanup;
+}
 function recordStep(recordingId, step) {
   const active = activeRecordings.get(recordingId);
   if (!active)
@@ -11425,6 +12050,64 @@ async function replayRecording(recordingId, page) {
     duration_ms: Date.now() - startTime
   };
 }
+function exportRecording(recordingId, format = "json") {
+  const recording = getRecording(recordingId);
+  if (format === "json") {
+    return JSON.stringify(recording, null, 2);
+  }
+  if (format === "playwright") {
+    const lines2 = [
+      `import { test, expect } from '@playwright/test';`,
+      ``,
+      `test('${recording.name}', async ({ page }) => {`
+    ];
+    for (const step of recording.steps) {
+      switch (step.type) {
+        case "navigate":
+          lines2.push(`  await page.goto('${step.url}');`);
+          break;
+        case "click":
+          lines2.push(`  await page.click('${step.selector}');`);
+          break;
+        case "type":
+          lines2.push(`  await page.type('${step.selector}', '${step.value}');`);
+          break;
+        case "scroll":
+          lines2.push(`  await page.evaluate(() => window.scrollBy(0, 300));`);
+          break;
+        case "evaluate":
+          lines2.push(`  await page.evaluate(${step.value});`);
+          break;
+      }
+    }
+    lines2.push(`});`);
+    return lines2.join(`
+`);
+  }
+  const lines = [
+    `const puppeteer = require('puppeteer');`,
+    ``,
+    `(async () => {`,
+    `  const browser = await puppeteer.launch();`,
+    `  const page = await browser.newPage();`
+  ];
+  for (const step of recording.steps) {
+    switch (step.type) {
+      case "navigate":
+        lines.push(`  await page.goto('${step.url}');`);
+        break;
+      case "click":
+        lines.push(`  await page.click('${step.selector}');`);
+        break;
+      case "type":
+        lines.push(`  await page.type('${step.selector}', '${step.value}');`);
+        break;
+    }
+  }
+  lines.push(`  await browser.close();`, `})();`);
+  return lines.join(`
+`);
+}
 var activeRecordings;
 var init_recorder = __esm(() => {
   init_recordings();
@@ -15399,118 +16082,6 @@ var init_zod = __esm(() => {
   init_external();
 });
 
-// src/engines/cdp.ts
-class CDPClient {
-  session;
-  networkEnabled = false;
-  performanceEnabled = false;
-  constructor(session) {
-    this.session = session;
-  }
-  static async fromPage(page) {
-    try {
-      const session = await page.context().newCDPSession(page);
-      return new CDPClient(session);
-    } catch (err) {
-      throw new BrowserError(`Failed to create CDP session: ${err instanceof Error ? err.message : String(err)}`, "CDP_SESSION_FAILED");
-    }
-  }
-  async send(method, params) {
-    try {
-      return await this.session.send(method, params);
-    } catch (err) {
-      throw new BrowserError(`CDP command '${method}' failed: ${err instanceof Error ? err.message : String(err)}`, "CDP_COMMAND_FAILED");
-    }
-  }
-  on(event, handler) {
-    this.session.on(event, handler);
-  }
-  off(event, handler) {
-    this.session.off(event, handler);
-  }
-  async enableNetwork() {
-    if (!this.networkEnabled) {
-      await this.send("Network.enable");
-      this.networkEnabled = true;
-    }
-  }
-  async enablePerformance() {
-    if (!this.performanceEnabled) {
-      await this.send("Performance.enable");
-      this.performanceEnabled = true;
-    }
-  }
-  async getPerformanceMetrics() {
-    await this.enablePerformance();
-    const result = await this.send("Performance.getMetrics");
-    const m = {};
-    for (const metric of result.metrics) {
-      m[metric.name] = metric.value;
-    }
-    return {
-      js_heap_size_used: m["JSHeapUsedSize"],
-      js_heap_size_total: m["JSHeapTotalSize"],
-      dom_interactive: m["DOMInteractive"],
-      dom_complete: m["DOMComplete"],
-      load_event: m["LoadEventEnd"]
-    };
-  }
-  async startJSCoverage() {
-    await this.send("Profiler.enable");
-    await this.send("Debugger.enable");
-    await this.send("Profiler.startPreciseCoverage", {
-      callCount: false,
-      detailed: true
-    });
-  }
-  async stopJSCoverage() {
-    const result = await this.send("Profiler.takePreciseCoverage");
-    await this.send("Profiler.stopPreciseCoverage");
-    return result.result.filter((r) => r.url && !r.url.startsWith("v8-snapshot://")).map((r) => ({
-      url: r.url,
-      text: "",
-      ranges: r.functions.flatMap((f) => f.ranges.filter((rng) => rng.count > 0).map((rng) => ({ start: rng.startOffset, end: rng.endOffset })))
-    }));
-  }
-  async getCoverage() {
-    await this.startJSCoverage();
-    const js = await this.stopJSCoverage();
-    const totalBytes = js.reduce((acc, e) => acc + e.ranges.reduce((sum, r) => sum + (r.end - r.start), 0), 0);
-    return { js, css: [], totalBytes, usedBytes: totalBytes, unusedPercent: 0 };
-  }
-  async captureHAREntries(page, handler) {
-    await this.enableNetwork();
-    const requestTimings = new Map;
-    const onRequest = (params) => {
-      requestTimings.set(params.requestId, params.timestamp);
-    };
-    const onResponse = (params) => {
-      const start = requestTimings.get(params.requestId);
-      const duration = start != null ? (params.timestamp - start) * 1000 : 0;
-      handler({
-        method: "GET",
-        url: params.response.url,
-        status: params.response.status,
-        duration
-      });
-    };
-    this.on("Network.requestWillBeSent", onRequest);
-    this.on("Network.responseReceived", onResponse);
-    return () => {
-      this.off("Network.requestWillBeSent", onRequest);
-      this.off("Network.responseReceived", onResponse);
-    };
-  }
-  async detach() {
-    try {
-      await this.session.detach();
-    } catch {}
-  }
-}
-var init_cdp = __esm(() => {
-  init_types();
-});
-
 // src/lib/performance.ts
 async function getPerformanceMetrics(page) {
   const navTiming = await page.evaluate(() => {
@@ -15616,16 +16187,16 @@ __export(exports_downloads, {
   cleanStaleDownloads: () => cleanStaleDownloads
 });
 import { randomUUID as randomUUID9 } from "crypto";
-import { join as join4, basename, extname } from "path";
-import { mkdirSync as mkdirSync4, existsSync, readdirSync, statSync, unlinkSync, copyFileSync, writeFileSync, readFileSync } from "fs";
-import { homedir as homedir4 } from "os";
+import { join as join5, basename, extname } from "path";
+import { mkdirSync as mkdirSync5, existsSync as existsSync2, readdirSync as readdirSync2, statSync, unlinkSync as unlinkSync2, copyFileSync, writeFileSync, readFileSync } from "fs";
+import { homedir as homedir5 } from "os";
 function getDataDir3() {
-  return process.env["BROWSER_DATA_DIR"] ?? join4(homedir4(), ".browser");
+  return process.env["BROWSER_DATA_DIR"] ?? join5(homedir5(), ".browser");
 }
 function getDownloadsDir(sessionId) {
-  const base = join4(getDataDir3(), "downloads");
-  const dir = sessionId ? join4(base, sessionId) : base;
-  mkdirSync4(dir, { recursive: true });
+  const base = join5(getDataDir3(), "downloads");
+  const dir = sessionId ? join5(base, sessionId) : base;
+  mkdirSync5(dir, { recursive: true });
   return dir;
 }
 function ensureDownloadsDir() {
@@ -15640,7 +16211,7 @@ function saveToDownloads(buffer, filename, opts) {
   const ext = extname(filename) || "";
   const stem = basename(filename, ext);
   const uniqueName = `${stem}-${id.slice(0, 8)}${ext}`;
-  const filePath = join4(dir, uniqueName);
+  const filePath = join5(dir, uniqueName);
   writeFileSync(filePath, buffer);
   const meta = {
     id,
@@ -15669,20 +16240,20 @@ function listDownloads(sessionId) {
   const dir = getDownloadsDir(sessionId);
   const results = [];
   function scanDir(d) {
-    if (!existsSync(d))
+    if (!existsSync2(d))
       return;
-    const entries = readdirSync(d);
+    const entries = readdirSync2(d);
     for (const entry of entries) {
       if (entry.endsWith(".meta.json"))
         continue;
-      const full = join4(d, entry);
+      const full = join5(d, entry);
       const stat = statSync(full);
       if (stat.isDirectory()) {
         scanDir(full);
         continue;
       }
       const mpath = metaPath(full);
-      if (!existsSync(mpath))
+      if (!existsSync2(mpath))
         continue;
       try {
         const meta = JSON.parse(readFileSync(mpath, "utf8"));
@@ -15712,9 +16283,9 @@ function deleteDownload(id, sessionId) {
   if (!file)
     return false;
   try {
-    unlinkSync(file.path);
-    if (existsSync(file.meta_path))
-      unlinkSync(file.meta_path);
+    unlinkSync2(file.path);
+    if (existsSync2(file.meta_path))
+      unlinkSync2(file.meta_path);
     return true;
   } catch {
     return false;
@@ -15764,9 +16335,9 @@ var exports_gallery_diff = {};
 __export(exports_gallery_diff, {
   diffImages: () => diffImages
 });
-import { join as join5 } from "path";
-import { mkdirSync as mkdirSync5 } from "fs";
-import { homedir as homedir5 } from "os";
+import { join as join6 } from "path";
+import { mkdirSync as mkdirSync6 } from "fs";
+import { homedir as homedir6 } from "os";
 async function diffImages(path1, path2) {
   const img1 = import_sharp2.default(path1);
   const img2 = import_sharp2.default(path2);
@@ -15797,10 +16368,10 @@ async function diffImages(path1, path2) {
       diffBuffer[i + 2] = Math.round(raw1[i + 2] * 0.4);
     }
   }
-  const dataDir = process.env["BROWSER_DATA_DIR"] ?? join5(homedir5(), ".browser");
-  const diffDir = join5(dataDir, "diffs");
-  mkdirSync5(diffDir, { recursive: true });
-  const diffPath = join5(diffDir, `diff-${Date.now()}.webp`);
+  const dataDir = process.env["BROWSER_DATA_DIR"] ?? join6(homedir6(), ".browser");
+  const diffDir = join6(dataDir, "diffs");
+  mkdirSync6(diffDir, { recursive: true });
+  const diffPath = join6(diffDir, `diff-${Date.now()}.webp`);
   const diffImageBuffer = await import_sharp2.default(diffBuffer, { raw: { width: w, height: h, channels } }).webp({ quality: 85 }).toBuffer();
   await Bun.write(diffPath, diffImageBuffer);
   return {
@@ -15817,9 +16388,9 @@ var init_gallery_diff = __esm(() => {
 });
 
 // src/lib/files-integration.ts
-import { join as join6 } from "path";
-import { mkdirSync as mkdirSync6, copyFileSync as copyFileSync2 } from "fs";
-import { homedir as homedir6 } from "os";
+import { join as join7 } from "path";
+import { mkdirSync as mkdirSync7, copyFileSync as copyFileSync2 } from "fs";
+import { homedir as homedir7 } from "os";
 async function persistFile(localPath, opts) {
   try {
     const mod = await import("@hasna/files");
@@ -15828,12 +16399,12 @@ async function persistFile(localPath, opts) {
       return { id: ref.id, path: ref.path ?? localPath, permanent: true, provider: "open-files" };
     }
   } catch {}
-  const dataDir = process.env["BROWSER_DATA_DIR"] ?? join6(homedir6(), ".browser");
+  const dataDir = process.env["BROWSER_DATA_DIR"] ?? join7(homedir7(), ".browser");
   const date = new Date().toISOString().split("T")[0];
-  const dir = join6(dataDir, "persistent", date);
-  mkdirSync6(dir, { recursive: true });
+  const dir = join7(dataDir, "persistent", date);
+  mkdirSync7(dir, { recursive: true });
   const filename = localPath.split("/").pop() ?? "file";
-  const targetPath = join6(dir, filename);
+  const targetPath = join7(dir, filename);
   copyFileSync2(localPath, targetPath);
   return {
     id: `local-${Date.now()}`,
@@ -15844,6 +16415,20 @@ async function persistFile(localPath, opts) {
 }
 var init_files_integration = () => {};
 
+// src/db/timeline.ts
+function logEvent(sessionId, eventType, details = {}) {
+  const db = getDatabase();
+  const id = crypto.randomUUID();
+  db.prepare("INSERT INTO session_events (id, session_id, event_type, details) VALUES (?, ?, ?, ?)").run(id, sessionId, eventType, JSON.stringify(details));
+}
+function getTimeline(sessionId, limit = 100) {
+  const db = getDatabase();
+  return db.query("SELECT * FROM session_events WHERE session_id = ? ORDER BY timestamp DESC LIMIT ?").all(sessionId, limit);
+}
+var init_timeline = __esm(() => {
+  init_schema();
+});
+
 // src/lib/tabs.ts
 async function newTab(page, url) {
   const context = page.context();
@@ -15934,23 +16519,23 @@ __export(exports_profiles, {
   deleteProfile: () => deleteProfile,
   applyProfile: () => applyProfile
 });
-import { mkdirSync as mkdirSync7, existsSync as existsSync3, readdirSync as readdirSync2, rmSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join7 } from "path";
-import { homedir as homedir7 } from "os";
+import { mkdirSync as mkdirSync8, existsSync as existsSync4, readdirSync as readdirSync3, rmSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir8 } from "os";
 function getProfilesDir() {
-  const dataDir = process.env["BROWSER_DATA_DIR"] ?? join7(homedir7(), ".browser");
-  const dir = join7(dataDir, "profiles");
-  mkdirSync7(dir, { recursive: true });
+  const dataDir = process.env["BROWSER_DATA_DIR"] ?? join8(homedir8(), ".browser");
+  const dir = join8(dataDir, "profiles");
+  mkdirSync8(dir, { recursive: true });
   return dir;
 }
 function getProfileDir2(name) {
-  return join7(getProfilesDir(), name);
+  return join8(getProfilesDir(), name);
 }
 async function saveProfile(page, name) {
   const dir = getProfileDir2(name);
-  mkdirSync7(dir, { recursive: true });
+  mkdirSync8(dir, { recursive: true });
   const cookies = await page.context().cookies();
-  writeFileSync2(join7(dir, "cookies.json"), JSON.stringify(cookies, null, 2));
+  writeFileSync2(join8(dir, "cookies.json"), JSON.stringify(cookies, null, 2));
   let localStorage2 = {};
   try {
     localStorage2 = await page.evaluate(() => {
@@ -15962,11 +16547,11 @@ async function saveProfile(page, name) {
       return result;
     });
   } catch {}
-  writeFileSync2(join7(dir, "storage.json"), JSON.stringify(localStorage2, null, 2));
+  writeFileSync2(join8(dir, "storage.json"), JSON.stringify(localStorage2, null, 2));
   const savedAt = new Date().toISOString();
   const url = page.url();
   const meta = { saved_at: savedAt, url };
-  writeFileSync2(join7(dir, "meta.json"), JSON.stringify(meta, null, 2));
+  writeFileSync2(join8(dir, "meta.json"), JSON.stringify(meta, null, 2));
   return {
     name,
     saved_at: savedAt,
@@ -15977,17 +16562,17 @@ async function saveProfile(page, name) {
 }
 function loadProfile(name) {
   const dir = getProfileDir2(name);
-  if (!existsSync3(dir)) {
+  if (!existsSync4(dir)) {
     throw new Error(`Profile not found: ${name}`);
   }
-  const cookiesPath = join7(dir, "cookies.json");
-  const storagePath = join7(dir, "storage.json");
-  const metaPath2 = join7(dir, "meta.json");
-  const cookies = existsSync3(cookiesPath) ? JSON.parse(readFileSync2(cookiesPath, "utf8")) : [];
-  const localStorage2 = existsSync3(storagePath) ? JSON.parse(readFileSync2(storagePath, "utf8")) : {};
+  const cookiesPath = join8(dir, "cookies.json");
+  const storagePath = join8(dir, "storage.json");
+  const metaPath2 = join8(dir, "meta.json");
+  const cookies = existsSync4(cookiesPath) ? JSON.parse(readFileSync2(cookiesPath, "utf8")) : [];
+  const localStorage2 = existsSync4(storagePath) ? JSON.parse(readFileSync2(storagePath, "utf8")) : {};
   let savedAt = new Date().toISOString();
   let url;
-  if (existsSync3(metaPath2)) {
+  if (existsSync4(metaPath2)) {
     const meta = JSON.parse(readFileSync2(metaPath2, "utf8"));
     savedAt = meta.saved_at ?? savedAt;
     url = meta.url;
@@ -16015,33 +16600,33 @@ async function applyProfile(page, profileData) {
 }
 function listProfiles() {
   const dir = getProfilesDir();
-  if (!existsSync3(dir))
+  if (!existsSync4(dir))
     return [];
-  const entries = readdirSync2(dir, { withFileTypes: true });
+  const entries = readdirSync3(dir, { withFileTypes: true });
   const profiles = [];
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
     const name = entry.name;
-    const profileDir = join7(dir, name);
+    const profileDir = join8(dir, name);
     let savedAt = "";
     let url;
     let cookieCount = 0;
     let storageKeyCount = 0;
     try {
-      const metaPath2 = join7(profileDir, "meta.json");
-      if (existsSync3(metaPath2)) {
+      const metaPath2 = join8(profileDir, "meta.json");
+      if (existsSync4(metaPath2)) {
         const meta = JSON.parse(readFileSync2(metaPath2, "utf8"));
         savedAt = meta.saved_at ?? "";
         url = meta.url;
       }
-      const cookiesPath = join7(profileDir, "cookies.json");
-      if (existsSync3(cookiesPath)) {
+      const cookiesPath = join8(profileDir, "cookies.json");
+      if (existsSync4(cookiesPath)) {
         const cookies = JSON.parse(readFileSync2(cookiesPath, "utf8"));
         cookieCount = Array.isArray(cookies) ? cookies.length : 0;
       }
-      const storagePath = join7(profileDir, "storage.json");
-      if (existsSync3(storagePath)) {
+      const storagePath = join8(profileDir, "storage.json");
+      if (existsSync4(storagePath)) {
         const storage = JSON.parse(readFileSync2(storagePath, "utf8"));
         storageKeyCount = Object.keys(storage).length;
       }
@@ -16058,7 +16643,7 @@ function listProfiles() {
 }
 function deleteProfile(name) {
   const dir = getProfileDir2(name);
-  if (!existsSync3(dir))
+  if (!existsSync4(dir))
     return false;
   try {
     rmSync(dir, { recursive: true, force: true });
@@ -16069,6 +16654,97 @@ function deleteProfile(name) {
 }
 var init_profiles = () => {};
 
+// src/lib/sanitize.ts
+var exports_sanitize = {};
+__export(exports_sanitize, {
+  sanitizeText: () => sanitizeText,
+  sanitizeHTML: () => sanitizeHTML
+});
+function sanitizeText(text) {
+  let stripped = 0;
+  const warnings = [];
+  let clean = text;
+  for (const pattern of INJECTION_PATTERNS) {
+    pattern.lastIndex = 0;
+    const matches = clean.match(pattern);
+    if (matches) {
+      stripped += matches.length;
+      warnings.push(`Stripped ${matches.length}x: ${pattern.source}`);
+      pattern.lastIndex = 0;
+      clean = clean.replace(pattern, "[STRIPPED]");
+    }
+  }
+  return { text: clean, stripped, warnings };
+}
+function sanitizeHTML(html) {
+  let stripped = 0;
+  const warnings = [];
+  let clean = html;
+  const commentMatches = clean.match(/<!--[\s\S]*?-->/g);
+  if (commentMatches) {
+    for (const comment of commentMatches) {
+      if (comment.replace(/<!--\s*-->/g, "").trim().length > 20) {
+        stripped++;
+        warnings.push(`Stripped HTML comment (${comment.length} chars)`);
+      }
+    }
+    clean = clean.replace(/<!--[\s\S]*?-->/g, "");
+  }
+  const hiddenPatterns = [
+    /style\s*=\s*"[^"]*display\s*:\s*none[^"]*"[^>]*>[\s\S]*?<\//gi,
+    /style\s*=\s*"[^"]*visibility\s*:\s*hidden[^"]*"[^>]*>[\s\S]*?<\//gi,
+    /style\s*=\s*"[^"]*opacity\s*:\s*0[^"]*"[^>]*>[\s\S]*?<\//gi,
+    /style\s*=\s*"[^"]*font-size\s*:\s*0[^"]*"[^>]*>[\s\S]*?<\//gi,
+    /style\s*=\s*"[^"]*position\s*:\s*absolute[^"]*left\s*:\s*-\d{4,}[^"]*"[^>]*>[\s\S]*?<\//gi
+  ];
+  for (const pattern of hiddenPatterns) {
+    pattern.lastIndex = 0;
+    const matches = clean.match(pattern);
+    if (matches) {
+      stripped += matches.length;
+      warnings.push(`Stripped ${matches.length} hidden elements`);
+      pattern.lastIndex = 0;
+      clean = clean.replace(pattern, "");
+    }
+  }
+  const ariaHiddenPattern = /aria-hidden\s*=\s*"true"[^>]*>[\s\S]*?<\//gi;
+  const ariaHidden = clean.match(ariaHiddenPattern);
+  if (ariaHidden) {
+    stripped += ariaHidden.length;
+    warnings.push(`Stripped ${ariaHidden.length} aria-hidden elements`);
+    ariaHiddenPattern.lastIndex = 0;
+    clean = clean.replace(ariaHiddenPattern, "");
+  }
+  const textResult = sanitizeText(clean);
+  return {
+    text: textResult.text,
+    stripped: stripped + textResult.stripped,
+    warnings: [...warnings, ...textResult.warnings]
+  };
+}
+var INJECTION_PATTERNS;
+var init_sanitize = __esm(() => {
+  INJECTION_PATTERNS = [
+    /ignore\s+(all\s+)?previous\s+instructions/gi,
+    /ignore\s+(all\s+)?prior\s+instructions/gi,
+    /disregard\s+(all\s+)?previous/gi,
+    /forget\s+(all\s+)?previous/gi,
+    /you\s+are\s+now\s+/gi,
+    /new\s+instructions?\s*:/gi,
+    /system\s+prompt\s*:/gi,
+    /\[INST\]/gi,
+    /\[\/INST\]/gi,
+    /<\|im_start\|>/gi,
+    /<\|im_end\|>/gi,
+    /<<SYS>>/gi,
+    /<<\/SYS>>/gi,
+    /IMPORTANT:\s*ignore/gi,
+    /CRITICAL:\s*override/gi,
+    /assistant:\s/gi,
+    /human:\s/gi
+  ];
+});
+
 // src/lib/annotate.ts
 var exports_annotate = {};
 __export(exports_annotate, {
@@ -16129,26 +16805,213 @@ var init_annotate = __esm(() => {
   import_sharp3 = __toESM(require_lib(), 1);
 });
 
+// src/lib/auth-flow.ts
+var exports_auth_flow = {};
+__export(exports_auth_flow, {
+  tryReplayAuth: () => tryReplayAuth,
+  touchAuthFlow: () => touchAuthFlow,
+  saveAuthFlow: () => saveAuthFlow,
+  listAuthFlows: () => listAuthFlows,
+  isAuthRedirect: () => isAuthRedirect,
+  isAuthPage: () => isAuthPage,
+  getAuthFlowByName: () => getAuthFlowByName,
+  getAuthFlowByDomain: () => getAuthFlowByDomain,
+  getAuthFlow: () => getAuthFlow,
+  deleteAuthFlow: () => deleteAuthFlow
+});
+import { randomUUID as randomUUID10 } from "crypto";
+function saveAuthFlow(data) {
+  const db = getDatabase();
+  const id = randomUUID10();
+  db.prepare("INSERT OR REPLACE INTO auth_flows (id, name, domain, recording_id, storage_state_path) VALUES (?, ?, ?, ?, ?)").run(id, data.name, data.domain, data.recordingId ?? null, data.storageStatePath ?? null);
+  return getAuthFlow(id);
+}
+function getAuthFlow(id) {
+  const db = getDatabase();
+  return db.query("SELECT * FROM auth_flows WHERE id = ?").get(id) ?? null;
+}
+function getAuthFlowByName(name) {
+  const db = getDatabase();
+  return db.query("SELECT * FROM auth_flows WHERE name = ?").get(name) ?? null;
+}
+function getAuthFlowByDomain(domain) {
+  const db = getDatabase();
+  return db.query("SELECT * FROM auth_flows WHERE domain = ? ORDER BY last_used DESC LIMIT 1").get(domain) ?? null;
+}
+function listAuthFlows() {
+  const db = getDatabase();
+  return db.query("SELECT * FROM auth_flows ORDER BY last_used DESC, created_at DESC").all();
+}
+function deleteAuthFlow(name) {
+  const db = getDatabase();
+  const result = db.prepare("DELETE FROM auth_flows WHERE name = ?").run(name);
+  return result.changes > 0;
+}
+function touchAuthFlow(id) {
+  const db = getDatabase();
+  db.prepare("UPDATE auth_flows SET last_used = datetime('now') WHERE id = ?").run(id);
+}
+function isAuthPage(url) {
+  return AUTH_URL_PATTERNS.some((pattern) => pattern.test(url));
+}
+function isAuthRedirect(fromUrl, toUrl) {
+  if (fromUrl === toUrl)
+    return false;
+  return isAuthPage(toUrl) && !isAuthPage(fromUrl);
+}
+async function tryReplayAuth(page, domain) {
+  const flow = getAuthFlowByDomain(domain);
+  if (!flow)
+    return { replayed: false };
+  if (flow.storage_state_path) {
+    try {
+      const { existsSync: existsSync5, readFileSync: readFileSync3 } = await import("fs");
+      if (existsSync5(flow.storage_state_path)) {
+        const state = JSON.parse(readFileSync3(flow.storage_state_path, "utf8"));
+        if (state.cookies?.length) {
+          await page.context().addCookies(state.cookies);
+          await page.reload();
+          await new Promise((r) => setTimeout(r, 1000));
+          if (!isAuthPage(page.url())) {
+            touchAuthFlow(flow.id);
+            return { replayed: true, flow, method: "storage_state" };
+          }
+        }
+      }
+    } catch {}
+  }
+  if (flow.recording_id) {
+    try {
+      const { replayRecording: replayRecording2 } = await Promise.resolve().then(() => (init_recorder(), exports_recorder));
+      const result = await replayRecording2(flow.recording_id, page);
+      if (result.success) {
+        try {
+          const { saveStateFromPage: saveStateFromPage2 } = await Promise.resolve().then(() => (init_storage_state(), exports_storage_state));
+          const path = await saveStateFromPage2(page, flow.name);
+          const db = getDatabase();
+          db.prepare("UPDATE auth_flows SET storage_state_path = ?, last_used = datetime('now') WHERE id = ?").run(path, flow.id);
+        } catch {}
+        touchAuthFlow(flow.id);
+        return { replayed: true, flow, method: "recording_replay" };
+      }
+    } catch {}
+  }
+  return { replayed: false, flow };
+}
+var AUTH_URL_PATTERNS;
+var init_auth_flow = __esm(() => {
+  init_schema();
+  AUTH_URL_PATTERNS = [
+    /\/login/i,
+    /\/signin/i,
+    /\/sign-in/i,
+    /\/auth/i,
+    /\/sso/i,
+    /\/oauth/i,
+    /\/cas\/login/i,
+    /accounts\.google\.com/i,
+    /login\.microsoftonline\.com/i,
+    /github\.com\/login/i,
+    /auth0\.com/i
+  ];
+});
+
+// src/lib/vision-fallback.ts
+var exports_vision_fallback = {};
+__export(exports_vision_fallback, {
+  findElementByVision: () => findElementByVision,
+  clickByVision: () => clickByVision
+});
+async function findElementByVision(page, description, opts) {
+  const model = opts?.model ?? process.env["BROWSER_VISION_MODEL"] ?? DEFAULT_MODEL;
+  const screenshot = await page.screenshot({ type: "jpeg", quality: 80 });
+  const base64 = screenshot.toString("base64");
+  const viewport = page.viewportSize() ?? { width: 1280, height: 720 };
+  const apiKey = process.env["ANTHROPIC_API_KEY"];
+  if (!apiKey) {
+    return { found: false, x: 0, y: 0, confidence: "none", description, model, error: "ANTHROPIC_API_KEY not set" };
+  }
+  try {
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model,
+        max_tokens: 256,
+        messages: [{
+          role: "user",
+          content: [
+            {
+              type: "image",
+              source: { type: "base64", media_type: "image/jpeg", data: base64 }
+            },
+            {
+              type: "text",
+              text: `Find the element matching this description: "${description}"
+
+The screenshot is ${viewport.width}x${viewport.height} pixels.
+
+Reply with ONLY a JSON object (no markdown, no explanation):
+{"found": true, "x": <pixel_x>, "y": <pixel_y>, "confidence": "high|medium|low", "description": "<what you found>"}
+
+If you cannot find the element:
+{"found": false, "x": 0, "y": 0, "confidence": "none", "description": "not found"}`
+            }
+          ]
+        }]
+      })
+    });
+    const data = await response.json();
+    const text = data.content?.[0]?.text ?? "";
+    const jsonStr = text.replace(/```json?\n?/g, "").replace(/```/g, "").trim();
+    const result = JSON.parse(jsonStr);
+    result.model = model;
+    return result;
+  } catch (err) {
+    return {
+      found: false,
+      x: 0,
+      y: 0,
+      confidence: "none",
+      description,
+      model,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function clickByVision(page, description, opts) {
+  const result = await findElementByVision(page, description, opts);
+  if (result.found && result.x > 0 && result.y > 0) {
+    await page.mouse.click(result.x, result.y);
+  }
+  return result;
+}
+var DEFAULT_MODEL = "claude-sonnet-4-5-20250929";
+
 // src/lib/auth.ts
 var exports_auth = {};
 __export(exports_auth, {
   loginWithCredentials: () => loginWithCredentials,
   getCredentials: () => getCredentials
 });
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { join as join8 } from "path";
-import { homedir as homedir8 } from "os";
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
+import { join as join9 } from "path";
+import { homedir as homedir9 } from "os";
 async function getCredentials(service) {
   try {
-    const { getSecret } = await import(`${homedir8()}/Workspace/hasna/opensource/opensourcedev/open-secrets/src/store.js`);
+    const { getSecret } = await import(`${homedir9()}/Workspace/hasna/opensource/opensourcedev/open-secrets/src/store.js`);
     const email = getSecret(`${service}_email`) ?? getSecret(`${service}_username`) ?? getSecret(`${service}_login`);
     const password = getSecret(`${service}_password`) ?? getSecret(`${service}_pass`);
     if (email?.value && password?.value) {
       return { email: email.value, password: password.value };
     }
   } catch {}
-  const secretsPath = join8(homedir8(), ".secrets");
-  if (existsSync4(secretsPath)) {
+  const secretsPath = join9(homedir9(), ".secrets");
+  if (existsSync5(secretsPath)) {
     const content = readFileSync3(secretsPath, "utf8");
     const lines = content.split(`
 `);
@@ -16235,6 +17098,7 @@ __export(exports_dist, {
   shortUuid: () => shortUuid,
   setFocus: () => setFocus,
   setActiveProfile: () => setActiveProfile,
+  setActiveModel: () => setActiveModel,
   searchMemories: () => searchMemories,
   runCleanup: () => runCleanup,
   resolveProjectId: () => resolveProjectId,
@@ -16285,6 +17149,8 @@ __export(exports_dist, {
   getAutoMemoryStats: () => getAutoMemoryStats,
   getAgent: () => getAgent2,
   getActiveProfile: () => getActiveProfile,
+  getActiveModel: () => getActiveModel,
+  gatherTrainingData: () => gatherTrainingData,
   focusFilterSQL: () => focusFilterSQL,
   findPath: () => findPath,
   enforceQuotas: () => enforceQuotas,
@@ -16301,6 +17167,7 @@ __export(exports_dist, {
   containsSecrets: () => containsSecrets,
   configureAutoMemory: () => configureAutoMemory,
   closeDatabase: () => closeDatabase,
+  clearActiveModel: () => clearActiveModel,
   cleanExpiredMemories: () => cleanExpiredMemories,
   cleanExpiredLocks: () => cleanExpiredLocks,
   checkMemoryWriteLock: () => checkMemoryWriteLock,
@@ -16321,25 +17188,29 @@ __export(exports_dist, {
   InvalidScopeError: () => InvalidScopeError,
   EntityNotFoundError: () => EntityNotFoundError,
   DuplicateMemoryError: () => DuplicateMemoryError,
+  DEFAULT_MODEL: () => DEFAULT_MODEL2,
   DEFAULT_CONFIG: () => DEFAULT_CONFIG
 });
 import { Database as Database2 } from "bun:sqlite";
-import { existsSync as existsSync5, mkdirSync as mkdirSync8 } from "fs";
-import { dirname, join as join9, resolve } from "path";
-import { existsSync as existsSync22, mkdirSync as mkdirSync22, readFileSync as readFileSync4, readdirSync as readdirSync3, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2 } from "fs";
-import { homedir as homedir9 } from "os";
+import { existsSync as existsSync6, mkdirSync as mkdirSync9 } from "fs";
+import { dirname, join as join10, resolve } from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync22, readFileSync as readFileSync4, readdirSync as readdirSync4, writeFileSync as writeFileSync3, unlinkSync as unlinkSync3 } from "fs";
+import { homedir as homedir10 } from "os";
 import { basename as basename2, dirname as dirname2, join as join22, resolve as resolve2 } from "path";
 import { existsSync as existsSync32, mkdirSync as mkdirSync32, readFileSync as readFileSync22, writeFileSync as writeFileSync22 } from "fs";
 import { homedir as homedir22 } from "os";
 import { join as join32 } from "path";
+import { existsSync as existsSync42, mkdirSync as mkdirSync42, readFileSync as readFileSync32, writeFileSync as writeFileSync32 } from "fs";
+import { homedir as homedir32 } from "os";
+import { join as join42 } from "path";
 function isInMemoryDb(path) {
   return path === ":memory:" || path.startsWith("file::memory:");
 }
 function findNearestMementosDb(startDir) {
   let dir = resolve(startDir);
   while (true) {
-    const candidate = join9(dir, ".mementos", "mementos.db");
-    if (existsSync5(candidate))
+    const candidate = join10(dir, ".mementos", "mementos.db");
+    if (existsSync6(candidate))
       return candidate;
     const parent = dirname(dir);
     if (parent === dir)
@@ -16351,7 +17222,7 @@ function findNearestMementosDb(startDir) {
 function findGitRoot(startDir) {
   let dir = resolve(startDir);
   while (true) {
-    if (existsSync5(join9(dir, ".git")))
+    if (existsSync6(join10(dir, ".git")))
       return dir;
     const parent = dirname(dir);
     if (parent === dir)
@@ -16371,25 +17242,25 @@ function getDbPath() {
   if (process.env["MEMENTOS_DB_SCOPE"] === "project") {
     const gitRoot = findGitRoot(cwd);
     if (gitRoot) {
-      return join9(gitRoot, ".mementos", "mementos.db");
+      return join10(gitRoot, ".mementos", "mementos.db");
     }
   }
   const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
-  return join9(home, ".mementos", "mementos.db");
+  return join10(home, ".mementos", "mementos.db");
 }
-function ensureDir(filePath) {
+function ensureDir2(filePath) {
   if (isInMemoryDb(filePath))
     return;
   const dir = dirname(resolve(filePath));
-  if (!existsSync5(dir)) {
-    mkdirSync8(dir, { recursive: true });
+  if (!existsSync6(dir)) {
+    mkdirSync9(dir, { recursive: true });
   }
 }
 function getDatabase2(dbPath) {
   if (_db2)
     return _db2;
   const path = dbPath || getDbPath();
-  ensureDir(path);
+  ensureDir2(path);
   _db2 = new Database2(path, { create: true });
   _db2.run("PRAGMA journal_mode = WAL");
   _db2.run("PRAGMA busy_timeout = 5000");
@@ -18232,7 +19103,7 @@ function isValidCategory(value) {
   return VALID_CATEGORIES.includes(value);
 }
 function loadConfig() {
-  const configPath = join22(homedir9(), ".mementos", "config.json");
+  const configPath = join22(homedir10(), ".mementos", "config.json");
   let fileConfig = {};
   if (existsSync22(configPath)) {
     try {
@@ -18259,10 +19130,10 @@ function loadConfig() {
   return merged;
 }
 function profilesDir() {
-  return join22(homedir9(), ".mementos", "profiles");
+  return join22(homedir10(), ".mementos", "profiles");
 }
 function globalConfigPath() {
-  return join22(homedir9(), ".mementos", "config.json");
+  return join22(homedir10(), ".mementos", "config.json");
 }
 function readGlobalConfig() {
   const p = globalConfigPath();
@@ -18276,7 +19147,7 @@ function readGlobalConfig() {
 }
 function writeGlobalConfig(data) {
   const p = globalConfigPath();
-  ensureDir2(dirname2(p));
+  ensureDir22(dirname2(p));
   writeFileSync3(p, JSON.stringify(data, null, 2), "utf-8");
 }
 function getActiveProfile() {
@@ -18299,18 +19170,18 @@ function listProfiles2() {
   const dir = profilesDir();
   if (!existsSync22(dir))
     return [];
-  return readdirSync3(dir).filter((f) => f.endsWith(".db")).map((f) => basename2(f, ".db")).sort();
+  return readdirSync4(dir).filter((f) => f.endsWith(".db")).map((f) => basename2(f, ".db")).sort();
 }
 function deleteProfile2(name) {
   const dbPath = join22(profilesDir(), `${name}.db`);
   if (!existsSync22(dbPath))
     return false;
-  unlinkSync2(dbPath);
+  unlinkSync3(dbPath);
   if (getActiveProfile() === name)
     setActiveProfile(null);
   return true;
 }
-function ensureDir2(dir) {
+function ensureDir22(dir) {
   if (!existsSync22(dir)) {
     mkdirSync22(dir, { recursive: true });
   }
@@ -19365,6 +20236,85 @@ function jaccardSimilarity(a, b) {
   const union = new Set([...a, ...b]).size;
   return intersection / union;
 }
+function memoryToRecallExample(memory) {
+  return {
+    messages: [
+      { role: "system", content: SYSTEM_PROMPT },
+      {
+        role: "user",
+        content: `What do you remember about "${memory.key}"?`
+      },
+      {
+        role: "assistant",
+        content: memory.summary ? `${memory.value}
+
+Summary: ${memory.summary}` : memory.value
+      }
+    ]
+  };
+}
+function memoryToSaveExample(memory) {
+  const tags = memory.tags ?? [];
+  return {
+    messages: [
+      { role: "system", content: SYSTEM_PROMPT },
+      {
+        role: "user",
+        content: `Remember this for me: ${memory.key} = ${memory.value}${tags.length ? ` (tags: ${tags.join(", ")})` : ""}`
+      },
+      {
+        role: "assistant",
+        content: `Saved to memory: "${memory.key}" with ${memory.category} category, importance ${memory.importance}/10, scope: ${memory.scope}.`
+      }
+    ]
+  };
+}
+function memoryToSearchExample(memories, category) {
+  const matched = memories.filter((m) => m.category === category && m.status === "active").slice(0, 5);
+  return {
+    messages: [
+      { role: "system", content: SYSTEM_PROMPT },
+      { role: "user", content: `What ${category} memories do you have?` },
+      {
+        role: "assistant",
+        content: matched.length > 0 ? `Here are my ${category} memories:
+${matched.map((m) => `- ${m.key}: ${m.value.slice(0, 120)}${m.value.length > 120 ? "..." : ""}`).join(`
+`)}` : `I don't have any ${category} memories stored yet.`
+      }
+    ]
+  };
+}
+function readConfig() {
+  if (!existsSync42(CONFIG_PATH))
+    return {};
+  try {
+    const raw = readFileSync32(CONFIG_PATH, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function writeConfig(config) {
+  if (!existsSync42(CONFIG_DIR)) {
+    mkdirSync42(CONFIG_DIR, { recursive: true });
+  }
+  writeFileSync32(CONFIG_PATH, JSON.stringify(config, null, 2) + `
+`, "utf-8");
+}
+function getActiveModel() {
+  const config = readConfig();
+  return config.activeModel ?? DEFAULT_MODEL2;
+}
+function setActiveModel(modelId) {
+  const config = readConfig();
+  config.activeModel = modelId;
+  writeConfig(config);
+}
+function clearActiveModel() {
+  const config = readConfig();
+  delete config.activeModel;
+  writeConfig(config);
+}
 var __defProp2, __export2 = (target, all) => {
   for (var name in all)
     __defProp2(target, name, {
@@ -19407,7 +20357,27 @@ Return JSON with this exact shape:
   "relations": [
     { "from": string, "to": string, "type": "uses"|"knows"|"depends_on"|"created_by"|"related_to"|"contradicts"|"part_of"|"implements"|"happened_before"|"happened_after"|"caused_by"|"resulted_in"|"supersedes"|"version_of" }
   ]
-}`, ANTHROPIC_MODELS, AnthropicProvider, OpenAICompatProvider, OPENAI_MODELS, OpenAIProvider, CEREBRAS_MODELS, CerebrasProvider, GROK_MODELS, GrokProvider, providerRegistry, MAX_QUEUE_SIZE = 100, CONCURRENCY = 3, autoMemoryQueue, DEDUP_SIMILARITY_THRESHOLD = 0.85, DEFAULT_CONFIG2, _stats;
+}`, ANTHROPIC_MODELS, AnthropicProvider, OpenAICompatProvider, OPENAI_MODELS, OpenAIProvider, CEREBRAS_MODELS, CerebrasProvider, GROK_MODELS, GrokProvider, providerRegistry, MAX_QUEUE_SIZE = 100, CONCURRENCY = 3, autoMemoryQueue, DEDUP_SIMILARITY_THRESHOLD = 0.85, DEFAULT_CONFIG2, _stats, SYSTEM_PROMPT = "You are an AI assistant with persistent memory that recalls and saves information across sessions.", gatherTrainingData = async (options = {}) => {
+  const allMemories = listMemories({ status: "active" });
+  const filtered = options.since ? allMemories.filter((m) => new Date(m.created_at) >= options.since) : allMemories;
+  const sorted = filtered.slice().sort((a, b) => b.importance - a.importance);
+  const fetchSet = options.limit ? sorted.slice(0, options.limit * 3) : sorted;
+  const examples = [];
+  for (const memory of fetchSet) {
+    examples.push(memoryToRecallExample(memory));
+    examples.push(memoryToSaveExample(memory));
+  }
+  const categories = [...new Set(fetchSet.map((m) => m.category))];
+  for (const category of categories) {
+    examples.push(memoryToSearchExample(fetchSet, category));
+  }
+  const finalExamples = options.limit ? examples.slice(0, options.limit) : examples;
+  return {
+    source: "mementos",
+    examples: finalExamples,
+    count: finalExamples.length
+  };
+}, DEFAULT_MODEL2 = "gpt-4o-mini", CONFIG_DIR, CONFIG_PATH;
 var init_dist = __esm(() => {
   __defProp2 = Object.defineProperty;
   exports_database = {};
@@ -20687,6 +21657,8 @@ Return only a number 0-10.`);
     keepLonger: true
   };
   _stats = { checked: 0, skipped: 0, updated: 0 };
+  CONFIG_DIR = join42(homedir32(), ".mementos");
+  CONFIG_PATH = join42(CONFIG_DIR, "config.json");
 });
 
 // src/lib/page-memory.ts
@@ -20841,30 +21813,30 @@ __export(exports_dist2, {
   acquireLock: () => acquireLock2
 });
 import { Database as Database3 } from "bun:sqlite";
-import { mkdirSync as mkdirSync9 } from "fs";
-import { join as join10, dirname as dirname3 } from "path";
-import { homedir as homedir10 } from "os";
-import { randomUUID as randomUUID10 } from "crypto";
+import { mkdirSync as mkdirSync10 } from "fs";
+import { join as join11, dirname as dirname3 } from "path";
+import { homedir as homedir11 } from "os";
+import { randomUUID as randomUUID11 } from "crypto";
 import { mkdirSync as mkdirSync23, copyFileSync as copyFileSync3, statSync as statSync2 } from "fs";
 import { join as join33 } from "path";
-import { homedir as homedir32 } from "os";
+import { homedir as homedir33 } from "os";
 import { readFileSync as readFileSync5 } from "fs";
 import { join as join23 } from "path";
 import { homedir as homedir23 } from "os";
 import { randomUUID as randomUUID22 } from "crypto";
 import { readFileSync as readFileSync23, writeFileSync as writeFileSync4, mkdirSync as mkdirSync33 } from "fs";
-import { join as join42, dirname as dirname22 } from "path";
+import { join as join43, dirname as dirname22 } from "path";
 import { homedir as homedir42 } from "os";
 function getDbPath2() {
   if (process.env.CONVERSATIONS_DB_PATH)
     return process.env.CONVERSATIONS_DB_PATH;
-  return join10(homedir10(), ".conversations", "messages.db");
+  return join11(homedir11(), ".conversations", "messages.db");
 }
 function getDb() {
   if (db)
     return db;
   const dbPath = getDbPath2();
-  mkdirSync9(dirname3(dbPath), { recursive: true });
+  mkdirSync10(dirname3(dbPath), { recursive: true });
   db = new Database3(dbPath, { create: true });
   db.exec("PRAGMA journal_mode = WAL");
   db.exec("PRAGMA busy_timeout = 5000");
@@ -21192,7 +22164,7 @@ function parseMessage(row) {
 function getAttachmentsDir() {
   if (process.env.CONVERSATIONS_ATTACHMENTS_DIR)
     return process.env.CONVERSATIONS_ATTACHMENTS_DIR;
-  return join33(homedir32(), ".conversations", "attachments");
+  return join33(homedir33(), ".conversations", "attachments");
 }
 function guessMimeType(name) {
   const ext = name.split(".").pop()?.toLowerCase();
@@ -21224,7 +22196,7 @@ function guessMimeType(name) {
 function sendMessage(opts) {
   const db2 = getDb();
   const explicitSession = opts.session_id && opts.session_id.trim().length > 0 ? opts.session_id : undefined;
-  const sessionId = explicitSession ?? (opts.space ? `space:${opts.space}` : `${[opts.from, opts.to].sort().join("-")}-${randomUUID10().slice(0, 8)}`);
+  const sessionId = explicitSession ?? (opts.space ? `space:${opts.space}` : `${[opts.from, opts.to].sort().join("-")}-${randomUUID11().slice(0, 8)}`);
   const metadata = opts.metadata ? JSON.stringify(opts.metadata) : null;
   const normalizedPriority = opts.priority === "low" || opts.priority === "normal" || opts.priority === "high" || opts.priority === "urgent" ? opts.priority : "normal";
   const blocking = opts.blocking ? 1 : 0;
@@ -24863,7 +25835,7 @@ Check the top-level render call using <` + parentName + ">.";
     "zinc-eagle",
     "zone-fox"
   ];
-  AGENT_ID_FILE = join42(homedir42(), ".conversations", "agent-id");
+  AGENT_ID_FILE = join43(homedir42(), ".conversations", "agent-id");
   init_db();
   init_db();
   CONFLICT_THRESHOLD_SECONDS = 30 * 60;
@@ -25205,7 +26177,7 @@ __export(exports_dist3, {
   deleteTemplate: () => deleteTemplate,
   deleteTaskList: () => deleteTaskList,
   deleteTask: () => deleteTask,
-  deleteSession: () => deleteSession,
+  deleteSession: () => deleteSession2,
   deleteProject: () => deleteProject2,
   deletePlan: () => deletePlan,
   deleteOrg: () => deleteOrg,
@@ -25266,17 +26238,17 @@ __export(exports_dist3, {
   AgentNotFoundError: () => AgentNotFoundError2
 });
 import { Database as Database4 } from "bun:sqlite";
-import { existsSync as existsSync6, mkdirSync as mkdirSync10 } from "fs";
-import { dirname as dirname5, join as join11, resolve as resolve3 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync11 } from "fs";
+import { dirname as dirname5, join as join12, resolve as resolve3 } from "path";
 import { existsSync as existsSync33 } from "fs";
 import { join as join34 } from "path";
-import { existsSync as existsSync23, mkdirSync as mkdirSync24, readFileSync as readFileSync6, readdirSync as readdirSync4, statSync as statSync3, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync23, mkdirSync as mkdirSync24, readFileSync as readFileSync6, readdirSync as readdirSync5, statSync as statSync3, writeFileSync as writeFileSync5 } from "fs";
 import { join as join24 } from "path";
-import { existsSync as existsSync42, readFileSync as readFileSync24, readdirSync as readdirSync22, writeFileSync as writeFileSync23 } from "fs";
-import { join as join43 } from "path";
+import { existsSync as existsSync43, readFileSync as readFileSync24, readdirSync as readdirSync22, writeFileSync as writeFileSync23 } from "fs";
+import { join as join44 } from "path";
 import { existsSync as existsSync52 } from "fs";
 import { join as join52 } from "path";
-import { readFileSync as readFileSync32, statSync as statSync22 } from "fs";
+import { readFileSync as readFileSync33, statSync as statSync22 } from "fs";
 import { relative, resolve as resolve22, join as join62 } from "path";
 import { execSync as execSync2 } from "child_process";
 
@@ -25500,8 +26472,8 @@ function isInMemoryDb2(path) {
 function findNearestTodosDb(startDir) {
   let dir = resolve3(startDir);
   while (true) {
-    const candidate = join11(dir, ".todos", "todos.db");
-    if (existsSync6(candidate))
+    const candidate = join12(dir, ".todos", "todos.db");
+    if (existsSync7(candidate))
       return candidate;
     const parent = dirname5(dir);
     if (parent === dir)
@@ -25513,7 +26485,7 @@ function findNearestTodosDb(startDir) {
 function findGitRoot2(startDir) {
   let dir = resolve3(startDir);
   while (true) {
-    if (existsSync6(join11(dir, ".git")))
+    if (existsSync7(join12(dir, ".git")))
       return dir;
     const parent = dirname5(dir);
     if (parent === dir)
@@ -25533,18 +26505,18 @@ function getDbPath3() {
   if (process.env["TODOS_DB_SCOPE"] === "project") {
     const gitRoot = findGitRoot2(cwd);
     if (gitRoot) {
-      return join11(gitRoot, ".todos", "todos.db");
+      return join12(gitRoot, ".todos", "todos.db");
     }
   }
   const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
-  return join11(home, ".todos", "todos.db");
+  return join12(home, ".todos", "todos.db");
 }
 function ensureDir3(filePath) {
   if (isInMemoryDb2(filePath))
     return;
   const dir = dirname5(resolve3(filePath));
-  if (!existsSync6(dir)) {
-    mkdirSync10(dir, { recursive: true });
+  if (!existsSync7(dir)) {
+    mkdirSync11(dir, { recursive: true });
   }
 }
 function getDatabase3(dbPath) {
@@ -26003,14 +26975,14 @@ function ensureProject2(name, path, db2) {
   }
   return createProject3({ name, path }, d);
 }
-function ensureDir22(dir) {
+function ensureDir23(dir) {
   if (!existsSync23(dir))
     mkdirSync24(dir, { recursive: true });
 }
 function listJsonFiles(dir) {
   if (!existsSync23(dir))
     return [];
-  return readdirSync4(dir).filter((f) => f.endsWith(".json"));
+  return readdirSync5(dir).filter((f) => f.endsWith(".json"));
 }
 function readJsonFile(path) {
   try {
@@ -27634,11 +28606,11 @@ function autoReleaseStaleAgents(db2) {
   const result = d.run("UPDATE agents SET session_id = NULL WHERE status = 'active' AND session_id IS NOT NULL AND last_seen_at < ?", [cutoff]);
   return result.changes;
 }
-function getAvailableNamesFromPool(pool, db2) {
+function getAvailableNamesFromPool(pool2, db2) {
   autoReleaseStaleAgents(db2);
   const cutoff = new Date(Date.now() - getActiveWindowMs()).toISOString();
   const activeNames = new Set(db2.query("SELECT name FROM agents WHERE status = 'active' AND last_seen_at > ?").all(cutoff).map((r) => r.name.toLowerCase()));
-  return pool.filter((name) => !activeNames.has(name.toLowerCase()));
+  return pool2.filter((name) => !activeNames.has(name.toLowerCase()));
 }
 function shortUuid2() {
   return crypto.randomUUID().slice(0, 8);
@@ -27715,9 +28687,9 @@ function registerAgent5(input, db2) {
 function isAgentConflict2(result) {
   return result.conflict === true;
 }
-function buildConflictError(existing, lastSeenMs, pool, d) {
+function buildConflictError(existing, lastSeenMs, pool2, d) {
   const minutesAgo = Math.round((Date.now() - lastSeenMs) / 60000);
-  const suggestions = pool ? getAvailableNamesFromPool(pool, d) : [];
+  const suggestions = pool2 ? getAvailableNamesFromPool(pool2, d) : [];
   return {
     conflict: true,
     existing_id: existing.id,
@@ -28003,7 +28975,7 @@ function updateSessionActivity(id, db2) {
   const d = db2 || getDatabase3();
   d.run("UPDATE sessions SET last_activity = ? WHERE id = ?", [now2(), id]);
 }
-function deleteSession(id, db2) {
+function deleteSession2(id, db2) {
   const d = db2 || getDatabase3();
   const result = d.run("DELETE FROM sessions WHERE id = ?", [id]);
   return result.changes > 0;
@@ -28822,13 +29794,13 @@ function searchTasks(options, projectId, taskListId, db2) {
   return rows.map(rowToTask3);
 }
 function getTaskListDir(taskListId) {
-  return join43(HOME, ".claude", "tasks", taskListId);
+  return join44(HOME, ".claude", "tasks", taskListId);
 }
 function readClaudeTask(dir, filename) {
-  return readJsonFile(join43(dir, filename));
+  return readJsonFile(join44(dir, filename));
 }
 function writeClaudeTask(dir, task) {
-  writeJsonFile(join43(dir, `${task.id}.json`), task);
+  writeJsonFile(join44(dir, `${task.id}.json`), task);
 }
 function toClaudeStatus(status) {
   if (status === "pending" || status === "in_progress" || status === "completed") {
@@ -28840,14 +29812,14 @@ function toSqliteStatus(status) {
   return status;
 }
 function readPrefixCounter(dir) {
-  const path = join43(dir, ".prefix-counter");
-  if (!existsSync42(path))
+  const path = join44(dir, ".prefix-counter");
+  if (!existsSync43(path))
     return 0;
   const val = parseInt(readFileSync24(path, "utf-8").trim(), 10);
   return isNaN(val) ? 0 : val;
 }
 function writePrefixCounter(dir, value) {
-  writeFileSync23(join43(dir, ".prefix-counter"), String(value));
+  writeFileSync23(join44(dir, ".prefix-counter"), String(value));
 }
 function formatPrefixedSubject(title, prefix, counter) {
   const padded = String(counter).padStart(5, "0");
@@ -28874,8 +29846,8 @@ function taskToClaudeTask(task, claudeTaskId, existingMeta) {
 }
 function pushToClaudeTaskList(taskListId, projectId, options = {}) {
   const dir = getTaskListDir(taskListId);
-  if (!existsSync42(dir))
-    ensureDir22(dir);
+  if (!existsSync43(dir))
+    ensureDir23(dir);
   const filter = {};
   if (projectId)
     filter["project_id"] = projectId;
@@ -28883,7 +29855,7 @@ function pushToClaudeTaskList(taskListId, projectId, options = {}) {
   const existingByTodosId = new Map;
   const files = listJsonFiles(dir);
   for (const f of files) {
-    const path = join43(dir, f);
+    const path = join44(dir, f);
     const ct = readClaudeTask(dir, f);
     if (ct?.metadata?.["todos_id"]) {
       existingByTodosId.set(ct.metadata["todos_id"], { task: ct, mtimeMs: getFileMtimeMs(path) });
@@ -28970,7 +29942,7 @@ function pushToClaudeTaskList(taskListId, projectId, options = {}) {
 }
 function pullFromClaudeTaskList(taskListId, projectId, options = {}) {
   const dir = getTaskListDir(taskListId);
-  if (!existsSync42(dir)) {
+  if (!existsSync43(dir)) {
     return { pushed: 0, pulled: 0, errors: [`Task list directory not found: ${dir}`] };
   }
   const files = readdirSync22(dir).filter((f) => f.endsWith(".json"));
@@ -28990,7 +29962,7 @@ function pullFromClaudeTaskList(taskListId, projectId, options = {}) {
   }
   for (const f of files) {
     try {
-      const filePath = join43(dir, f);
+      const filePath = join44(dir, f);
       const ct = readClaudeTask(dir, f);
       if (!ct)
         continue;
@@ -29093,7 +30065,7 @@ function metadataKey(agent) {
 function pushToAgentTaskList(agent, taskListId, projectId, options = {}) {
   const dir = getTaskListDir2(agent, taskListId);
   if (!existsSync52(dir))
-    ensureDir22(dir);
+    ensureDir23(dir);
   const filter = {};
   if (projectId)
     filter["project_id"] = projectId;
@@ -29401,7 +30373,7 @@ function extractTodos(options, db2) {
   for (const file of files) {
     const fullPath = statSync22(basePath).isFile() ? basePath : join62(basePath, file);
     try {
-      const source = readFileSync32(fullPath, "utf-8");
+      const source = readFileSync33(fullPath, "utf-8");
       const relPath = statSync22(basePath).isFile() ? relative(resolve22(basePath, ".."), fullPath) : file;
       const comments = extractFromSource(source, relPath, tags);
       allComments.push(...comments);
@@ -30621,13 +31593,13 @@ __export(exports_dist4, {
   CATEGORIES: () => CATEGORIES,
   AGENT_TARGETS: () => AGENT_TARGETS
 });
-import { existsSync as existsSync7, cpSync, mkdirSync as mkdirSync11, writeFileSync as writeFileSync6, rmSync as rmSync2, readdirSync as readdirSync5, statSync as statSync4, readFileSync as readFileSync7, accessSync, constants } from "fs";
-import { join as join12, dirname as dirname6 } from "path";
-import { homedir as homedir11 } from "os";
+import { existsSync as existsSync8, cpSync, mkdirSync as mkdirSync12, writeFileSync as writeFileSync6, rmSync as rmSync2, readdirSync as readdirSync6, statSync as statSync4, readFileSync as readFileSync7, accessSync, constants } from "fs";
+import { join as join13, dirname as dirname6 } from "path";
+import { homedir as homedir12 } from "os";
 import { fileURLToPath } from "url";
 import { existsSync as existsSync24, readFileSync as readFileSync25, readdirSync as readdirSync23 } from "fs";
 import { join as join25 } from "path";
-import { existsSync as existsSync34, readFileSync as readFileSync33, writeFileSync as writeFileSync24, mkdirSync as mkdirSync25 } from "fs";
+import { existsSync as existsSync34, readFileSync as readFileSync34, writeFileSync as writeFileSync24, mkdirSync as mkdirSync25 } from "fs";
 import { join as join35, dirname as dirname23 } from "path";
 import { homedir as homedir24 } from "os";
 function getSkillsByCategory(category) {
@@ -30734,35 +31706,35 @@ function normalizeSkillName(name) {
 function findSkillsDir() {
   let dir = __dirname2;
   for (let i = 0;i < 5; i++) {
-    const candidate = join12(dir, "skills");
-    if (existsSync7(candidate)) {
+    const candidate = join13(dir, "skills");
+    if (existsSync8(candidate)) {
       return candidate;
     }
     dir = dirname6(dir);
   }
-  return join12(__dirname2, "..", "skills");
+  return join13(__dirname2, "..", "skills");
 }
 function getSkillPath(name) {
   const skillName = normalizeSkillName(name);
-  return join12(SKILLS_DIR, skillName);
+  return join13(SKILLS_DIR, skillName);
 }
 function skillExists(name) {
-  return existsSync7(getSkillPath(name));
+  return existsSync8(getSkillPath(name));
 }
 function installSkill(name, options = {}) {
   const { targetDir = process.cwd(), overwrite = false } = options;
   const skillName = normalizeSkillName(name);
   const sourcePath = getSkillPath(name);
-  const destDir = join12(targetDir, ".skills");
-  const destPath = join12(destDir, skillName);
-  if (!existsSync7(sourcePath)) {
+  const destDir = join13(targetDir, ".skills");
+  const destPath = join13(destDir, skillName);
+  if (!existsSync8(sourcePath)) {
     return {
       skill: name,
       success: false,
       error: `Skill '${name}' not found`
     };
   }
-  if (existsSync7(destPath) && !overwrite) {
+  if (existsSync8(destPath) && !overwrite) {
     return {
       skill: name,
       success: false,
@@ -30771,10 +31743,10 @@ function installSkill(name, options = {}) {
     };
   }
   try {
-    if (!existsSync7(destDir)) {
-      mkdirSync11(destDir, { recursive: true });
+    if (!existsSync8(destDir)) {
+      mkdirSync12(destDir, { recursive: true });
     }
-    if (existsSync7(destPath) && overwrite) {
+    if (existsSync8(destPath) && overwrite) {
       rmSync2(destPath, { recursive: true, force: true });
     }
     cpSync(sourcePath, destPath, {
@@ -30813,10 +31785,10 @@ function installSkills(names, options = {}) {
   return names.map((name) => installSkill(name, options));
 }
 function updateSkillsIndex(skillsDir) {
-  const indexPath = join12(skillsDir, "index.ts");
+  const indexPath = join13(skillsDir, "index.ts");
   const meta = loadMeta(skillsDir);
   const disabledSet = new Set(meta.disabled || []);
-  const skills = readdirSync5(skillsDir).filter((f) => f.startsWith("skill-") && !f.includes(".") && !disabledSet.has(f.replace("skill-", "")));
+  const skills = readdirSync6(skillsDir).filter((f) => f.startsWith("skill-") && !f.includes(".") && !disabledSet.has(f.replace("skill-", "")));
   const exports = skills.map((s) => {
     const name = s.replace("skill-", "").replace(/-/g, "_");
     return `export * as ${name} from './${s}/src/index.js';`;
@@ -30832,11 +31804,11 @@ ${exports}
   writeFileSync6(indexPath, content);
 }
 function getMetaPath(skillsDir) {
-  return join12(skillsDir, ".meta.json");
+  return join13(skillsDir, ".meta.json");
 }
 function loadMeta(skillsDir) {
   const metaPath2 = getMetaPath(skillsDir);
-  if (existsSync7(metaPath2)) {
+  if (existsSync8(metaPath2)) {
     try {
       return JSON.parse(readFileSync7(metaPath2, "utf-8"));
     } catch {}
@@ -30851,8 +31823,8 @@ function recordInstall(skillsDir, name) {
   const skillName = normalizeSkillName(name);
   let version = "unknown";
   try {
-    const pkgPath = join12(skillsDir, skillName, "package.json");
-    if (existsSync7(pkgPath)) {
+    const pkgPath = join13(skillsDir, skillName, "package.json");
+    if (existsSync8(pkgPath)) {
       const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
       version = pkg.version || "unknown";
     }
@@ -30866,12 +31838,12 @@ function recordRemove(skillsDir, name) {
   saveMeta(skillsDir, meta);
 }
 function getInstallMeta(targetDir = process.cwd()) {
-  return loadMeta(join12(targetDir, ".skills"));
+  return loadMeta(join13(targetDir, ".skills"));
 }
 function disableSkill(name, targetDir = process.cwd()) {
-  const skillsDir = join12(targetDir, ".skills");
+  const skillsDir = join13(targetDir, ".skills");
   const skillName = normalizeSkillName(name);
-  if (!existsSync7(join12(skillsDir, skillName)))
+  if (!existsSync8(join13(skillsDir, skillName)))
     return false;
   const meta = loadMeta(skillsDir);
   const disabled = new Set(meta.disabled || []);
@@ -30884,7 +31856,7 @@ function disableSkill(name, targetDir = process.cwd()) {
   return true;
 }
 function enableSkill(name, targetDir = process.cwd()) {
-  const skillsDir = join12(targetDir, ".skills");
+  const skillsDir = join13(targetDir, ".skills");
   const meta = loadMeta(skillsDir);
   const disabled = new Set(meta.disabled || []);
   if (!disabled.has(name))
@@ -30896,24 +31868,24 @@ function enableSkill(name, targetDir = process.cwd()) {
   return true;
 }
 function getDisabledSkills(targetDir = process.cwd()) {
-  const meta = loadMeta(join12(targetDir, ".skills"));
+  const meta = loadMeta(join13(targetDir, ".skills"));
   return meta.disabled || [];
 }
 function getInstalledSkills(targetDir = process.cwd()) {
-  const skillsDir = join12(targetDir, ".skills");
-  if (!existsSync7(skillsDir)) {
+  const skillsDir = join13(targetDir, ".skills");
+  if (!existsSync8(skillsDir)) {
     return [];
   }
-  return readdirSync5(skillsDir).filter((f) => {
-    const fullPath = join12(skillsDir, f);
+  return readdirSync6(skillsDir).filter((f) => {
+    const fullPath = join13(skillsDir, f);
     return f.startsWith("skill-") && statSync4(fullPath).isDirectory();
   }).map((f) => f.replace("skill-", ""));
 }
 function removeSkill(name, targetDir = process.cwd()) {
   const skillName = normalizeSkillName(name);
-  const skillsDir = join12(targetDir, ".skills");
-  const skillPath = join12(skillsDir, skillName);
-  if (!existsSync7(skillPath)) {
+  const skillsDir = join13(targetDir, ".skills");
+  const skillPath = join13(skillsDir, skillName);
+  if (!existsSync8(skillPath)) {
     return false;
   }
   rmSync2(skillPath, { recursive: true, force: true });
@@ -30924,24 +31896,24 @@ function removeSkill(name, targetDir = process.cwd()) {
 function getAgentSkillsDir(agent, scope = "global", projectDir) {
   const agentDir = `.${agent}`;
   if (scope === "project") {
-    return join12(projectDir || process.cwd(), agentDir, "skills");
+    return join13(projectDir || process.cwd(), agentDir, "skills");
   }
-  return join12(homedir11(), agentDir, "skills");
+  return join13(homedir12(), agentDir, "skills");
 }
 function getAgentSkillPath(name, agent, scope = "global", projectDir) {
   const skillName = normalizeSkillName(name);
-  return join12(getAgentSkillsDir(agent, scope, projectDir), skillName);
+  return join13(getAgentSkillsDir(agent, scope, projectDir), skillName);
 }
 function installSkillForAgent(name, options, generateSkillMd) {
   const { agent, scope = "global", projectDir } = options;
   const skillName = normalizeSkillName(name);
   const sourcePath = getSkillPath(name);
-  if (!existsSync7(sourcePath)) {
+  if (!existsSync8(sourcePath)) {
     return { skill: name, success: false, error: `Skill '${name}' not found` };
   }
   let skillMdContent = null;
-  const skillMdPath = join12(sourcePath, "SKILL.md");
-  if (existsSync7(skillMdPath)) {
+  const skillMdPath = join13(sourcePath, "SKILL.md");
+  if (existsSync8(skillMdPath)) {
     skillMdContent = readFileSync7(skillMdPath, "utf-8");
   } else if (generateSkillMd) {
     skillMdContent = generateSkillMd(name);
@@ -30951,8 +31923,8 @@ function installSkillForAgent(name, options, generateSkillMd) {
   }
   const destDir = getAgentSkillPath(name, agent, scope, projectDir);
   if (scope === "global") {
-    const agentBaseDir2 = join12(homedir11(), `.${agent}`);
-    if (!existsSync7(agentBaseDir2)) {
+    const agentBaseDir2 = join13(homedir12(), `.${agent}`);
+    if (!existsSync8(agentBaseDir2)) {
       const agentLabels = {
         claude: "Claude Code",
         codex: "Codex CLI",
@@ -30975,8 +31947,8 @@ function installSkillForAgent(name, options, generateSkillMd) {
     }
   }
   try {
-    mkdirSync11(destDir, { recursive: true });
-    writeFileSync6(join12(destDir, "SKILL.md"), skillMdContent);
+    mkdirSync12(destDir, { recursive: true });
+    writeFileSync6(join13(destDir, "SKILL.md"), skillMdContent);
     return { skill: name, success: true, path: destDir };
   } catch (error) {
     return {
@@ -30989,7 +31961,7 @@ function installSkillForAgent(name, options, generateSkillMd) {
 function removeSkillForAgent(name, options) {
   const { agent, scope = "global", projectDir } = options;
   const destDir = getAgentSkillPath(name, agent, scope, projectDir);
-  if (!existsSync7(destDir)) {
+  if (!existsSync8(destDir)) {
     return false;
   }
   rmSync2(destDir, { recursive: true, force: true });
@@ -31281,7 +32253,7 @@ function readConfigFile(path) {
   if (!existsSync34(path))
     return {};
   try {
-    const raw = readFileSync33(path, "utf-8");
+    const raw = readFileSync34(path, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
       return {};
@@ -31314,7 +32286,7 @@ function saveConfig(key, value, scope = "project") {
   let existing = {};
   if (existsSync34(filePath)) {
     try {
-      existing = JSON.parse(readFileSync33(filePath, "utf-8"));
+      existing = JSON.parse(readFileSync34(filePath, "utf-8"));
       if (typeof existing !== "object" || existing === null || Array.isArray(existing)) {
         existing = {};
       }
@@ -32913,7 +33885,7 @@ __export(exports_cron_manager, {
   deleteCronJob: () => deleteCronJob,
   createCronJob: () => createCronJob
 });
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 function ensureCronTable() {
   const db2 = getDatabase();
   db2.exec(`
@@ -32942,7 +33914,7 @@ function ensureCronTable() {
 function createCronJob(schedule, task, name) {
   ensureCronTable();
   const db2 = getDatabase();
-  const id = randomUUID11();
+  const id = randomUUID12();
   db2.prepare(`
     INSERT INTO cron_jobs (id, name, schedule, task_json, enabled)
     VALUES (?, ?, ?, ?, 1)
@@ -33000,7 +33972,7 @@ function getCronEvents(jobId, limit = 10) {
 async function executeCronJob(job) {
   ensureCronTable();
   const db2 = getDatabase();
-  const eventId = randomUUID11();
+  const eventId = randomUUID12();
   const startedAt = new Date().toISOString();
   db2.prepare("INSERT INTO cron_events (id, job_id, started_at) VALUES (?, ?, ?)").run(eventId, job.id, startedAt);
   try {
@@ -33091,7 +34063,7 @@ __export(exports_url_watcher, {
   deleteWatchJob: () => deleteWatchJob,
   createWatchJob: () => createWatchJob
 });
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID13 } from "crypto";
 import { createHash } from "crypto";
 function ensureWatchTables() {
   const db2 = getDatabase();
@@ -33123,7 +34095,7 @@ function ensureWatchTables() {
 function createWatchJob(url, schedule, opts) {
   ensureWatchTables();
   const db2 = getDatabase();
-  const id = randomUUID12();
+  const id = randomUUID13();
   db2.prepare(`
     INSERT INTO watch_jobs (id, name, url, schedule, selector, extract_schema, enabled)
     VALUES (?, ?, ?, ?, ?, ?, 1)
@@ -33159,7 +34131,7 @@ function getWatchEvents(watchId, limit = 20) {
 async function checkWatchJob(job) {
   ensureWatchTables();
   const db2 = getDatabase();
-  const eventId = randomUUID12();
+  const eventId = randomUUID13();
   const checkedAt = new Date().toISOString();
   let newContent = "";
   try {
@@ -33256,7 +34228,7 @@ ${snap.tree.slice(0, 2000)}`;
     const response = await client.messages.create({
       model,
       max_tokens: 512,
-      system: SYSTEM_PROMPT,
+      system: SYSTEM_PROMPT2,
       messages: [{
         role: "user",
         content: `Task: ${task}
@@ -33321,7 +34293,7 @@ What actions should I take next? Return JSON array.`
   }
   return { success: false, result: null, steps_taken: steps.length, steps, cost_estimate: totalTokens / 1000 * 0.00025, error: `Reached max steps (${maxSteps}) without completing task` };
 }
-var SYSTEM_PROMPT = `You are a browser automation agent. Given a task and the current page state, decide which browser actions to take.
+var SYSTEM_PROMPT2 = `You are a browser automation agent. Given a task and the current page state, decide which browser actions to take.
 
 Return a JSON array of at most 3 actions to execute next:
 [{"tool": "navigate|click|type|scroll|evaluate|done", "args": {...}, "reason": "..."}]
@@ -33335,7 +34307,7 @@ var exports_mcp = {};
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { readFileSync as readFileSync8 } from "fs";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 function json(data) {
   return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
 }
@@ -33347,6 +34319,34 @@ function err(e) {
     isError: true
   };
 }
+async function errWithScreenshot(e, sessionId) {
+  const msg = e instanceof Error ? e.message : String(e);
+  const code = e instanceof BrowserError ? e.code : "ERROR";
+  let screenshot_path;
+  if (sessionId) {
+    try {
+      const sid = resolveSessionId(sessionId);
+      const page = getSessionPage(sid);
+      const result = await takeScreenshot(page, { maxWidth: 800, quality: 50, track: false, thumbnail: false });
+      screenshot_path = result.path;
+    } catch {}
+  }
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error: msg, code, error_screenshot: screenshot_path }) }],
+    isError: true
+  };
+}
+function resolveSessionId(sessionId) {
+  if (sessionId)
+    return sessionId;
+  const def = getDefaultSession();
+  if (def)
+    return def.session.id;
+  const count = countActiveSessions2();
+  if (count === 0)
+    throw new BrowserError("No active sessions. Create one with browser_session_create first.", "NO_SESSION");
+  throw new BrowserError(`${count} active sessions \u2014 specify session_id to choose one.`, "AMBIGUOUS_SESSION");
+}
 var _pkg, networkLogCleanup, consoleCaptureCleanup, harCaptures, server, activeWatchHandles2, _startupToolCount, transport;
 var init_mcp = __esm(async () => {
   init_zod();
@@ -33368,10 +34368,11 @@ var init_mcp = __esm(async () => {
   init_snapshot();
   init_files_integration();
   init_recordings();
+  init_timeline();
   init_dialogs();
   init_profiles();
   init_types();
-  _pkg = JSON.parse(readFileSync8(join13(import.meta.dir, "../../package.json"), "utf8"));
+  _pkg = JSON.parse(readFileSync8(join14(import.meta.dir, "../../package.json"), "utf8"));
   networkLogCleanup = new Map;
   consoleCaptureCleanup = new Map;
   harCaptures = new Map;
@@ -33379,7 +34380,7 @@ var init_mcp = __esm(async () => {
     name: "@hasna/browser",
     version: "0.0.1"
   });
-  server.tool("browser_session_create", "Create a new browser session with the specified engine", {
+  server.tool("browser_session_create", "Create a new browser session. If agent_id is set and already has an active session, returns the existing one (use force_new to override). If session_id is omitted on other tools, the single active session is auto-selected. Use cdp_url to attach to an already-running Chrome instance.", {
     engine: exports_external.enum(["playwright", "cdp", "lightpanda", "bun", "auto"]).optional().default("auto"),
     use_case: exports_external.string().optional(),
     project_id: exports_external.string().optional(),
@@ -33388,9 +34389,19 @@ var init_mcp = __esm(async () => {
     headless: exports_external.boolean().optional().default(true),
     viewport_width: exports_external.number().optional().default(1280),
     viewport_height: exports_external.number().optional().default(720),
-    stealth: exports_external.boolean().optional().default(false)
-  }, async ({ engine, use_case, project_id, agent_id, start_url, headless, viewport_width, viewport_height, stealth }) => {
+    stealth: exports_external.boolean().optional().default(false),
+    auto_gallery: exports_external.boolean().optional().default(false),
+    storage_state: exports_external.string().optional().describe("Name of saved storage state to load (restores cookies/auth from previous session)"),
+    force_new: exports_external.boolean().optional().default(false).describe("Force create a new session even if agent already has one"),
+    tags: exports_external.array(exports_external.string()).optional(),
+    cdp_url: exports_external.string().optional().describe("Connect to existing Chrome via CDP (e.g. http://localhost:9222). Start Chrome with --remote-debugging-port=9222")
+  }, async ({ engine, use_case, project_id, agent_id, start_url, headless, viewport_width, viewport_height, stealth, auto_gallery, storage_state, force_new, tags, cdp_url }) => {
     try {
+      if (agent_id && !force_new) {
+        const existing = getActiveSessionForAgent2(agent_id);
+        if (existing)
+          return json({ session: existing.session, reused: true });
+      }
       const { session } = await createSession2({
         engine,
         useCase: use_case,
@@ -33399,44 +34410,68 @@ var init_mcp = __esm(async () => {
         startUrl: start_url,
         headless,
         viewport: { width: viewport_width, height: viewport_height },
-        stealth
+        stealth,
+        autoGallery: auto_gallery,
+        storageState: storage_state,
+        cdpUrl: cdp_url
       });
-      return json({ session });
+      if (tags?.length) {
+        const { addSessionTag: addSessionTag2 } = await Promise.resolve().then(() => (init_sessions(), exports_sessions));
+        for (const tag of tags)
+          addSessionTag2(session.id, tag);
+      }
+      logEvent(session.id, "session_created", { engine: session.engine });
+      return json({ session, reused: false });
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_session_list", "List all browser sessions", { status: exports_external.enum(["active", "closed", "error"]).optional(), project_id: exports_external.string().optional() }, async ({ status, project_id }) => {
+  server.tool("browser_session_list", "List all browser sessions. Optionally filter by tag.", { status: exports_external.enum(["active", "closed", "error"]).optional(), project_id: exports_external.string().optional(), tag: exports_external.string().optional() }, async ({ status, project_id, tag }) => {
     try {
+      if (tag) {
+        const { listSessionsByTag: listSessionsByTag2 } = await Promise.resolve().then(() => (init_sessions(), exports_sessions));
+        return json({ sessions: listSessionsByTag2(tag) });
+      }
       return json({ sessions: listSessions2({ status, projectId: project_id }) });
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_session_close", "Close a browser session", { session_id: exports_external.string() }, async ({ session_id }) => {
+  server.tool("browser_session_close", "Close a browser session", { session_id: exports_external.string().optional() }, async ({ session_id }) => {
     try {
-      const session = await closeSession2(session_id);
-      networkLogCleanup.get(session_id)?.();
-      consoleCaptureCleanup.get(session_id)?.();
-      networkLogCleanup.delete(session_id);
-      consoleCaptureCleanup.delete(session_id);
-      harCaptures.delete(session_id);
+      const sid = resolveSessionId(session_id);
+      const session = await closeSession2(sid);
+      networkLogCleanup.get(sid)?.();
+      consoleCaptureCleanup.get(sid)?.();
+      networkLogCleanup.delete(sid);
+      consoleCaptureCleanup.delete(sid);
+      harCaptures.delete(sid);
       return json({ session });
     } catch (e) {
       return err(e);
     }
   });
+  server.tool("browser_session_timeline", "Get chronological action log for a session", { session_id: exports_external.string().optional(), limit: exports_external.number().optional().default(50) }, async ({ session_id, limit }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      const events = getTimeline(sid, limit);
+      return json({ events, count: events.length });
+    } catch (e) {
+      return err(e);
+    }
+  });
   server.tool("browser_navigate", "Navigate to a URL. Auto-detects redirects, auto-names session, returns compact refs + thumbnail.", {
-    session_id: exports_external.string(),
+    session_id: exports_external.string().optional(),
     url: exports_external.string(),
     timeout: exports_external.number().optional().default(30000),
     auto_snapshot: exports_external.boolean().optional().default(true),
     auto_thumbnail: exports_external.boolean().optional().default(true)
   }, async ({ session_id, url, timeout, auto_snapshot, auto_thumbnail }) => {
     try {
-      const page = getSessionPage(session_id);
-      if (isBunSession(session_id)) {
-        const bunView = getSessionBunView(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
+      if (isBunSession(sid)) {
+        const bunView = getSessionBunView(sid);
         await bunView.goto(url, { timeout });
         await new Promise((r) => setTimeout(r, 500));
       } else {
@@ -33463,10 +34498,10 @@ var init_mcp = __esm(async () => {
         } catch {}
       }
       try {
-        const session = getSession2(session_id);
+        const session = getSession2(sid);
         if (!session.name) {
           const hostname = new URL(current_url).hostname;
-          renameSession2(session_id, hostname);
+          renameSession2(sid, hostname);
         }
       } catch {}
       const result = {
@@ -33482,86 +34517,110 @@ var init_mcp = __esm(async () => {
           result.thumbnail_base64 = ss.base64.length > 50000 ? "" : ss.base64;
         } catch {}
       }
-      if (isBunSession(session_id) && auto_snapshot) {
+      if (isAutoGallery(sid)) {
+        try {
+          const ss = await takeScreenshot(page, { maxWidth: 1280, quality: 70, thumbnail: true });
+          const { createEntry: createEntry2 } = await Promise.resolve().then(() => (init_gallery(), exports_gallery));
+          createEntry2({ session_id: sid, url: current_url, title, path: ss.path, thumbnail_path: ss.thumbnail_path, format: "webp", width: ss.width, height: ss.height, original_size_bytes: ss.original_size_bytes, compressed_size_bytes: ss.compressed_size_bytes, compression_ratio: ss.compression_ratio, tags: [], is_favorite: false });
+        } catch {}
+      }
+      if (isBunSession(sid) && auto_snapshot) {
         await new Promise((r) => setTimeout(r, 200));
       }
       if (auto_snapshot) {
         try {
-          const snap = await takeSnapshot(page, session_id);
-          setLastSnapshot(session_id, snap);
+          const snap = await takeSnapshot(page, sid);
+          setLastSnapshot(sid, snap);
           const refEntries = Object.entries(snap.refs).slice(0, 30);
           result.snapshot_refs = refEntries.map(([ref, info]) => `${info.role}:${info.name.slice(0, 50)} [${ref}]`).join(", ");
           result.interactive_count = snap.interactive_count;
-          result.has_errors = getConsoleLog(session_id, "error").length > 0;
+          result.has_errors = getConsoleLog(sid, "error").length > 0;
         } catch {}
       }
+      logEvent(sid, "navigate", { url, title, current_url });
       return json(result);
     } catch (e) {
-      return err(e);
+      return errWithScreenshot(e, session_id);
     }
   });
-  server.tool("browser_back", "Navigate back in browser history", { session_id: exports_external.string() }, async ({ session_id }) => {
+  server.tool("browser_back", "Navigate back in browser history", { session_id: exports_external.string().optional() }, async ({ session_id }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       await goBack(page);
       return json({ url: page.url() });
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_forward", "Navigate forward in browser history", { session_id: exports_external.string() }, async ({ session_id }) => {
+  server.tool("browser_forward", "Navigate forward in browser history", { session_id: exports_external.string().optional() }, async ({ session_id }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       await goForward(page);
       return json({ url: page.url() });
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_reload", "Reload the current page", { session_id: exports_external.string() }, async ({ session_id }) => {
+  server.tool("browser_reload", "Reload the current page", { session_id: exports_external.string().optional() }, async ({ session_id }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       await reload(page);
       return json({ url: page.url() });
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_click", "Click an element by ref (from snapshot) or CSS selector. Prefer ref for reliability.", { session_id: exports_external.string(), selector: exports_external.string().optional(), ref: exports_external.string().optional(), button: exports_external.enum(["left", "right", "middle"]).optional(), timeout: exports_external.number().optional() }, async ({ session_id, selector, ref, button, timeout }) => {
+  server.tool("browser_click", "Click an element by ref (from snapshot) or CSS selector. Prefer ref for reliability. Self-healing auto-tries fallback selectors if element not found.", { session_id: exports_external.string().optional(), selector: exports_external.string().optional(), ref: exports_external.string().optional(), button: exports_external.enum(["left", "right", "middle"]).optional(), timeout: exports_external.number().optional(), self_heal: exports_external.boolean().optional().default(true).describe("Auto-try fallback selectors if element not found") }, async ({ session_id, selector, ref, button, timeout, self_heal }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       if (ref) {
-        await clickRef(page, session_id, ref, { timeout });
+        await clickRef(page, sid, ref, { timeout });
+        logEvent(sid, "click", { selector: ref, method: "ref" });
         return json({ clicked: ref, method: "ref" });
       }
       if (!selector)
         return err(new Error("Either ref or selector is required"));
-      await click(page, selector, { button, timeout });
+      const healInfo = await click(page, selector, { button, timeout, selfHeal: self_heal });
+      logEvent(sid, "click", { selector, method: healInfo.healed ? "healed" : "selector" });
+      if (healInfo.healed) {
+        return json({ clicked: selector, method: "healed", heal_method: healInfo.method, attempts: healInfo.attempts });
+      }
       return json({ clicked: selector, method: "selector" });
     } catch (e) {
-      return err(e);
+      return errWithScreenshot(e, session_id);
     }
   });
-  server.tool("browser_type", "Type text into an element by ref or selector. Prefer ref.", { session_id: exports_external.string(), selector: exports_external.string().optional(), ref: exports_external.string().optional(), text: exports_external.string(), clear: exports_external.boolean().optional().default(false), delay: exports_external.number().optional() }, async ({ session_id, selector, ref, text, clear, delay }) => {
+  server.tool("browser_type", "Type text into an element by ref or selector. Prefer ref. Self-healing auto-tries fallback selectors if element not found.", { session_id: exports_external.string().optional(), selector: exports_external.string().optional(), ref: exports_external.string().optional(), text: exports_external.string(), clear: exports_external.boolean().optional().default(false), delay: exports_external.number().optional(), self_heal: exports_external.boolean().optional().default(true).describe("Auto-try fallback selectors if element not found") }, async ({ session_id, selector, ref, text, clear, delay, self_heal }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       if (ref) {
-        await typeRef(page, session_id, ref, text, { clear, delay });
+        await typeRef(page, sid, ref, text, { clear, delay });
+        logEvent(sid, "type", { selector: ref, text: text.slice(0, 100) });
         return json({ typed: text, ref, method: "ref" });
       }
       if (!selector)
         return err(new Error("Either ref or selector is required"));
-      await type(page, selector, text, { clear, delay });
+      const healInfo = await type(page, selector, text, { clear, delay, selfHeal: self_heal });
+      logEvent(sid, "type", { selector, text: text.slice(0, 100), method: healInfo.healed ? "healed" : "selector" });
+      if (healInfo.healed) {
+        return json({ typed: text, selector, method: "healed", heal_method: healInfo.method, attempts: healInfo.attempts });
+      }
       return json({ typed: text, selector, method: "selector" });
     } catch (e) {
-      return err(e);
+      return errWithScreenshot(e, session_id);
     }
   });
-  server.tool("browser_hover", "Hover over an element by ref or selector", { session_id: exports_external.string(), selector: exports_external.string().optional(), ref: exports_external.string().optional() }, async ({ session_id, selector, ref }) => {
+  server.tool("browser_hover", "Hover over an element by ref or selector", { session_id: exports_external.string().optional(), selector: exports_external.string().optional(), ref: exports_external.string().optional() }, async ({ session_id, selector, ref }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       if (ref) {
-        await hoverRef(page, session_id, ref);
+        await hoverRef(page, sid, ref);
         return json({ hovered: ref, method: "ref" });
       }
       if (!selector)
@@ -33572,20 +34631,22 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_scroll", "Scroll the page", { session_id: exports_external.string(), direction: exports_external.enum(["up", "down", "left", "right"]).optional().default("down"), amount: exports_external.number().optional().default(300) }, async ({ session_id, direction, amount }) => {
+  server.tool("browser_scroll", "Scroll the page", { session_id: exports_external.string().optional(), direction: exports_external.enum(["up", "down", "left", "right"]).optional().default("down"), amount: exports_external.number().optional().default(300) }, async ({ session_id, direction, amount }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       await scroll(page, direction, amount);
       return json({ scrolled: direction, amount });
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_select", "Select a dropdown option by ref or selector", { session_id: exports_external.string(), selector: exports_external.string().optional(), ref: exports_external.string().optional(), value: exports_external.string() }, async ({ session_id, selector, ref, value }) => {
+  server.tool("browser_select", "Select a dropdown option by ref or selector", { session_id: exports_external.string().optional(), selector: exports_external.string().optional(), ref: exports_external.string().optional(), value: exports_external.string() }, async ({ session_id, selector, ref, value }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       if (ref) {
-        const selected2 = await selectRef(page, session_id, ref, value);
+        const selected2 = await selectRef(page, sid, ref, value);
         return json({ selected: selected2, method: "ref" });
       }
       if (!selector)
@@ -33596,11 +34657,12 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_toggle", "Check or uncheck a checkbox by ref or selector", { session_id: exports_external.string(), selector: exports_external.string().optional(), ref: exports_external.string().optional(), checked: exports_external.boolean() }, async ({ session_id, selector, ref, checked }) => {
+  server.tool("browser_toggle", "Check or uncheck a checkbox by ref or selector", { session_id: exports_external.string().optional(), selector: exports_external.string().optional(), ref: exports_external.string().optional(), checked: exports_external.boolean() }, async ({ session_id, selector, ref, checked }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       if (ref) {
-        await checkRef(page, session_id, ref, checked);
+        await checkRef(page, sid, ref, checked);
         return json({ checked, ref, method: "ref" });
       }
       if (!selector)
@@ -33611,75 +34673,111 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_upload", "Upload a file to an input element", { session_id: exports_external.string(), selector: exports_external.string(), file_path: exports_external.string() }, async ({ session_id, selector, file_path }) => {
+  server.tool("browser_upload", "Upload a file to an input element", { session_id: exports_external.string().optional(), selector: exports_external.string(), file_path: exports_external.string() }, async ({ session_id, selector, file_path }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       await uploadFile(page, selector, file_path);
       return json({ uploaded: file_path, selector });
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_press_key", "Press a keyboard key", { session_id: exports_external.string(), key: exports_external.string() }, async ({ session_id, key }) => {
+  server.tool("browser_press_key", "Press a keyboard key", { session_id: exports_external.string().optional(), key: exports_external.string() }, async ({ session_id, key }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       await pressKey(page, key);
       return json({ pressed: key });
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_wait", "Wait for a selector to appear", { session_id: exports_external.string(), selector: exports_external.string(), state: exports_external.enum(["attached", "detached", "visible", "hidden"]).optional(), timeout: exports_external.number().optional() }, async ({ session_id, selector, state, timeout }) => {
+  server.tool("browser_wait", "Wait for a selector to appear", { session_id: exports_external.string().optional(), selector: exports_external.string(), state: exports_external.enum(["attached", "detached", "visible", "hidden"]).optional(), timeout: exports_external.number().optional() }, async ({ session_id, selector, state, timeout }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       await waitForSelector(page, selector, { state, timeout });
       return json({ ready: selector });
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_get_text", "Get text content from the page or a selector", { session_id: exports_external.string(), selector: exports_external.string().optional() }, async ({ session_id, selector }) => {
+  server.tool("browser_get_text", "Get text content from the page or a selector. Sanitizes prompt injection by default.", { session_id: exports_external.string().optional(), selector: exports_external.string().optional(), sanitize: exports_external.boolean().optional().default(true).describe("Strip prompt injection patterns from text (default: true)") }, async ({ session_id, selector, sanitize }) => {
     try {
-      const page = getSessionPage(session_id);
-      return json({ text: await getText(page, selector) });
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
+      const text = await getText(page, selector);
+      if (sanitize) {
+        const { sanitizeText: sanitizeText2 } = await Promise.resolve().then(() => (init_sanitize(), exports_sanitize));
+        const sanitized = sanitizeText2(text);
+        return json({ text: sanitized.text, stripped: sanitized.stripped, warnings: sanitized.warnings });
+      }
+      return json({ text });
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_get_html", "Get HTML content from the page or a selector", { session_id: exports_external.string(), selector: exports_external.string().optional() }, async ({ session_id, selector }) => {
+  server.tool("browser_get_html", "Get HTML content from the page or a selector. Sanitizes prompt injection by default.", { session_id: exports_external.string().optional(), selector: exports_external.string().optional(), sanitize: exports_external.boolean().optional().default(true).describe("Strip prompt injection patterns and hidden elements from HTML (default: true)") }, async ({ session_id, selector, sanitize }) => {
     try {
-      const page = getSessionPage(session_id);
-      return json({ html: await getHTML(page, selector) });
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
+      const html = await getHTML(page, selector);
+      if (sanitize) {
+        const { sanitizeHTML: sanitizeHTML2 } = await Promise.resolve().then(() => (init_sanitize(), exports_sanitize));
+        const sanitized = sanitizeHTML2(html);
+        return json({ html: sanitized.text, stripped: sanitized.stripped, warnings: sanitized.warnings });
+      }
+      return json({ html });
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_get_links", "Get all links from the current page", { session_id: exports_external.string() }, async ({ session_id }) => {
+  server.tool("browser_get_links", "Get all links from the current page", { session_id: exports_external.string().optional() }, async ({ session_id }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const links = await getLinks(page);
       return json({ links, count: links.length });
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_extract", "Extract content from the page in a specified format", {
-    session_id: exports_external.string(),
+  server.tool("browser_extract", "Extract content from the page in a specified format. Sanitizes prompt injection by default.", {
+    session_id: exports_external.string().optional(),
     format: exports_external.enum(["text", "html", "links", "table", "structured"]).optional().default("text"),
     selector: exports_external.string().optional(),
-    schema: exports_external.record(exports_external.string()).optional()
-  }, async ({ session_id, format, selector, schema }) => {
+    schema: exports_external.record(exports_external.string()).optional(),
+    sanitize: exports_external.boolean().optional().default(true).describe("Strip prompt injection patterns from extracted content (default: true)")
+  }, async ({ session_id, format, selector, schema, sanitize }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const result = await extract(page, { format, selector, schema });
+      if (sanitize) {
+        const { sanitizeText: sanitizeText2, sanitizeHTML: sanitizeHTML2 } = await Promise.resolve().then(() => (init_sanitize(), exports_sanitize));
+        if (result.text) {
+          const s = sanitizeText2(result.text);
+          result.text = s.text;
+          result.stripped = s.stripped;
+          result.warnings = s.warnings;
+        }
+        if (result.html) {
+          const s = sanitizeHTML2(result.html);
+          result.html = s.text;
+          result.stripped = s.stripped;
+          result.warnings = s.warnings;
+        }
+      }
       return json(result);
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_find", "Find elements matching a selector and return their text", { session_id: exports_external.string(), selector: exports_external.string() }, async ({ session_id, selector }) => {
+  server.tool("browser_find", "Find elements matching a selector and return their text", { session_id: exports_external.string().optional(), selector: exports_external.string() }, async ({ session_id, selector }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const elements = await findElements(page, selector);
       const texts = await Promise.all(elements.map((el) => el.textContent()));
       return json({ count: elements.length, texts });
@@ -33687,16 +34785,27 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_snapshot", "Get accessibility snapshot with element refs (@e0, @e1...). Use compact=true (default) for token-efficient output. Use refs in browser_click, browser_type, etc.", {
-    session_id: exports_external.string(),
+  server.tool("browser_snapshot", "Get accessibility snapshot with element refs (@e0, @e1...). Use compact=true (default) for token-efficient output. Use refs in browser_click, browser_type, etc. Sanitizes prompt injection by default.", {
+    session_id: exports_external.string().optional(),
     compact: exports_external.boolean().optional().default(true),
     max_refs: exports_external.number().optional().default(50),
-    full_tree: exports_external.boolean().optional().default(false)
-  }, async ({ session_id, compact, max_refs, full_tree }) => {
+    full_tree: exports_external.boolean().optional().default(false),
+    sanitize: exports_external.boolean().optional().default(true).describe("Strip prompt injection patterns from snapshot text (default: true)")
+  }, async ({ session_id, compact, max_refs, full_tree, sanitize }) => {
     try {
-      const page = getSessionPage(session_id);
-      const result = await takeSnapshot(page, session_id);
-      setLastSnapshot(session_id, result);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
+      const result = await takeSnapshot(page, sid);
+      setLastSnapshot(sid, result);
+      let injection_warnings;
+      if (sanitize) {
+        const { sanitizeText: sanitizeText2 } = await Promise.resolve().then(() => (init_sanitize(), exports_sanitize));
+        const sanitized = sanitizeText2(result.tree);
+        if (sanitized.stripped > 0) {
+          injection_warnings = sanitized.warnings;
+          result.tree = sanitized.text;
+        }
+      }
       const refEntries = Object.entries(result.refs).slice(0, max_refs);
       const limitedRefs = Object.fromEntries(refEntries);
       const truncated = Object.keys(result.refs).length > max_refs;
@@ -33708,32 +34817,35 @@ var init_mcp = __esm(async () => {
           interactive_count: result.interactive_count,
           shown_count: refEntries.length,
           truncated,
-          refs: limitedRefs
+          refs: limitedRefs,
+          ...injection_warnings ? { injection_warnings } : {}
         });
       }
       const tree = full_tree ? result.tree : result.tree.slice(0, 5000) + (result.tree.length > 5000 ? `
 ... (truncated \u2014 use full_tree=true for complete)` : "");
-      return json({ snapshot: tree, refs: limitedRefs, interactive_count: result.interactive_count, truncated });
+      return json({ snapshot: tree, refs: limitedRefs, interactive_count: result.interactive_count, truncated, ...injection_warnings ? { injection_warnings } : {} });
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_screenshot", "Take a screenshot. Use annotate=true to overlay numbered labels on interactive elements for visual+ref workflows.", {
-    session_id: exports_external.string(),
-    selector: exports_external.string().optional(),
+  server.tool("browser_screenshot", "Take a screenshot. Use selector to capture a specific element/section instead of the full page. Use detail='high' for AI-readable full image, 'low' for fast thumbnail. Use annotate=true to overlay numbered labels on interactive elements.", {
+    session_id: exports_external.string().optional(),
+    selector: exports_external.string().optional().describe("CSS selector to screenshot a specific section (e.g. '#main', '.header', 'form')"),
     full_page: exports_external.boolean().optional().default(false),
     format: exports_external.enum(["png", "jpeg", "webp"]).optional().default("webp"),
-    quality: exports_external.number().optional(),
-    max_width: exports_external.number().optional().default(1280),
+    quality: exports_external.number().optional().default(60),
+    max_width: exports_external.number().optional().default(800),
     compress: exports_external.boolean().optional().default(true),
     thumbnail: exports_external.boolean().optional().default(true),
-    annotate: exports_external.boolean().optional().default(false)
-  }, async ({ session_id, selector, full_page, format, quality, max_width, compress, thumbnail, annotate }) => {
+    annotate: exports_external.boolean().optional().default(false),
+    detail: exports_external.enum(["low", "high"]).optional().default("low").describe("'low' = thumbnail only (fast, saves tokens). 'high' = full readable image in base64 (larger but AI can read text).")
+  }, async ({ session_id, selector, full_page, format, quality, max_width, compress, thumbnail, annotate, detail }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       if (annotate && !selector && !full_page) {
         const { annotateScreenshot: annotateScreenshot2 } = await Promise.resolve().then(() => (init_annotate(), exports_annotate));
-        const annotated = await annotateScreenshot2(page, session_id);
+        const annotated = await annotateScreenshot2(page, sid);
         const base64 = annotated.buffer.toString("base64");
         return json({
           base64: base64.length > 50000 ? undefined : base64,
@@ -33744,37 +34856,42 @@ var init_mcp = __esm(async () => {
           annotation_count: annotated.annotations.length
         });
       }
-      const result = await takeScreenshot(page, { selector, fullPage: full_page, format, quality, maxWidth: max_width, compress, thumbnail });
+      const effectiveMaxWidth = detail === "high" ? 1280 : max_width;
+      const effectiveQuality = detail === "high" ? 75 : quality;
+      const result = await takeScreenshot(page, { selector, fullPage: full_page, format, quality: effectiveQuality, maxWidth: effectiveMaxWidth, compress, thumbnail });
       result.url = page.url();
       try {
         const buf = Buffer.from(result.base64, "base64");
         const filename = result.path.split("/").pop() ?? `screenshot.${format ?? "webp"}`;
-        const dl = saveToDownloads(buf, filename, { sessionId: session_id, type: "screenshot", sourceUrl: page.url() });
+        const dl = saveToDownloads(buf, filename, { sessionId: sid, type: "screenshot", sourceUrl: page.url() });
         result.download_id = dl.id;
       } catch {}
-      if (result.base64.length > 50000) {
+      result.estimated_tokens = Math.ceil(result.base64.length / 4);
+      if (detail !== "high" && result.base64.length > 40000) {
         result.base64_truncated = true;
         result.full_image_path = result.path;
         result.base64 = result.thumbnail_base64 ?? "";
       }
+      logEvent(sid, "screenshot", { path: result.path, detail, selector });
       return json(result);
     } catch (e) {
       return err(e);
     }
   });
   server.tool("browser_pdf", "Generate a PDF of the current page", {
-    session_id: exports_external.string(),
+    session_id: exports_external.string().optional(),
     format: exports_external.enum(["A4", "Letter", "A3", "A5"]).optional().default("A4"),
     landscape: exports_external.boolean().optional().default(false),
     print_background: exports_external.boolean().optional().default(true)
   }, async ({ session_id, format, landscape, print_background }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const result = await generatePDF(page, { format, landscape, printBackground: print_background });
       try {
         const buf = Buffer.from(result.base64, "base64");
         const filename = result.path.split("/").pop() ?? "document.pdf";
-        const dl = saveToDownloads(buf, filename, { sessionId: session_id, type: "pdf", sourceUrl: page.url() });
+        const dl = saveToDownloads(buf, filename, { sessionId: sid, type: "pdf", sourceUrl: page.url() });
         result.download_id = dl.id;
       } catch {}
       return json(result);
@@ -33782,25 +34899,27 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_evaluate", "Execute JavaScript in the page context", { session_id: exports_external.string(), script: exports_external.string() }, async ({ session_id, script }) => {
+  server.tool("browser_evaluate", "Execute JavaScript in the page context", { session_id: exports_external.string().optional(), script: exports_external.string() }, async ({ session_id, script }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const result = await page.evaluate(script);
       return json({ result });
     } catch (e) {
-      return err(e);
+      return errWithScreenshot(e, session_id);
     }
   });
-  server.tool("browser_cookies_get", "Get cookies from the current session", { session_id: exports_external.string(), name: exports_external.string().optional(), domain: exports_external.string().optional() }, async ({ session_id, name, domain }) => {
+  server.tool("browser_cookies_get", "Get cookies from the current session", { session_id: exports_external.string().optional(), name: exports_external.string().optional(), domain: exports_external.string().optional() }, async ({ session_id, name, domain }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       return json({ cookies: await getCookies(page, { name, domain }) });
     } catch (e) {
       return err(e);
     }
   });
   server.tool("browser_cookies_set", "Set a cookie in the current session", {
-    session_id: exports_external.string(),
+    session_id: exports_external.string().optional(),
     name: exports_external.string(),
     value: exports_external.string(),
     domain: exports_external.string().optional(),
@@ -33810,7 +34929,8 @@ var init_mcp = __esm(async () => {
     secure: exports_external.boolean().optional().default(false)
   }, async ({ session_id, name, value, domain, path, expires, http_only, secure }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       await setCookie(page, {
         name,
         value,
@@ -33826,27 +34946,30 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_cookies_clear", "Clear cookies from the current session", { session_id: exports_external.string(), name: exports_external.string().optional(), domain: exports_external.string().optional() }, async ({ session_id, name, domain }) => {
+  server.tool("browser_cookies_clear", "Clear cookies from the current session", { session_id: exports_external.string().optional(), name: exports_external.string().optional(), domain: exports_external.string().optional() }, async ({ session_id, name, domain }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       await clearCookies(page, name || domain ? { name, domain } : undefined);
       return json({ cleared: true });
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_storage_get", "Get localStorage or sessionStorage values", { session_id: exports_external.string(), key: exports_external.string().optional(), storage_type: exports_external.enum(["local", "session"]).optional().default("local") }, async ({ session_id, key, storage_type }) => {
+  server.tool("browser_storage_get", "Get localStorage or sessionStorage values", { session_id: exports_external.string().optional(), key: exports_external.string().optional(), storage_type: exports_external.enum(["local", "session"]).optional().default("local") }, async ({ session_id, key, storage_type }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const value = storage_type === "session" ? await getSessionStorage(page, key) : await getLocalStorage(page, key);
       return json({ value });
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_storage_set", "Set a localStorage or sessionStorage value", { session_id: exports_external.string(), key: exports_external.string(), value: exports_external.string(), storage_type: exports_external.enum(["local", "session"]).optional().default("local") }, async ({ session_id, key, value, storage_type }) => {
+  server.tool("browser_storage_set", "Set a localStorage or sessionStorage value", { session_id: exports_external.string().optional(), key: exports_external.string(), value: exports_external.string(), storage_type: exports_external.enum(["local", "session"]).optional().default("local") }, async ({ session_id, key, value, storage_type }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       if (storage_type === "session") {
         await setSessionStorage(page, key, value);
       } else {
@@ -33857,28 +34980,30 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_network_log", "Get captured network requests for a session", { session_id: exports_external.string() }, async ({ session_id }) => {
+  server.tool("browser_network_log", "Get captured network requests for a session", { session_id: exports_external.string().optional() }, async ({ session_id }) => {
     try {
-      if (!networkLogCleanup.has(session_id)) {
-        const page = getSessionPage(session_id);
-        const cleanup = enableNetworkLogging(page, session_id);
-        networkLogCleanup.set(session_id, cleanup);
+      const sid = resolveSessionId(session_id);
+      if (!networkLogCleanup.has(sid)) {
+        const page = getSessionPage(sid);
+        const cleanup = enableNetworkLogging(page, sid);
+        networkLogCleanup.set(sid, cleanup);
       }
-      const log = getNetworkLog(session_id);
+      const log = getNetworkLog(sid);
       return json({ requests: log, count: log.length });
     } catch (e) {
       return err(e);
     }
   });
   server.tool("browser_network_intercept", "Add a network interception rule", {
-    session_id: exports_external.string(),
+    session_id: exports_external.string().optional(),
     pattern: exports_external.string(),
     action: exports_external.enum(["block", "modify", "log"]),
     response_status: exports_external.number().optional(),
     response_body: exports_external.string().optional()
   }, async ({ session_id, pattern, action, response_status, response_body }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       await addInterceptRule(page, {
         pattern,
         action,
@@ -33889,27 +35014,29 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_har_start", "Start HAR capture for a session", { session_id: exports_external.string() }, async ({ session_id }) => {
+  server.tool("browser_har_start", "Start HAR capture for a session", { session_id: exports_external.string().optional() }, async ({ session_id }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const capture = startHAR(page);
-      harCaptures.set(session_id, capture);
+      harCaptures.set(sid, capture);
       return json({ started: true });
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_har_stop", "Stop HAR capture and return the HAR data", { session_id: exports_external.string() }, async ({ session_id }) => {
+  server.tool("browser_har_stop", "Stop HAR capture and return the HAR data", { session_id: exports_external.string().optional() }, async ({ session_id }) => {
     try {
-      const capture = harCaptures.get(session_id);
+      const sid = resolveSessionId(session_id);
+      const capture = harCaptures.get(sid);
       if (!capture)
         return err(new Error("No active HAR capture for this session"));
       const har = capture.stop();
-      harCaptures.delete(session_id);
+      harCaptures.delete(sid);
       let download_id;
       try {
         const harBuf = Buffer.from(JSON.stringify(har, null, 2));
-        const dl = saveToDownloads(harBuf, `capture-${Date.now()}.har`, { sessionId: session_id, type: "har" });
+        const dl = saveToDownloads(harBuf, `capture-${Date.now()}.har`, { sessionId: sid, type: "har" });
         download_id = dl.id;
       } catch {}
       return json({ har, entry_count: har.log.entries.length, download_id });
@@ -33917,32 +35044,35 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_performance", "Get performance metrics for the current page", { session_id: exports_external.string() }, async ({ session_id }) => {
+  server.tool("browser_performance", "Get performance metrics for the current page", { session_id: exports_external.string().optional() }, async ({ session_id }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const metrics = await getPerformanceMetrics(page);
       return json({ metrics });
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_console_log", "Get captured console messages for a session", { session_id: exports_external.string(), level: exports_external.enum(["log", "warn", "error", "debug", "info"]).optional() }, async ({ session_id, level }) => {
+  server.tool("browser_console_log", "Get captured console messages for a session", { session_id: exports_external.string().optional(), level: exports_external.enum(["log", "warn", "error", "debug", "info"]).optional() }, async ({ session_id, level }) => {
     try {
-      if (!consoleCaptureCleanup.has(session_id)) {
-        const page = getSessionPage(session_id);
-        const cleanup = enableConsoleCapture(page, session_id);
-        consoleCaptureCleanup.set(session_id, cleanup);
+      const sid = resolveSessionId(session_id);
+      if (!consoleCaptureCleanup.has(sid)) {
+        const page = getSessionPage(sid);
+        const cleanup = enableConsoleCapture(page, sid);
+        consoleCaptureCleanup.set(sid, cleanup);
       }
-      const messages = getConsoleLog(session_id, level);
+      const messages = getConsoleLog(sid, level);
       return json({ messages, count: messages.length });
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_record_start", "Start recording actions in a session", { session_id: exports_external.string(), name: exports_external.string(), project_id: exports_external.string().optional() }, async ({ session_id, name }) => {
+  server.tool("browser_record_start", "Start recording actions in a session", { session_id: exports_external.string().optional(), name: exports_external.string(), project_id: exports_external.string().optional() }, async ({ session_id, name }) => {
     try {
-      const page = getSessionPage(session_id);
-      const recording = startRecording(session_id, name, page.url());
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
+      const recording = startRecording(sid, name, page.url());
       return json({ recording_id: recording.id, name: recording.name });
     } catch (e) {
       return err(e);
@@ -33970,9 +35100,10 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_record_replay", "Replay a recorded sequence in a session", { session_id: exports_external.string(), recording_id: exports_external.string() }, async ({ session_id, recording_id }) => {
+  server.tool("browser_record_replay", "Replay a recorded sequence in a session", { session_id: exports_external.string().optional(), recording_id: exports_external.string() }, async ({ session_id, recording_id }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const result = await replayRecording(recording_id, page);
       return json(result);
     } catch (e) {
@@ -34010,7 +35141,7 @@ var init_mcp = __esm(async () => {
   server.tool("browser_register_agent", "Register an agent with the browser service", {
     name: exports_external.string(),
     description: exports_external.string().optional(),
-    session_id: exports_external.string().optional(),
+    session_id: exports_external.string().optional().optional(),
     project_id: exports_external.string().optional(),
     working_dir: exports_external.string().optional()
   }, async ({ name, description, session_id, project_id, working_dir }) => {
@@ -34051,9 +35182,10 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_scroll_and_screenshot", "Scroll the page and take a screenshot in one call. Saves 3 separate tool calls.", { session_id: exports_external.string(), direction: exports_external.enum(["up", "down", "left", "right"]).optional().default("down"), amount: exports_external.number().optional().default(500), wait_ms: exports_external.number().optional().default(300) }, async ({ session_id, direction, amount, wait_ms }) => {
+  server.tool("browser_scroll_and_screenshot", "Scroll the page and take a screenshot in one call. Saves 3 separate tool calls.", { session_id: exports_external.string().optional(), direction: exports_external.enum(["up", "down", "left", "right"]).optional().default("down"), amount: exports_external.number().optional().default(500), wait_ms: exports_external.number().optional().default(300) }, async ({ session_id, direction, amount, wait_ms }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       await scroll(page, direction, amount);
       await new Promise((r) => setTimeout(r, wait_ms));
       const result = await takeScreenshot(page, { maxWidth: 1280, track: true });
@@ -34068,9 +35200,10 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_wait_for_navigation", "Wait for URL change after a click or action. Returns the new URL and title.", { session_id: exports_external.string(), timeout: exports_external.number().optional().default(30000), url_pattern: exports_external.string().optional() }, async ({ session_id, timeout, url_pattern }) => {
+  server.tool("browser_wait_for_navigation", "Wait for URL change after a click or action. Returns the new URL and title.", { session_id: exports_external.string().optional(), timeout: exports_external.number().optional().default(30000), url_pattern: exports_external.string().optional() }, async ({ session_id, timeout, url_pattern }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const start = Date.now();
       if (url_pattern) {
         await page.waitForURL(url_pattern, { timeout });
@@ -34092,38 +35225,200 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_session_rename", "Rename a browser session", { session_id: exports_external.string(), name: exports_external.string() }, async ({ session_id, name }) => {
+  server.tool("browser_session_rename", "Rename a browser session", { session_id: exports_external.string().optional(), name: exports_external.string() }, async ({ session_id, name }) => {
     try {
-      return json({ session: renameSession2(session_id, name) });
+      const sid = resolveSessionId(session_id);
+      return json({ session: renameSession2(sid, name) });
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_click_text", "Click an element by its visible text content", { session_id: exports_external.string(), text: exports_external.string(), exact: exports_external.boolean().optional().default(false), timeout: exports_external.number().optional() }, async ({ session_id, text, exact, timeout }) => {
+  server.tool("browser_session_lock", "Lock a session so only the specified agent can use it", { session_id: exports_external.string().optional(), agent_id: exports_external.string() }, async ({ session_id, agent_id }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const { lockSession: lockSession2 } = await Promise.resolve().then(() => (init_sessions(), exports_sessions));
+      return json({ session: lockSession2(sid, agent_id) });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_session_unlock", "Unlock a session", { session_id: exports_external.string().optional(), agent_id: exports_external.string().optional() }, async ({ session_id, agent_id }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      const { unlockSession: unlockSession2 } = await Promise.resolve().then(() => (init_sessions(), exports_sessions));
+      return json({ session: unlockSession2(sid, agent_id) });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_session_transfer", "Transfer session ownership to another agent", { session_id: exports_external.string().optional(), to_agent_id: exports_external.string() }, async ({ session_id, to_agent_id }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      const { transferSession: transferSession2 } = await Promise.resolve().then(() => (init_sessions(), exports_sessions));
+      return json({ session: transferSession2(sid, to_agent_id) });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_session_tag", "Add a tag to a session for categorization (e.g. qa, scraping, monitoring)", { session_id: exports_external.string().optional(), tag: exports_external.string() }, async ({ session_id, tag }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      const { addSessionTag: addSessionTag2 } = await Promise.resolve().then(() => (init_sessions(), exports_sessions));
+      return json({ tags: addSessionTag2(sid, tag) });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_session_untag", "Remove a tag from a session", { session_id: exports_external.string().optional(), tag: exports_external.string() }, async ({ session_id, tag }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      const { removeSessionTag: removeSessionTag2 } = await Promise.resolve().then(() => (init_sessions(), exports_sessions));
+      return json({ tags: removeSessionTag2(sid, tag) });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_session_save_state", "Save current session's auth state (cookies, localStorage) for reuse. Use after login to avoid re-authenticating.", { session_id: exports_external.string().optional(), name: exports_external.string().describe("Name for this state (e.g. 'github', 'gmail')") }, async ({ session_id, name }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
+      const { saveStateFromPage: saveStateFromPage2 } = await Promise.resolve().then(() => (init_storage_state(), exports_storage_state));
+      const path = await saveStateFromPage2(page, name);
+      return json({ saved: true, name, path });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_session_list_states", "List all saved storage states (auth snapshots)", {}, async () => {
+    try {
+      const { listStates: listStates2 } = await Promise.resolve().then(() => (init_storage_state(), exports_storage_state));
+      const states = listStates2();
+      return json({ states, count: states.length });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_session_delete_state", "Delete a saved storage state", { name: exports_external.string() }, async ({ name }) => {
+    try {
+      const { deleteState: deleteState2 } = await Promise.resolve().then(() => (init_storage_state(), exports_storage_state));
+      return json({ deleted: deleteState2(name), name });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_auth_record", "Start recording a login flow. Navigate to the login page, perform the login, then call browser_auth_stop to save.", { session_id: exports_external.string().optional(), name: exports_external.string().describe("Name for this auth flow (e.g. 'github', 'gmail')"), start_url: exports_external.string().optional().describe("Login page URL") }, async ({ session_id, name, start_url }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
+      if (start_url)
+        await navigate(page, start_url);
+      const recording = startRecording(sid, `auth-${name}`, page.url());
+      return json({ recording_id: recording.id, name, message: "Recording started. Perform login, then call browser_auth_stop." });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_auth_stop", "Stop recording a login flow and save as a reusable auth flow with storage state.", { session_id: exports_external.string().optional(), name: exports_external.string(), recording_id: exports_external.string() }, async ({ session_id, name, recording_id }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
+      const recording = stopRecording(recording_id);
+      const { saveStateFromPage: saveStateFromPage2 } = await Promise.resolve().then(() => (init_storage_state(), exports_storage_state));
+      const statePath2 = await saveStateFromPage2(page, name);
+      let domain = "";
+      try {
+        domain = new URL(page.url()).hostname;
+      } catch {}
+      const { saveAuthFlow: saveAuthFlow2 } = await Promise.resolve().then(() => (init_auth_flow(), exports_auth_flow));
+      const flow = saveAuthFlow2({ name, domain, recordingId: recording.id, storageStatePath: statePath2 });
+      return json({ flow, recording_steps: recording.steps.length });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_auth_replay", "Manually replay a saved auth flow for a domain", { session_id: exports_external.string().optional(), name: exports_external.string().describe("Auth flow name to replay") }, async ({ session_id, name }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
+      const { getAuthFlowByName: getAuthFlowByName2, tryReplayAuth: tryReplayAuth2 } = await Promise.resolve().then(() => (init_auth_flow(), exports_auth_flow));
+      const flow = getAuthFlowByName2(name);
+      if (!flow)
+        return err(new Error(`Auth flow '${name}' not found`));
+      const result = await tryReplayAuth2(page, flow.domain);
+      return json(result);
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_auth_list", "List all saved auth flows", {}, async () => {
+    try {
+      const { listAuthFlows: listAuthFlows2 } = await Promise.resolve().then(() => (init_auth_flow(), exports_auth_flow));
+      return json({ flows: listAuthFlows2() });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_auth_delete", "Delete a saved auth flow", { name: exports_external.string() }, async ({ name }) => {
+    try {
+      const { deleteAuthFlow: deleteAuthFlow2 } = await Promise.resolve().then(() => (init_auth_flow(), exports_auth_flow));
+      return json({ deleted: deleteAuthFlow2(name) });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_click_text", "Click an element by its visible text content", { session_id: exports_external.string().optional(), text: exports_external.string(), exact: exports_external.boolean().optional().default(false), timeout: exports_external.number().optional() }, async ({ session_id, text, exact, timeout }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       await clickText(page, text, { exact, timeout });
       return json({ clicked: text });
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_fill_form", "Fill multiple form fields in one call. Fields map: { selector: value }. Handles text, checkboxes, selects.", {
-    session_id: exports_external.string(),
+  server.tool("browser_fill_form", "Fill multiple form fields in one call. Fields map: { selector: value }. Handles text, checkboxes, selects. Self-healing auto-tries fallback selectors per field.", {
+    session_id: exports_external.string().optional(),
     fields: exports_external.record(exports_external.union([exports_external.string(), exports_external.boolean()])),
-    submit_selector: exports_external.string().optional()
-  }, async ({ session_id, fields, submit_selector }) => {
+    submit_selector: exports_external.string().optional(),
+    self_heal: exports_external.boolean().optional().default(true).describe("Auto-try fallback selectors if element not found")
+  }, async ({ session_id, fields, submit_selector, self_heal }) => {
     try {
-      const page = getSessionPage(session_id);
-      const result = await fillForm(page, fields, submit_selector);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
+      const result = await fillForm(page, fields, submit_selector, self_heal);
       return json(result);
+    } catch (e) {
+      return errWithScreenshot(e, session_id);
+    }
+  });
+  server.tool("browser_find_visual", "Find an element using AI vision when selectors and a11y refs fail. Useful for canvas, images, custom widgets. Takes a screenshot and asks a vision model to locate the element.", {
+    session_id: exports_external.string().optional(),
+    description: exports_external.string().describe("Natural language description of the element to find (e.g. 'the blue Submit button', 'the search icon in the top right')"),
+    click: exports_external.boolean().optional().default(false).describe("Click the element after finding it"),
+    model: exports_external.string().optional().describe("Vision model to use (default: claude-sonnet-4-5-20250929)")
+  }, async ({ session_id, description, click: doClick, model }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
+      if (doClick) {
+        const { clickByVision: clickByVision2 } = await Promise.resolve().then(() => exports_vision_fallback);
+        const result = await clickByVision2(page, description, { model });
+        logEvent(sid, "vision_click", { query: description, ...result });
+        return json(result);
+      } else {
+        const { findElementByVision: findElementByVision2 } = await Promise.resolve().then(() => exports_vision_fallback);
+        const result = await findElementByVision2(page, description, { model });
+        logEvent(sid, "vision_find", { query: description, ...result });
+        return json(result);
+      }
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_wait_for_text", "Wait until specific text appears on the page", { session_id: exports_external.string(), text: exports_external.string(), timeout: exports_external.number().optional().default(1e4), exact: exports_external.boolean().optional().default(false) }, async ({ session_id, text, timeout, exact }) => {
+  server.tool("browser_wait_for_text", "Wait until specific text appears on the page", { session_id: exports_external.string().optional(), text: exports_external.string(), timeout: exports_external.number().optional().default(1e4), exact: exports_external.boolean().optional().default(false) }, async ({ session_id, text, timeout, exact }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const start = Date.now();
       await waitForText(page, text, { timeout, exact });
       return json({ found: true, elapsed_ms: Date.now() - start });
@@ -34131,46 +35426,51 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_element_exists", "Check if a selector exists on the page (no throw, returns boolean)", { session_id: exports_external.string(), selector: exports_external.string(), check_visible: exports_external.boolean().optional().default(false) }, async ({ session_id, selector, check_visible }) => {
+  server.tool("browser_element_exists", "Check if a selector exists on the page (no throw, returns boolean)", { session_id: exports_external.string().optional(), selector: exports_external.string(), check_visible: exports_external.boolean().optional().default(false) }, async ({ session_id, selector, check_visible }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       return json(await elementExists(page, selector, { visible: check_visible }));
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_get_page_info", "Get a full page summary in one call: url, title, meta tags, link/image/form counts, text length", { session_id: exports_external.string() }, async ({ session_id }) => {
+  server.tool("browser_get_page_info", "Get a full page summary in one call: url, title, meta tags, link/image/form counts, text length", { session_id: exports_external.string().optional() }, async ({ session_id }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const info = await getPageInfo(page);
-      const errors2 = getConsoleLog(session_id, "error");
+      const errors2 = getConsoleLog(sid, "error");
       info.has_console_errors = errors2.length > 0;
       return json(info);
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_has_errors", "Quick check: does the session have any console errors?", { session_id: exports_external.string() }, async ({ session_id }) => {
+  server.tool("browser_has_errors", "Quick check: does the session have any console errors?", { session_id: exports_external.string().optional() }, async ({ session_id }) => {
     try {
-      const errors2 = getConsoleLog(session_id, "error");
+      const sid = resolveSessionId(session_id);
+      const errors2 = getConsoleLog(sid, "error");
       return json({ has_errors: errors2.length > 0, error_count: errors2.length, errors: errors2 });
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_clear_errors", "Clear console error log for a session", { session_id: exports_external.string() }, async ({ session_id }) => {
+  server.tool("browser_clear_errors", "Clear console error log for a session", { session_id: exports_external.string().optional() }, async ({ session_id }) => {
     try {
+      const sid = resolveSessionId(session_id);
       const { clearConsoleLog: clearConsoleLog2 } = await Promise.resolve().then(() => (init_console_log(), exports_console_log));
-      clearConsoleLog2(session_id);
+      clearConsoleLog2(sid);
       return json({ cleared: true });
     } catch (e) {
       return err(e);
     }
   });
   activeWatchHandles2 = new Map;
-  server.tool("browser_watch_start", "Start watching a page for DOM changes", { session_id: exports_external.string(), selector: exports_external.string().optional(), interval_ms: exports_external.number().optional().default(500), max_changes: exports_external.number().optional().default(50) }, async ({ session_id, selector, interval_ms, max_changes }) => {
+  server.tool("browser_watch_start", "Start watching a page for DOM changes", { session_id: exports_external.string().optional(), selector: exports_external.string().optional(), interval_ms: exports_external.number().optional().default(500), max_changes: exports_external.number().optional().default(50) }, async ({ session_id, selector, interval_ms, max_changes }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const handle = watchPage(page, { selector, intervalMs: interval_ms, maxChanges: max_changes });
       activeWatchHandles2.set(handle.id, handle);
       return json({ watch_id: handle.id });
@@ -34197,7 +35497,7 @@ var init_mcp = __esm(async () => {
   });
   server.tool("browser_gallery_list", "List screenshot gallery entries with optional filters", {
     project_id: exports_external.string().optional(),
-    session_id: exports_external.string().optional(),
+    session_id: exports_external.string().optional().optional(),
     tag: exports_external.string().optional(),
     is_favorite: exports_external.boolean().optional(),
     date_from: exports_external.string().optional(),
@@ -34285,14 +35585,14 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_downloads_list", "List all files in the downloads folder", { session_id: exports_external.string().optional() }, async ({ session_id }) => {
+  server.tool("browser_downloads_list", "List all files in the downloads folder", { session_id: exports_external.string().optional().optional() }, async ({ session_id }) => {
     try {
       return json({ downloads: listDownloads(session_id), count: listDownloads(session_id).length });
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_downloads_get", "Get a downloaded file by id, returning base64 content and metadata", { id: exports_external.string(), session_id: exports_external.string().optional() }, async ({ id, session_id }) => {
+  server.tool("browser_downloads_get", "Get a downloaded file by id, returning base64 content and metadata", { id: exports_external.string(), session_id: exports_external.string().optional().optional() }, async ({ id, session_id }) => {
     try {
       const file = getDownload(id, session_id);
       if (!file)
@@ -34303,7 +35603,7 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_downloads_delete", "Delete a downloaded file by id", { id: exports_external.string(), session_id: exports_external.string().optional() }, async ({ id, session_id }) => {
+  server.tool("browser_downloads_delete", "Delete a downloaded file by id", { id: exports_external.string(), session_id: exports_external.string().optional().optional() }, async ({ id, session_id }) => {
     try {
       const deleted = deleteDownload(id, session_id);
       return json({ deleted });
@@ -34318,7 +35618,7 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_downloads_export", "Copy a downloaded file to a target path", { id: exports_external.string(), target_path: exports_external.string(), session_id: exports_external.string().optional() }, async ({ id, target_path, session_id }) => {
+  server.tool("browser_downloads_export", "Copy a downloaded file to a target path", { id: exports_external.string(), target_path: exports_external.string(), session_id: exports_external.string().optional().optional() }, async ({ id, target_path, session_id }) => {
     try {
       const finalPath = exportToPath(id, target_path, session_id);
       return json({ path: finalPath });
@@ -34343,12 +35643,13 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_snapshot_diff", "Take a new accessibility snapshot and diff it against the last snapshot for this session. Shows added/removed/modified interactive elements.", { session_id: exports_external.string() }, async ({ session_id }) => {
+  server.tool("browser_snapshot_diff", "Take a new accessibility snapshot and diff it against the last snapshot for this session. Shows added/removed/modified interactive elements.", { session_id: exports_external.string().optional() }, async ({ session_id }) => {
     try {
-      const page = getSessionPage(session_id);
-      const before = getLastSnapshot(session_id);
-      const after = await takeSnapshot(page, session_id);
-      setLastSnapshot(session_id, after);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
+      const before = getLastSnapshot(sid);
+      const after = await takeSnapshot(page, sid);
+      setLastSnapshot(sid, after);
       if (!before) {
         return json({
           message: "No previous snapshot \u2014 returning current snapshot only.",
@@ -34371,12 +35672,13 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_session_stats", "Get session info and estimated token usage (based on network log, console log, and gallery entry sizes).", { session_id: exports_external.string() }, async ({ session_id }) => {
+  server.tool("browser_session_stats", "Get session info and estimated token usage (based on network log, console log, and gallery entry sizes).", { session_id: exports_external.string().optional() }, async ({ session_id }) => {
     try {
-      const session = getSession2(session_id);
-      const networkLog = getNetworkLog(session_id);
-      const consoleLog = getConsoleLog(session_id);
-      const galleryEntries = listEntries({ sessionId: session_id, limit: 1000 });
+      const sid = resolveSessionId(session_id);
+      const session = getSession2(sid);
+      const networkLog = getNetworkLog(sid);
+      const consoleLog = getConsoleLog(sid);
+      const galleryEntries = listEntries({ sessionId: sid, limit: 1000 });
       let totalChars = 0;
       for (const req of networkLog) {
         totalChars += (req.url?.length ?? 0) + (req.request_headers?.length ?? 0) + (req.response_headers?.length ?? 0) + (req.request_body?.length ?? 0);
@@ -34388,7 +35690,7 @@ var init_mcp = __esm(async () => {
         totalChars += (entry.url?.length ?? 0) + (entry.title?.length ?? 0) + (entry.notes?.length ?? 0) + (entry.tags?.join(",").length ?? 0);
       }
       const estimatedTokens = Math.ceil(totalChars / 4);
-      const tokenBudget = getTokenBudget(session_id);
+      const tokenBudget = getTokenBudget(sid);
       return json({
         session,
         network_request_count: networkLog.length,
@@ -34402,52 +35704,57 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_tab_new", "Open a new tab in the session's browser context, optionally navigating to a URL", { session_id: exports_external.string(), url: exports_external.string().optional() }, async ({ session_id, url }) => {
+  server.tool("browser_tab_new", "Open a new tab in the session's browser context, optionally navigating to a URL", { session_id: exports_external.string().optional(), url: exports_external.string().optional() }, async ({ session_id, url }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const tab = await newTab(page, url);
       return json(tab);
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_tab_list", "List all open tabs in the session's browser context", { session_id: exports_external.string() }, async ({ session_id }) => {
+  server.tool("browser_tab_list", "List all open tabs in the session's browser context", { session_id: exports_external.string().optional() }, async ({ session_id }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const tabs = await listTabs(page);
       return json({ tabs, count: tabs.length });
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_tab_switch", "Switch to a different tab by index. Updates the session's active page.", { session_id: exports_external.string(), tab_id: exports_external.number() }, async ({ session_id, tab_id }) => {
+  server.tool("browser_tab_switch", "Switch to a different tab by index. Updates the session's active page.", { session_id: exports_external.string().optional(), tab_id: exports_external.number() }, async ({ session_id, tab_id }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const result = await switchTab(page, tab_id);
-      setSessionPage(session_id, result.page);
+      setSessionPage(sid, result.page);
       return json(result.tab);
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_tab_close", "Close a tab by index. Cannot close the last tab.", { session_id: exports_external.string(), tab_id: exports_external.number() }, async ({ session_id, tab_id }) => {
+  server.tool("browser_tab_close", "Close a tab by index. Cannot close the last tab.", { session_id: exports_external.string().optional(), tab_id: exports_external.number() }, async ({ session_id, tab_id }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const context = page.context();
       const result = await closeTab(page, tab_id);
       const remainingPages = context.pages();
       const newActivePage = remainingPages[result.active_tab.index];
       if (newActivePage) {
-        setSessionPage(session_id, newActivePage);
+        setSessionPage(sid, newActivePage);
       }
       return json(result);
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_handle_dialog", "Accept or dismiss a pending dialog (alert, confirm, prompt). Handles the oldest pending dialog.", { session_id: exports_external.string(), action: exports_external.enum(["accept", "dismiss"]), prompt_text: exports_external.string().optional() }, async ({ session_id, action, prompt_text }) => {
+  server.tool("browser_handle_dialog", "Accept or dismiss a pending dialog (alert, confirm, prompt). Handles the oldest pending dialog.", { session_id: exports_external.string().optional(), action: exports_external.enum(["accept", "dismiss"]), prompt_text: exports_external.string().optional() }, async ({ session_id, action, prompt_text }) => {
     try {
-      const result = await handleDialog(session_id, action, prompt_text);
+      const sid = resolveSessionId(session_id);
+      const result = await handleDialog(sid, action, prompt_text);
       if (!result.handled)
         return err(new Error("No pending dialogs for this session"));
       return json(result);
@@ -34455,28 +35762,31 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_get_dialogs", "Get all pending dialogs for a session", { session_id: exports_external.string() }, async ({ session_id }) => {
+  server.tool("browser_get_dialogs", "Get all pending dialogs for a session", { session_id: exports_external.string().optional() }, async ({ session_id }) => {
     try {
-      const dialogs = getDialogs(session_id);
+      const sid = resolveSessionId(session_id);
+      const dialogs = getDialogs(sid);
       return json({ dialogs, count: dialogs.length });
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_profile_save", "Save cookies + localStorage from the current session as a named profile", { session_id: exports_external.string(), name: exports_external.string() }, async ({ session_id, name }) => {
+  server.tool("browser_profile_save", "Save cookies + localStorage from the current session as a named profile", { session_id: exports_external.string().optional(), name: exports_external.string() }, async ({ session_id, name }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const info = await saveProfile(page, name);
       return json(info);
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_profile_load", "Load a saved profile and apply cookies + localStorage to the current session", { session_id: exports_external.string().optional(), name: exports_external.string() }, async ({ session_id, name }) => {
+  server.tool("browser_profile_load", "Load a saved profile and apply cookies + localStorage to the current session", { session_id: exports_external.string().optional().optional(), name: exports_external.string() }, async ({ session_id, name }) => {
     try {
       const profileData = loadProfile(name);
       if (session_id) {
-        const page = getSessionPage(session_id);
+        const sid = resolveSessionId(session_id);
+        const page = getSessionPage(sid);
         const applied = await applyProfile(page, profileData);
         return json({ ...applied, profile: name });
       }
@@ -34525,6 +35835,7 @@ var init_mcp = __esm(async () => {
           { tool: "browser_wait", description: "Wait for a selector to appear" },
           { tool: "browser_wait_for_text", description: "Wait for text to appear" },
           { tool: "browser_fill_form", description: "Fill multiple form fields at once" },
+          { tool: "browser_find_visual", description: "Find element using AI vision (for canvas, images, custom widgets)" },
           { tool: "browser_handle_dialog", description: "Accept or dismiss a dialog" }
         ],
         Extraction: [
@@ -34553,7 +35864,10 @@ var init_mcp = __esm(async () => {
           { tool: "browser_profile_save", description: "Save cookies + localStorage as profile" },
           { tool: "browser_profile_load", description: "Load and apply a saved profile" },
           { tool: "browser_profile_list", description: "List saved profiles" },
-          { tool: "browser_profile_delete", description: "Delete a saved profile" }
+          { tool: "browser_profile_delete", description: "Delete a saved profile" },
+          { tool: "browser_session_save_state", description: "Save auth state (Playwright storageState) for reuse" },
+          { tool: "browser_session_list_states", description: "List saved storage states" },
+          { tool: "browser_session_delete_state", description: "Delete a saved storage state" }
         ],
         Network: [
           { tool: "browser_network_log", description: "Get captured network requests" },
@@ -34577,6 +35891,13 @@ var init_mcp = __esm(async () => {
           { tool: "browser_record_replay", description: "Replay a recorded sequence" },
           { tool: "browser_recordings_list", description: "List all recordings" }
         ],
+        Auth: [
+          { tool: "browser_auth_record", description: "Start recording a login flow" },
+          { tool: "browser_auth_stop", description: "Stop recording and save auth flow" },
+          { tool: "browser_auth_replay", description: "Replay a saved auth flow" },
+          { tool: "browser_auth_list", description: "List all saved auth flows" },
+          { tool: "browser_auth_delete", description: "Delete a saved auth flow" }
+        ],
         Crawl: [
           { tool: "browser_crawl", description: "Crawl a URL recursively" }
         ],
@@ -34614,7 +35935,13 @@ var init_mcp = __esm(async () => {
           { tool: "browser_session_close", description: "Close a session" },
           { tool: "browser_session_get_by_name", description: "Get session by name" },
           { tool: "browser_session_rename", description: "Rename a session" },
+          { tool: "browser_session_lock", description: "Lock a session for an agent" },
+          { tool: "browser_session_unlock", description: "Unlock a session" },
+          { tool: "browser_session_transfer", description: "Transfer session to another agent" },
+          { tool: "browser_session_tag", description: "Add a tag to a session" },
+          { tool: "browser_session_untag", description: "Remove a tag from a session" },
           { tool: "browser_session_stats", description: "Get session stats and token usage" },
+          { tool: "browser_session_timeline", description: "Get chronological action log" },
           { tool: "browser_tab_new", description: "Open a new tab" },
           { tool: "browser_tab_list", description: "List all open tabs" },
           { tool: "browser_tab_switch", description: "Switch to a tab by index" },
@@ -34627,7 +35954,8 @@ var init_mcp = __esm(async () => {
           { tool: "browser_snapshot_diff", description: "Diff current snapshot vs previous" },
           { tool: "browser_watch_start", description: "Watch page for DOM changes" },
           { tool: "browser_watch_get_changes", description: "Get captured DOM changes" },
-          { tool: "browser_watch_stop", description: "Stop DOM watcher" }
+          { tool: "browser_watch_stop", description: "Stop DOM watcher" },
+          { tool: "browser_parallel", description: "Execute actions across multiple sessions in parallel" }
         ]
       };
       const totalTools = Object.values(groups).reduce((sum, g) => sum + g.length, 0);
@@ -34652,18 +35980,19 @@ var init_mcp = __esm(async () => {
     }
   });
   server.tool("browser_scroll_to_element", "Scroll an element into view (by ref or selector) then optionally take a screenshot of it. Replaces scroll + wait + screenshot pattern.", {
-    session_id: exports_external.string(),
+    session_id: exports_external.string().optional(),
     selector: exports_external.string().optional(),
     ref: exports_external.string().optional(),
     screenshot: exports_external.boolean().optional().default(true),
     wait_ms: exports_external.number().optional().default(200)
   }, async ({ session_id, selector, ref, screenshot: doScreenshot, wait_ms }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       let locator;
       if (ref) {
         const { getRefLocator: getRefLocator2 } = await Promise.resolve().then(() => (init_snapshot(), exports_snapshot));
-        locator = getRefLocator2(page, session_id, ref);
+        locator = getRefLocator2(page, sid, ref);
       } else if (selector) {
         locator = page.locator(selector).first();
       } else {
@@ -34688,11 +36017,12 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_check", "RECOMMENDED FIRST CALL: one-shot page summary \u2014 url, title, errors, performance, thumbnail, refs. Replaces 4+ separate tool calls.", { session_id: exports_external.string() }, async ({ session_id }) => {
+  server.tool("browser_check", "RECOMMENDED FIRST CALL: one-shot page summary \u2014 url, title, errors, performance, thumbnail, refs. Replaces 4+ separate tool calls.", { session_id: exports_external.string().optional() }, async ({ session_id }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const info = await getPageInfo(page);
-      const errors2 = getConsoleLog(session_id, "error");
+      const errors2 = getConsoleLog(sid, "error");
       info.has_console_errors = errors2.length > 0;
       let perf = {};
       try {
@@ -34706,8 +36036,8 @@ var init_mcp = __esm(async () => {
       let snapshot_refs = "";
       let interactive_count = 0;
       try {
-        const snap = await takeSnapshot(page, session_id);
-        setLastSnapshot(session_id, snap);
+        const snap = await takeSnapshot(page, sid);
+        setLastSnapshot(sid, snap);
         interactive_count = snap.interactive_count;
         snapshot_refs = Object.entries(snap.refs).slice(0, 30).map(([ref, i]) => `${i.role}:${i.name.slice(0, 50)} [${ref}]`).join(", ");
       } catch {}
@@ -34716,9 +36046,10 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_secrets_login", "Login to a service using credentials from open-secrets vault or ~/.secrets. One call replaces 10+ tool calls.", { session_id: exports_external.string(), service: exports_external.string(), login_url: exports_external.string().optional(), save_profile: exports_external.boolean().optional().default(true) }, async ({ session_id, service, login_url, save_profile }) => {
+  server.tool("browser_secrets_login", "Login to a service using credentials from open-secrets vault or ~/.secrets. One call replaces 10+ tool calls.", { session_id: exports_external.string().optional(), service: exports_external.string(), login_url: exports_external.string().optional(), save_profile: exports_external.boolean().optional().default(true) }, async ({ session_id, service, login_url, save_profile }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const { getCredentials: getCredentials2, loginWithCredentials: loginWithCredentials2 } = await Promise.resolve().then(() => (init_auth(), exports_auth));
       const creds = await getCredentials2(service);
       if (!creds)
@@ -34732,9 +36063,10 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_remember", "Store page facts in open-mementos for future recall. Agents skip re-scraping on repeat visits.", { session_id: exports_external.string(), facts: exports_external.record(exports_external.unknown()), tags: exports_external.array(exports_external.string()).optional() }, async ({ session_id, facts, tags }) => {
+  server.tool("browser_remember", "Store page facts in open-mementos for future recall. Agents skip re-scraping on repeat visits.", { session_id: exports_external.string().optional(), facts: exports_external.record(exports_external.unknown()), tags: exports_external.array(exports_external.string()).optional() }, async ({ session_id, facts, tags }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const { rememberPage: rememberPage2 } = await Promise.resolve().then(() => (init_page_memory(), exports_page_memory));
       const url = page.url();
       await rememberPage2(url, facts, tags);
@@ -34752,12 +36084,13 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_session_announce", "Announce to other agents via open-conversations what this session is browsing.", { session_id: exports_external.string(), message: exports_external.string().optional() }, async ({ session_id, message }) => {
+  server.tool("browser_session_announce", "Announce to other agents via open-conversations what this session is browsing.", { session_id: exports_external.string().optional(), message: exports_external.string().optional() }, async ({ session_id, message }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const { announceNavigation: announceNavigation2 } = await Promise.resolve().then(() => (init_coordination(), exports_coordination));
       const url = page.url();
-      await announceNavigation2(url, session_id);
+      await announceNavigation2(url, sid);
       return json({ announced: true, url, message });
     } catch (e) {
       return err(e);
@@ -34797,9 +36130,10 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_skill_run", "Run a pre-built browser skill (login, extract-pricing, extract-nav-links, monitor-price, get-metadata). One call replaces 5\u201315 tool calls.", { session_id: exports_external.string(), skill: exports_external.string(), params: exports_external.record(exports_external.unknown()).optional().default({}) }, async ({ session_id, skill, params }) => {
+  server.tool("browser_skill_run", "Run a pre-built browser skill (login, extract-pricing, extract-nav-links, monitor-price, get-metadata). One call replaces 5\u201315 tool calls.", { session_id: exports_external.string().optional(), skill: exports_external.string(), params: exports_external.record(exports_external.unknown()).optional().default({}) }, async ({ session_id, skill, params }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const { runBrowserSkill: runBrowserSkill2 } = await Promise.resolve().then(() => (init_skills_runner(), exports_skills_runner));
       return json(await runBrowserSkill2(skill, params, page));
     } catch (e) {
@@ -34815,7 +36149,7 @@ var init_mcp = __esm(async () => {
     }
   });
   server.tool("browser_batch", "Execute multiple browser actions in one call. Returns final snapshot. Eliminates 80% of round trips for multi-step flows.", {
-    session_id: exports_external.string(),
+    session_id: exports_external.string().optional(),
     actions: exports_external.array(exports_external.object({
       tool: exports_external.string(),
       args: exports_external.record(exports_external.unknown()).optional().default({})
@@ -34823,12 +36157,13 @@ var init_mcp = __esm(async () => {
   }, async ({ session_id, actions }) => {
     try {
       const results = [];
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const t0 = Date.now();
       for (const action of actions) {
         try {
           const toolName = action.tool.replace(/^browser_/, "");
-          const args = { session_id, ...action.args };
+          const args = { session_id: sid, ...action.args };
           switch (toolName) {
             case "navigate":
               await navigate(page, action.args.url);
@@ -34837,7 +36172,7 @@ var init_mcp = __esm(async () => {
             case "click":
               if (args.ref) {
                 const { clickRef: clickRef2 } = await Promise.resolve().then(() => (init_actions(), exports_actions));
-                await clickRef2(page, session_id, args.ref);
+                await clickRef2(page, sid, args.ref);
               } else if (args.selector)
                 await page.click(args.selector);
               results.push({ tool: action.tool, success: true });
@@ -34845,7 +36180,7 @@ var init_mcp = __esm(async () => {
             case "type":
               if (args.ref && args.text) {
                 const { typeRef: typeRef2 } = await Promise.resolve().then(() => (init_actions(), exports_actions));
-                await typeRef2(page, session_id, args.ref, args.text);
+                await typeRef2(page, sid, args.ref, args.text);
               } else if (args.selector && args.text)
                 await page.fill(args.selector, args.text);
               results.push({ tool: action.tool, success: true });
@@ -34885,7 +36220,7 @@ var init_mcp = __esm(async () => {
       }
       let final_snapshot = {};
       try {
-        const snap = await takeSnapshot(page, session_id);
+        const snap = await takeSnapshot(page, sid);
         final_snapshot = {
           refs: Object.fromEntries(Object.entries(snap.refs).slice(0, 20)),
           interactive_count: snap.interactive_count
@@ -34903,6 +36238,82 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
+  server.tool("browser_parallel", "Execute actions across multiple sessions in parallel. Each action targets a different session. Returns results array.", {
+    actions: exports_external.array(exports_external.object({
+      session_id: exports_external.string().describe("Target session ID"),
+      tool: exports_external.string().describe("Tool name (e.g. browser_navigate, browser_screenshot, browser_click)"),
+      args: exports_external.record(exports_external.unknown()).optional().default({})
+    })),
+    timeout: exports_external.number().optional().default(30000).describe("Timeout per action in ms")
+  }, async ({ actions, timeout }) => {
+    try {
+      const t0 = Date.now();
+      const promises = actions.map(async (action, index) => {
+        try {
+          const sid = action.session_id;
+          const page = getSessionPage(sid);
+          const args = action.args;
+          const toolName = action.tool.replace(/^browser_/, "");
+          const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Timeout after ${timeout}ms`)), timeout));
+          const actionPromise = (async () => {
+            switch (toolName) {
+              case "navigate": {
+                await navigate(page, args.url);
+                const title = await page.title();
+                return { url: page.url(), title };
+              }
+              case "screenshot": {
+                const result2 = await takeScreenshot(page, {
+                  maxWidth: args.max_width ?? 800,
+                  quality: args.quality ?? 60
+                });
+                return { path: result2.path, size_bytes: result2.size_bytes };
+              }
+              case "click": {
+                if (args.selector)
+                  await click(page, args.selector);
+                return { clicked: args.selector };
+              }
+              case "type": {
+                if (args.selector && args.text)
+                  await type(page, args.selector, args.text);
+                return { typed: args.text };
+              }
+              case "get_text": {
+                const text = await getText(page);
+                return { text: text.slice(0, 1000), length: text.length };
+              }
+              case "get_links": {
+                const links = await getLinks(page);
+                return { links, count: links.length };
+              }
+              case "snapshot": {
+                const snap = await takeSnapshot(page, sid);
+                return { interactive_count: snap.interactive_count, refs_count: Object.keys(snap.refs).length };
+              }
+              case "evaluate": {
+                const result2 = await page.evaluate(args.expression);
+                return { result: result2 };
+              }
+              default:
+                return { error: `Unknown tool: ${action.tool}` };
+            }
+          })();
+          const result = await Promise.race([actionPromise, timeoutPromise]);
+          return { index, session_id: sid, tool: action.tool, success: true, result };
+        } catch (e) {
+          return { index, session_id: action.session_id, tool: action.tool, success: false, error: e instanceof Error ? e.message : String(e) };
+        }
+      });
+      const results = await Promise.all(promises);
+      const duration_ms = Date.now() - t0;
+      const succeeded = results.filter((r) => r.success).length;
+      const failed = results.filter((r) => !r.success).length;
+      return json({ results, duration_ms, succeeded, failed, total: actions.length });
+    } catch (e) {
+      return err(e);
+    }
+  });
   server.tool("browser_pool_status", "Get status of the pre-warmed browser session pool.", {}, async () => {
     try {
       return json({ message: "Session pool not yet implemented in this version. Coming in v0.0.6+", ready: 0, total: 0 });
@@ -34982,18 +36393,20 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
-  server.tool("browser_task", "Execute a natural language browser task autonomously using Claude Haiku. Returns result + steps taken.", { session_id: exports_external.string(), task: exports_external.string(), max_steps: exports_external.number().optional().default(10), model: exports_external.string().optional() }, async ({ session_id, task, max_steps, model }) => {
+  server.tool("browser_task", "Execute a natural language browser task autonomously using Claude Haiku. Returns result + steps taken.", { session_id: exports_external.string().optional(), task: exports_external.string(), max_steps: exports_external.number().optional().default(10), model: exports_external.string().optional() }, async ({ session_id, task, max_steps, model }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const { executeBrowserTask: executeBrowserTask2 } = await Promise.resolve().then(() => (init_ai_task(), exports_ai_task));
-      return json(await executeBrowserTask2(page, task, { maxSteps: max_steps, model, sessionId: session_id }));
+      return json(await executeBrowserTask2(page, task, { maxSteps: max_steps, model, sessionId: sid }));
     } catch (e) {
       return err(e);
     }
   });
-  server.tool("browser_assert", `Assert page conditions in one call. Conditions: 'url contains X', 'text:"Y" is visible', 'element:"#id" exists', 'count:"a" > 10', 'title contains Z'. Chain with AND.`, { session_id: exports_external.string(), condition: exports_external.string() }, async ({ session_id, condition }) => {
+  server.tool("browser_assert", `Assert page conditions in one call. Conditions: 'url contains X', 'text:"Y" is visible', 'element:"#id" exists', 'count:"a" > 10', 'title contains Z'. Chain with AND.`, { session_id: exports_external.string().optional(), condition: exports_external.string() }, async ({ session_id, condition }) => {
     try {
-      const page = getSessionPage(session_id);
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
       const checks = [];
       let passed = true;
       for (const part of condition.split(/\s+AND\s+/i)) {
@@ -35055,10 +36468,10 @@ __export(exports_snapshots, {
   deleteSnapshot: () => deleteSnapshot,
   createSnapshot: () => createSnapshot
 });
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID14 } from "crypto";
 function createSnapshot(data) {
   const db2 = getDatabase();
-  const id = randomUUID13();
+  const id = randomUUID14();
   db2.prepare("INSERT INTO snapshots (id, session_id, url, title, html, screenshot_path) VALUES (?, ?, ?, ?, ?, ?)").run(id, data.session_id, data.url, data.title ?? null, data.html ?? null, data.screenshot_path ?? null);
   return getSnapshot(id);
 }
@@ -35084,8 +36497,8 @@ var init_snapshots = __esm(() => {
 
 // src/server/index.ts
 var exports_server = {};
-import { join as join14 } from "path";
-import { existsSync as existsSync8 } from "fs";
+import { join as join15 } from "path";
+import { existsSync as existsSync9 } from "fs";
 function ok(data, status = 200) {
   return new Response(JSON.stringify(data), {
     status,
@@ -35335,14 +36748,14 @@ var init_server = __esm(() => {
         if (path.match(/^\/api\/gallery\/([^/]+)\/thumbnail$/) && method === "GET") {
           const id = path.split("/")[3];
           const entry = getEntry(id);
-          if (!entry?.thumbnail_path || !existsSync8(entry.thumbnail_path))
+          if (!entry?.thumbnail_path || !existsSync9(entry.thumbnail_path))
             return notFound("Thumbnail not found");
           return new Response(Bun.file(entry.thumbnail_path), { headers: { ...CORS_HEADERS } });
         }
         if (path.match(/^\/api\/gallery\/([^/]+)\/image$/) && method === "GET") {
           const id = path.split("/")[3];
           const entry = getEntry(id);
-          if (!entry?.path || !existsSync8(entry.path))
+          if (!entry?.path || !existsSync9(entry.path))
             return notFound("Image not found");
           return new Response(Bun.file(entry.path), { headers: { ...CORS_HEADERS } });
         }
@@ -35370,7 +36783,7 @@ var init_server = __esm(() => {
         if (path.match(/^\/api\/downloads\/([^/]+)\/raw$/) && method === "GET") {
           const id = path.split("/")[3];
           const file = getDownload(id);
-          if (!file || !existsSync8(file.path))
+          if (!file || !existsSync9(file.path))
             return notFound("Download not found");
           return new Response(Bun.file(file.path), { headers: { ...CORS_HEADERS } });
         }
@@ -35378,13 +36791,13 @@ var init_server = __esm(() => {
           const id = path.split("/")[3];
           return ok({ deleted: deleteDownload(id) });
         }
-        const dashboardDist = join14(import.meta.dir, "../../dashboard/dist");
-        if (existsSync8(dashboardDist)) {
-          const filePath = path === "/" ? join14(dashboardDist, "index.html") : join14(dashboardDist, path);
-          if (existsSync8(filePath)) {
+        const dashboardDist = join15(import.meta.dir, "../../dashboard/dist");
+        if (existsSync9(dashboardDist)) {
+          const filePath = path === "/" ? join15(dashboardDist, "index.html") : join15(dashboardDist, path);
+          if (existsSync9(filePath)) {
             return new Response(Bun.file(filePath), { headers: CORS_HEADERS });
           }
-          return new Response(Bun.file(join14(dashboardDist, "index.html")), { headers: CORS_HEADERS });
+          return new Response(Bun.file(join15(dashboardDist, "index.html")), { headers: CORS_HEADERS });
         }
         if (path === "/" || path === "") {
           return new Response("@hasna/browser REST API running. Dashboard not built.", {
@@ -35427,31 +36840,71 @@ init_recorder();
 init_recordings();
 init_lightpanda();
 import { readFileSync as readFileSync9 } from "fs";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 import chalk from "chalk";
-var pkg = JSON.parse(readFileSync9(join15(import.meta.dir, "../../package.json"), "utf8"));
+var pkg = JSON.parse(readFileSync9(join16(import.meta.dir, "../../package.json"), "utf8"));
 var program2 = new Command;
 program2.name("browser").description("@hasna/browser \u2014 general-purpose browser agent CLI").version(pkg.version);
-program2.command("navigate <url>").description("Navigate to a URL and optionally take a screenshot").option("--engine <engine>", "Browser engine: playwright|cdp|lightpanda|auto", "auto").option("--screenshot", "Take a screenshot after navigation").option("--extract", "Extract page text after navigation").option("--headless", "Run in headless mode (default: true)", true).action(async (url, opts) => {
-  const { session, page } = await createSession2({ engine: opts.engine, headless: true });
-  console.log(chalk.gray(`Session: ${session.id} (${session.engine})`));
+program2.command("navigate <url>").description("Navigate to a URL and optionally take a screenshot").option("--engine <engine>", "Browser engine: playwright|cdp|lightpanda|auto", "auto").option("--screenshot", "Take a screenshot after navigation").option("--extract", "Extract page text after navigation").option("--headed", "Run in headed (visible) mode").option("--json", "Output as JSON").action(async (url, opts) => {
+  const { session, page } = await createSession2({ engine: opts.engine, headless: !opts.headed });
   await navigate(page, url);
   const title = await page.title();
-  console.log(chalk.green(`\u2713 Navigated to: ${url}`));
-  console.log(chalk.blue(`  Title: ${title}`));
+  let screenshotPath;
   if (opts.screenshot) {
     const result = await takeScreenshot(page);
-    console.log(chalk.blue(`  Screenshot: ${result.path}`));
+    screenshotPath = result.path;
   }
+  let text;
   if (opts.extract) {
-    const text = await getText(page);
-    console.log(chalk.white(`
+    text = await getText(page);
+  }
+  if (opts.json) {
+    const output = { session_id: session.id, engine: session.engine, url, title };
+    if (screenshotPath)
+      output.screenshot = screenshotPath;
+    if (text)
+      output.text = text.slice(0, 500);
+    console.log(JSON.stringify(output, null, 2));
+  } else {
+    console.log(chalk.gray(`Session: ${session.id} (${session.engine})`));
+    console.log(chalk.green(`\u2713 Navigated to: ${url}`));
+    console.log(chalk.blue(`  Title: ${title}`));
+    if (screenshotPath)
+      console.log(chalk.blue(`  Screenshot: ${screenshotPath}`));
+    if (text)
+      console.log(chalk.white(`
 ${text.slice(0, 500)}...`));
   }
   await closeSession2(session.id);
 });
-program2.command("screenshot <url>").description("Navigate to a URL and take a screenshot").option("--engine <engine>", "Browser engine", "auto").option("--selector <selector>", "CSS selector for element screenshot").option("--full-page", "Capture full page").option("--format <format>", "Image format: png|jpeg|webp", "png").action(async (url, opts) => {
-  const { session, page } = await createSession2({ engine: opts.engine, headless: true });
+program2.command("check <url>").description("One-liner page health check: navigate, screenshot, extract info, check errors").option("--engine <engine>", "Browser engine", "auto").option("--headed", "Run in headed (visible) mode").option("--json", "Output as JSON").action(async (url, opts) => {
+  const { session, page } = await createSession2({ engine: opts.engine, headless: !opts.headed });
+  await navigate(page, url);
+  const title = await page.title();
+  const currentUrl = page.url();
+  const text = await getText(page);
+  const links = await getLinks(page);
+  const result = await takeScreenshot(page);
+  const summary = {
+    url: currentUrl,
+    title,
+    text_length: text.length,
+    links_count: links.length,
+    screenshot: result.path,
+    screenshot_size_kb: +(result.size_bytes / 1024).toFixed(1)
+  };
+  if (opts.json) {
+    console.log(JSON.stringify(summary, null, 2));
+  } else {
+    console.log(chalk.green(`\u2713 ${title}`));
+    console.log(chalk.blue(`  URL: ${currentUrl}`));
+    console.log(chalk.gray(`  Text: ${text.length} chars, Links: ${links.length}`));
+    console.log(chalk.gray(`  Screenshot: ${result.path} (${summary.screenshot_size_kb} KB)`));
+  }
+  await closeSession2(session.id);
+});
+program2.command("screenshot <url>").description("Navigate to a URL and take a screenshot").option("--engine <engine>", "Browser engine", "auto").option("--selector <selector>", "CSS selector for element screenshot").option("--full-page", "Capture full page").option("--format <format>", "Image format: png|jpeg|webp", "png").option("--headed", "Run in headed (visible) mode").action(async (url, opts) => {
+  const { session, page } = await createSession2({ engine: opts.engine, headless: !opts.headed });
   await navigate(page, url);
   const result = await takeScreenshot(page, {
     selector: opts.selector,
@@ -35462,11 +36915,13 @@ program2.command("screenshot <url>").description("Navigate to a URL and take a s
   console.log(chalk.gray(`  Size: ${(result.size_bytes / 1024).toFixed(1)} KB`));
   await closeSession2(session.id);
 });
-program2.command("extract <url>").description("Extract content from a URL").option("--engine <engine>", "Browser engine", "auto").option("--selector <selector>", "CSS selector").option("--format <format>", "Format: text|html|links|table|structured", "text").action(async (url, opts) => {
-  const { session, page } = await createSession2({ engine: opts.engine, headless: true });
+program2.command("extract <url>").description("Extract content from a URL").option("--engine <engine>", "Browser engine", "auto").option("--selector <selector>", "CSS selector").option("--format <format>", "Format: text|html|links|table|structured", "text").option("--headed", "Run in headed (visible) mode").option("--json", "Output as JSON").action(async (url, opts) => {
+  const { session, page } = await createSession2({ engine: opts.engine, headless: !opts.headed });
   await navigate(page, url);
   const result = await extract(page, { format: opts.format, selector: opts.selector });
-  if (opts.format === "links" && result.links) {
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else if (opts.format === "links" && result.links) {
     result.links.forEach((l) => console.log(l));
   } else if (opts.format === "table" && result.table) {
     result.table.forEach((row) => console.log(row.join("\t")));
@@ -35475,8 +36930,8 @@ program2.command("extract <url>").description("Extract content from a URL").opti
   }
   await closeSession2(session.id);
 });
-program2.command("eval <url> <script>").description("Run JavaScript in a page context").option("--engine <engine>", "Browser engine", "auto").action(async (url, script, opts) => {
-  const { session, page } = await createSession2({ engine: opts.engine, headless: true });
+program2.command("eval <url> <script>").description("Run JavaScript in a page context").option("--engine <engine>", "Browser engine", "auto").option("--headed", "Run in headed (visible) mode").action(async (url, script, opts) => {
+  const { session, page } = await createSession2({ engine: opts.engine, headless: !opts.headed });
   await navigate(page, url);
   const result = await page.evaluate(script);
   console.log(JSON.stringify(result, null, 2));
@@ -35502,14 +36957,16 @@ ${result.errors.length} errors:`));
   }
 });
 var sessionCmd = program2.command("session").description("Manage browser sessions");
-sessionCmd.command("create").description("Create a new browser session").option("--engine <engine>", "Browser engine", "auto").option("--url <url>", "Start URL").action(async (opts) => {
-  const { session } = await createSession2({ engine: opts.engine, startUrl: opts.url });
+sessionCmd.command("create").description("Create a new browser session").option("--engine <engine>", "Browser engine", "auto").option("--url <url>", "Start URL").option("--headed", "Run in headed (visible) mode").action(async (opts) => {
+  const { session } = await createSession2({ engine: opts.engine, startUrl: opts.url, headless: !opts.headed });
   console.log(chalk.green(`\u2713 Session created`));
   console.log(JSON.stringify(session, null, 2));
 });
-sessionCmd.command("list").description("List all sessions").option("--status <status>", "Filter by status").action((opts) => {
+sessionCmd.command("list").description("List all sessions").option("--status <status>", "Filter by status").option("--json", "Output as JSON").action((opts) => {
   const sessions = listSessions2(opts.status ? { status: opts.status } : undefined);
-  if (sessions.length === 0) {
+  if (opts.json) {
+    console.log(JSON.stringify(sessions, null, 2));
+  } else if (sessions.length === 0) {
     console.log(chalk.gray("No sessions found"));
   } else {
     sessions.forEach((s) => console.log(`${s.id} [${s.status}] ${s.engine} ${s.start_url ?? ""}`));
@@ -35519,9 +36976,25 @@ sessionCmd.command("close <id>").description("Close a session").action(async (id
   await closeSession2(id);
   console.log(chalk.green(`\u2713 Session closed: ${id}`));
 });
+sessionCmd.command("save-state <name>").description("Save current session auth state for reuse").requiredOption("--session <id>", "Session ID").action(async (name, opts) => {
+  const page = getSessionPage(opts.session);
+  const { saveStateFromPage: saveStateFromPage2 } = await Promise.resolve().then(() => (init_storage_state(), exports_storage_state));
+  const path = await saveStateFromPage2(page, name);
+  console.log(chalk.green(`\u2713 State saved: ${name}`));
+  console.log(chalk.gray(`  Path: ${path}`));
+});
+sessionCmd.command("list-states").description("List saved auth states").action(async () => {
+  const { listStates: listStates2 } = await Promise.resolve().then(() => (init_storage_state(), exports_storage_state));
+  const states = listStates2();
+  if (states.length === 0) {
+    console.log(chalk.gray("No saved states"));
+    return;
+  }
+  states.forEach((s) => console.log(`${s.name} ${chalk.gray(s.modified)}`));
+});
 var recordCmd = program2.command("record").description("Manage action recordings");
-recordCmd.command("start <name>").description("Start recording actions in a new session").option("--url <url>", "Start URL").option("--engine <engine>", "Browser engine", "auto").action(async (name, opts) => {
-  const { session } = await createSession2({ engine: opts.engine, startUrl: opts.url });
+recordCmd.command("start <name>").description("Start recording actions in a new session").option("--url <url>", "Start URL").option("--engine <engine>", "Browser engine", "auto").option("--headed", "Run in headed (visible) mode").action(async (name, opts) => {
+  const { session } = await createSession2({ engine: opts.engine, startUrl: opts.url, headless: !opts.headed });
   const recording = startRecording(session.id, name, opts.url);
   console.log(chalk.green(`\u2713 Recording started`));
   console.log(`  Recording ID: ${recording.id}`);
@@ -35532,8 +37005,8 @@ recordCmd.command("stop <recording_id>").description("Stop an active recording")
   console.log(chalk.green(`\u2713 Recording stopped: ${recording.name}`));
   console.log(`  Steps: ${recording.steps.length}`);
 });
-recordCmd.command("replay <recording_id>").description("Replay a recording in a new session").option("--url <url>", "Override start URL").option("--engine <engine>", "Browser engine", "auto").action(async (id, opts) => {
-  const { session, page } = await createSession2({ engine: opts.engine, startUrl: opts.url });
+recordCmd.command("replay <recording_id>").description("Replay a recording in a new session").option("--url <url>", "Override start URL").option("--engine <engine>", "Browser engine", "auto").option("--headed", "Run in headed (visible) mode").action(async (id, opts) => {
+  const { session, page } = await createSession2({ engine: opts.engine, startUrl: opts.url, headless: !opts.headed });
   const result = await replayRecording(id, page);
   console.log(result.success ? chalk.green("\u2713 Replay complete") : chalk.red("\u2717 Replay had errors"));
   console.log(`  Steps: ${result.steps_executed} executed, ${result.steps_failed} failed`);
@@ -35581,6 +37054,19 @@ projectCmd.command("list").description("List all projects").action(() => {
     projects.forEach((p) => console.log(`${p.id} "${p.name}" ${p.path}`));
   }
 });
+program2.command("attach").description("Attach to a running Chrome browser via CDP").option("--port <port>", "Chrome debugging port", "9222").option("--host <host>", "Chrome debugging host", "localhost").option("--json", "Output as JSON").action(async (opts) => {
+  const cdpUrl = `http://${opts.host}:${opts.port}`;
+  const { session, page } = await createSession2({ cdpUrl });
+  const title = await page.title();
+  const url = page.url();
+  if (opts.json) {
+    console.log(JSON.stringify({ session_id: session.id, url, title, cdp_url: cdpUrl }));
+  } else {
+    console.log(chalk.green(`\u2713 Attached to Chrome at ${cdpUrl}`));
+    console.log(chalk.blue(`  Session: ${session.id}`));
+    console.log(chalk.blue(`  Page: ${title} (${url})`));
+  }
+});
 program2.command("install-browser").description("Install a browser engine").option("--engine <engine>", "Engine to install: lightpanda|chromium", "chromium").action(async (opts) => {
   if (opts.engine === "chromium") {
     const { execSync: execSync3 } = await import("child_process");
@@ -35672,11 +37158,11 @@ galleryCmd.command("stats").description("Show gallery statistics").option("--pro
 });
 galleryCmd.command("clean").description("Delete gallery entries with missing files").action(async () => {
   const { listEntries: listEntries2, deleteEntry: deleteEntry2 } = await Promise.resolve().then(() => (init_gallery(), exports_gallery));
-  const { existsSync: existsSync9 } = await import("fs");
+  const { existsSync: existsSync10 } = await import("fs");
   const entries = listEntries2({ limit: 9999 });
   let removed = 0;
   for (const e of entries) {
-    if (!existsSync9(e.path)) {
+    if (!existsSync10(e.path)) {
       deleteEntry2(e.id);
       removed++;
     }