cdpilot 0.4.3 → 0.5.0

package/src/cdpilot.py

@@ -14,9 +14,10 @@ Environment:
   CDPILOT_PROFILE      Isolated browser profile directory
 """
 
-__version__ = "0.4.3"
+__version__ = "0.5.0"
 
 import asyncio
+import atexit
 import json
 import sys
 import base64
@@ -465,6 +466,9 @@ CAPTCHA_DETECT_JS = r"""
 PROXY_CONFIG_FILE = os.path.join(PROFILE_DIR, 'proxy.json')
 HEADLESS_CONFIG_FILE = os.path.join(PROFILE_DIR, 'headless.json')
 STEALTH_CONFIG_FILE = os.path.join(PROFILE_DIR, 'stealth.json')
+BLOCK_CONFIG_FILE = os.path.join(PROFILE_DIR, 'block.json')
+FAST_CONFIG_FILE = os.path.join(PROFILE_DIR, 'fast.json')
+ADAPTIVE_CONFIG_FILE = os.path.join(PROFILE_DIR, 'adaptive.json')
 DOWNLOAD_CONFIG_FILE = os.path.join(PROFILE_DIR, 'download-config.json')
 SESSION_FILE = os.path.join(PROFILE_DIR, 'sessions.json')
 
@@ -791,6 +795,12 @@ async def _control_start(ws_url):
     the currently-loaded document — that's by design.
     """
     global _glow_script_id
+    # Visual feedback default OFF since 0.4.4. _control_start is the per-command
+    # entry point — gating here turns off glow/cursor/ripples globally without
+    # touching every command's code path. Backward compat preserved by
+    # get_visual_config() honoring CDPILOT_MCP_SESSION=1 and CDPILOT_SHOW=1.
+    if not get_visual_config():
+        return
     try:
         # NOTE: addScriptToEvaluateOnNewDocument registered here is session-bound
         # to the WS connection cdp_send opens — it dies when this call returns.
@@ -825,6 +835,11 @@ async def _control_end(ws_url):
     In CLI mode: glow fades after 10s idle (GLOW_TIMEOUT_JS).
     """
     global _glow_script_id
+    # Symmetric with _control_start: if visual feedback is off, skip the
+    # re-inject + timeout dance entirely. Caller checked this already, but
+    # belt-and-braces in case some other path invokes _control_end directly.
+    if not get_visual_config():
+        return
     try:
         cmds = [
             (903, "Runtime.evaluate", {"expression": INPUT_BLOCKER_OFF, "returnByValue": True}),
@@ -869,13 +884,38 @@ async def _vfx_move_cursor(ws_url, x, y):
 
 # ─── Connection Helpers ───
 
-def cdp_get(path):
-    """GET request to a CDP HTTP endpoint."""
+# Per-process micro-cache for hot CDP HTTP endpoints (`/json`, `/json/version`).
+# A typical CLI invocation calls `cdp_get("/json")` 3-7 times (session lookup,
+# tab discovery, target validation). Each call is a ~10-30ms blocking HTTP
+# roundtrip via urllib. Caching for a short window collapses those into one
+# fetch without changing semantics — CDP tab list rarely changes mid-command.
+# TTL is intentionally tiny: long enough to dedupe within a single command's
+# call graph, short enough that stale state is never a concern across commands.
+_CDP_GET_CACHE = {}  # path -> (timestamp, value)
+_CDP_GET_TTL_S = 0.5
+_CDP_GET_CACHEABLE = ("/json", "/json/version")
+
+
+def cdp_get(path, no_cache=False):
+    """GET request to a CDP HTTP endpoint, with TTL cache for hot paths."""
+    if not no_cache and path in _CDP_GET_CACHEABLE:
+        hit = _CDP_GET_CACHE.get(path)
+        if hit and (time.time() - hit[0]) < _CDP_GET_TTL_S:
+            return hit[1]
     try:
         with urllib.request.urlopen(f"{CDP_BASE}{path}", timeout=3) as resp:
-            return json.loads(resp.read())
-    except Exception as e:
+            data = json.loads(resp.read())
+    except Exception:
         return None
+    if path in _CDP_GET_CACHEABLE:
+        _CDP_GET_CACHE[path] = (time.time(), data)
+    return data
+
+
+def cdp_cache_invalidate():
+    """Drop the cdp_get cache. Call after operations that mutate the tab set
+    (create/close/switch tab) so the next read sees fresh state."""
+    _CDP_GET_CACHE.clear()
 
 
 def get_tabs():
@@ -966,6 +1006,7 @@ def _create_session_window():
         resp = urllib.request.urlopen(req, timeout=5)
         data = json.loads(resp.read())
         target_id = data.get("id")
+        cdp_cache_invalidate()
     except Exception:
         target_id = None
 
@@ -998,12 +1039,35 @@ def _ensure_session_window():
 def get_page_ws(prefer_url=None):
     """Find the WebSocket URL for the appropriate page target.
 
-    If a session window exists, only looks at tabs in that window.
-    Otherwise creates a new session window.
+    Resolution order:
+      1. CDPILOT_TARGET env — explicit target_id pin. Used by the browser
+         context pool to address a specific tab inside a specific browser
+         context from a parallel CLI invocation. Bypasses session lookup
+         entirely.
+      2. Session window target_id (CWD-keyed).
+      3. Create a new session window.
+
+    Why the env override matters: a parallel workflow like
+        ID=$(cdpilot context create) ; CDPILOT_TARGET=$ID cdpilot go URL
+    needs to address the just-created tab without polluting the CWD-keyed
+    session state (which would be a race condition between concurrent calls).
     """
     tabs = get_tabs()
     pages = [t for t in tabs if t.get("type") == "page"]
 
+    # Explicit target pin via env — used by context pool callers.
+    pin = os.environ.get('CDPILOT_TARGET')
+    if pin:
+        for p in pages:
+            if p.get("id") == pin:
+                return p["webSocketDebuggerUrl"], p
+        # Pin was specified but the tab is gone — fail loudly rather than
+        # silently switching to a different tab (would be a heisenbug for
+        # parallel workflows).
+        print(f"CDPILOT_TARGET={pin} but no such tab. Did the context get destroyed?",
+              file=sys.stderr)
+        sys.exit(1)
+
     # Get target ID for the current session window
     session_target_id = _get_session_window_target_id()
 
@@ -1061,12 +1125,169 @@ def activate_tab(page_id):
 
 # ─── CDP WebSocket Operations ───
 
+# ─── WebSocket Connection Pool ───
+#
+# Goal: amortise the ~30-50 ms TCP+WebSocket handshake across repeated
+# cdp_send calls within a single process (MCP server, batch mode).
+# Tekil CLI invocations are unaffected — the process exits after one call
+# so the pool never holds more than one entry anyway.
+# Opt-out: CDPILOT_WS_POOL=0 reverts to the original open-use-close path.
+# navigate_collect, cmd_new_tab, cmd_close_tab keep their own short-lived
+# connections because they enable CDP domains that would pollute pooled WS
+# with unrelated events.
+
+_WS_POOL = {}          # ws_url -> open websockets.WebSocketClientProtocol
+_WS_LOCKS = {}         # ws_url -> asyncio.Lock  (per-URL serialisation)
+_WS_POOL_ENABLED = os.environ.get("CDPILOT_WS_POOL", "1") != "0"
+
+
+def _ws_lock(ws_url):
+    """Return the per-URL asyncio.Lock bound to the CURRENT running loop.
+
+    On Python 3.9 and earlier, asyncio.Lock() snapshots the running loop at
+    construction time and raises if reused on a different loop later. If a
+    process invokes asyncio.run() twice (rare, but possible — e.g. a CLI
+    command that schedules a follow-up async call after the main one), the
+    cached Lock from the first run is bound to a closed loop. We guard by
+    stamping each entry with the current loop and evicting on mismatch.
+    Evicting the lock also drops any pooled WS for that URL — that WS is
+    bound to the dead loop too and calling anything async on it would raise.
+    """
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        loop = asyncio.get_event_loop()
+    entry = _WS_LOCKS.get(ws_url)
+    if entry is None or entry[0] is not loop:
+        # Stale or absent. Evict pooled WS too — same loop, same fate.
+        if entry is not None:
+            _WS_POOL.pop(ws_url, None)
+        _WS_LOCKS[ws_url] = (loop, asyncio.Lock())
+    return _WS_LOCKS[ws_url][1]
+
+
+def _ws_is_open(ws):
+    """Return True if `ws` looks usable, False if it is closed/half-closed.
+
+    Prefers the typed State enum introduced in websockets 10+; falls back to
+    the boolean `.closed` attribute on older versions so we don't hard-dep
+    on a specific websockets release.
+    """
+    try:
+        from websockets.protocol import State
+        return ws.state is State.OPEN
+    except (ImportError, AttributeError):
+        return not getattr(ws, "closed", True)
+
+
+async def _ws_drain(ws, max_drain=64):
+    """Consume leftover event frames on a reused connection.
+
+    CDP servers push unsolicited events (Page.loadEventFired, DOM mutations
+    etc.) between our calls. Leaving them in the recv buffer would cause
+    the next cdp_send's id-dispatch loop to waste iterations on stale data
+    and could trigger false TimeoutErrors when the buffer fills.
+    We read up to max_drain frames with a near-zero timeout; any timeout or
+    error just means the buffer is empty — that's the happy path.
+    """
+    for _ in range(max_drain):
+        try:
+            await asyncio.wait_for(ws.recv(), timeout=0.001)
+        except Exception:
+            break
+
+
+def _ws_pool_close_all():
+    """atexit handler: synchronously close pooled WebSocket transports.
+
+    Earlier this used asyncio.new_event_loop() + run_until_complete(ws.close()),
+    but `await ws.close()` raises if invoked from a different loop than the one
+    that owns the protocol — and at process-exit time the original loop is
+    already dead. The exception was swallowed, so the "graceful close" was
+    effectively a no-op and FDs leaked until kernel reaped them.
+
+    Going loop-agnostic: close the underlying asyncio.Transport synchronously.
+    The TCP FIN goes out cleanly without needing a running event loop.
+    """
+    for ws in list(_WS_POOL.values()):
+        transport = getattr(ws, 'transport', None)
+        if transport is not None:
+            try:
+                if not transport.is_closing():
+                    transport.close()
+            except Exception:
+                pass
+    _WS_POOL.clear()
+    _WS_LOCKS.clear()
+
+
+atexit.register(_ws_pool_close_all)
+
+
 async def cdp_send(ws_url, commands, timeout=15):
     """Send multiple CDP commands and collect results."""
     import websockets
-    results = {}
-    try:
-        async with websockets.connect(ws_url, max_size=100 * 1024 * 1024) as ws:
+
+    # ── Non-pooled path (CDPILOT_WS_POOL=0) — identical to original ──
+    if not _WS_POOL_ENABLED:
+        results = {}
+        try:
+            async with websockets.connect(ws_url, max_size=100 * 1024 * 1024) as ws:
+                for cmd_id, method, params in commands:
+                    await ws.send(json.dumps({"id": cmd_id, "method": method, "params": params or {}}))
+                pending = {c[0] for c in commands}
+                start = time.time()
+                while pending and (time.time() - start) < timeout:
+                    try:
+                        resp = await asyncio.wait_for(ws.recv(), timeout=2)
+                        data = json.loads(resp)
+                        if "id" in data and data["id"] in pending:
+                            pending.discard(data["id"])
+                            results[data["id"]] = data.get("result", data.get("error", {}))
+                    except asyncio.TimeoutError:
+                        continue
+            return results
+        except ConnectionRefusedError:
+            print("Browser is not running. Run 'cdpilot launch' first.", file=sys.stderr)
+            sys.exit(1)
+        except Exception as e:
+            err = str(e)
+            if "websocket" in err.lower() or "connect" in err.lower() or "ws://" in err.lower():
+                print(f"Browser is not running or CDP port {CDP_PORT} is unreachable. Run 'cdpilot launch' first.", file=sys.stderr)
+                sys.exit(1)
+            raise
+
+    # ── Pooled path ──
+    async with _ws_lock(ws_url):
+        results = {}
+        reused = False  # track whether we fetched from pool or opened fresh
+
+        # Fetch or create the connection for this URL.
+        # Note: we never drain on the happy path. A pooled connection is only
+        # put back after `pending` was fully consumed (recv loop exited cleanly,
+        # see post-loop check below), so by construction there are no stale
+        # response frames waiting. Skipping the drain saves ~1ms per call —
+        # this matters because cdp_send is called dozens of times per command.
+        ws = _WS_POOL.get(ws_url)
+        if ws is not None and _ws_is_open(ws):
+            reused = True
+        else:
+            # Pool miss or dead entry — open a fresh connection
+            if ws_url in _WS_POOL:
+                _WS_POOL.pop(ws_url)
+            try:
+                ws = await websockets.connect(ws_url, max_size=100 * 1024 * 1024)
+            except ConnectionRefusedError:
+                print("Browser is not running. Run 'cdpilot launch' first.", file=sys.stderr)
+                sys.exit(1)
+            except Exception as e:
+                err = str(e)
+                if "websocket" in err.lower() or "connect" in err.lower() or "ws://" in err.lower():
+                    print(f"Browser is not running or CDP port {CDP_PORT} is unreachable. Run 'cdpilot launch' first.", file=sys.stderr)
+                    sys.exit(1)
+                raise
+
+        try:
             for cmd_id, method, params in commands:
                 await ws.send(json.dumps({"id": cmd_id, "method": method, "params": params or {}}))
 
@@ -1081,16 +1302,78 @@ async def cdp_send(ws_url, commands, timeout=15):
                         results[data["id"]] = data.get("result", data.get("error", {}))
                 except asyncio.TimeoutError:
                     continue
-        return results
-    except ConnectionRefusedError:
-        print("Browser is not running. Run 'cdpilot launch' first.", file=sys.stderr)
-        sys.exit(1)
-    except Exception as e:
-        err = str(e)
-        if "websocket" in err.lower() or "connect" in err.lower() or "ws://" in err.lower():
-            print(f"Browser is not running or CDP port {CDP_PORT} is unreachable. Run 'cdpilot launch' first.", file=sys.stderr)
-            sys.exit(1)
-        raise
+
+            # Only re-pool if we drained `pending` to zero. If we timed out
+            # with responses still in flight, late frames could arrive on this
+            # connection and confuse the NEXT cdp_send call (which restarts
+            # IDs from 1 and would mismatch IDs from the previous call).
+            # Drop in that case — safer to pay a fresh handshake next time.
+            if pending:
+                _WS_POOL.pop(ws_url, None)
+                try:
+                    await ws.close()
+                except Exception:
+                    pass
+            else:
+                _WS_POOL[ws_url] = ws
+            return results
+
+        except Exception:
+            # Drop the dead/errored connection from the pool
+            _WS_POOL.pop(ws_url, None)
+            try:
+                await ws.close()
+            except Exception:
+                pass
+
+            # Retry ONCE with a fresh connection, but only when no responses
+            # have arrived yet — replaying after partial progress would
+            # re-fire non-idempotent commands (mouse events, form submits).
+            if not results and reused:
+                try:
+                    ws2 = await websockets.connect(ws_url, max_size=100 * 1024 * 1024)
+                except ConnectionRefusedError:
+                    print("Browser is not running. Run 'cdpilot launch' first.", file=sys.stderr)
+                    sys.exit(1)
+                except Exception as e2:
+                    err = str(e2)
+                    if "websocket" in err.lower() or "connect" in err.lower() or "ws://" in err.lower():
+                        print(f"Browser is not running or CDP port {CDP_PORT} is unreachable. Run 'cdpilot launch' first.", file=sys.stderr)
+                        sys.exit(1)
+                    raise
+                results2 = {}
+                try:
+                    for cmd_id, method, params in commands:
+                        await ws2.send(json.dumps({"id": cmd_id, "method": method, "params": params or {}}))
+                    pending2 = {c[0] for c in commands}
+                    start2 = time.time()
+                    while pending2 and (time.time() - start2) < timeout:
+                        try:
+                            resp2 = await asyncio.wait_for(ws2.recv(), timeout=2)
+                            data2 = json.loads(resp2)
+                            if "id" in data2 and data2["id"] in pending2:
+                                pending2.discard(data2["id"])
+                                results2[data2["id"]] = data2.get("result", data2.get("error", {}))
+                        except asyncio.TimeoutError:
+                            continue
+                    # Same invariant as the main path: only re-pool on full drain.
+                    if pending2:
+                        try:
+                            await ws2.close()
+                        except Exception:
+                            pass
+                    else:
+                        _WS_POOL[ws_url] = ws2
+                    return results2
+                except Exception:
+                    _WS_POOL.pop(ws_url, None)
+                    try:
+                        await ws2.close()
+                    except Exception:
+                        pass
+                    raise
+
+            raise
 
 
 async def navigate_collect(ws_url, url, network=False, console=False, glow=True):
@@ -1117,6 +1400,18 @@ async def navigate_collect(ws_url, url, network=False, console=False, glow=True)
                 "params": {"source": STEALTH_JS}
             }))
 
+        # Apply request blocking BEFORE navigate, on this same WS session.
+        # Network.setBlockedURLs is session-bound (just like the stealth
+        # script): the patterns are honored until this connection closes.
+        # Setting it before Page.navigate ensures the very first requests
+        # for this page already get blocked.
+        block_cfg = get_block_config()
+        if block_cfg['enabled'] and block_cfg['patterns']:
+            await ws.send(json.dumps({
+                "id": 60, "method": "Network.setBlockedURLs",
+                "params": {"urls": block_cfg['patterns']}
+            }))
+
         # Navigate
         await ws.send(json.dumps({"id": 100, "method": "Page.navigate", "params": {"url": url}}))
 
@@ -1155,14 +1450,21 @@ async def navigate_collect(ws_url, url, network=False, console=False, glow=True)
 
                 if method == "Page.loadEventFired":
                     loaded = True
-                    await asyncio.sleep(1.5)
+                    # Was 1.5s blind sleep. Most pages settle within 300ms
+                    # of the load event. Pages with late JS still get up to
+                    # the outer 20s deadline via the next iteration's recv —
+                    # we just don't pay 1.2s of dead waiting on every nav.
+                    await asyncio.sleep(0.3)
                     break
             except asyncio.TimeoutError:
                 if loaded:
                     break
 
-        # Inject visual indicator (glow overlay + visual feedback)
-        if glow:
+        # Inject visual indicator (glow overlay + visual feedback).
+        # Default OFF since 0.4.4 — the glow/cursor animations made cdpilot
+        # feel sluggish in real automation. Re-enable with `cdpilot show on`
+        # or via CDPILOT_MCP_SESSION=1 / CDPILOT_SHOW=1.
+        if glow and get_visual_config():
             await ws.send(json.dumps({
                 "id": 200, "method": "Runtime.evaluate",
                 "params": {"expression": GLOW_CSS, "returnByValue": True}
@@ -1563,6 +1865,39 @@ def get_stealth_config():
             pass
     return False
 
+def _sanitize_profile_state(profile_dir):
+    """Patch Default/Preferences to suppress launch dialogs.
+
+    Sets exit_type=Normal so Chrome doesn't show the crash-restore bubble after
+    we kill the process, and disables the password-save infobar. Idempotent —
+    safe to run every launch. Profile is isolated under ~/.cdpilot/, user's
+    personal browser state is never touched.
+    """
+    prefs_path = os.path.join(profile_dir, 'Default', 'Preferences')
+    try:
+        if os.path.exists(prefs_path):
+            with open(prefs_path) as f:
+                prefs = json.load(f)
+        else:
+            os.makedirs(os.path.dirname(prefs_path), exist_ok=True)
+            prefs = {}
+        prof = prefs.setdefault('profile', {})
+        prof['exit_type'] = 'Normal'
+        prof['exited_cleanly'] = True
+        prof['password_manager_enabled'] = False
+        prof['password_manager_leak_detection'] = False
+        prefs['credentials_enable_service'] = False
+        prefs['credentials_enable_autosignin'] = False
+        autofill = prefs.setdefault('autofill', {})
+        autofill['enabled'] = False
+        autofill['profile_enabled'] = False
+        autofill['credit_card_enabled'] = False
+        with open(prefs_path, 'w') as f:
+            json.dump(prefs, f)
+    except (OSError, ValueError):
+        pass
+
+
 # ─── Commands ───
 
 def cmd_launch():
@@ -1622,6 +1957,7 @@ def cmd_launch():
         # Default: chrome and unknown chromium-based browsers
         profile_dir = PROFILE_DIR + '-chrome'
     os.makedirs(profile_dir, exist_ok=True)
+    _sanitize_profile_state(profile_dir)
 
     chrome_args = [
         CHROME_BIN,
@@ -1648,6 +1984,7 @@ def cmd_launch():
             'BraveVPN', 'BraveWalletBubble', 'SpeedReader', 'Tor',
             'IPFSCompanion', 'Translate', 'OptimizationGuideModelDownloading',
             'InterestFeedContentSuggestions', 'CalculateNativeWinOcclusion',
+            'PasswordManagerOnboarding', 'AutofillServerCommunication',
         ]),
         # ─── Chromium performance flags ───
         '--disable-background-networking',
@@ -1669,6 +2006,8 @@ def cmd_launch():
         '--no-pings',
         '--safebrowsing-disable-auto-update',
         '--password-store=basic',
+        '--use-mock-keychain',
+        '--disable-session-crashed-bubble',
         # ─── GPU / rendering ───
         # --disable-gpu-compositing REMOVED: caused EXC_BREAKPOINT on Apple
         # Silicon Brave 147+ after ~7min. Let the browser use its default
@@ -1726,8 +2065,21 @@ async def cmd_go(url):
         cmd_launch()
 
     ws, page = get_page_ws()
+
+    # Adaptive mode: if this hostname is in the learned stealth-required list,
+    # temporarily enable stealth for the navigation that's about to happen.
+    # We do this by setting the env var (which get_stealth_config honors first)
+    # instead of writing to stealth.json — keeps the user's permanent setting
+    # untouched and only changes behavior for this one cmd_go call.
+    adaptive_stealth = False
+    if _adaptive_host_requires_stealth(url) and not get_stealth_config():
+        os.environ['CDPILOT_STEALTH'] = '1'
+        adaptive_stealth = True
+        sys.stderr.write(f"🛡️  Adaptive: enabling stealth for known-hostile host\n")
+
     content, _ = await navigate_collect(ws, url)
     print(content)
+
     # Post-navigation CAPTCHA probe. Non-blocking: stderr warning only.
     # Users can run `cdpilot captcha-wait` to pause for manual solve.
     try:
@@ -1735,6 +2087,31 @@ async def cmd_go(url):
         if info.get("detected"):
             types = ",".join(info.get("types", [])) or "unknown"
             sys.stderr.write(f"⚠️  CAPTCHA tespit edildi ({types}). Çözüm için: cdpilot captcha-wait\n")
+
+            # Adaptive escalation: remember this host so the next visit starts
+            # in stealth, and if stealth was off this round, try once more
+            # right now with stealth on. Re-nav is gated to once-per-call to
+            # avoid an infinite loop if stealth doesn't actually fix it.
+            cfg = get_adaptive_config()
+            if cfg['enabled']:
+                try:
+                    from urllib.parse import urlparse
+                    host = (urlparse(url).hostname or '').lower()
+                except Exception:
+                    host = ''
+                if host:
+                    _adaptive_remember_host(host)
+                    sys.stderr.write(f"🛡️  Adaptive: remembered {host} as stealth-required\n")
+                if not adaptive_stealth and not get_stealth_config():
+                    sys.stderr.write("🛡️  Adaptive: retrying once with stealth on...\n")
+                    os.environ['CDPILOT_STEALTH'] = '1'
+                    await navigate_collect(ws, url)
+                    # Re-probe after stealth re-nav
+                    info2 = await _detect_captcha(ws)
+                    if info2.get("detected"):
+                        sys.stderr.write("⚠️  Adaptive: CAPTCHA still present after stealth retry. Manual solve needed.\n")
+                    else:
+                        sys.stderr.write("✅ Adaptive: CAPTCHA cleared with stealth.\n")
     except Exception:
         pass
 
@@ -1926,14 +2303,66 @@ async def cmd_eval(js_code):
             print(json.dumps(val, indent=2, ensure_ascii=False))
 
 
+async def cmd_eval_batch(exprs_json):
+    """Evaluate N JS expressions in a SINGLE Runtime.evaluate call.
+
+    Input: JSON array of strings. Each string is one JS expression.
+    Output: JSON array of results (one per expression). Per-expression errors
+    are reported as {"error": "..."} without aborting the batch.
+
+    Why this exists:
+      Every CDP `Runtime.evaluate` is a WebSocket roundtrip (~10-40ms over
+      localhost, more over network). For workflows that need many small
+      observations (e.g. read 12 DOM values to fill a report), N sequential
+      `eval` commands cost N × roundtrip. This packs them into one IIFE that
+      runs all N expressions and returns the result array — one roundtrip
+      total. Typical speedup: 5-30x for batches of 5+ expressions.
+    """
+    try:
+        exprs = json.loads(exprs_json) if isinstance(exprs_json, str) else exprs_json
+        if not isinstance(exprs, list) or not all(isinstance(e, str) for e in exprs):
+            print(json.dumps({"error": "Input must be a JSON array of strings"}), file=sys.stderr)
+            sys.exit(1)
+    except (json.JSONDecodeError, TypeError) as exc:
+        print(json.dumps({"error": f"JSON parse error: {exc}"}), file=sys.stderr)
+        sys.exit(1)
+
+    ws, _ = get_page_ws()
+    # Wrap each expression in its own try/catch so one failure doesn't sink
+    # the batch. The user's expression is dropped directly into a parenthesized
+    # position, so any value-producing JS works as-is (`1+1`, `document.title`,
+    # `await fetch(...).then(r=>r.json())`). Statement-style code that needs
+    # `let`/`const` must be wrapped manually: `(function(){let x=1; return x})()`.
+    wrapped = []
+    for e in exprs:
+        wrapped.append(
+            "(async function(){try{return {ok:true, value: (" + e + ")};}"
+            "catch(err){return {ok:false, error:String(err && err.message || err)};}})()"
+        )
+    js = "Promise.all([" + ",".join(wrapped) + "])"
+    r = await cdp_send(ws, [(1, "Runtime.evaluate", {
+        "expression": js,
+        "returnByValue": True,
+        "awaitPromise": True,
+    })], timeout=30)
+    result = r.get(1, {})
+    if "exceptionDetails" in result:
+        exc = result["exceptionDetails"]
+        print(json.dumps({"error": f"batch failed: {exc.get('text', '')}"}), file=sys.stderr)
+        sys.exit(1)
+    val = result.get("result", {}).get("value", [])
+    print(json.dumps(val, indent=2, ensure_ascii=False))
+
+
 async def cmd_click(selector):
     ws, _ = get_page_ws()
     safe_sel = json.dumps(selector)
+    wait_ms = get_auto_wait_ms()
     js = WAIT_AND_QUERY_JS + f"""
 (function() {{
-    return window.__cdpilot_waitFor({safe_sel}, 5000).then(function(el) {{
+    return window.__cdpilot_waitFor({safe_sel}, {wait_ms}).then(function(el) {{
         if (!el) return 'Timeout waiting for: ' + {safe_sel};
-        el.scrollIntoView({{behavior:'smooth', block:'center'}});
+        el.scrollIntoView({{behavior:'instant', block:'center'}});
         if (window.__cdpilot_vfx) {{
             var r = el.getBoundingClientRect();
             var cx = Math.round(r.left + r.width/2), cy = Math.round(r.top + r.height/2);
@@ -1953,9 +2382,10 @@ async def cmd_fill(selector, value):
     ws, _ = get_page_ws()
     safe_sel = json.dumps(selector)
     safe_value = json.dumps(value)
+    wait_ms = get_auto_wait_ms()
     js = WAIT_AND_QUERY_JS + f"""
 (function() {{
-    return window.__cdpilot_waitFor({safe_sel}, 5000).then(function(el) {{
+    return window.__cdpilot_waitFor({safe_sel}, {wait_ms}).then(function(el) {{
         if (!el) return 'Timeout waiting for: ' + {safe_sel};
         el.focus();
         if (window.__cdpilot_vfx) {{
@@ -2090,7 +2520,79 @@ async def cmd_console(url=None):
     print(f"\n=== Content (first 3000 chars) ===\n{content[:3000]}")
 
 
-async def cmd_cookies(domain=None):
+async def cmd_cookies(*args):
+    """List, export, or import cookies.
+
+    Usage:
+      cdpilot cookies                          # list all cookies (or for current page)
+      cdpilot cookies <domain>                 # list cookies for a specific domain
+      cdpilot cookies save <file> [<domain>]   # export to JSON (all or scoped)
+      cdpilot cookies load <file>              # import cookies from JSON
+
+    Why save/load: once you've beaten a Cloudflare/DataDome challenge in one
+    cdpilot process, the `cf_clearance` (or equivalent) cookie sits in this
+    browser instance's jar. Exporting it lets you skip the wall in a separate
+    process or after a `cdpilot stop` cycle. Same applies to logged-in
+    sessions — capture once, replay across runs.
+    """
+    sub = args[0].lower() if args else None
+
+    if sub == 'save':
+        if len(args) < 2:
+            print('Usage: cdpilot cookies save <file> [<domain>]', file=sys.stderr)
+            sys.exit(1)
+        out_path = os.path.expanduser(args[1])
+        domain_filter = args[2] if len(args) >= 3 else None
+        ws, _ = get_page_ws()
+        # Get all cookies (no urls filter → all). Domain filter is applied
+        # client-side so we can match subdomains via endswith.
+        r = await cdp_send(ws, [(1, "Network.getCookies", {})])
+        cookies = r.get(1, {}).get("cookies", [])
+        if domain_filter:
+            d = domain_filter.lstrip('.')
+            cookies = [c for c in cookies
+                       if c.get('domain', '').lstrip('.').endswith(d)]
+        with open(out_path, 'w') as f:
+            json.dump(cookies, f, indent=2)
+        print(f'Saved {len(cookies)} cookies → {out_path}')
+        return
+
+    if sub == 'load':
+        if len(args) < 2:
+            print('Usage: cdpilot cookies load <file>', file=sys.stderr)
+            sys.exit(1)
+        in_path = os.path.expanduser(args[1])
+        if not os.path.exists(in_path):
+            print(f'File not found: {in_path}', file=sys.stderr)
+            sys.exit(1)
+        try:
+            with open(in_path) as f:
+                cookies = json.load(f)
+        except (OSError, ValueError) as e:
+            print(f'Cannot parse cookie file: {e}', file=sys.stderr)
+            sys.exit(1)
+        if not isinstance(cookies, list):
+            print('Cookie file must contain a JSON array of cookie objects', file=sys.stderr)
+            sys.exit(1)
+        ws, _ = get_page_ws()
+        # Network.setCookies takes the same shape Network.getCookies returns.
+        # CDP will skip cookies it considers invalid; we log the count it
+        # actually accepted by re-reading.
+        await cdp_send(ws, [(1, "Network.setCookies", {"cookies": cookies})])
+        # Verify count
+        r = await cdp_send(ws, [(2, "Network.getCookies", {})])
+        loaded = r.get(2, {}).get("cookies", [])
+        # Map by (name, domain, path) for set inclusion check
+        want = {(c.get('name'), c.get('domain'), c.get('path', '/')) for c in cookies}
+        have = {(c.get('name'), c.get('domain'), c.get('path', '/')) for c in loaded}
+        accepted = len(want & have)
+        print(f'Loaded {accepted}/{len(cookies)} cookies from {in_path}')
+        if accepted < len(cookies):
+            print(f'  ({len(cookies) - accepted} rejected by CDP — usually because of expiry or domain mismatch)')
+        return
+
+    # List mode
+    domain = args[0] if args else None
     ws, _ = get_page_ws()
     params = {}
     if domain:
@@ -2541,11 +3043,162 @@ def cmd_ext_remove(ext_id):
     print(f"🗑️ Extension removed: {name}")
     print("   Note: Restart the browser (stop → launch).")
 
+# ─── Browser context pool (Target.createBrowserContext × N) ───
+#
+# Browser contexts are isolated cookie/storage namespaces inside the SAME
+# browser process. Playwright's parallel-tabs model — true concurrency for
+# automation workloads that would otherwise serialize on one shared cookie
+# jar. Use cases:
+#   - Run a citation tracker across 50 Perplexity queries in parallel
+#     without each query stomping on the previous one's chat history.
+#   - Test a flow against logged-in + logged-out + guest variants in
+#     parallel without spinning up 3 browsers.
+#   - Beat a Cloudflare wall in one context, keep the clearance there;
+#     start a fresh anonymous context for the next sensitive operation.
+#
+# How parallelism works at the cdpilot CLI layer:
+#   ID=$(cdpilot context create https://example.com)
+#   ID2=$(cdpilot context create https://google.com)
+#   CDPILOT_TARGET=$ID cdpilot eval 'document.title' &
+#   CDPILOT_TARGET=$ID2 cdpilot eval 'document.title' &
+#   wait
+# Each invocation is a separate Python process with its own WS pool, talking
+# to the SAME browser but a DIFFERENT tab inside a DIFFERENT context. They
+# don't share cookies, storage, or auth state — but they DO share renderer
+# CPU/memory (single browser process limit still applies).
+
+
+async def cmd_context_create(url='about:blank'):
+    """Create a fresh browser context + tab inside it. Print JSON to stdout.
+
+    Output: {"context_id": "...", "target_id": "...", "url": "..."}
+    The target_id is what CDPILOT_TARGET expects.
+    """
+    if not cdp_get('/json/version'):
+        cmd_launch()
+    # Resolve a base WS to talk to the browser itself (not a tab).
+    ver = cdp_get('/json/version')
+    browser_ws = ver.get('webSocketDebuggerUrl') if ver else None
+    if not browser_ws:
+        print('Cannot reach browser-level WS', file=sys.stderr)
+        sys.exit(1)
+    r = await cdp_send(browser_ws, [
+        (1, "Target.createBrowserContext", {}),
+    ])
+    ctx_id = r.get(1, {}).get("browserContextId")
+    if not ctx_id:
+        print(f'createBrowserContext failed: {r.get(1)}', file=sys.stderr)
+        sys.exit(1)
+    r2 = await cdp_send(browser_ws, [
+        (2, "Target.createTarget", {"url": url, "browserContextId": ctx_id}),
+    ])
+    tgt_id = r2.get(2, {}).get("targetId")
+    if not tgt_id:
+        # Roll back the empty context — orphaned contexts leak memory.
+        await cdp_send(browser_ws, [
+            (3, "Target.disposeBrowserContext", {"browserContextId": ctx_id})
+        ])
+        print(f'createTarget failed: {r2.get(2)}', file=sys.stderr)
+        sys.exit(1)
+    cdp_cache_invalidate()
+    print(json.dumps({
+        "context_id": ctx_id,
+        "target_id": tgt_id,
+        "url": url,
+    }))
+
+
+async def cmd_context_list():
+    """List all browser contexts and their tabs as JSON."""
+    ver = cdp_get('/json/version')
+    browser_ws = ver.get('webSocketDebuggerUrl') if ver else None
+    if not browser_ws:
+        print('Cannot reach browser-level WS', file=sys.stderr)
+        sys.exit(1)
+    r = await cdp_send(browser_ws, [
+        (1, "Target.getBrowserContexts", {}),
+        (2, "Target.getTargets", {}),
+    ])
+    ctx_ids = r.get(1, {}).get("browserContextIds", [])
+    targets = r.get(2, {}).get("targetInfos", [])
+    # Group page targets by their browserContextId. Targets without a
+    # browserContextId are in the default context.
+    grouped = {}
+    for t in targets:
+        if t.get("type") != "page":
+            continue
+        cid = t.get("browserContextId", "default")
+        grouped.setdefault(cid, []).append({
+            "target_id": t.get("targetId"),
+            "url": t.get("url", "")[:120],
+            "title": (t.get("title") or '')[:80],
+        })
+    # Make sure every reported context shows up even if it has no tabs.
+    for cid in ctx_ids:
+        grouped.setdefault(cid, [])
+    grouped.setdefault("default", grouped.get("default", []))
+    print(json.dumps({
+        "default_context": grouped.get("default", []),
+        "browser_contexts": [
+            {"context_id": cid, "tabs": grouped[cid]}
+            for cid in ctx_ids
+        ],
+    }, indent=2))
+
+
+async def cmd_context_close(context_id):
+    """Destroy a browser context. All tabs inside it close automatically.
+
+    Refuses to destroy the default context (which has no context_id anyway).
+    """
+    if not context_id or context_id == 'default':
+        print('Cannot destroy the default context.', file=sys.stderr)
+        sys.exit(1)
+    ver = cdp_get('/json/version')
+    browser_ws = ver.get('webSocketDebuggerUrl') if ver else None
+    if not browser_ws:
+        print('Cannot reach browser-level WS', file=sys.stderr)
+        sys.exit(1)
+    r = await cdp_send(browser_ws, [
+        (1, "Target.disposeBrowserContext", {"browserContextId": context_id}),
+    ])
+    cdp_cache_invalidate()
+    err = r.get(1, {}).get("error") if isinstance(r.get(1), dict) else None
+    if err:
+        print(f'disposeBrowserContext failed: {err}', file=sys.stderr)
+        sys.exit(1)
+    print(f'Closed context: {context_id}')
+
+
+def cmd_context(*args):
+    """Dispatcher for the context subcommand family.
+
+    Usage:
+      cdpilot context create [url]
+      cdpilot context list
+      cdpilot context close <context_id>
+    """
+    sub = args[0].lower() if args else None
+    if sub == 'create':
+        asyncio.run(cmd_context_create(args[1] if len(args) > 1 else 'about:blank'))
+    elif sub == 'list':
+        asyncio.run(cmd_context_list())
+    elif sub == 'close':
+        if len(args) < 2:
+            print('Usage: cdpilot context close <context_id>', file=sys.stderr)
+            sys.exit(1)
+        asyncio.run(cmd_context_close(args[1]))
+    else:
+        print('Usage: cdpilot context [create|list|close]', file=sys.stderr)
+        sys.exit(1)
+
+
 async def cmd_new_tab(url='about:blank'):
     """Open a new tab."""
     import urllib.parse
     safe_chars = ":/?#[]@!$&'()*+,;="
     data = cdp_get(f'/json/new?{urllib.parse.quote(url, safe=safe_chars)}')
+    cdp_cache_invalidate()
     if data:
         print(f'New tab opened: {data.get("url", url)}')
         print(f'  ID: {data.get("id", "?")}')
@@ -2582,6 +3235,7 @@ async def cmd_close_tab(index_or_id=None):
     if index_or_id is None:
         ws, page = get_page_ws()
         r = await cdp_send(ws, [(1, 'Page.close', {})])
+        cdp_cache_invalidate()
         print('Active tab closed')
         return
 
@@ -2607,6 +3261,7 @@ async def cmd_close_tab(index_or_id=None):
                 await asyncio.wait_for(ws.recv(), timeout=3)
             except:
                 pass
+        cdp_cache_invalidate()
         print(f'Tab closed: {target.get("title", "")[:60]}')
     else:
         print(f'Tab not found: {index_or_id}', file=sys.stderr)
@@ -2848,6 +3503,132 @@ def cmd_health():
     sys.exit(0 if info['alive'] else 2)
 
 
+# ─── Resource Block (perf opt-in) ───
+#
+# Why this exists:
+#   Many automation workloads don't need images, fonts, or analytics pings.
+#   Blocking them via CDP Network.setBlockedURLs cuts page load time
+#   dramatically (often 3-10x) — bytes transferred drop, decoder pressure
+#   drops, third-party connections drop.
+#
+# Stealth caveat:
+#   Blocking changes the fingerprint surface — a real browser fetches images
+#   and fonts. Cloudflare-class bot detectors notice missing requests. Keep
+#   block-resources OFF when fighting bot challenges; turn it ON for known
+#   internal/safe sites where speed matters more than blending in.
+#
+# Preset patterns are wildcards understood by Chromium's Network.setBlockedURLs.
+BLOCK_PRESETS = {
+    'images': ['*.png', '*.jpg', '*.jpeg', '*.gif', '*.webp', '*.svg', '*.ico', '*.bmp'],
+    'fonts':  ['*.woff', '*.woff2', '*.ttf', '*.otf', '*.eot'],
+    'media':  ['*.mp4', '*.webm', '*.mp3', '*.wav', '*.ogg', '*.m4a', '*.m4v'],
+    'ads': [
+        '*googletagmanager.com*', '*google-analytics.com*', '*doubleclick.net*',
+        '*facebook.com/tr*', '*facebook.net*', '*hotjar.com*', '*segment.io*',
+        '*mixpanel.com*', '*amplitude.com*', '*googlesyndication.com*',
+        '*adservice.google.*', '*ads.yahoo.com*', '*scorecardresearch.com*',
+    ],
+}
+
+
+def get_block_config():
+    """Return {'enabled': bool, 'patterns': [str, ...]} for the block system."""
+    if not os.path.exists(BLOCK_CONFIG_FILE):
+        return {'enabled': False, 'patterns': []}
+    try:
+        with open(BLOCK_CONFIG_FILE) as f:
+            data = json.load(f)
+        return {
+            'enabled': bool(data.get('enabled', False)),
+            'patterns': list(data.get('patterns', [])),
+        }
+    except (OSError, ValueError):
+        return {'enabled': False, 'patterns': []}
+
+
+def _save_block_config(enabled, patterns):
+    os.makedirs(os.path.dirname(BLOCK_CONFIG_FILE), exist_ok=True)
+    with open(BLOCK_CONFIG_FILE, 'w') as f:
+        json.dump({'enabled': enabled, 'patterns': patterns}, f)
+
+
+def cmd_block(*args):
+    """Manage CDP request blocking (Network.setBlockedURLs).
+
+    Usage:
+      cdpilot block                                   # status
+      cdpilot block on                                # enable with current patterns (default preset if none set)
+      cdpilot block off                               # disable
+      cdpilot block preset images,fonts,ads,media     # set patterns from named presets
+      cdpilot block patterns '*.png' '*.woff2'        # set custom patterns directly
+      cdpilot block clear                             # drop all patterns
+
+    Effect applies on the next `cdpilot go <url>` (or any command that triggers
+    navigate_collect). Existing pages keep their network policy. Opt-in only —
+    breaks fingerprint plausibility, do NOT combine with stealth-mode targets.
+    """
+    cfg = get_block_config()
+
+    if not args:
+        print(f'Block: {"on" if cfg["enabled"] else "off"}')
+        if cfg['patterns']:
+            print(f'  Patterns ({len(cfg["patterns"])}):')
+            for p in cfg['patterns'][:10]:
+                print(f'    {p}')
+            if len(cfg['patterns']) > 10:
+                print(f'    ... and {len(cfg["patterns"]) - 10} more')
+        else:
+            print('  Patterns: (none)')
+        return
+
+    sub = args[0].lower()
+    if sub in ('status',):
+        cmd_block()
+        return
+    if sub in ('on', '1', 'true', 'yes'):
+        patterns = cfg['patterns'] or (
+            BLOCK_PRESETS['images'] + BLOCK_PRESETS['fonts'] + BLOCK_PRESETS['ads']
+        )
+        _save_block_config(True, patterns)
+        print(f'Block: on ({len(patterns)} patterns)')
+        print('Effect applies on next navigation.')
+        return
+    if sub in ('off', '0', 'false', 'no'):
+        _save_block_config(False, cfg['patterns'])
+        print('Block: off')
+        return
+    if sub == 'clear':
+        _save_block_config(False, [])
+        print('Block: cleared')
+        return
+    if sub == 'preset':
+        if len(args) < 2:
+            print('Usage: cdpilot block preset <names>  (e.g. images,fonts,ads,media)', file=sys.stderr)
+            sys.exit(1)
+        names = [n.strip().lower() for n in args[1].split(',') if n.strip()]
+        unknown = [n for n in names if n not in BLOCK_PRESETS]
+        if unknown:
+            print(f'Unknown preset(s): {", ".join(unknown)}. Available: {", ".join(BLOCK_PRESETS)}', file=sys.stderr)
+            sys.exit(1)
+        patterns = []
+        for n in names:
+            patterns.extend(BLOCK_PRESETS[n])
+        _save_block_config(True, patterns)
+        print(f'Block: on — preset {",".join(names)} → {len(patterns)} patterns')
+        return
+    if sub == 'patterns':
+        if len(args) < 2:
+            print('Usage: cdpilot block patterns <pattern1> [pattern2 ...]', file=sys.stderr)
+            sys.exit(1)
+        patterns = list(args[1:])
+        _save_block_config(True, patterns)
+        print(f'Block: on — {len(patterns)} custom pattern(s)')
+        return
+
+    print(f'Unknown subcommand: {sub}. Use on|off|status|preset|patterns|clear.', file=sys.stderr)
+    sys.exit(1)
+
+
 def cmd_stealth(state=None):
     """Toggle stealth fingerprint patches.
 
@@ -2880,6 +3661,278 @@ def cmd_stealth(state=None):
     print('Effect applies on next navigation (`cdpilot go <url>`).')
 
 
+# ─── Visual feedback config (default OFF) ───
+#
+# Why default OFF (BEHAVIOR CHANGE from 0.4.x):
+#   The visual feedback layer (green glow border, fake cursor, click ripples,
+#   keystroke display) was an early "is the AI working?" trust signal. In
+#   real automation use it makes cdpilot feel slow and amateurish — animated
+#   cursor moves take frames, the glow flashes between pages, every action
+#   triggers a ripple. Defaulting OFF gives a quiet, professional experience.
+#   Use `cdpilot show on` (or set `CDPILOT_MCP_SESSION=1`) to bring it back.
+#
+# Backwards-compat: CDPILOT_MCP_SESSION=1 still forces visual ON (used by
+# the MCP server's persistent-glow flow). Existing scripts that rely on the
+# visual layer can opt in via `cdpilot show on` once.
+
+VISUAL_CONFIG_FILE = os.path.join(PROFILE_DIR, 'visual.json')
+
+
+def _atomic_write_json(path, data):
+    """Write JSON to `path` atomically — write to a temp file then os.replace.
+
+    Without this, a concurrent reader (every command opens get_visual_config
+    or get_fast_config) could observe a truncated file mid-write and fall
+    through to the default. For the visual toggle this means glow flickering
+    off for a single command. os.replace is POSIX-atomic on the same fs.
+    """
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    tmp = path + '.tmp'
+    with open(tmp, 'w') as f:
+        json.dump(data, f)
+    os.replace(tmp, path)
+
+
+def get_visual_config():
+    """Return True if the visual feedback layer should be injected on navigate."""
+    # MCP persistent-glow flow takes precedence — it's how AI sessions signal
+    # "I'm using this browser" to the human watching, and that promise was
+    # made in 0.4.x docs. Don't break it silently.
+    if os.environ.get('CDPILOT_MCP_SESSION') == '1':
+        return True
+    if os.environ.get('CDPILOT_SHOW') in ('1', 'true', 'yes', 'on'):
+        return True
+    if os.path.exists(VISUAL_CONFIG_FILE):
+        try:
+            with open(VISUAL_CONFIG_FILE) as f:
+                return bool(json.load(f).get('enabled', False))
+        except (OSError, ValueError):
+            pass
+    return False
+
+
+def cmd_show(state=None):
+    """Toggle the visual feedback layer (glow + cursor + ripples + keystrokes).
+
+    Usage:
+      cdpilot show              # status
+      cdpilot show on|off       # toggle
+      cdpilot show status       # status (alias)
+
+    Default since 0.4.4: OFF. The MCP server's `CDPILOT_MCP_SESSION=1` flow
+    still forces ON regardless of this setting — that's the persistent-glow
+    promise to humans watching an AI session. The `cdpilot glow on/off`
+    command is an explicit per-action override and is NOT gated by this
+    config — call it directly to flash glow on demand without persisting.
+    """
+    if state is None or state.lower() == 'status':
+        current = get_visual_config()
+        print(f'Visual feedback: {"on" if current else "off"}')
+        if os.environ.get('CDPILOT_MCP_SESSION') == '1':
+            print('  (forced ON by CDPILOT_MCP_SESSION=1)')
+        return
+    s = state.lower()
+    if s not in ('on', 'off', '1', '0', 'true', 'false', 'yes', 'no'):
+        print(f"Invalid state: {state}. Use 'on', 'off', or 'status'.", file=sys.stderr)
+        sys.exit(1)
+    enabled = s in ('on', '1', 'true', 'yes')
+    _atomic_write_json(VISUAL_CONFIG_FILE, {'enabled': enabled})
+    print(f'Visual feedback: {"on" if enabled else "off"}')
+    print('Effect applies on next navigation.')
+
+
+# ─── Fast mode (auto-wait shrink, post-load shrink, opt-in bundle) ───
+#
+# A single switch that flips multiple timing knobs to "professional speed":
+# - auto-wait timeout default 5000ms → 2000ms (configurable via CDPILOT_WAIT_MS)
+# Visual feedback toggling has its own command (`show`) because it's a UX
+# concern, not a timing one. `fast` is purely about how long we wait.
+
+FAST_DEFAULT_WAIT_MS = 2000
+NORMAL_DEFAULT_WAIT_MS = 5000
+
+
+def get_fast_config():
+    """Return True if fast mode is enabled."""
+    if os.environ.get('CDPILOT_FAST') in ('1', 'true', 'yes', 'on'):
+        return True
+    if os.path.exists(FAST_CONFIG_FILE):
+        try:
+            with open(FAST_CONFIG_FILE) as f:
+                return bool(json.load(f).get('enabled', False))
+        except (OSError, ValueError):
+            pass
+    return False
+
+
+def get_auto_wait_ms():
+    """Return the effective auto-wait timeout in milliseconds.
+
+    Resolution order: explicit CDPILOT_WAIT_MS env (user override) → fast
+    mode default (2000) → normal default (5000). The env variable wins
+    even over fast mode so power users can dial it independently.
+
+    The env value is clamped to [100, 120_000]:
+      - 0 would make __cdpilot_waitFor return null instantly, breaking every
+        click on pages where the element renders even one paint frame late.
+      - 100ms is a sane floor — single render tick + small buffer.
+      - 120s (2 min) is a sane ceiling — beyond that the outer command timeout
+        kicks in anyway; asyncio also handles very large floats poorly.
+    """
+    env = os.environ.get('CDPILOT_WAIT_MS')
+    if env and env.isdigit():
+        return max(100, min(int(env), 120_000))
+    return FAST_DEFAULT_WAIT_MS if get_fast_config() else NORMAL_DEFAULT_WAIT_MS
+
+
+def cmd_fast(state=None):
+    """Toggle fast mode — shorter auto-wait, less idle padding.
+
+    Usage:
+      cdpilot fast              # status (shows effective auto-wait ms)
+      cdpilot fast on|off       # toggle
+      cdpilot fast status       # status (alias)
+
+    Override the timeout independently via env CDPILOT_WAIT_MS=<ms>.
+    """
+    if state is None or state.lower() == 'status':
+        current = get_fast_config()
+        effective = get_auto_wait_ms()
+        print(f'Fast mode: {"on" if current else "off"}')
+        print(f'  Effective auto-wait: {effective}ms')
+        return
+    s = state.lower()
+    if s not in ('on', 'off', '1', '0', 'true', 'false', 'yes', 'no'):
+        print(f"Invalid state: {state}. Use 'on', 'off', or 'status'.", file=sys.stderr)
+        sys.exit(1)
+    enabled = s in ('on', '1', 'true', 'yes')
+    _atomic_write_json(FAST_CONFIG_FILE, {'enabled': enabled})
+    print(f'Fast mode: {"on" if enabled else "off"}')
+    print(f'  Effective auto-wait: {get_auto_wait_ms()}ms')
+
+
+# ─── Adaptive mode: "run fast, climb walls when seen" ───
+#
+# Default cdpilot mode is "fast lane" — no stealth, agile defaults. Some sites
+# (Cloudflare Turnstile, hCaptcha, DataDome, PerimeterX) detect this and serve
+# a challenge. Without adaptive mode the user has to manually `cdpilot stealth
+# on` then re-navigate. Adaptive does it automatically:
+#
+#   1. cmd_go navigates as usual
+#   2. _detect_captcha runs (it already runs today, just for warnings)
+#   3. If CAPTCHA detected AND adaptive is ON:
+#      - Persist this hostname so future visits start in stealth
+#      - If stealth is currently OFF: flip it ON and re-navigate once
+#      - Print what we did so the user sees the decision
+#
+# State persists in adaptive.json as {enabled, stealth_hosts: [hostname,...]}.
+# We only AUTO-promote hostnames, never auto-demote — if you turn stealth on
+# for example.com once, it stays on for example.com forever (until you
+# manually clear the list). Conservative: prevents flapping when CAPTCHA
+# detection has a false negative.
+
+
+def get_adaptive_config():
+    """Return {'enabled': bool, 'stealth_hosts': [hostname,...]}."""
+    if not os.path.exists(ADAPTIVE_CONFIG_FILE):
+        return {'enabled': False, 'stealth_hosts': []}
+    try:
+        with open(ADAPTIVE_CONFIG_FILE) as f:
+            data = json.load(f)
+        return {
+            'enabled': bool(data.get('enabled', False)),
+            'stealth_hosts': list(data.get('stealth_hosts', [])),
+        }
+    except (OSError, ValueError):
+        return {'enabled': False, 'stealth_hosts': []}
+
+
+def _adaptive_remember_host(hostname):
+    """Add hostname to the stealth_hosts list. Idempotent."""
+    cfg = get_adaptive_config()
+    if hostname in cfg['stealth_hosts']:
+        return
+    cfg['stealth_hosts'].append(hostname)
+    _atomic_write_json(ADAPTIVE_CONFIG_FILE, cfg)
+
+
+def _adaptive_host_requires_stealth(url):
+    """True if the URL's hostname is in the adaptive stealth list."""
+    cfg = get_adaptive_config()
+    if not cfg['enabled']:
+        return False
+    try:
+        from urllib.parse import urlparse
+        host = (urlparse(url).hostname or '').lower()
+    except Exception:
+        return False
+    return host in cfg['stealth_hosts']
+
+
+def cmd_adaptive(state=None):
+    """Toggle adaptive mode — auto-escalate to stealth when a CAPTCHA is seen.
+
+    Usage:
+      cdpilot adaptive               # status — shows enabled + stealth host list
+      cdpilot adaptive on|off        # toggle
+      cdpilot adaptive clear         # drop the stealth host memory
+      cdpilot adaptive forget <host> # remove one hostname from the list
+
+    Default: OFF. When ON, cdpilot will:
+      - Auto-enable stealth for known-hostile hostnames before navigating.
+      - After every navigation, detect CAPTCHA and remember the hostname for
+        future visits.
+      - If a CAPTCHA appears AND stealth is currently off, flip stealth on and
+        re-navigate once automatically.
+
+    Never auto-demotes — once a hostname is in the list, it stays unless you
+    run `cdpilot adaptive forget <host>` or `cdpilot adaptive clear`. This
+    prevents flapping from a single false-negative CAPTCHA detection.
+    """
+    cfg = get_adaptive_config()
+
+    if state is None or state.lower() == 'status':
+        print(f'Adaptive: {"on" if cfg["enabled"] else "off"}')
+        if cfg['stealth_hosts']:
+            print(f'  Stealth hosts ({len(cfg["stealth_hosts"])}):')
+            for h in cfg['stealth_hosts'][:10]:
+                print(f'    {h}')
+            if len(cfg['stealth_hosts']) > 10:
+                print(f'    ... and {len(cfg["stealth_hosts"]) - 10} more')
+        else:
+            print('  Stealth hosts: (none)')
+        return
+
+    s = state.lower()
+    if s in ('clear',):
+        _atomic_write_json(ADAPTIVE_CONFIG_FILE, {'enabled': cfg['enabled'], 'stealth_hosts': []})
+        print('Adaptive: stealth host list cleared')
+        return
+    if s in ('forget',):
+        # Stub — actual hostname comes via sys.argv parsing in the dispatch
+        print("Usage: cdpilot adaptive forget <hostname>", file=sys.stderr)
+        sys.exit(1)
+    if s not in ('on', 'off', '1', '0', 'true', 'false', 'yes', 'no'):
+        print(f"Invalid state: {state}. Use 'on', 'off', 'clear', 'forget', or 'status'.", file=sys.stderr)
+        sys.exit(1)
+    enabled = s in ('on', '1', 'true', 'yes')
+    _atomic_write_json(ADAPTIVE_CONFIG_FILE, {'enabled': enabled, 'stealth_hosts': cfg['stealth_hosts']})
+    print(f'Adaptive: {"on" if enabled else "off"}')
+    if enabled and not cfg['stealth_hosts']:
+        print('  (no stealth hosts learned yet — visit a CAPTCHA-protected site to start the memory)')
+
+
+def cmd_adaptive_forget(hostname):
+    """Remove one hostname from the adaptive stealth list."""
+    cfg = get_adaptive_config()
+    if hostname not in cfg['stealth_hosts']:
+        print(f'Adaptive: "{hostname}" was not in the stealth list')
+        return
+    cfg['stealth_hosts'].remove(hostname)
+    _atomic_write_json(ADAPTIVE_CONFIG_FILE, cfg)
+    print(f'Adaptive: forgot "{hostname}"')
+
+
 async def _detect_captcha(ws_url):
     """Run CAPTCHA_DETECT_JS in the active page, return parsed dict.
 
@@ -3776,6 +4829,203 @@ async def cmd_smart_click(text):
         print(f'  Also found: {", ".join(data["alternatives"])}')
 
 
+# ─── Auto-dismiss: heuristic click for "leave me alone" modal buttons ───
+#
+# Many sites (especially LLM chat UIs — ChatGPT, Perplexity, Claude.ai, Gemini)
+# gate access behind a sign-up modal but offer an escape hatch like "Stay
+# signed out" or "Continue without". For unauthenticated query workflows
+# (citation tracking, scraping public AI answers, etc.) we need to find and
+# click that escape hatch reliably without firing on dangerous lookalikes.
+#
+# Two lists, evaluated against every visible clickable's text/aria/title:
+#   POSITIVE → contribute a positive score (higher = more dismissive)
+#   NEGATIVE → contribute a negative penalty (any hit = element is disqualified)
+#
+# Conservative on purpose: anti-patterns block obvious traps ("Delete account",
+# "Sign out"), and the minimum score threshold (40) means weak partial matches
+# don't trigger a click.
+
+DISMISS_POSITIVE = [
+    # English — direct anonymous-use intent
+    ("stay signed out", 100), ("keep me signed out", 100),
+    ("continue without signing in", 100), ("continue without an account", 100),
+    ("use without an account", 95), ("continue as guest", 95),
+    ("stay logged out", 95), ("no, thanks", 90),
+    # English — generic dismiss
+    ("no thanks", 85), ("not now", 80), ("maybe later", 75),
+    ("skip for now", 75), ("skip", 65), ("dismiss", 70),
+    ("later", 55), ("close", 50),
+    # Cookie / GDPR — these unblock the page without consenting away rights
+    ("reject all", 60), ("only necessary", 60), ("only essential", 60),
+    ("decline", 55),
+    # Turkish
+    ("şimdi değil", 80), ("şimdilik geç", 80), ("üye olmadan", 95),
+    ("hesapsız devam et", 95), ("girişsiz", 90), ("kapat", 50),
+    ("atla", 65), ("vazgeç", 55), ("yok teşekkürler", 85),
+    ("reddet", 55), ("tümünü reddet", 60),
+]
+
+DISMISS_NEGATIVE = [
+    # Account destruction — never auto-click these
+    "delete account", "remove account", "deactivate account",
+    "hesabı sil", "hesabımı sil", "hesabı kapat",
+    # Session destruction — opposite of what we want
+    "sign out", "log out", "logout", "çıkış yap", "oturumu kapat",
+    # Destructive confirmations
+    "yes, delete", "confirm delete", "permanently delete",
+    "evet, sil", "kalıcı olarak sil",
+    # Subscription / payment
+    "subscribe", "upgrade", "buy now", "satın al", "abone ol",
+]
+
+
+def _dismiss_js_template():
+    """Build the JS expression for cmd_dismiss. Inlines pattern lists as JSON.
+
+    Pulled out into a helper so tests can grep for the patterns without
+    paying for a 200-line literal string in every function definition.
+    """
+    return f"""
+    (function() {{
+      var POS = {json.dumps(DISMISS_POSITIVE)};
+      var NEG = {json.dumps(DISMISS_NEGATIVE)};
+      var MIN_SCORE = 40;
+
+      function checkText(t) {{
+        if (!t) return {{ pos: 0, neg: false, hit: '' }};
+        var s = (t + '').toLowerCase().trim();
+        // Disqualifier first — one negative hit and the element is out,
+        // regardless of how many positive patterns also match.
+        for (var i = 0; i < NEG.length; i++) {{
+          if (s.indexOf(NEG[i]) !== -1) return {{ pos: 0, neg: true, hit: NEG[i] }};
+        }}
+        var bestPos = 0, bestHit = '';
+        for (var j = 0; j < POS.length; j++) {{
+          var pat = POS[j][0], weight = POS[j][1];
+          if (s.indexOf(pat) !== -1) {{
+            // Exact match bonus; otherwise scaled by how much of the
+            // element's text matches the pattern (longer match = more
+            // confident).
+            var score = (s === pat) ? weight + 10 : weight;
+            if (score > bestPos) {{ bestPos = score; bestHit = pat; }}
+          }}
+        }}
+        return {{ pos: bestPos, neg: false, hit: bestHit }};
+      }}
+
+      var els = document.querySelectorAll(
+        'a, button, input[type=submit], input[type=button], ' +
+        '[role=button], [role=link], [role=menuitem], [role=option], ' +
+        'summary, [onclick], [tabindex]'
+      );
+
+      var best = null;
+      Array.from(els).forEach(function(el) {{
+        // Must be visible — invisible/0-size elements are not real buttons
+        var rect = el.getBoundingClientRect();
+        if (rect.width === 0 && rect.height === 0) return;
+        var style = window.getComputedStyle(el);
+        if (style.display === 'none' || style.visibility === 'hidden') return;
+        if (parseFloat(style.opacity) < 0.1) return;
+
+        var texts = [
+          el.textContent || '',
+          el.getAttribute('aria-label') || '',
+          el.getAttribute('title') || '',
+          el.value || '',
+          el.getAttribute('alt') || ''
+        ];
+
+        var disq = false, bestPos = 0, bestHit = '';
+        for (var k = 0; k < texts.length; k++) {{
+          var r = checkText(texts[k]);
+          if (r.neg) {{ disq = true; break; }}
+          if (r.pos > bestPos) {{ bestPos = r.pos; bestHit = r.hit; }}
+        }}
+        if (disq) return;
+        if (bestPos < MIN_SCORE) return;
+
+        if (best === null || bestPos > best.score) {{
+          best = {{
+            score: bestPos,
+            hit: bestHit,
+            text: (texts[0] || texts[1] || '').trim().substring(0, 80),
+            tag: el.tagName.toLowerCase(),
+            x: rect.x + rect.width / 2,
+            y: rect.y + rect.height / 2,
+            el: el
+          }};
+        }}
+      }});
+
+      if (best === null) return JSON.stringify({{ found: false }});
+
+      best.el.scrollIntoView({{behavior:'instant', block:'center'}});
+      best.el.click();
+      return JSON.stringify({{
+        found: true,
+        tag: best.tag,
+        text: best.text,
+        pattern: best.hit,
+        score: best.score
+      }});
+    }})()
+    """
+
+
+async def cmd_dismiss(repeat=None):
+    """Find and click the strongest "dismiss / continue without account" button.
+
+    Designed for LLM chat sites that gate queries behind a sign-up modal but
+    offer an escape hatch ("Stay signed out", "No thanks", etc.). Built-in
+    pattern library covers English + Turkish dismissive phrases and explicitly
+    excludes destructive lookalikes ("Delete account", "Sign out", "Subscribe").
+
+    Usage:
+      cdpilot dismiss              # one shot — click best dismiss button if any
+      cdpilot dismiss 3            # repeat up to 3 times (chained modals)
+      cdpilot dismiss aggressive   # repeat until no candidates found (max 5)
+
+    Exit code: 0 if something was clicked or nothing to dismiss, 1 on error.
+    """
+    # Parse repeat: int N, "aggressive" (=5), or default 1
+    if repeat is None:
+        max_iter = 1
+    elif isinstance(repeat, str) and repeat.lower() == 'aggressive':
+        max_iter = 5
+    else:
+        try:
+            max_iter = max(1, min(int(repeat), 10))
+        except (TypeError, ValueError):
+            print(f"Invalid repeat: {repeat}. Use a number 1-10 or 'aggressive'.", file=sys.stderr)
+            sys.exit(1)
+
+    ws_url, _ = get_page_ws()
+    js = _dismiss_js_template()
+    total_clicked = 0
+    for i in range(max_iter):
+        r = await cdp_send(ws_url, [(1, "Runtime.evaluate", {"expression": js, "returnByValue": True})])
+        raw = r.get(1, {}).get("result", {}).get("value", "")
+        try:
+            data = json.loads(raw)
+        except (json.JSONDecodeError, TypeError):
+            print("Error parsing dismiss result", file=sys.stderr)
+            sys.exit(1)
+        if not data.get("found"):
+            if total_clicked == 0:
+                print("No dismiss candidates on page.")
+            break
+        total_clicked += 1
+        print(f'Dismissed: {data["tag"].upper()} "{data["text"]}" '
+              f'(pattern: "{data["pattern"]}", score: {data["score"]})')
+        # Give the modal a moment to close before next scan
+        if i + 1 < max_iter:
+            await asyncio.sleep(0.4)
+
+    if total_clicked:
+        print(f'Total dismissed: {total_clicked}')
+
+
 async def cmd_smart_fill(text, value):
     """Fill input by label/placeholder text — no CSS selector needed.
 
@@ -4075,6 +5325,50 @@ async def cmd_wait_for(selector, timeout_ms=5000):
     print(result)
 
 
+async def cmd_wait_for_text(text, timeout_ms=5000):
+    """Wait for text content to appear anywhere in document.body, up to timeout.
+
+    Useful when you don't know the selector but know the text will appear (e.g.
+    streaming AI responses, dynamic banners, late-loaded copy). Uses
+    MutationObserver — returns as soon as the text is rendered, no fixed sleep.
+    """
+    ws_url, _ = get_page_ws()
+    safe_text = json.dumps(text)
+    js = f"""
+    (function() {{
+      return new Promise(function(resolve) {{
+        var needle = {safe_text};
+        function check() {{
+          var bodyText = (document.body && document.body.innerText) || '';
+          var idx = bodyText.indexOf(needle);
+          if (idx === -1) return null;
+          var ctx = bodyText.substring(Math.max(0, idx - 30), Math.min(bodyText.length, idx + needle.length + 30));
+          return 'FOUND: "' + ctx.replace(/\\s+/g, ' ').trim() + '"';
+        }}
+        var hit = check();
+        if (hit) return resolve(hit);
+        var pending = false, done = false;
+        function schedule() {{
+          if (pending || done) return;
+          pending = true;
+          requestAnimationFrame(function() {{
+            pending = false;
+            if (done) return;
+            var r = check();
+            if (r) {{ done = true; obs.disconnect(); resolve(r); }}
+          }});
+        }}
+        var obs = new MutationObserver(schedule);
+        obs.observe(document.body, {{childList: true, subtree: true, characterData: true}});
+        setTimeout(function() {{ if (done) return; done = true; obs.disconnect(); resolve('TIMEOUT: text "' + needle.substring(0, 40) + '" not found after {timeout_ms}ms'); }}, {timeout_ms});
+      }});
+    }})()
+    """
+    r = await cdp_send(ws_url, [(1, "Runtime.evaluate", {"expression": js, "returnByValue": True, "awaitPromise": True})], timeout=max(15, timeout_ms // 1000 + 5))
+    result = r.get(1, {}).get("result", {}).get("value", "ERROR")
+    print(result)
+
+
 async def cmd_check(checks_json=None):
     """Run batch assertions. Input: JSON array of {selector, text?} objects."""
     ws_url, _ = get_page_ws()
@@ -4561,7 +5855,7 @@ async def cmd_keys(combo):
 async def cmd_scroll_to(selector):
     """Scroll the specified element into view."""
     ws_url, _ = get_page_ws()
-    js = f"(function(){{ var el=document.querySelector({json.dumps(selector)}); if(!el) return false; el.scrollIntoView({{behavior:'smooth',block:'center'}}); return true; }})()"
+    js = f"(function(){{ var el=document.querySelector({json.dumps(selector)}); if(!el) return false; el.scrollIntoView({{behavior:'instant',block:'center'}}); return true; }})()"
     res = await cdp_send(ws_url, [(1, "Runtime.evaluate", {"expression": js, "returnByValue": True})])
     ok = res.get(1, {}).get("result", {}).get("value", False)
     if ok:
@@ -4827,6 +6121,8 @@ class MCPServer:
              "inputSchema": {"type": "object", "properties": {}}},
             {"name": "browser_eval", "description": "Execute arbitrary JavaScript code in the browser page context and return the result. Use for custom DOM queries, data extraction, or page manipulation that other tools don't cover. Expression is evaluated via Runtime.evaluate.",
              "inputSchema": {"type": "object", "properties": {"expression": {"type": "string", "description": "JavaScript expression to evaluate (e.g. 'document.title', 'document.querySelectorAll(\"a\").length')"}}, "required": ["expression"]}},
+            {"name": "browser_eval_batch", "description": "Evaluate N JavaScript expressions in a SINGLE round-trip. Returns an array of {ok, value} or {ok:false, error} objects, one per expression — a failure in one does not abort the batch. Use this when you need many small observations (read 10 DOM values, query multiple selectors, build a report) — collapses N×roundtrip into 1×roundtrip, typically 5-30x faster than calling browser_eval repeatedly.",
+             "inputSchema": {"type": "object", "properties": {"expressions": {"type": "array", "items": {"type": "string"}, "description": "Array of JavaScript expression strings. Each runs in its own try/catch."}}, "required": ["expressions"]}},
             {"name": "browser_tabs", "description": "List all open browser tabs with their IDs, URLs, and titles. Use this to see what pages are open and get tab IDs for switching between them with other navigation commands.",
              "inputSchema": {"type": "object", "properties": {}}},
             {"name": "browser_console", "description": "Navigate to a URL and capture all browser console output (log, warn, error, info) and uncaught exceptions. Use for debugging JavaScript errors, monitoring API calls logged to console, or verifying application behavior.",
@@ -4847,6 +6143,8 @@ class MCPServer:
              "inputSchema": {"type": "object", "properties": {}}},
             {"name": "browser_smart_click", "description": "Click an element by its visible text — no CSS selector needed. Uses fuzzy matching across text content, aria-label, title, placeholder, and value. Returns match score and alternatives. Like Stagehand act('Click login') but without LLM cost. Use when you know WHAT to click but not the exact selector.",
              "inputSchema": {"type": "object", "properties": {"text": {"type": "string", "description": "Visible text of the element to click (e.g. 'Login', 'Submit Order', 'Learn more')"}}, "required": ["text"]}},
+            {"name": "browser_dismiss", "description": "Find and click the strongest 'dismiss / continue without account' button on the page. Built-in pattern library covers English + Turkish dismissive phrases ('Stay signed out', 'No thanks', 'Skip', 'Continue without', etc.) and explicitly excludes destructive lookalikes (Delete account, Sign out, Subscribe). Designed for LLM chat sites that gate queries behind a sign-up modal. Pass 'aggressive' or an integer N (max 10) to handle chained modals.",
+             "inputSchema": {"type": "object", "properties": {"repeat": {"type": "string", "description": "Optional. Number of dismiss attempts (1-10) or 'aggressive' (up to 5 chained). Default: 1.", "default": "1"}}}},
             {"name": "browser_smart_fill", "description": "Fill an input by its label or placeholder text — no CSS selector needed. Finds input by associated label, placeholder, aria-label, name, or id. React-compatible value setting. Use when you know WHAT field to fill but not the exact selector.",
              "inputSchema": {"type": "object", "properties": {"label": {"type": "string", "description": "Label or placeholder text of the input (e.g. 'Email', 'Password', 'Search')"}, "value": {"type": "string", "description": "Value to fill in the input"}}, "required": ["label", "value"]}},
             {"name": "browser_smart_select", "description": "Select a dropdown option by label and option text — no CSS selector needed. Finds the select element by label/name, then selects the matching option. Use for dropdown interactions without knowing selectors.",
@@ -4857,6 +6155,8 @@ class MCPServer:
              "inputSchema": {"type": "object", "properties": {"selector": {"type": "string", "description": "CSS selector to check for existence"}, "text": {"type": "string", "description": "Optional: expected text content (substring match)"}, "visible": {"type": "boolean", "description": "Check element is visible (not hidden/zero-size)", "default": True}}, "required": ["selector"]}},
             {"name": "browser_wait_for", "description": "Wait for an element matching the CSS selector to appear in the DOM, up to the specified timeout. Uses MutationObserver for efficient waiting. Returns the element's tag and text when found, or TIMEOUT if not found. Use before interactions with dynamically loaded content.",
              "inputSchema": {"type": "object", "properties": {"selector": {"type": "string", "description": "CSS selector to wait for"}, "timeout": {"type": "number", "description": "Maximum wait time in milliseconds", "default": 5000}}, "required": ["selector"]}},
+            {"name": "browser_wait_for_text", "description": "Wait for a specific text string to appear anywhere in document.body, up to the specified timeout. Uses MutationObserver (subtree + characterData) for efficient adaptive waiting — returns the moment the text renders, no fixed sleeps. Ideal for streaming AI responses, async toasts, late-loaded banners, and citation tracking where you know the text but not the selector. Returns surrounding context on hit.",
+             "inputSchema": {"type": "object", "properties": {"text": {"type": "string", "description": "Text fragment to wait for (substring match on document.body.innerText)"}, "timeout": {"type": "number", "description": "Maximum wait time in milliseconds", "default": 5000}}, "required": ["text"]}},
             {"name": "browser_check", "description": "Run a batch of assertions on the current page and return a test report. Each check verifies element existence and optional text content. Returns a summary with PASS/FAIL count. Use this for comprehensive page validation after a series of actions.",
              "inputSchema": {"type": "object", "properties": {"checks": {"type": "array", "description": "Array of checks, each with 'selector' (required) and 'text' (optional)", "items": {"type": "object", "properties": {"selector": {"type": "string"}, "text": {"type": "string"}}, "required": ["selector"]}}}, "required": ["checks"]}},
             {"name": "browser_assert_url", "description": "Assert the current page URL contains the expected substring. Returns PASS with the full URL or FAIL. Use this after navigation to verify you landed on the correct page.",
@@ -4918,6 +6218,7 @@ class MCPServer:
             "browser_content": lambda a: ["content"],
             "browser_html": lambda a: ["html"],
             "browser_eval": lambda a: ["eval", a.get("expression", "")],
+            "browser_eval_batch": lambda a: ["eval-batch", json.dumps(a.get("expressions", []))],
             "browser_tabs": lambda a: ["tabs"],
             "browser_console": lambda a: ["console"] + ([a["url"]] if a.get("url") else []),
             "browser_network": lambda a: ["network"] + ([a["url"]] if a.get("url") else []),
@@ -4928,11 +6229,13 @@ class MCPServer:
             "browser_extract": lambda a: ["extract", a.get("selector", "")] + ([f"--{a['format']}"] if a.get("format") and a["format"] != "text" else []),
             "browser_observe": lambda a: ["observe"],
             "browser_smart_click": lambda a: ["smart-click", a.get("text", "")],
+            "browser_dismiss": lambda a: ["dismiss"] + ([str(a["repeat"])] if a.get("repeat") else []),
             "browser_smart_fill": lambda a: ["smart-fill", a.get("label", ""), a.get("value", "")],
             "browser_smart_select": lambda a: ["smart-select", a.get("label", ""), a.get("option", "")],
             "browser_describe": lambda a: ["describe"],
             "browser_assert": lambda a: ["assert", a.get("selector", "")] + ([a["text"]] if a.get("text") else []),
             "browser_wait_for": lambda a: ["wait-for", a.get("selector", "")] + ([str(a["timeout"])] if a.get("timeout") else []),
+            "browser_wait_for_text": lambda a: ["wait-for-text", a.get("text", "")] + ([str(a["timeout"])] if a.get("timeout") else []),
             "browser_check": lambda a: ["check", json.dumps(a.get("checks", []))],
             "browser_assert_url": lambda a: ["assert-url", a.get("expected_url", "")],
             "browser_assert_title": lambda a: ["assert-title", a.get("expected_title", "")],
@@ -5006,6 +6309,15 @@ if __name__ == "__main__":
     cmd = sys.argv[1]
     args = sys.argv[2:]
 
+    # POSIX-style flag aliases — accepted at the Python entry point too,
+    # not just at the Node wrapper. Lets `python src/cdpilot.py --version`
+    # work in CI and for users who skip the Node wrapper entirely.
+    if cmd in ('--version', '-v'):
+        cmd = 'version'
+    elif cmd in ('--help', '-h'):
+        print(__doc__)
+        sys.exit(0)
+
     sync_cmds = {
         'launch': cmd_launch,
         'tabs': cmd_tabs,
@@ -5015,6 +6327,11 @@ if __name__ == "__main__":
         'proxy': lambda: cmd_proxy(args[0] if args else None),
         'headless': lambda: cmd_headless(args[0] if args else None),
         'stealth': lambda: cmd_stealth(args[0] if args else None),
+        'block': lambda: cmd_block(*args),
+        'context': lambda: cmd_context(*args),
+        'show': lambda: cmd_show(args[0] if args else None),
+        'fast': lambda: cmd_fast(args[0] if args else None),
+        'adaptive': (lambda: cmd_adaptive_forget(args[1])) if (len(args) >= 2 and args[0].lower() == 'forget') else (lambda: cmd_adaptive(args[0] if args else None)),
         'browser': lambda: cmd_browser(args[0] if args else None),
         'health': cmd_health,
         'session': cmd_session,
@@ -5073,6 +6390,7 @@ if __name__ == "__main__":
         "shot-annotated": lambda: cmd_shot_annotated(args[0] if args else None),
         "batch": cmd_batch,
         "eval": lambda: (require_args(1, "eval <js>"), None)[1] if not args else cmd_eval(" ".join(args)),
+        "eval-batch": lambda: (require_args(1, "eval-batch <json_array_of_expressions>"), None)[1] if not args else cmd_eval_batch(args[0]),
         "click": lambda: (require_args(1, "click <selector>"), None)[1] if not args else cmd_click(args[0]),
         "fill": lambda: (require_args(2, "fill <selector> <value>"), None)[1] if len(args) < 2 else cmd_fill(args[0], " ".join(args[1:])),
         "submit": lambda: cmd_submit(args[0] if args else "form"),
@@ -5081,7 +6399,7 @@ if __name__ == "__main__":
         "tabs": cmd_tabs,
         "network": lambda: cmd_network(args[0] if args else None),
         "console": lambda: cmd_console(args[0] if args else None),
-        "cookies": lambda: cmd_cookies(args[0] if args else None),
+        "cookies": lambda: cmd_cookies(*args),
         "storage": cmd_storage,
         "perf": cmd_perf,
         "emulate": lambda: (require_args(1, "emulate <device>"), None)[1] if not args else cmd_emulate(args[0]),
@@ -5101,10 +6419,12 @@ if __name__ == "__main__":
         'observe': cmd_observe,
         'run': lambda: (require_args(1, 'run <script.cdp>'), None)[1] if not args else cmd_run_script(args[0]),
         'smart-click': lambda: (require_args(1, 'smart-click <text>'), None)[1] if not args else cmd_smart_click(" ".join(args)),
+        'dismiss': lambda: cmd_dismiss(args[0] if args else None),
         'smart-fill': lambda: (require_args(2, 'smart-fill <label> <value>'), None)[1] if len(args) < 2 else cmd_smart_fill(args[0], " ".join(args[1:])),
         'smart-select': lambda: (require_args(2, 'smart-select <label> <option>'), None)[1] if len(args) < 2 else cmd_smart_select(args[0], " ".join(args[1:])),
         'assert': lambda: (require_args(1, 'assert <selector> [text]'), None)[1] if not args else cmd_assert(args[0], args[1] if len(args) > 1 else None),
         'wait-for': lambda: (require_args(1, 'wait-for <selector> [timeout_ms]'), None)[1] if not args else cmd_wait_for(args[0], int(args[1]) if len(args) > 1 else 5000),
+        'wait-for-text': lambda: (require_args(1, 'wait-for-text <text> [timeout_ms]'), None)[1] if not args else cmd_wait_for_text(args[0], int(args[1]) if len(args) > 1 else 5000),
         'check': lambda: cmd_check(args[0] if args else None),
         'assert-url': lambda: (require_args(1, 'assert-url <expected>'), None)[1] if not args else cmd_assert_url(args[0]),
         'assert-title': lambda: (require_args(1, 'assert-title <expected>'), None)[1] if not args else cmd_assert_title(args[0]),